interactor 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6832397e4ab11a93ded8ded31c4e47519be8fe34
-  data.tar.gz: 3ffdfed6582a46b97745356133e5b34a2c3d3b0c
+  metadata.gz: 61cda0fd8ba19d73ab1928d83b89f1e033ea7ece
+  data.tar.gz: df675488f9066ff98f40e7ef7f30becca42f57b1
 SHA512:
-  metadata.gz: e744650c5033bab652b44d122fc7a1b785d7ab8d22e9afc654a2b1f2e1071f8fdf1846e7c3c68e3163cdd2892ea1ad8d98c37ef9bf8b75c8351b21f13d04215f
-  data.tar.gz: 81ba3295b6dc2cf3991919708b46cb7e83d1f964799f9b6262e46bfbc78733c337f823bc4401c3fec6822154ddf7ccc0abdc63167cc15865ca5f01453f5381df
+  metadata.gz: c5c02256cb1688170d08dcef72e7d6f390dda20a4263e1daf5f7e8596f54968ad39b0a352dd2659888c45e4360db62142cc0240100db7a8a82a96b43f3063012
+  data.tar.gz: d58aa049b0de1c0bf204fc8bcc4a7475a4e9158d90e3bd8ba9072a5ae15e34137e98d68ce772e945d32537d7cb525c29db1ed969cfd3f4fc4c515796cac962d3

data/README.md

@@ -242,10 +242,33 @@ Because interactors and organizers adhere to the same interface, it's trivial fo
 
 If an organizer has three interactors and the second one fails, the third one is never called.
 
-In addition to halting the chain, an organizer will also *rollback* through the interactors that it has performed so that each interactor has the opportunity to undo itself. Just define a `rollback` method. It has all the same access to the context as `perform` does.
+In addition to halting the chain, an organizer will also *rollback* through the interactors that it has successfully performed so that each interactor has the opportunity to undo itself. Just define a `rollback` method. It has all the same access to the context as `perform` does.
+
+Note that the the failed interactor itself will not be rolled back. Interactors are expected to be single-purpose, so there should be nothing to undo if the interactor fails.
 
 ## Conventions
 
+### Good Practice
+
+To allow rollbacks to work without fuss in organizers, interactors should only *add* to the context. They should not transform any values already in the context. For example, the following is a bad idea:
+
+```ruby
+class FindUser
+  include Interactor
+
+  def perform
+    context[:user] = User.find(context[:user])
+    # Now, context[:user] contains a User object.
+    # Before, context[:user] held a user ID.
+    # This is bad.
+  end
+end
+```
+
+If an organizer rolls back, any interactor before `FindUser` will now see a `User` object during the rollback when they were probably expecting a simple ID. This could cause problems.
+
+### Rails
+
 We love Rails, and we use Interactor with Rails. We put our interactors in `app/interactors` and we name them as verbs:
 
 * `AddProductToCart`

data/interactor.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name    = "interactor"
-  spec.version = "1.0.0"
+  spec.version = "2.0.0"
 
   spec.author      = "Collective Idea"
   spec.email       = "info@collectiveidea.com"

data/lib/interactor.rb

@@ -5,7 +5,6 @@ module Interactor
   def self.included(base)
     base.class_eval do
       extend ClassMethods
-      include InstanceMethods
 
       attr_reader :context
     end
@@ -15,45 +14,39 @@ module Interactor
     def perform(context = {})
       new(context).tap(&:perform)
     end
-
-    def rollback(context = {})
-      new(context).tap(&:rollback)
-    end
   end
 
-  module InstanceMethods
-    def initialize(context = {})
-      @context = Context.build(context)
-      setup
-    end
+  def initialize(context = {})
+    @context = Context.build(context)
+    setup
+  end
 
-    def setup
-    end
+  def setup
+  end
 
-    def perform
-    end
+  def perform
+  end
 
-    def rollback
-    end
+  def rollback
+  end
 
-    def success?
-      context.success?
-    end
+  def success?
+    context.success?
+  end
 
-    def failure?
-      context.failure?
-    end
+  def failure?
+    context.failure?
+  end
 
-    def fail!(*args)
-      context.fail!(*args)
-    end
+  def fail!(*args)
+    context.fail!(*args)
+  end
 
-    def method_missing(method, *)
-      context.fetch(method) { super }
-    end
+  def method_missing(method, *)
+    context.fetch(method) { super }
+  end
 
-    def respond_to_missing?(method, *)
-      context.key?(method) || super
-    end
+  def respond_to_missing?(method, *)
+    context.key?(method) || super
   end
 end

data/lib/interactor/organizer.rb

@@ -26,16 +26,14 @@ module Interactor
 
       def perform
         interactors.each do |interactor|
-          performed << interactor
-          interactor.perform(context)
-          rollback && break if context.failure?
+          instance = interactor.perform(context)
+          rollback && break if failure?
+          performed << instance
         end
       end
 
       def rollback
-        performed.reverse_each do |interactor|
-          interactor.rollback(context)
-        end
+        performed.reverse_each(&:rollback)
       end
 
       def performed

data/spec/interactor/organizer_spec.rb

@@ -4,11 +4,11 @@ module Interactor
   describe Organizer do
     include_examples :lint
 
-    let(:interactor) { Class.new.send(:include, Organizer) }
+    let(:organizer) { Class.new.send(:include, Organizer) }
 
     describe ".interactors" do
       it "is empty by default" do
-        expect(interactor.interactors).to eq([])
+        expect(organizer.interactors).to eq([])
       end
     end
 
@@ -18,27 +18,27 @@ module Interactor
 
       it "sets interactors given class arguments" do
         expect {
-          interactor.organize(interactor2, interactor3)
+          organizer.organize(interactor2, interactor3)
         }.to change {
-          interactor.interactors
+          organizer.interactors
         }.from([]).to([interactor2, interactor3])
       end
 
       it "sets interactors given an array of classes" do
         expect {
-          interactor.organize([interactor2, interactor3])
+          organizer.organize([interactor2, interactor3])
         }.to change {
-          interactor.interactors
+          organizer.interactors
         }.from([]).to([interactor2, interactor3])
       end
     end
 
     describe "#interactors" do
       let(:interactors) { double(:interactors) }
-      let(:instance) { interactor.new }
+      let(:instance) { organizer.new }
 
       before do
-        interactor.stub(:interactors) { interactors }
+        organizer.stub(:interactors) { interactors }
       end
 
       it "defers to the class" do
@@ -47,20 +47,23 @@ module Interactor
     end
 
     describe "#perform" do
+      let(:instance) { organizer.new }
+      let(:context) { instance.context }
       let(:interactor2) { double(:interactor2) }
       let(:interactor3) { double(:interactor3) }
       let(:interactor4) { double(:interactor4) }
-      let(:instance) { interactor.new }
-      let(:context) { instance.context }
+      let(:instance2) { double(:instance2) }
+      let(:instance3) { double(:instance3) }
+      let(:instance4) { double(:instance4) }
 
       before do
-        interactor.stub(:interactors) { [interactor2, interactor3, interactor4] }
+        organizer.stub(:interactors) { [interactor2, interactor3, interactor4] }
       end
 
       it "performs each interactor in order with the context" do
-        expect(interactor2).to receive(:perform).once.with(context).ordered
-        expect(interactor3).to receive(:perform).once.with(context).ordered
-        expect(interactor4).to receive(:perform).once.with(context).ordered
+        expect(interactor2).to receive(:perform).once.with(context).ordered { instance2 }
+        expect(interactor3).to receive(:perform).once.with(context).ordered { instance3 }
+        expect(interactor4).to receive(:perform).once.with(context).ordered { instance4 }
 
         expect(instance).not_to receive(:rollback)
 
@@ -69,31 +72,34 @@ module Interactor
 
       it "builds up the performed interactors" do
         interactor2.stub(:perform) do
-          expect(instance.performed).to eq([interactor2])
+          expect(instance.performed).to eq([])
+          instance2
         end
 
         interactor3.stub(:perform) do
-          expect(instance.performed).to eq([interactor2, interactor3])
+          expect(instance.performed).to eq([instance2])
+          instance3
         end
 
         interactor4.stub(:perform) do
-          expect(instance.performed).to eq([interactor2, interactor3, interactor4])
+          expect(instance.performed).to eq([instance2, instance3])
+          instance4
         end
 
         expect {
           instance.perform
         }.to change {
           instance.performed
-        }.from([]).to([interactor2, interactor3, interactor4])
+        }.from([]).to([instance2, instance3, instance4])
       end
 
       it "aborts and rolls back on failure" do
-        expect(interactor2).to receive(:perform).once.with(context).ordered
+        expect(interactor2).to receive(:perform).once.with(context).ordered { instance2 }
         expect(interactor3).to receive(:perform).once.with(context).ordered { context.fail! }
         expect(interactor4).not_to receive(:perform)
 
         expect(instance).to receive(:rollback).once.ordered do
-          expect(instance.performed).to eq([interactor2, interactor3])
+          expect(instance.performed).to eq([instance2])
         end
 
         instance.perform
@@ -101,32 +107,91 @@ module Interactor
     end
 
     describe "#rollback" do
-      let(:interactor2) { double(:interactor2) }
-      let(:interactor3) { double(:interactor3) }
-      let(:interactor4) { double(:interactor4) }
-      let(:instance) { interactor.new }
-      let(:context) { instance.context }
+      let(:instance) { organizer.new }
+      let(:instance2) { double(:instance2) }
+      let(:instance3) { double(:instance3) }
 
       before do
-        interactor.stub(:interactors) { [interactor2, interactor3, interactor4] }
-        instance.stub(:performed) { [interactor2, interactor3] }
+        instance.stub(:performed) { [instance2, instance3] }
       end
 
       it "rolls back each performed interactor in reverse" do
-        expect(interactor4).not_to receive(:rollback)
-        expect(interactor3).to receive(:rollback).once.with(context).ordered
-        expect(interactor2).to receive(:rollback).once.with(context).ordered
+        expect(instance3).to receive(:rollback).once.ordered
+        expect(instance2).to receive(:rollback).once.ordered
 
         instance.rollback
       end
     end
 
     describe "#performed" do
-      let(:instance) { interactor.new }
+      let(:instance) { organizer.new }
 
       it "is empty by default" do
         expect(instance.performed).to eq([])
       end
     end
+
+    # organizer
+    #  ├─ organizer2
+    #  │   ├─ interactor2a
+    #  │   ├─ interactor2b
+    #  │   └─ interactor2c
+    #  ├─ interactor3
+    #  ├─ organizer4
+    #  │   ├─ interactor4a
+    #  │   ├─ interactor4b
+    #  │   └─ interactor4c
+    #  └─ interactor5
+    #
+    context "organizers within organizers" do
+      let(:instance) { organizer.new }
+      let(:context) { instance.context }
+      let(:organizer2) { Class.new.send(:include, Organizer) }
+      let(:interactor2a) { double(:interactor2a) }
+      let(:interactor2b) { double(:interactor2b) }
+      let(:interactor2c) { double(:interactor2c) }
+      let(:interactor3) { double(:interactor3) }
+      let(:organizer4) { Class.new.send(:include, Organizer) }
+      let(:interactor4a) { double(:interactor4a) }
+      let(:interactor4b) { double(:interactor4b) }
+      let(:interactor4c) { double(:interactor4c) }
+      let(:interactor5) { double(:interactor5) }
+
+      let(:instance2a) { double(:instance2a) }
+      let(:instance2b) { double(:instance2b) }
+      let(:instance2c) { double(:instance2c) }
+      let(:instance3) { double(:instance3) }
+      let(:instance4a) { double(:instance4a) }
+      let(:instance4b) { double(:instance4b) }
+
+      before do
+        organizer.stub(:interactors) { [organizer2, interactor3, organizer4, interactor5] }
+        organizer2.stub(:interactors) { [interactor2a, interactor2b, interactor2c] }
+        organizer4.stub(:interactors) { [interactor4a, interactor4b, interactor4c] }
+      end
+
+      it "performs and rolls back properly" do
+        expect(interactor2a).to receive(:perform).once.with(context).ordered { instance2a }
+        expect(interactor2b).to receive(:perform).once.with(context).ordered { instance2b }
+        expect(interactor2c).to receive(:perform).once.with(context).ordered { instance2c }
+        expect(interactor3).to receive(:perform).once.with(context).ordered { instance3 }
+        expect(interactor4a).to receive(:perform).once.with(context).ordered { instance4a }
+        expect(interactor4b).to receive(:perform).once.with(context).ordered do
+          context.fail!
+          instance4b
+        end
+        expect(interactor4c).not_to receive(:perform)
+        expect(interactor5).not_to receive(:perform)
+
+        expect(instance4b).not_to receive(:rollback)
+        expect(instance4a).to receive(:rollback).once.with(no_args).ordered
+        expect(instance3).to receive(:rollback).once.with(no_args).ordered
+        expect(instance2c).to receive(:rollback).once.with(no_args).ordered
+        expect(instance2b).to receive(:rollback).once.with(no_args).ordered
+        expect(instance2a).to receive(:rollback).once.with(no_args).ordered
+
+        instance.perform
+      end
+    end
   end
 end

data/spec/support/lint.rb

@@ -19,24 +19,6 @@ shared_examples :lint do
     end
   end
 
-  describe ".rollback" do
-    let(:instance) { double(:instance) }
-
-    it "rolls back an instance with the given context" do
-      expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
-      expect(instance).to receive(:rollback).once.with(no_args)
-
-      expect(interactor.rollback(foo: "bar")).to eq(instance)
-    end
-
-    it "provides a blank context if none is given" do
-      expect(interactor).to receive(:new).once.with({}) { instance }
-      expect(instance).to receive(:rollback).once.with(no_args)
-
-      expect(interactor.rollback).to eq(instance)
-    end
-  end
-
   describe ".new" do
     let(:context) { double(:context) }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interactor
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Collective Idea
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-17 00:00:00.000000000 Z
+date: 2013-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler