interaktor 0.1.5 → 0.2.0

data/lib/interaktor/context.rb

@@ -62,7 +62,7 @@ class Interaktor::Context < OpenStruct
   # @return [void]
   def success!(context = {})
     context.each { |key, value| self[key.to_sym] = value }
-    throw :early_return, self
+    early_return!
   end
 
   # Roll back the Interaktor::Context. Any interaktors to which this context
@@ -98,4 +98,19 @@ class Interaktor::Context < OpenStruct
   def _called
     @called ||= []
   end
+
+  # Trigger an early return throw.
+  #
+  # @return [void]
+  def early_return!
+    @early_return = true
+    throw :early_return, self
+  end
+
+  # Whether or not the context has been returned from early.
+  #
+  # @return [Boolean]
+  def early_return?
+    (@early_return == true) || false
+  end
 end

data/lib/interaktor/error/attribute_error.rb

@@ -0,0 +1,16 @@
+class Interaktor::Error::AttributeError < Interaktor::Error::Base
+  # @return [Array<Symbol>]
+  attr_reader :attributes
+
+  # @param interaktor [Class]
+  # @param attributes [Array<Symbol>]
+  def initialize(interaktor, attributes)
+    super(interaktor)
+
+    @attributes = attributes
+  end
+
+  def message
+    raise NotImplementedError
+  end
+end

data/lib/interaktor/error/base.rb

@@ -0,0 +1,9 @@
+class Interaktor::Error::Base < StandardError
+  # @return [Class]
+  attr_reader :interaktor
+
+  # @param interaktor [Class]
+  def initialize(interaktor)
+    @interaktor = interaktor
+  end
+end

data/lib/interaktor/error/disallowed_attribute_assignment_error.rb

@@ -0,0 +1,9 @@
+class Interaktor::Error::DisallowedAttributeAssignmentError < Interaktor::Error::AttributeError
+  def message
+    <<~MESSAGE.strip.tr("\n", "")
+      Attempted a disallowed assignment to the '#{attributes.first}'
+      attribute which was not included when the #{interaktor} interaktor was
+      originally called.
+    MESSAGE
+  end
+end

data/lib/interaktor/error/missing_attribute_error.rb

@@ -0,0 +1,5 @@
+class Interaktor::Error::MissingAttributeError < Interaktor::Error::AttributeError
+  def message
+    "Missing attribute(s) in call to #{interaktor}: #{attributes.join(", ")}"
+  end
+end

data/lib/interaktor/error/option_error.rb

@@ -0,0 +1,16 @@
+class Interaktor::Error::OptionError < Interaktor::Error::Base
+  # @return [Hash{Symbol=>Object}]
+  attr_reader :options
+
+  # @param interaktor [Class]
+  # @param options [Hash{Symbol=>Object}]
+  def initialize(interaktor, options)
+    super(interaktor)
+
+    @options = options
+  end
+
+  def message
+    raise NotImplementedError
+  end
+end

data/lib/interaktor/error/unknown_attribute_error.rb

@@ -0,0 +1,5 @@
+class Interaktor::Error::UnknownAttributeError < Interaktor::Error::AttributeError
+  def message
+    "Unknown attribute(s) in call to #{interaktor}: #{attributes.join(", ")}"
+  end
+end

data/lib/interaktor/error/unknown_option_error.rb

@@ -0,0 +1,5 @@
+class Interaktor::Error::UnknownOptionError < Interaktor::Error::OptionError
+  def message
+    "Unknown option(s) in #{interaktor} interaktor: #{options.keys.join(", ")}"
+  end
+end

data/lib/interaktor/organizer.rb

@@ -40,28 +40,15 @@ module Interaktor::Organizer
     # @return [void]
     def call
       self.class.organized.each do |interaktor|
+        # Take the context that is being passed to each interaktor and remove
+        # any attributes from it that are not required by the interactor.
+        @context.to_h
+                .keys
+                .reject { |attr| interaktor.input_attributes.include?(attr) }
+                .each { |attr| @context.delete_field(attr) }
+
         catch(:early_return) { interaktor.call!(@context) }
       end
     end
-
-    private
-
-    # A list of attributes required to invoke the organized Interaktors.
-    # Obtained by compiling a list of all required attributes of all organized
-    # interaktors. Duplicates are removed.
-    #
-    # @return [Array<Symbol>]
-    def required_attributes
-      self.class.organized.map(&:required_attributes).flatten.uniq
-    end
-
-    # A list of optional attributes allowed to be included when invoking the
-    # organized Interaktors. Obtained by compiling a list of all optional
-    # attributes of all organized interaktors. Duplicates are removed.
-    #
-    # @return [Array<Symbol>]
-    def optional_attributes
-      self.class.organized.map(&:optional_attributes).flatten.uniq
-    end
   end
 end

data/spec/integration_spec.rb

@@ -5,30 +5,33 @@
 
 describe "Integration" do
   def build_interaktor(&block)
-    interaktor = Class.new.send(:include, Interaktor)
-    interaktor.class_eval(&block) if block
-    interaktor.class_eval do
-      optional :steps
+    Class.new.tap do |interaktor|
+      interaktor.send(:include, Interaktor)
+      interaktor.class_eval(&block) if block
+      interaktor.class_eval do
+        optional :steps
 
-      def unexpected_error!
-        raise "foo"
+        def unexpected_error!
+          raise "foo"
+        end
       end
     end
-    interaktor
   end
 
   def build_organizer(options = {}, &block)
-    organizer = Class.new.send(:include, Interaktor::Organizer)
-    organizer.organize(options[:organize]) if options[:organize]
-    organizer.class_eval(&block) if block
-    organizer.class_eval do
-      optional :steps
+    Class.new.tap do |organizer|
+      organizer.send(:include, Interaktor::Organizer)
+
+      organizer.organize(options[:organize]) if options[:organize]
+      organizer.class_eval(&block) if block
+      organizer.class_eval do
+        optional :steps
 
-      def unexpected_error!
-        raise "foo"
+        def unexpected_error!
+          raise "foo"
+        end
       end
     end
-    organizer
   end
 
   # rubocop:disable Style/AsciiComments

data/spec/interactor/organizer_spec.rb

@@ -36,24 +36,92 @@ module Interaktor
     end
 
     describe "#call" do
-      it "calls each interaktor in order with the context" do
-        instance = organizer.new
-        context = instance_double(Interaktor::Context)
-        interaktor2 = class_double(Class.new.include(Interaktor))
-        interaktor3 = class_double(Class.new.include(Interaktor))
-        interaktor4 = class_double(Class.new.include(Interaktor))
-
-        allow(instance).to receive(:context).and_return(context)
-        instance.instance_variable_set(:@context, context)
+      it "calls each interaktor in order" do
+        organizer.class_eval { required :foo }
+
+        interaktor2 = Class.new.include(Interaktor)
+        interaktor2.class_eval { required :foo }
+        interaktor2.define_method(:call) { self.foo = "bar" }
+
+        interaktor3 = Class.new.include(Interaktor)
+        interaktor3.class_eval { required :foo }
+        interaktor3.define_method(:call) { self.foo = "baz" }
+
+        interaktor4 = Class.new.include(Interaktor)
+        interaktor4.class_eval { required :foo }
+        interaktor4.define_method(:call) { self.foo = "wadus" }
+
         allow(organizer).to receive(:organized) {
           [interaktor2, interaktor3, interaktor4]
         }
 
-        expect(interaktor2).to receive(:call!).once.with(context).ordered
-        expect(interaktor3).to receive(:call!).once.with(context).ordered
-        expect(interaktor4).to receive(:call!).once.with(context).ordered
+        expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+        expect(interaktor3).to receive(:call!).once.ordered.and_call_original
+        expect(interaktor4).to receive(:call!).once.ordered.and_call_original
+
+        result = organizer.call(foo: "asdf")
+
+        expect(result.foo).to eq "wadus"
+      end
+
+      it "calls each interaktor in order and passes success attributes" do
+        organizer.class_eval { required :foo }
+
+        interaktor2 = Class.new.include(Interaktor)
+        interaktor2.class_eval do
+          required :foo
+          success :bar
+        end
+        interaktor2.define_method(:call) { success!(bar: "baz") }
+
+        interaktor3 = Class.new.include(Interaktor)
+        interaktor3.class_eval { required :bar }
+        interaktor3.define_method(:call) { self.bar = "wadus" }
+
+        allow(organizer).to receive(:organized) {
+          [interaktor2, interaktor3]
+        }
+
+        expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+        expect(interaktor3).to receive(:call!).once.ordered.and_call_original
+
+        result = organizer.call(foo: "asdf")
 
-        instance.call
+        expect(result.bar).to eq "wadus"
+      end
+
+      it "raises an exception if the organizer attributes do not satisfy the first interaktor" do
+        organizer.class_eval { required :foo }
+
+        interaktor2 = Class.new.include(Interaktor)
+        interaktor2.class_eval { required :bar }
+
+        allow(organizer).to receive(:organized).and_return([interaktor2])
+
+        expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+
+        expect {
+          organizer.call(foo: "bar")
+        }.to raise_error(an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar]))
+      end
+
+      it "raises an exception if the organizer attributes do not satisfy a non-first interaktor" do
+        organizer.class_eval { required :foo }
+
+        interaktor2 = Class.new.include(Interaktor)
+        interaktor2.class_eval { required :foo }
+
+        interaktor3 = Class.new.include(Interaktor)
+        interaktor3.class_eval { required :bar }
+
+        allow(organizer).to receive(:organized).and_return([interaktor2, interaktor3])
+
+        expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+        expect(interaktor3).to receive(:call!).once.ordered.and_call_original
+
+        expect {
+          organizer.call(foo: "bar")
+        }.to raise_error(an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar]))
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,8 +1,13 @@
-if ENV["CODECLIMATE_REPO_TOKEN"]
-  require "simplecov"
-  SimpleCov.start
+require "simplecov"
+SimpleCov.start do
+  enable_coverage :branch
+
+  add_filter "/spec/"
+  add_filter "/vendor/"
+  add_filter "/lib/interaktor/error"
 end
 
+Bundler.require(:default, :test)
 require "interaktor"
 
 Dir[File.expand_path("support/*.rb", __dir__)].sort.each { |f| require f }

data/spec/support/lint.rb

@@ -1,82 +1,51 @@
 shared_examples "lint" do
-  let(:interaktor) do
-    klass = Class.new.include(described_class)
-    klass.class_eval do
-      optional :foo
-    end
-
-    klass
-  end
+  let(:interaktor) { Class.new.include(described_class) }
 
   describe ".call" do
-    let(:context) { instance_double(Interaktor::Context) }
     let(:instance) { instance_double(interaktor) }
 
-    it "calls an instance with the given context" do
-      instance.instance_variable_set(:@context, context)
-      expect(interaktor).to receive(:new).once.with(foo: "bar").and_return(instance)
-      expect(instance).to receive(:run).once.with(no_args)
+    it "calls an instance" do
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
 
-      resulting_context = interaktor.call(foo: "bar")
+      result = interaktor.call
 
-      expect(resulting_context).to eq(context)
+      expect(result.success?).to be true
     end
 
-    it "provides a blank context if none is given" do
-      instance.instance_variable_set(:@context, context)
-      expect(interaktor).to receive(:new).once.with({}).and_return(instance)
-      expect(instance).to receive(:run).once.with(no_args)
-
-      resulting_context = interaktor.call({})
+    it "fails when an unknown attribute is provided" do
+      expect {
+        interaktor.call(baz: "wadus")
+      }.to raise_error(an_instance_of(Interaktor::Error::UnknownAttributeError).and having_attributes(attributes: [:baz]))
+    end
 
-      expect(resulting_context).to eq(context)
+    it "fails when a non-hash or non-context argument is passed" do
+      expect {
+        interaktor.call("foo")
+      }.to raise_error(ArgumentError, /Expected a hash argument/)
     end
   end
 
   describe ".call!" do
-    let(:context) { instance_double(Interaktor::Context) }
     let(:instance) { instance_double(interaktor) }
 
-    it "calls an instance with the given context" do
-      instance.instance_variable_set(:@context, context)
-      expect(interaktor).to receive(:new).once.with(foo: "bar").and_return(instance)
-      expect(instance).to receive(:run!).once.with(no_args)
+    it "calls an instance" do
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
 
-      resulting_context = interaktor.call!(foo: "bar")
+      result = interaktor.call!
 
-      expect(resulting_context).to eq(context)
+      expect(result.success?).to be true
     end
 
-    it "provides a blank context if none is given" do
-      instance.instance_variable_set(:@context, context)
-      expect(interaktor).to receive(:new).once.with({}).and_return(instance)
-      expect(instance).to receive(:run!).once.with(no_args)
-
-      resulting_context = interaktor.call!({})
-
-      expect(resulting_context).to eq(context)
-    end
-  end
-
-  describe ".new" do
-    let(:context) { instance_double(Interaktor::Context) }
-
-    it "initializes a context" do
-      expect(Interaktor::Context).to receive(:build).once.with(foo: "bar").and_return(context)
-
-      instance = interaktor.new(foo: "bar")
-
-      expect(instance).to be_an(interaktor)
-      expect(instance.instance_variable_get(:@context)).to eq(context)
+    it "fails when an unknown attribute is provided" do
+      expect {
+        interaktor.call!(baz: "wadus")
+      }.to raise_error(an_instance_of(Interaktor::Error::UnknownAttributeError).and having_attributes(attributes: [:baz]))
     end
 
-    it "initializes a blank context if none is given" do
-      expect(Interaktor::Context).to receive(:build).once.with({}).and_return(context)
-
-      instance = interaktor.new
-
-      expect(instance).to be_a(interaktor)
-      expect(instance.instance_variable_get(:@context)).to eq(context)
+    it "fails when a non-hash or non-context argument is passed" do
+      expect {
+        interaktor.call!("foo")
+      }.to raise_error(ArgumentError, /Expected a hash argument/)
     end
   end
 
@@ -151,4 +120,267 @@ shared_examples "lint" do
       expect { instance.method(:rollback) }.not_to raise_error
     end
   end
+
+  describe "required attributes" do
+    let(:instance) { instance_double(interaktor) }
+
+    it "initializes successfully when the attribute is provided" do
+      interaktor.class_eval { required :bar }
+
+      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+
+      result = interaktor.call(bar: "baz")
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "creates a value setter" do
+      interaktor.class_eval { required :bar }
+
+      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+
+      interaktor.define_method(:call) do
+        self.bar = "wadus"
+      end
+
+      result = interaktor.call(bar: "baz")
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "wadus"
+    end
+
+    it "raises an exception when the attribute is not provided" do
+      interaktor.class_eval { required :bar }
+
+      expect {
+        interaktor.call!
+      }.to raise_error(an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar]))
+    end
+
+    describe "options" do
+      it "raises an exception when an unknown option is provided" do
+        expect {
+          interaktor.class_eval { required :bar, unknown: true }
+        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+      end
+    end
+  end
+
+  describe "optional attributes" do
+    let(:instance) { instance_double(interaktor) }
+
+    it "initializes successfully when the attribute is provided" do
+      interaktor.class_eval { optional :bar }
+
+      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+
+      result = interaktor.call(bar: "baz")
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "initializes successfully when the attribute is not provided" do
+      interaktor.class_eval { optional :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      result = interaktor.call
+
+      expect(result.success?).to be true
+      expect(result.bar).to be_nil
+    end
+
+    it "creates a value setter" do
+      interaktor.class_eval { optional :bar }
+
+      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+
+      interaktor.define_method(:call) do
+        self.bar = "wadus"
+      end
+
+      result = interaktor.call(bar: "baz")
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "wadus"
+    end
+
+    it "raises an exception when assigning a value to an optional parameter which was not originally provided" do
+      interaktor.class_eval { optional :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      interaktor.define_method(:call) do
+        self.bar = "baz"
+      end
+
+      expect { interaktor.call }.to(
+        raise_error(
+          an_instance_of(Interaktor::Error::DisallowedAttributeAssignmentError)
+            .and(having_attributes(attributes: [:bar]))
+        )
+      )
+    end
+
+    describe "options" do
+      it "accepts a default value for the attribute" do
+        interaktor.class_eval { optional :bar, default: "baz" }
+
+        expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+
+        result = interaktor.call
+
+        expect(result.success?).to be true
+        expect(result.bar).to eq "baz"
+      end
+
+      it "raises an exception when an unknown option is provided" do
+        expect {
+          interaktor.class_eval { optional :bar, unknown: true }
+        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+      end
+    end
+  end
+
+  describe "success attributes" do
+    it "succeeds when the correct attributes are provided" do
+      interaktor.class_eval { success :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      interaktor.define_method(:call) do
+        success!(bar: "baz")
+      end
+
+      result = interaktor.call
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "raises an exception when the correct attributes are not provided because #success! is not called" do
+      interaktor.class_eval { success :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      expect { interaktor.call }.to(
+        raise_error(
+          an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
+        )
+      )
+    end
+
+    it "raises an exception when the correct attributes are not provided in the call to #success!" do
+      interaktor.class_eval { success :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      interaktor.define_method(:call) do
+        success!({})
+      end
+
+      expect { interaktor.call }.to(
+        raise_error(
+          an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
+        )
+      )
+    end
+
+    it "raises an exception when unknown attributes are provided" do
+      interaktor.class_eval { success :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      interaktor.define_method(:call) do
+        success!(bar: "baz", baz: "wadus")
+      end
+
+      expect { interaktor.call }.to(
+        raise_error(
+          an_instance_of(Interaktor::Error::UnknownAttributeError).and having_attributes(attributes: [:baz])
+        )
+      )
+    end
+
+    describe "options" do
+      it "raises an exception when an unknown option is provided" do
+        expect {
+          interaktor.class_eval { success :bar, unknown: true }
+        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+      end
+    end
+  end
+
+  describe "failure attributes" do
+    it "fails when the correct attributes are provided" do
+      interaktor.class_eval { failure :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      interaktor.define_method(:call) do
+        fail!(bar: "baz")
+      end
+
+      result = interaktor.call
+
+      expect(result.success?).to be false
+      expect(result.bar).to eq "baz"
+    end
+
+    it "raises an exception when the correct attributes are not provided" do
+      interaktor.class_eval { failure :bar }
+
+      expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+      interaktor.define_method(:call) do
+        fail!({})
+      end
+
+      expect { interaktor.call }.to(
+        raise_error(
+          an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
+        )
+      )
+    end
+
+    context "when the interaktor is called with #call!" do
+      it "raises an exception when the correct attributes are provided" do
+        interaktor.class_eval { failure :bar }
+
+        expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+        interaktor.define_method(:call) do
+          fail!(bar: "baz")
+        end
+
+        expect { interaktor.call! }.to raise_error(Interaktor::Failure)
+      end
+
+      it "raises an exception when the correct attributes are not provided" do
+        interaktor.class_eval { failure :bar }
+
+        expect(interaktor).to receive(:new).once.with({}).and_call_original
+
+        interaktor.define_method(:call) do
+          fail!({})
+        end
+
+        expect { interaktor.call }.to(
+          raise_error(
+            an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
+          )
+        )
+      end
+    end
+
+    describe "options" do
+      it "raises an exception when an unknown option is provided" do
+        expect {
+          interaktor.class_eval { failure :bar, unknown: true }
+        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+      end
+    end
+  end
 end