transfers responsibility of states to performances to keep actors lig…

…ht and fixes some other stuff in the process

lib/transactor/actor.rb

@@ -1,8 +1,6 @@
 module Transactor
   class Actor
-    attr_reader :props, :state, :error, :rollback_error
-
-    STATES = [:cast, :performing, :performed, :bombed, :rolling_back, :rolled_back, :rollback_bombed]
+    attr_reader :props
 
     class << self
       def configuration
@@ -34,28 +32,6 @@ def rollback_on_failure?
       configuration.rollback_on_failure
     end
 
-    def perform!(&block)
-      @state = :performing
-      result = perform(&block)
-      @state = :performed
-      result
-    rescue StandardError => e
-      @state = :bombed
-      @error = e
-      raise e
-    end
-
-    def rollback!(&block)
-      @state = :rolling_back
-      result = rollback(&block)
-      @state = :rolled_back
-      result
-    rescue StandardError => e
-      @state = :rollback_bombed
-      @rollback_error = e
-      raise e
-    end
-
     def perform(&block)
       raise PerformNotImplemented, "#{self.class.name}##{__method__} has not been implemented"
     end
@@ -65,13 +41,7 @@ def rollback(&block)
     end
 
     def to_s
-      "#{self.class.name} #{state} #{props.to_h}"
-    end
-
-    STATES.each do |state|
-      define_method "#{state}?" do
-        @state == state
-      end
+      "#{self.class.name} #{props.to_h}"
     end
 
     def method_missing(meth, *args, &block)
@@ -90,7 +60,6 @@ def respond_to_missing?(meth, include_private=false)
 
     def initialize(*args)
       @props = Props.new(args.extract_options!)
-      @state = :cast
     end
   end
 end

lib/transactor/improv/transaction.rb

@@ -6,12 +6,12 @@ class Transaction
       def perform
         @transaction.performances << @performance
         @transaction.transaction! do
-          performances.last.perform
+          performances.last.perform!
         end
       end
 
       def rollback(&block)
-        @performance.rollback(&block)
+        @performance.rollback!(&block)
         self
       end
 
@@ -29,7 +29,7 @@ def initialize(*args, &block)
         @transaction = Transactor::Transaction.new
         @performance = Improv::Performance.new(Improv::Actor, *args)
         @performance.actor.rollback_on_failure!
-        @performance.perform(&block)
+        @performance.perform!(&block)
       end
     end
   end

lib/transactor/performance.rb

@@ -1,40 +1,50 @@
 module Transactor
   class Performance
-    attr_reader :actor, :result
+    attr_reader :actor, :result, :state, :error, :rollback_error
+
+    STATES = [:cast, :performing, :performed, :bombed, :rolling_back, :rolled_back, :rollback_bombed]
 
     def self.perform(actor, *args, &block)
       new(actor, *args).perform(&block)
     end
 
     def perform(&block)
-      @result = actor.perform!(&block)
-      self
+      @result = actor.perform(&block)
     end
 
     def rollback(&block)
-      actor.rollback!(&block)
-      self
-    end
-
-    def state
-      actor.state
+      actor.rollback(&block)
     end
 
-    def to_s
-      actor.to_s
+    def perform!(&block)
+      @state = :performing
+      perform(&block)
+      @state = :performed
+      self
+    rescue StandardError => e
+      @state = :bombed
+      @error = e
+      raise e
     end
 
-    def error
-      actor.error
+    def rollback!(&block)
+      @state = :rolling_back
+      rollback(&block)
+      @state = :rolled_back
+      self
+    rescue StandardError => e
+      @state = :rollback_bombed
+      @rollback_error = e
+      raise e
     end
 
-    def rollback_error
-      actor.rollback_error
+    def to_s
+      "#{actor.to_s} #{state}"
     end
 
-    Actor::STATES.each do |state|
+    STATES.each do |state|
       define_method "#{state}?" do
-        actor.send "#{state}?"
+        @state == state
       end
     end
 
@@ -53,6 +63,7 @@ def initialize(actor, *args)
         end
       end
       @actor = actor.new(*args)
+      @state = :cast
     end
   end
 end

lib/transactor/stage.rb

@@ -6,7 +6,7 @@ def perform(actor, *args, &block)
       args = performance_props(*args)
       performance = Performance.new(actor, *args)
       performances << performance
-      performance.perform(&block)
+      performance.perform!(&block)
       performance.result
     rescue => e
       raise PerformanceBombed.new(e, performance)
@@ -17,7 +17,7 @@ def improvise(*args, &block)
       args = performance_props(*args)
       performance = Improv::Performance.new(Improv::Actor, *args)
       performances << performance
-      performance.perform(&block)
+      performance.perform!(&block)
       performance
     rescue PerformanceBombed => e
       raise e

lib/transactor/transaction.rb

@@ -48,7 +48,7 @@ def rollback
     def rollback_performances
       performances.reverse.each do |performance|
         begin
-          performance.rollback
+          performance.rollback!
         rescue RollbackNotImplemented => e
           # noop, rollback was not implemented
         rescue StandardError => e

spec/transactor/actor_spec.rb

@@ -53,7 +53,7 @@
 
   describe '#to_s' do
     it 'stringifies the class name, state and props' do
-      expect(subject.to_s).to eql("#{subject.class.name} #{subject.state} #{subject.props.to_h}")
+      expect(subject.to_s).to eql("#{subject.class.name} #{subject.props.to_h}")
     end
   end
 

spec/transactor/performance_spec.rb

@@ -24,21 +24,21 @@
   describe '#perform' do
     it "calls the actor's perform method" do
       subject.perform
-      expect(subject.actor.performed).to be_true
+      expect(subject.actor.instance_variable_get(:@performed)).to be_true
     end
   end
 
   describe '#rollback' do
     it "calls the actor's rollback method" do
       subject.perform
       subject.rollback
-      expect(subject.actor.performed).to be_false
+      expect(subject.actor.instance_variable_get(:@performed)).to be_false
     end
   end
 
   describe '#to_s' do
     it 'stringifies the actor' do
-      expect(subject.to_s).to eql(subject.actor.to_s)
+      expect(subject.to_s).to eql("#{subject.actor.to_s} #{subject.state}")
     end
   end
 end

spec/transactor/transaction_spec.rb

@@ -104,17 +104,17 @@
   describe '#bombed' do
     it 'returns an array of bombed or rolled back performances' do
       5.times { subject.stage.perform(TestActor) }
-      subject.performances[0].rollback
-      subject.performances[2].actor.instance_variable_set :@state, :bombed
+      subject.performances[0].rollback!
+      subject.performances[2].instance_variable_set :@state, :bombed
       expect(subject.bombed).to eql([subject.performances[0], subject.performances[2]])
     end
   end
 
   describe '#rolled_back' do
     it 'returns an array of rolled back performances' do
       5.times { subject.stage.perform(TestActor) }
-      subject.performances[0].rollback
-      subject.performances[2].rollback
+      subject.performances[0].rollback!
+      subject.performances[2].rollback!
       expect(subject.rolled_back).to eql([subject.performances[0], subject.performances[2]])
     end
   end
@@ -123,10 +123,10 @@
     it 'returns an array of bombed rollbacks' do
       5.times { subject.stage.perform(BlockActor) }
       begin
-      subject.performances[0].rollback { raise 'fail' }
+      subject.performances[0].rollback! { raise 'fail' }
       rescue; end
       begin
-      subject.performances[2].rollback { raise 'fail' }
+      subject.performances[2].rollback! { raise 'fail' }
       rescue; end
       expect(subject.bombed_rollbacks).to eql([subject.performances[0], subject.performances[2]])
     end