transactor 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8331830dc14c86bbbf9ad2b1b21aa98ad1d9a6a3
-  data.tar.gz: bb78c366ffec92d43ea435b8c9c779d664d184cf
+  metadata.gz: 2d8d6c6a970b35c85e5a2a609ac666587c91179c
+  data.tar.gz: 3065ef3b42767dff92f403034c3fa1b568e8cb86
 SHA512:
-  metadata.gz: 903cf6bf83f34408331ccd94a74a2c7770cb439d42513e8886eb6453ecfece184cf88f8007299425783dfcf466dd6f621c8afd86346cadb04ba45740c05a4601
-  data.tar.gz: 6caed1c9a9155186cc1081571a91fee562739451612cd191b1c0a447881e469b2a6f88b2211c737692e0c87d817d2fa65eed55bc03073b867a442414a06367a0
+  metadata.gz: 4dc2cde00f77e7742000a41d5f8b3487cde6fbfc039f554fc07abdb844a35a61d233d26b18d86c96cf5fd47703160ee10833599a5e6cf0332afb8b7d8f2c4c89
+  data.tar.gz: a739ebfc8a4751838aa3e31a04e5f28a66d4d92c614fe333dee4dabec830574e57283f8e992e8c618a0c0c9daca3e5de6c0e97f05f03e98a7fd954df9c183a74

data/lib/transactor/actor.rb

@@ -0,0 +1,66 @@
+module Transactor
+  class Actor
+    attr_reader :props
+
+    class << self
+      def perform(*args, &block)
+        new(*args).perform(&block)
+      end
+
+      def rollback_on_failure!
+        @rollback_on_failure = true
+      end
+
+      def rollback_on_failure?
+        return Transactor.configuration.rollback_failed_actors if @rollback_on_failure.nil?
+        @rollback_on_failure
+      end
+    end
+
+    def rollback_on_failure?
+      self.class.rollback_on_failure?
+    end
+
+    def perform(&block)
+      if block_given?
+        instance_eval &block
+      else
+        raise PerformNotImplemented, "#{self.class.name}##{__method__} has not been implemented"
+      end
+    end
+
+    def rollback(&block)
+      if block_given?
+        instance_eval &block
+      else
+        raise RollbackNotImplemented, "#{self.class.name}##{__method__} has not been implemented"
+      end
+    end
+
+    def state
+      props.to_h
+    end
+
+    def to_s
+      "#{self.class.name} #{state.to_s}"
+    end
+
+    def method_missing(meth, *args, &block)
+      if props.respond_to?(meth)
+        props.send meth, *args, &block
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, include_private=false)
+      props.respond_to?(meth, include_private)
+    end
+
+    protected
+
+    def initialize(*args)
+      @props = Props.new(args.extract_options!)
+    end
+  end
+end

data/lib/transactor/errors.rb

@@ -0,0 +1,30 @@
+module Transactor
+  class ActorInvalid < ArgumentError; end
+  class PerformNotImplemented < NotImplementedError; end
+  class RollbackNotImplemented < NotImplementedError; end
+
+  class PerformanceBombed < StandardError
+    attr_reader :performance
+
+    def initialize(e, performance=nil)
+      super("#{e.class.name}: #{e.message} #{performance.to_s}")
+      set_backtrace e.backtrace
+      @performance = performance
+    end
+  end
+
+  class RollbackBombed < PerformanceBombed; end
+
+  class TransactionError < StandardError
+    attr_reader :transaction
+
+    def initialize(e, transaction)
+      super("#{e.class.name}: #{e.message}")
+      set_backtrace e.backtrace
+      @transaction = transaction
+    end
+  end
+
+  class TransactionFailed < TransactionError; end
+  class RollbackFailed < TransactionError; end
+end

data/lib/transactor/improv.rb

@@ -0,0 +1,25 @@
+module Transactor
+  class Improv < Performance
+    def perform(&block)
+      if block_given?
+        super(&block)
+      else
+        super { nil }
+      end
+    end
+
+    def rollback(&block)
+      if block_given?
+        super(&block)
+      else
+        super { nil }
+      end
+    end
+
+    protected
+
+    def initialize(*args)
+      super(Actor, *args)
+    end
+  end
+end

data/lib/transactor/performance.rb

@@ -0,0 +1,85 @@
+module Transactor
+  class Performance
+    attr_reader :actor, :result
+
+    def self.perform(actor, *args, &block)
+      new(actor, *args).perform(&block)
+    end
+
+    def perform(&block)
+      @started = true
+      @result = actor.perform(&block)
+      @performed = true
+      self
+    end
+
+    def rollback(&block)
+      actor.rollback(&block)
+      @rolled_back = true
+      self
+    end
+
+    def started?
+      !!@started
+    end
+
+    def performed?
+      !!@performed
+    end
+
+    def rolled_back?
+      !!@rolled_back
+    end
+
+    def performing?
+      started? && !performed?
+    end
+
+    def successful?
+      performed? && !rolled_back?
+    end
+
+    def failed?
+      started? && rolled_back?
+    end
+
+    def rollback_on_failure?
+      actor.rollback_on_failure?
+    end
+
+    def state
+      if failed?
+        :failed
+      elsif successful?
+        :successful
+      elsif performing?
+        :performing
+      elsif !started?
+        :not_started
+      else
+        :unknown
+      end
+    end
+
+    def to_s
+      "#{actor.to_s} #{state}"
+    end
+
+    protected
+
+    def initialize(actor, *args)
+      actor = begin
+        if actor.is_a?(Array)
+          actor.map { |a| a.to_s.camelize }.join('::').constantize
+        elsif actor.is_a?(Symbol) || actor.is_a?(String)
+          actor.to_s.camelize.constantize
+        elsif actor.is_a?(Class) && actor <= Transactor::Actor
+          actor
+        else
+          raise ArgumentError, "An actor must be provided as a symbol, string, array or class (inherited from Transactor::Actor)"
+        end
+      end
+      @actor = actor.new(*args)
+    end
+  end
+end

data/lib/transactor/props.rb

@@ -0,0 +1,6 @@
+require 'ostruct'
+
+module Transactor
+  class Props < OpenStruct
+  end
+end

data/lib/transactor/transaction.rb

@@ -0,0 +1,105 @@
+module Transactor
+  class Transaction
+    attr_reader :performances, :result
+
+    def in_transaction(&block)
+      begin
+        @result = instance_eval &block if block_given?
+      rescue Exception => e # yes, we want to catch everything
+        begin
+          rollback
+        rescue Exception => e # yes, here too
+          raise RollbackFailed.new(e, self)
+        end
+
+        raise TransactionFailed.new(e, self)
+      end
+    end
+
+    def transaction!(&block)
+      if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:transaction)
+        ActiveRecord::Base.transaction { in_transaction &block }
+      else
+        in_transaction &block
+      end
+      self
+    end
+
+    def transaction(&block)
+      transaction!(&block)
+    rescue => e
+      false
+    end
+
+    def perform(actor, *args, &block)
+      performance = Performance.new(actor, *args)
+      performances << performance
+      performance.perform(&block)
+      performance.result
+    rescue => e
+      raise PerformanceBombed.new(e, performance)
+    end
+
+    def improvise(*args, &block)
+      performance = Improv.new(*args)
+      performances << performance
+      performance.perform(&block)
+      performance
+    rescue => e
+      raise PerformanceBombed.new(e, performance)
+    end
+
+    def rollback
+      return true if performances.empty?
+
+      if rollback_last_performance?
+        rollback_performances
+      else
+        bombed = performances.pop
+        rollback_performances
+        performances << bombed
+      end
+      
+      true
+    end
+
+    def rollback_performances
+      performances.reverse.each do |performance|
+        begin
+          performance.rollback
+        rescue RollbackNotImplemented => e
+          # noop, rollback was not implemented
+        rescue => e
+          # there was an error rolling back the performance
+          # do we halt the transaction rollback here? return the performances and allow manual rollbacks?
+          raise RollbackBombed.new(e, performance)
+        end
+      end
+    end
+
+    def last_performance
+      performances.last
+    end
+
+    def rollback_last_performance?
+      # only rollback the last performance if it didn't bomb OR if
+      # it did and is configured to rollback on failure
+      !last_performance.failed? || (last_performance.failed? && last_performance.rollback_on_failure?)
+    end
+
+    def method_missing(meth, *args, &block)
+      perform meth, *args, &block
+    end
+
+    def respond_to_missing?(meth, include_private=false)
+      true # *shrug* we try to perform just about anything
+    end
+
+    protected
+
+    def initialize(*args, &block)
+      @performances = []
+      transaction! &block if block_given?
+    end
+  end
+end

data/lib/transactor/version.rb

@@ -1,3 +1,3 @@
 module Transactor
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/transactor.rb

@@ -1,4 +1,23 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/output_safety'
+require 'canfig'
+require 'transactor/version'
+require 'transactor/errors'
+require 'transactor/props'
+require 'transactor/actor'
+require 'transactor/performance'
+require 'transactor/improv'
+require 'transactor/transaction'
+
 module Transactor
-end
+  include Canfig::Module
 
-require 'transactor/version'
+  configure do |config|
+    config.rollback_failed_actors = false
+  end
+
+  def self.transaction(&block)
+    Transactor::Transaction.new &block
+  end
+end

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ require 'rspec'
 require 'coveralls'
 Coveralls.wear!
 
-#Dir[File.join(File.dirname(__FILE__), '..', "spec/support/**/*.rb")].each { |f| require f }
+Dir[File.join(File.dirname(__FILE__), '..', "spec/support/**/*.rb")].each { |f| require f }
 
 RSpec.configure do |config|
   #config.before(:suite) do

data/spec/support/test_actors.rb

@@ -0,0 +1,23 @@
+class TestActor < Transactor::Actor
+  attr_reader :performed
+
+  def perform
+    @performed = true
+  end
+
+  def rollback
+    @performed = false
+  end
+end
+
+class FailingActor < Transactor::Actor
+  attr_reader :rolled_back
+
+  def perform
+    raise "FAIL"
+  end
+
+  def rollback
+    @rolled_back = true
+  end
+end

data/spec/transactor/actor_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+RSpec.describe Transactor::Actor do
+  subject { Transactor::Actor.new(test_one: 'one', test_two: 2) }
+
+  describe '#initialize' do
+    it 'converts options hash to a set of props' do
+      expect(subject.props).to respond_to(:test_one)
+      expect(subject.props.test_one).to eql('one')
+      expect(subject.props).to respond_to(:test_two)
+      expect(subject.props.test_two).to eql(2)
+    end
+
+    it 'provides attribute readers for options hash keys' do
+      expect(subject).to respond_to(:test_one)
+      expect(subject).to respond_to(:test_two)
+    end
+  end
+
+  describe '#perform' do
+    context 'when passed a block' do
+      it 'executes the block and returns the value' do
+        expect(subject.perform { 5+5 }).to eql(10)
+      end
+    end
+
+    context 'when not passed a block' do
+      it 'raises a PerformNotImplemented error' do
+        expect { subject.perform }.to raise_exception(Transactor::PerformNotImplemented)
+      end
+    end
+  end
+
+  describe '#rollback' do
+    context 'when passed a block' do
+      it 'executes the block and returns the value' do
+        expect(subject.rollback { 5+5 }).to eql(10)
+      end
+    end
+
+    context 'when not passed a block' do
+      it 'raises a PerformNotImplemented error' do
+        expect { subject.rollback }.to raise_exception(Transactor::RollbackNotImplemented)
+      end
+    end
+  end
+
+  describe '#state' do
+    it 'converts props into a hash' do
+      expect(subject.state).to eql({test_one: 'one', test_two: 2})
+    end
+  end
+
+  describe '#to_s' do
+    it 'stringifies the class name and state' do
+      expect(subject.to_s).to eql("#{subject.class.name} #{subject.state.to_s}")
+    end
+  end
+
+  describe '.rollback_on_failure!' do
+    before(:each) { Transactor::Actor.remove_instance_variable :@rollback_on_failure rescue nil }
+
+    it 'sets the class instance variable to true' do
+      Transactor::Actor.rollback_on_failure!
+      expect(Transactor::Actor.instance_variable_get(:@rollback_on_failure)).to be_true
+    end
+  end
+
+  describe '.rollback_on_failure?' do
+    before(:each) { Transactor::Actor.remove_instance_variable :@rollback_on_failure rescue nil }
+
+    context 'when the actor is configured to rollback on failure' do
+      it 'returns true'do
+        Transactor::Actor.rollback_on_failure!
+        expect(Transactor::Actor.rollback_on_failure?).to be_true
+      end
+    end
+
+    context 'when the actor is configured not to rollback on failure' do
+      it 'returns false' do
+        Transactor::Actor.rollback_on_failure!
+        expect(Transactor::Actor.rollback_on_failure?).to be_true
+      end
+    end
+
+    context 'when the actor is not configured' do
+      context 'when Transactor is configured to rollback failed actors' do
+        it 'returns true' do
+          Transactor.configure { |config| config.rollback_failed_actors = true }
+          expect(Transactor::Actor.rollback_on_failure?).to be_true
+        end
+      end
+
+      context 'when Transactor is configured not to rollback failed actors' do
+        it 'returns false' do
+          Transactor.configure { |config| config.rollback_failed_actors = false }
+          expect(Transactor::Actor.rollback_on_failure?).to be_false
+        end
+      end
+    end
+  end
+
+  describe '#rollback_on_failure?' do
+    before(:each) { Transactor::Actor.remove_instance_variable :@rollback_on_failure rescue nil }
+
+    context 'when the actor is configured to rollback on failure' do
+      it 'returns true'do
+        Transactor::Actor.rollback_on_failure!
+        expect(Transactor::Actor.new.rollback_on_failure?).to be_true
+      end
+    end
+
+    context 'when the actor is configured not to rollback on failure' do
+      it 'returns false' do
+        Transactor::Actor.rollback_on_failure!
+        expect(Transactor::Actor.new.rollback_on_failure?).to be_true
+      end
+    end
+
+    context 'when the actor is not configured' do
+      context 'when Transactor is configured to rollback failed actors' do
+        it 'returns true' do
+          Transactor.configure { |config| config.rollback_failed_actors = true }
+          expect(Transactor::Actor.new.rollback_on_failure?).to be_true
+        end
+      end
+
+      context 'when Transactor is configured not to rollback failed actors' do
+        it 'returns false' do
+          Transactor.configure { |config| config.rollback_failed_actors = false }
+          expect(Transactor::Actor.new.rollback_on_failure?).to be_false
+        end
+      end
+    end
+  end
+end

data/spec/transactor/improv_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Transactor::Improv do
+  describe '#initialize' do
+    it 'uses the default actor' do
+      expect(subject.actor).to be_an_instance_of(Transactor::Actor)
+    end
+  end
+end

data/spec/transactor/performance_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Transactor::Performance do
+  subject { Transactor::Performance.new(TestActor) }
+
+  describe '#initialize' do
+    it 'accepts a class constant as an actor' do
+      expect(Transactor::Performance.new(TestActor).actor).to be_an_instance_of(TestActor)
+    end
+
+    it 'accepts a symbol as an actor' do
+      expect(Transactor::Performance.new(:test_actor).actor).to be_an_instance_of(TestActor)
+    end
+
+    it 'accepts a string as an actor' do
+      expect(Transactor::Performance.new('test_actor').actor).to be_an_instance_of(TestActor)
+    end
+
+    it 'accepts an array as an actor' do
+      expect(Transactor::Performance.new([:transactor, :actor]).actor).to be_an_instance_of(Transactor::Actor)
+    end
+  end
+
+  describe '#perform' do
+    it "calls the actor's perform method" do
+      subject.perform
+      expect(subject.actor.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
+    end
+  end
+
+  describe '#to_s' do
+    it 'stringifies the actor and state' do
+      expect(subject.to_s).to eql("#{subject.actor.to_s} #{subject.state.to_s}")
+    end
+  end
+end

data/spec/transactor/transaction_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+RSpec.describe Transactor::Transaction do
+  describe '#transaction!' do
+    it 'returns self' do
+      expect(subject.transaction!).to eql(subject)
+    end
+
+    it 'accepts a block' do
+      expect(subject.transaction! { 5+5 }).to eql(subject)
+    end
+
+    it 'bubbles any raised exceptions' do
+      expect do
+        subject.transaction! do
+          raise "Transaction Error"
+        end
+      end.to raise_exception(Transactor::TransactionFailed)
+    end
+  end
+
+  describe '#transaction' do
+    it 'returns self' do
+      expect(subject.transaction).to eql(subject)
+    end
+
+    it 'accepts a block' do
+      expect(subject.transaction { 5+5 }).to eql(subject)
+    end
+
+    it 'rescues any raised exceptions' do
+      expect do
+        subject.transaction do
+          raise "Transaction Error"
+        end
+      end.to_not raise_exception
+    end
+  end
+
+  describe '#result' do
+    it 'returns the result of the block' do
+      subject.transaction! { 5+5 }
+      expect(subject.result).to eql(10)
+    end
+  end
+
+  describe '#perform' do
+    it 'adds a performance to the performances array' do
+      subject.perform(TestActor)
+      expect(subject.performances.length).to eql(1)
+    end
+
+    it 'casts the provided actor in the performance' do
+      subject.perform(TestActor)
+      expect(subject.performances.last.actor).to be_an_instance_of(TestActor)
+    end
+
+    it "triggers the actor's performance" do
+      subject.perform(TestActor)
+      expect(subject.performances.last.actor.performed).to be_true
+    end
+
+    it 'bubbles exceptions as PerformanceBombed errors' do
+      expect { subject.perform(FailingActor) }.to raise_exception(Transactor::PerformanceBombed)
+    end
+  end
+
+  describe '#improvise' do
+    it 'returns an improv performance' do
+      expect(subject.improvise).to be_an_instance_of(Transactor::Improv)
+    end
+
+    it 'adds a performance to the performances array' do
+      subject.improvise
+      expect(subject.performances.length).to eql(1)
+    end
+
+    it 'casts the default actor in the performance' do
+      subject.improvise
+      expect(subject.performances.last.actor).to be_an_instance_of(Transactor::Actor)
+    end
+
+    it 'executes the improv block' do
+      subject.improvise { 5+5 }
+      expect(subject.performances.last.result).to eql(10)
+    end
+
+    it 'bubbles exceptions as PerformanceBombed errors' do
+      expect do
+        subject.improvise do
+          raise "Bombing"
+        end
+      end.to raise_exception(Transactor::PerformanceBombed)
+    end
+  end
+
+  describe '#rollback' do
+    context 'when there are no failed performances' do
+      it 'rolls back all performances' do
+        3.times { subject.perform(TestActor) }
+        subject.performances.each do |performance|
+          expect(performance.actor.performed).to be_true
+        end
+        subject.rollback
+        subject.performances.each do |performance|
+          expect(performance.actor.performed).to be_false
+        end
+      end
+    end
+
+    context 'when the last performance failed' do
+      context 'and is configured to rollback on failure' do
+        it 'rolls back all performances' do
+          3.times { subject.perform(TestActor) }
+          subject.performances.each do |performance|
+            expect(performance.actor.performed).to be_true
+          end
+          
+          TestActor.instance_variable_set :@rollback_on_failure, true
+          subject.performances.last.instance_variable_set :@failed, true
+          subject.rollback
+          TestActor.instance_variable_set :@rollback_on_failure, false
+          
+          subject.performances.each do |performance|
+            expect(performance.actor.performed).to be_false
+          end
+        end
+      end
+
+      context 'and is configured not to rollback on failure' do
+        it 'rolls back all performances except the one that failed' do
+          TestActor.instance_variable_set :@rollback_on_failure, false
+          3.times { subject.perform(TestActor) }
+          subject.performances.each do |performance|
+            expect(performance.actor.performed).to be_true
+          end
+          subject.performances.last.instance_variable_set :@failed, true
+          subject.rollback
+          subject.performances.each do |performance|
+            expect(performance.actor.performed).to be_false
+          end
+        end
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    it 'translates method calls to actor performances' do
+      subject.transaction! do
+        test_actor
+      end
+      expect(subject.performances.last.actor).to be_an_instance_of(TestActor)
+    end
+  end
+end

data/spec/transactor_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Transactor do
+  describe '#transaction' do
+    it 'returns a Transactor::Transaction' do
+      expect(Transactor.transaction).to be_an_instance_of(Transactor::Transaction)
+    end
+  end
+
+  context 'configuration' do
+    describe 'rollback_failed_actors' do
+      it 'defaults to false' do
+        expect(Transactor.configuration.rollback_failed_actors).to be_false
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: transactor
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Mark Rebec
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-15 00:00:00.000000000 Z
+date: 2015-05-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: canfig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -46,8 +74,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/transactor.rb
+- lib/transactor/actor.rb
+- lib/transactor/errors.rb
+- lib/transactor/improv.rb
+- lib/transactor/performance.rb
+- lib/transactor/props.rb
+- lib/transactor/transaction.rb
 - lib/transactor/version.rb
 - spec/spec_helper.rb
+- spec/support/test_actors.rb
+- spec/transactor/actor_spec.rb
+- spec/transactor/improv_spec.rb
+- spec/transactor/performance_spec.rb
+- spec/transactor/transaction_spec.rb
+- spec/transactor_spec.rb
 homepage: http://github.com/markrebec/transactor
 licenses: []
 metadata: {}
@@ -73,3 +113,9 @@ specification_version: 4
 summary: Transactional actors for easy rollbacks
 test_files:
 - spec/spec_helper.rb
+- spec/support/test_actors.rb
+- spec/transactor/actor_spec.rb
+- spec/transactor/improv_spec.rb
+- spec/transactor/performance_spec.rb
+- spec/transactor/transaction_spec.rb
+- spec/transactor_spec.rb