aasm 2.1.3 → 2.1.4

data/.gitignore

@@ -1,4 +1,3 @@
-*.gemspec
 *.sw?
 *~
 .DS_Store

data/README.rdoc

@@ -54,7 +54,8 @@ The latest AASM can currently be pulled from the git repository on github.
 
 === Building your own gems
 
-  % rake gem
+  % rake gemspec
+  % rake build
   % sudo gem install pkg/aasm-2.1.gem
 
 
@@ -65,6 +66,8 @@ Here's a quick example highlighting some of the features.
   class Conversation
     include AASM
 
+    aasm_column :current_state # defaults to aasm_state
+
     aasm_initial_state :unread
 
     aasm_state :unread
@@ -87,6 +90,8 @@ This example uses a few of the more complex features available.
 
   class Relationship
     include AASM
+
+    aasm_column :status
     
     aasm_initial_state Proc.new { |relationship| relationship.strictly_for_fun? ? :intimate : :dating }
     

data/VERSION

@@ -1 +1 @@
-2.1.3
+2.1.4

data/lib/aasm.rb

@@ -1 +1,9 @@
+module AASM
+end
+
+require 'ostruct'
+
+require File.join(File.dirname(__FILE__), 'aasm', 'supporting_classes')
+require File.join(File.dirname(__FILE__), 'aasm', 'state_machine')
+require File.join(File.dirname(__FILE__), 'aasm', 'persistence')
 require File.join(File.dirname(__FILE__), 'aasm', 'aasm')

data/lib/aasm/aasm.rb

@@ -1,8 +1,3 @@
-require File.join(File.dirname(__FILE__), 'event')
-require File.join(File.dirname(__FILE__), 'state')
-require File.join(File.dirname(__FILE__), 'state_machine')
-require File.join(File.dirname(__FILE__), 'persistence')
-
 module AASM
   class InvalidTransition < RuntimeError
   end
@@ -146,50 +141,55 @@ module AASM
   end
 
   def aasm_fire_event(name, persist, *args)
-    old_state = aasm_state_object_for_state(aasm_current_state)
     event = self.class.aasm_events[name]
+    begin
+      old_state = aasm_state_object_for_state(aasm_current_state)
 
-    old_state.call_action(:exit, self)
 
-    # new event before callback
-    event.call_action(:before, self)
+      old_state.call_action(:exit, self)
 
-    new_state_name = event.fire(self, *args)
+      # new event before callback
+      event.call_action(:before, self)
 
-    unless new_state_name.nil?
-      new_state = aasm_state_object_for_state(new_state_name)
+      new_state_name = event.fire(self, *args)
 
-      # new before_ callbacks
-      old_state.call_action(:before_exit, self)
-      new_state.call_action(:before_enter, self)
+      unless new_state_name.nil?
+        new_state = aasm_state_object_for_state(new_state_name)
 
-      new_state.call_action(:enter, self)
+        # new before_ callbacks
+        old_state.call_action(:before_exit, self)
+        new_state.call_action(:before_enter, self)
 
-      persist_successful = true
-      if persist
-        persist_successful = set_aasm_current_state_with_persistence(new_state_name)
-        event.execute_success_callback(self) if persist_successful
-      else
-        self.aasm_current_state = new_state_name
-      end
+        new_state.call_action(:enter, self)
+
+        persist_successful = true
+        if persist
+          persist_successful = set_aasm_current_state_with_persistence(new_state_name)
+          event.execute_success_callback(self) if persist_successful
+        else
+          self.aasm_current_state = new_state_name
+        end
 
-      if persist_successful
-        old_state.call_action(:after_exit, self)
-        new_state.call_action(:after_enter, self)
-        event.call_action(:after, self)
+        if persist_successful
+          old_state.call_action(:after_exit, self)
+          new_state.call_action(:after_enter, self)
+          event.call_action(:after, self)
 
-        self.aasm_event_fired(name, old_state.name, self.aasm_current_state) if self.respond_to?(:aasm_event_fired)
+          self.aasm_event_fired(name, old_state.name, self.aasm_current_state) if self.respond_to?(:aasm_event_fired)
+        else
+          self.aasm_event_failed(name, old_state.name) if self.respond_to?(:aasm_event_failed)
+        end
+
+        persist_successful
       else
-        self.aasm_event_failed(name, old_state.name) if self.respond_to?(:aasm_event_failed)
-      end
+        if self.respond_to?(:aasm_event_failed)
+          self.aasm_event_failed(name, old_state.name)
+        end
 
-      persist_successful
-    else
-      if self.respond_to?(:aasm_event_failed)
-        self.aasm_event_failed(name, old_state.name)
+        false
       end
-
-      false
+    rescue StandardError => e
+      event.execute_error_callback(self, e)
     end
   end
 end

data/lib/aasm/event.rb

@@ -1,98 +1,109 @@
-require File.join(File.dirname(__FILE__), 'state_transition')
+class AASM::SupportingClasses::Event
+  attr_reader :name, :success, :options
 
-module AASM
-  module SupportingClasses
-    class Event
-      attr_reader :name, :success, :options
-
-      def initialize(name, options = {}, &block)
-        @name = name
-        @transitions = []
-        update(options, &block)
-      end
+  def initialize(name, options = {}, &block)
+    @name = name
+    @transitions = []
+    update(options, &block)
+  end
 
-      def fire(obj, to_state=nil, *args)
-        transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
-        raise AASM::InvalidTransition, "Event '#{name}' cannot transition from '#{obj.aasm_current_state}'" if transitions.size == 0
+  def fire(obj, to_state=nil, *args)
+    transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
+    raise AASM::InvalidTransition, "Event '#{name}' cannot transition from '#{obj.aasm_current_state}'" if transitions.size == 0
 
-        next_state = nil
-        transitions.each do |transition|
-          next if to_state and !Array(transition.to).include?(to_state)
-          if transition.perform(obj)
-            next_state = to_state || Array(transition.to).first
-            transition.execute(obj, *args)
-            break
-          end
-        end
-        next_state
+    next_state = nil
+    transitions.each do |transition|
+      next if to_state and !Array(transition.to).include?(to_state)
+      if transition.perform(obj)
+        next_state = to_state || Array(transition.to).first
+        transition.execute(obj, *args)
+        break
       end
+    end
+    next_state
+  end
 
-      def transitions_from_state?(state)
-        @transitions.any? { |t| t.from == state }
-      end
+  def transitions_from_state?(state)
+    @transitions.any? { |t| t.from == state }
+  end
 
-      def transitions_from_state(state)
-        @transitions.select { |t| t.from == state }
-      end
+  def transitions_from_state(state)
+    @transitions.select { |t| t.from == state }
+  end
 
-      def all_transitions
-        @transitions
-      end
+  def all_transitions
+    @transitions
+  end
 
-      def call_action(action, record)
-        action = @options[action]
-        action.is_a?(Array) ?
-                action.each {|a| _call_action(a, record)} :
-                _call_action(action, record)
-      end
+  def call_action(action, record)
+    action = @options[action]
+    action.is_a?(Array) ?
+            action.each {|a| _call_action(a, record)} :
+            _call_action(action, record)
+  end
 
-      def ==(event)
-        if event.is_a? Symbol
-          name == event
-        else
-          name == event.name
-        end
-      end
+  def ==(event)
+    if event.is_a? Symbol
+      name == event
+    else
+      name == event.name
+    end
+  end
 
-      def update(options = {}, &block)
-        if options.key?(:success) then
-          @success = options[:success]
-        end
-        if block then
-          instance_eval(&block)
-        end
-        @options = options
-        self
-      end
+  def update(options = {}, &block)
+    if options.key?(:success) then
+      @success = options[:success]
+    end
+    if options.key?(:error) then
+      @error = options[:error]
+    end
+    if block then
+      instance_eval(&block)
+    end
+    @options = options
+    self
+  end
 
-      def execute_success_callback(obj, success = nil)
-        callback = success || @success
-        case(callback)
-          when String, Symbol
-            obj.send(callback)
-          when Proc
-            callback.call(obj)
-          when Array
-            callback.each{|meth|self.execute_success_callback(obj, meth)}
-        end
-      end
+  def execute_success_callback(obj, success = nil)
+    callback = success || @success
+    case(callback)
+      when String, Symbol
+        obj.send(callback)
+      when Proc
+        callback.call(obj)
+      when Array
+        callback.each{|meth|self.execute_success_callback(obj, meth)}
+    end
+  end
 
-      private
+  def execute_error_callback(obj, error, error_callback=nil)
+    callback = error_callback || @error
+    raise error unless callback
+    case(callback)
+      when String, Symbol
+        raise NoMethodError unless obj.respond_to?(callback.to_sym)
+        obj.send(callback, error)
+      when Proc
+        callback.call(obj, error)
+      when Array
+        callback.each{|meth|self.execute_error_callback(obj, error, meth)}
+    end
+  end
 
-      def _call_action(action, record)
-        case action
-          when Symbol, String
-            record.send(action)
-          when Proc
-            action.call(record)
-        end
-      end
+  private
 
-      def transitions(trans_opts)
-        Array(trans_opts[:from]).each do |s|
-          @transitions << SupportingClasses::StateTransition.new(trans_opts.merge({:from => s.to_sym}))
-        end
-      end
+  def _call_action(action, record)
+    case action
+      when Symbol, String
+        record.send(action)
+      when Proc
+        action.call(record)
+    end
+  end
+
+  def transitions(trans_opts)
+    Array(trans_opts[:from]).each do |s|
+      @transitions << AASM::SupportingClasses::StateTransition.new(trans_opts.merge({:from => s.to_sym}))
     end
   end
 end

data/lib/aasm/persistence.rb

@@ -1,16 +1,14 @@
-module AASM
-  module Persistence
+module AASM::Persistence
 
-    # Checks to see this class or any of it's superclasses inherit from
-    # ActiveRecord::Base and if so includes ActiveRecordPersistence
-    def self.set_persistence(base)
-      # Use a fancier auto-loading thingy, perhaps.  When there are more persistence engines.
-      hierarchy = base.ancestors.map {|klass| klass.to_s}
+  # Checks to see this class or any of it's superclasses inherit from
+  # ActiveRecord::Base and if so includes ActiveRecordPersistence
+  def self.set_persistence(base)
+    # Use a fancier auto-loading thingy, perhaps.  When there are more persistence engines.
+    hierarchy = base.ancestors.map {|klass| klass.to_s}
 
-      if hierarchy.include?("ActiveRecord::Base")
-        require File.join(File.dirname(__FILE__), 'persistence', 'active_record_persistence')
-        base.send(:include, AASM::Persistence::ActiveRecordPersistence)
-      end
+    if hierarchy.include?("ActiveRecord::Base")
+      require File.join(File.dirname(__FILE__), 'persistence', 'active_record_persistence')
+      base.send(:include, AASM::Persistence::ActiveRecordPersistence)
     end
   end
 end

data/lib/aasm/state.rb

@@ -1,55 +1,53 @@
-module AASM
-  module SupportingClasses
-    class State
-      attr_reader :name, :options
-
-      def initialize(name, options={})
-        @name = name
-        update(options)
-      end
-
-      def ==(state)
-        if state.is_a? Symbol
-          name == state
-        else
-          name == state.name
-        end
-      end
-
-      def call_action(action, record)
-        action = @options[action]
-        action.is_a?(Array) ?
-                action.each {|a| _call_action(a, record)} :
-                _call_action(action, record)
-      end
-
-      def display_name
-        @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
-      end
-
-      def for_select
-        [display_name, name.to_s]
-      end
-
-      def update(options = {})
-        if options.key?(:display) then
-          @display_name = options.delete(:display)
-        end
-        @options = options
-        self
-      end
-
-      private
-
-      def _call_action(action, record)
-        case action
-          when Symbol, String
-            record.send(action)
-          when Proc
-            action.call(record)
-        end
-      end
+class AASM::SupportingClasses::State
+  attr_reader :name, :options
 
+  def initialize(name, options={})
+    @name = name
+    update(options)
+  end
+
+  def ==(state)
+    if state.is_a? Symbol
+      name == state
+    else
+      name == state.name
+    end
+  end
+
+  def call_action(action, record)
+    action = @options[action]
+    catch :halt_aasm_chain do
+      action.is_a?(Array) ?
+              action.each {|a| _call_action(a, record)} :
+              _call_action(action, record)
     end
   end
+
+  def display_name
+    @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
+  end
+
+  def for_select
+    [display_name, name.to_s]
+  end
+
+  def update(options = {})
+    if options.key?(:display) then
+      @display_name = options.delete(:display)
+    end
+    @options = options
+    self
+  end
+
+  private
+
+  def _call_action(action, record)
+    case action
+      when Symbol, String
+        record.send(action)
+      when Proc
+        action.call(record)
+    end
+  end
+
 end

data/lib/aasm/state_machine.rb

@@ -1,36 +1,32 @@
-require 'ostruct'
-
-module AASM
-  class StateMachine
-    def self.[](*args)
-      (@machines ||= {})[args]
-    end
+class AASM::StateMachine
+  def self.[](*args)
+    (@machines ||= {})[args]
+  end
 
-    def self.[]=(*args)
-      val = args.pop
-      (@machines ||= {})[args] = val
-    end
+  def self.[]=(*args)
+    val = args.pop
+    (@machines ||= {})[args] = val
+  end
 
-    attr_accessor :states, :events, :initial_state, :config
-    attr_reader :name
+  attr_accessor :states, :events, :initial_state, :config
+  attr_reader :name
 
-    def initialize(name)
-      @name = name
-      @initial_state = nil
-      @states = []
-      @events = {}
-      @config = OpenStruct.new
-    end
+  def initialize(name)
+    @name = name
+    @initial_state = nil
+    @states = []
+    @events = {}
+    @config = OpenStruct.new
+  end
 
-    def clone
-      klone = super
-      klone.states = states.clone
-      klone.events = events.clone
-      klone
-    end
+  def clone
+    klone = super
+    klone.states = states.clone
+    klone.events = events.clone
+    klone
+  end
 
-    def create_state(name, options)
-      @states << AASM::SupportingClasses::State.new(name, options) unless @states.include?(name)
-    end
+  def create_state(name, options)
+    @states << AASM::SupportingClasses::State.new(name, options) unless @states.include?(name)
   end
 end

data/lib/aasm/state_transition.rb

@@ -1,50 +1,46 @@
-module AASM
-  module SupportingClasses
-    class StateTransition
-      attr_reader :from, :to, :opts
-      alias_method :options, :opts
-
-      def initialize(opts)
-        @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
-        @opts = opts
-      end
-
-      def perform(obj)
-        case @guard
-          when Symbol, String
-            obj.send(@guard)
-          when Proc
-            @guard.call(obj)
-          else
-            true
-        end
-      end
-
-      def execute(obj, *args)
-        @on_transition.is_a?(Array) ?
-                @on_transition.each {|ot| _execute(obj, ot, *args)} :
-                _execute(obj, @on_transition, *args)
-      end
-
-      def ==(obj)
-        @from == obj.from && @to == obj.to
-      end
-
-      def from?(value)
-        @from == value
-      end
-
-      private
-
-      def _execute(obj, on_transition, *args)
-        case on_transition
-          when Symbol, String
-            obj.send(on_transition, *args)
-          when Proc
-            on_transition.call(obj, *args)
-        end
-      end
+class AASM::SupportingClasses::StateTransition
+  attr_reader :from, :to, :opts
+  alias_method :options, :opts
 
+  def initialize(opts)
+    @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
+    @opts = opts
+  end
+
+  def perform(obj)
+    case @guard
+      when Symbol, String
+        obj.send(@guard)
+      when Proc
+        @guard.call(obj)
+      else
+        true
     end
   end
+
+  def execute(obj, *args)
+    @on_transition.is_a?(Array) ?
+            @on_transition.each {|ot| _execute(obj, ot, *args)} :
+            _execute(obj, @on_transition, *args)
+  end
+
+  def ==(obj)
+    @from == obj.from && @to == obj.to
+  end
+
+  def from?(value)
+    @from == value
+  end
+
+  private
+
+  def _execute(obj, on_transition, *args)
+    case on_transition
+      when Symbol, String
+        obj.send(on_transition, *args)
+      when Proc
+        on_transition.call(obj, *args)
+    end
+  end
+
 end

data/lib/aasm/supporting_classes.rb

@@ -0,0 +1,6 @@
+module AASM::SupportingClasses
+end
+
+require File.join(File.dirname(__FILE__), 'state_transition')
+require File.join(File.dirname(__FILE__), 'event')
+require File.join(File.dirname(__FILE__), 'state')

data/spec/unit/aasm_spec.rb

@@ -92,7 +92,7 @@ describe AASM, '- subclassing' do
       FooTwo.aasm_states.should include(state)
     end
   end
-  
+
   it 'should not add the child states to the parent machine' do
     Foo.aasm_states.should_not include(:foo)
   end
@@ -270,6 +270,36 @@ describe AASM, '- getting events for a state' do
 end
 
 describe AASM, '- event callbacks' do
+  describe "with an error callback defined" do
+    before do
+      class Foo
+        aasm_event :safe_close, :success => :success_callback, :error => :error_callback do
+          transitions :to => :closed, :from => [:open]
+        end
+      end
+
+      @foo = Foo.new
+    end
+
+    it "should run error_callback if an exception is raised and error_callback defined" do
+      def @foo.error_callback(e)
+      end
+      @foo.stub!(:enter).and_raise(e=StandardError.new)
+      @foo.should_receive(:error_callback).with(e)
+      @foo.safe_close!
+    end
+
+    it "should raise NoMethodError if exceptionis raised and error_callback is declared but not defined" do
+      @foo.stub!(:enter).and_raise(StandardError)
+      lambda{@foo.safe_close!}.should raise_error(NoMethodError)
+    end
+    
+    it "should propagate an error if no error callback is declared" do
+        @foo.stub!(:enter).and_raise("Cannot enter safe")
+        lambda{@foo.close!}.should raise_error(StandardError, "Cannot enter safe")  
+    end
+  end
+
   describe "with aasm_event_fired defined" do
     before do
       @foo = Foo.new

data/spec/unit/state_spec.rb

@@ -63,6 +63,17 @@ describe AASM::SupportingClasses::State do
     state.call_action(:entering, record)
   end
 
+  it "should stop calling actions if one of them raises :halt_aasm_chain" do
+    state = new_state(:entering => [:a, :b, :c])
+
+    record = mock('record')
+    record.should_receive(:a)
+    record.should_receive(:b).and_throw(:halt_aasm_chain)
+    record.should_not_receive(:c)
+
+    state.call_action(:entering, record)
+  end
+
   it 'should call a proc, passing in the record for an action if the action is present' do
     state = new_state(:entering => Proc.new {|r| r.foobar})
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aasm
 version: !ruby/object:Gem::Version 
-  version: 2.1.3
+  version: 2.1.4
 platform: ruby
 authors: 
 - Scott Barron
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-23 00:00:00 -04:00
+date: 2010-01-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -68,6 +68,7 @@ files:
 - lib/aasm/state.rb
 - lib/aasm/state_machine.rb
 - lib/aasm/state_transition.rb
+- lib/aasm/supporting_classes.rb
 - spec/functional/conversation.rb
 - spec/functional/conversation_spec.rb
 - spec/spec_helper.rb