refactors filter class

lib/moonshine/filter.rb

@@ -1,40 +1,40 @@
 module Moonshine
   class Filter
 
-    attr_accessor :name, :method_name, :transform, :default, :as_boolean
+    attr_accessor :name, :method_name, :options, :klass
 
-    def initialize(name, method_name: nil, transform: nil, default: nil, as_boolean: nil, &block)
+    def initialize(name, method_name: nil, **options, &block)
       @name = name
-      @method_name = method_name || block
-      @transform = transform
-      @default = default
-      @as_boolean = as_boolean
+      @method_name = block || method_name
+      @options = options
     end
 
     def execute(klass)
-      unless as_boolean
-         args = set_transform(klass, set_default(klass.filters[name]))
-      end
-      return method_call(klass, args) if klass.filters[name] || default
+      @klass = klass
+      return method_call if klass.filters[name] || options[:default]
       klass.subject
     end
 
     private
 
-    def method_call(klass, *args)
+    def method_call
       if method_name.is_a? Proc
-        method_name.call(klass, *args)
+        method_name.call(klass.subject, *args)
       else
         klass.subject.send(method_name, *args)
       end
     end
 
+    def args
+      set_transform(set_default(klass.filters[name])) unless options[:as_boolean]
+    end
+
     def set_default value
-      value || default
+      value || options[:default]
     end
 
-    def set_transform klass, value
-      return klass.send(transform, value) if transform
+    def set_transform value
+      return klass.send(options[:transform], value) if options[:transform]
       value
     end
   end

test/lib/moonshine/filter_test.rb

@@ -22,7 +22,7 @@
     end
 
     it 'return subject when default and value are nil' do
-      filter.default = nil
+      filter.options[:default] = nil
       chain_builder_instance.filters = {}
       filter.execute(chain_builder_instance).must_equal chain_builder_instance.subject
     end
@@ -32,15 +32,15 @@
         block = Proc.new { |subject, value| subject.some_method(value) }
         filter = Moonshine::Filter.new(:filter, &block)
         chain_builder_instance = @chain_builder.new({ filter: 1 })
-        filter.method_name.expects(:call)
+        filter.method_name.expects(:call).with(chain_builder_instance.subject, 1)
         filter.execute(chain_builder_instance)
       end
     end
 
     describe 'options' do
       describe 'transform' do
         it 'changes value with transform method from klass' do
-          filter.transform = :transform_method
+          filter.options[:transform] = :transform_method
           chain_builder_instance.subject.stubs(:filter)
           chain_builder_instance.expects(:transform_method).with(1)
           filter.execute(chain_builder_instance)
@@ -49,21 +49,21 @@
 
       describe 'default' do
         it 'uses default value if filter is nil' do
-          filter.default = 2
+          filter.options[:default] = 2
           chain_builder_instance.filters = {}
           chain_builder_instance.subject.expects(:filter).with(2)
           filter.execute(chain_builder_instance)
         end
 
         it 'not use default value if filter is not nil' do
-          filter.default = 2
+          filter.options[:default] = 2
           chain_builder_instance.filters = { filter: 1 }
           chain_builder_instance.subject.expects(:filter).with(1)
           filter.execute(chain_builder_instance)
         end
 
         it 'not sends filter if default and value are nil' do
-          filter.default = nil
+          filter.options[:default] = nil
           chain_builder_instance.filters = {}
           chain_builder_instance.subject.expects(:filter).never
           filter.execute(chain_builder_instance)
@@ -72,14 +72,14 @@
 
       describe 'as_boolean' do
         it 'sends method without value when true' do
-          filter.as_boolean = true
+          filter.options[:as_boolean] = true
           chain_builder_instance.filters = { filter: true }
           chain_builder_instance.subject.expects(:filter)
           filter.execute(chain_builder_instance)
         end
 
         it 'sends method without value when false' do
-          filter.as_boolean = true
+          filter.options[:as_boolean] = true
           chain_builder_instance.filters = { filter: false }
           chain_builder_instance.subject.expects(:filter).never
           filter.execute(chain_builder_instance)