Allow developers to define #call with arguments for convenience

.rubocop.yml

@@ -1,7 +1,7 @@
 # This should always correspond to the required Ruby version specified in the
 # gemspec.
 AllCops:
-  TargetRubyVersion: 2.0
+  TargetRubyVersion: 2.1
 
 # TODO: What should we do here?
 Style/FrozenStringLiteralComment:
@@ -43,3 +43,5 @@ Style/StringLiterals:
   EnforcedStyle: double_quotes
 Style/SymbolArray:
   Enabled: false
+Style/WordArray:
+  Enabled: false

.travis.yml

@@ -8,15 +8,13 @@ cache: bundler
 language: ruby
 matrix:
   allow_failures:
-    - rvm: "2.0"
     - rvm: ruby-head
 notifications:
   webhooks:
     on_start: always
     urls:
       - http://buildlight.collectiveidea.com/
 rvm:
-  - "2.0"
   - "2.1"
   - "2.2"
   - "2.3.4"

interactor.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.files      = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.test_files = spec.files.grep(/^spec/)
 
-  spec.required_ruby_version = ">= 2.0"
+  spec.required_ruby_version = ">= 2.1"
 
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.4"

lib/interactor.rb

@@ -140,7 +140,7 @@ def run
   # Raises Interactor::Failure if the context is failed.
   def run!
     with_hooks do
-      call
+      call(*arguments_for_call)
       context.called!(self)
     end
   rescue
@@ -163,4 +163,30 @@ def call
   # Returns nothing.
   def rollback
   end
+
+  private
+
+  # Internal: Determine what arguments (if any) should be passed to the "call"
+  # instance method when invoking an Interactor. The "call" instance method may
+  # accept any combination of positional and keyword arguments. This method
+  # will extract values from the context in order to populate those arguments
+  # based on their names.
+  #
+  # Returns an Array of arguments to be applied as an argument list.
+  def arguments_for_call # rubocop:disable Metrics/MethodLength
+    positional_arguments = []
+    keyword_arguments = {}
+
+    method(:call).parameters.each do |(type, name)|
+      next unless context.include?(name)
+
+      case type
+      when :req, :opt then positional_arguments << context[name]
+      when :keyreq, :key then keyword_arguments[name] = context[name]
+      end
+    end
+
+    positional_arguments << keyword_arguments if keyword_arguments.any?
+    positional_arguments
+  end
 end

lib/interactor/context.rb

@@ -121,7 +121,7 @@ def failure?
     #
     # Raises Interactor::Failure initialized with the Interactor::Context.
     def fail!(context = {})
-      context.each { |key, value| modifiable[key.to_sym] = value }
+      context.each { |key, value| self[key] = value }
       @failure = true
       raise Failure, self
     end
@@ -158,6 +158,15 @@ def rollback!
       @rolled_back = true
     end
 
+    # Public: Check for the presence of a given key in the context. This does
+    # not check whether the value is truthy, just whether the key is set to any
+    # value at all.
+    #
+    # Returns true if the key is found or false otherwise.
+    def include?(key)
+      table.include?(key.to_sym)
+    end
+
     # Internal: An Array of successfully called Interactor instances invoked
     # against this Interactor::Context instance.
     #

spec/interactor/context_spec.rb

@@ -164,6 +164,26 @@ module Interactor
       end
     end
 
+    describe "#include?" do
+      it "returns true if the key is found" do
+        context = Context.build(foo: "bar")
+
+        expect(context.include?(:foo)).to eq(true)
+      end
+
+      it "returns true if the symbolized key is found" do
+        context = Context.build(foo: "bar")
+
+        expect(context.include?("foo")).to eq(true)
+      end
+
+      it "returns false if the key is not found" do
+        context = Context.build(foo: "bar")
+
+        expect(context.include?(:hello)).to eq(false)
+      end
+    end
+
     describe "#_called" do
       let(:context) { Context.build }
 

spec/interactor_spec.rb

@@ -1,3 +1,213 @@
 describe Interactor do
   include_examples :lint
+
+  describe "#call" do
+    let(:interactor) { Class.new.send(:include, described_class) }
+
+    context "positional arguments" do
+      it "accepts required positional arguments" do
+        interactor.class_eval do
+          def call(foo)
+            context.output = foo
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq("baz")
+      end
+
+      it "accepts optional positional arguments" do
+        interactor.class_eval do
+          def call(foo = "bar")
+            context.output = foo
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq("baz")
+      end
+
+      it "assigns absent positional arguments" do
+        interactor.class_eval do
+          def call(foo = "bar")
+            context.output = foo
+          end
+        end
+
+        result = interactor.call(hello: "world")
+
+        expect(result.output).to eq("bar")
+      end
+
+      it "raises an error for missing positional arguments" do
+        interactor.class_eval do
+          def call(foo)
+            context.output = foo
+          end
+        end
+
+        expect { interactor.call(hello: "world") }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "keyword arguments" do
+      it "accepts required keyword arguments" do
+        interactor.class_eval do
+          def call(foo:)
+            context.output = foo
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq("baz")
+      end
+
+      it "accepts optional keyword arguments" do
+        interactor.class_eval do
+          def call(foo: "bar")
+            context.output = foo
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq("baz")
+      end
+
+      it "assigns absent keyword arguments" do
+        interactor.class_eval do
+          def call(foo: "bar")
+            context.output = foo
+          end
+        end
+
+        result = interactor.call(hello: "world")
+
+        expect(result.output).to eq("bar")
+      end
+
+      it "raises an error for missing keyword arguments" do
+        interactor.class_eval do
+          def call(foo:)
+            context.output = foo
+          end
+        end
+
+        expect { interactor.call(hello: "world") }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "combination arguments" do
+      it "accepts required positional with required keyword arguments" do
+        interactor.class_eval do
+          def call(foo, hello:)
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq(["baz", "world"])
+      end
+
+      it "accepts required positional with optional keyword arguments" do
+        interactor.class_eval do
+          def call(foo, hello: "there")
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq(["baz", "world"])
+      end
+
+      it "accepts required positional and assigns absent keyword arguments" do
+        interactor.class_eval do
+          def call(foo, hello: "there")
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(foo: "baz")
+
+        expect(result.output).to eq(["baz", "there"])
+      end
+
+      it "accepts optional positional with required keyword arguments" do
+        interactor.class_eval do
+          def call(foo = "bar", hello:)
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq(["baz", "world"])
+      end
+
+      it "accepts optional positional with optional keyword arguments" do
+        interactor.class_eval do
+          def call(foo = "bar", hello: "there")
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(foo: "baz", hello: "world")
+
+        expect(result.output).to eq(["baz", "world"])
+      end
+
+      it "accepts optional positional and assigns absent keyword arguments" do
+        interactor.class_eval do
+          def call(foo = "bar", hello: "there")
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(foo: "baz")
+
+        expect(result.output).to eq(["baz", "there"])
+      end
+
+      it "assigns absent positional and accepts required keyword arguments" do
+        interactor.class_eval do
+          def call(foo = "bar", hello:)
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(hello: "world")
+
+        expect(result.output).to eq(["bar", "world"])
+      end
+
+      it "assigns absent positional and accepts optional keyword arguments" do
+        interactor.class_eval do
+          def call(foo = "bar", hello: "there")
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call(hello: "world")
+
+        expect(result.output).to eq(["bar", "world"])
+      end
+
+      it "assigns absent positional and absent keyword arguments" do
+        interactor.class_eval do
+          def call(foo = "bar", hello: "there")
+            context.output = [foo, hello]
+          end
+        end
+
+        result = interactor.call
+
+        expect(result.output).to eq(["bar", "there"])
+      end
+    end
+  end
 end