aasm 2.4.0 → 3.0.0

data/lib/aasm/supporting_classes/event.rb

@@ -0,0 +1,132 @@
+module AASM
+  module SupportingClasses
+    class Event
+      attr_reader :name, :success, :options
+
+      def initialize(name, options = {}, &block)
+        @name = name
+        @transitions = []
+        update(options, &block)
+      end
+
+      # a neutered version of fire - it doesn't actually fire the event, it just
+      # executes the transition guards to determine if a transition is even
+      # an option given current conditions.
+      def may_fire?(obj, to_state=nil)
+        transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
+        return false if transitions.size == 0
+    
+        result = false
+        transitions.each do |transition|
+          next if to_state and !Array(transition.to).include?(to_state)
+          if transition.perform(obj)
+            result = true
+            break
+          end
+        end
+        result
+      end
+  
+      def fire(obj, to_state=nil, *args)
+        transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
+        return nil 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, *args)
+            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.select { |t| t.from == state }
+      end
+
+      def all_transitions
+        @transitions
+      end
+
+      def fire_callbacks(action, record)
+        action = @options[action]
+        action.is_a?(Array) ?
+                action.each {|a| _fire_callbacks(a, record)} :
+                _fire_callbacks(action, record)
+      end
+
+      def ==(event)
+        if event.is_a? Symbol
+          name == event
+        else
+          name == event.name
+        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
+
+      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
+
+    private
+
+      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 _fire_callbacks(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
+  end # SupportingClasses
+end # AASM

data/lib/aasm/supporting_classes/localizer.rb

@@ -0,0 +1,40 @@
+module AASM
+  module SupportingClasses
+    class Localizer
+      def human_event_name(klass, event)
+        defaults = ancestors_list(klass).map do |ancestor|
+          :"#{i18n_scope(klass)}.events.#{i18n_klass(ancestor)}.#{event}"
+        end << event.to_s.humanize
+
+        I18n.translate(defaults.shift, :default => defaults, :raise => true)
+      end
+
+      def human_state(obj)
+        klass = obj.class
+        defaults = ancestors_list(klass).map do |ancestor|
+          :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm_column}.#{obj.aasm_current_state}"
+        end << obj.aasm_current_state.to_s.humanize
+
+        I18n.translate(defaults.shift, :default => defaults, :raise => true)
+      end
+
+      private
+
+      # added for rails 2.x compatibility
+      def i18n_scope(klass)
+        klass.respond_to?(:i18n_scope) ? klass.i18n_scope : :activerecord
+      end
+
+      # added for rails < 3.0.3 compatibility
+      def i18n_klass(klass)
+        klass.model_name.respond_to?(:i18n_key) ? klass.model_name.i18n_key : klass.name.underscore
+      end
+
+      def ancestors_list(klass)
+        klass.ancestors.select do |ancestor|
+          ancestor.respond_to?(:model_name) unless ancestor == ActiveRecord::Base
+        end
+      end
+    end
+  end # SupportingClasses
+end # AASM

data/lib/aasm/supporting_classes/state.rb

@@ -0,0 +1,57 @@
+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 fire_callbacks(action, record)
+        action = @options[action]
+        catch :halt_aasm_chain do
+          action.is_a?(Array) ?
+                  action.each {|a| _fire_callbacks(a, record)} :
+                  _fire_callbacks(action, record)
+        end
+      end
+
+      def display_name
+        @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
+      end
+
+      def for_select
+        [display_name, name.to_s]
+      end
+
+    private
+
+      def update(options = {})
+        if options.key?(:display) then
+          @display_name = options.delete(:display)
+        end
+        @options = options
+        self
+      end
+
+      def _fire_callbacks(action, record)
+        case action
+          when Symbol, String
+            record.send(action)
+          when Proc
+            action.call(record)
+        end
+      end
+
+    end
+  end # SupportingClasses
+end # AASM

data/lib/aasm/supporting_classes/state_transition.rb

@@ -0,0 +1,50 @@
+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, *args)
+        case @guard
+          when Symbol, String
+            obj.send(@guard, *args)
+          when Proc
+            @guard.call(obj, *args)
+          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 Proc
+          on_transition.arity == 0 ? on_transition.call : on_transition.call(obj, *args)
+        when Symbol, String
+          obj.send(:method, on_transition.to_sym).arity == 0 ? obj.send(on_transition) : obj.send(on_transition, *args)
+        end
+      end
+
+    end
+  end # SupportingClasses
+end # AASM

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "2.4.0"
+  VERSION = "3.0.0"
 end

data/spec/models/conversation.rb

@@ -1,33 +1,33 @@
 class Conversation
   include AASM
 
-  aasm_initial_state :needs_attention
+  aasm do
+    state :needs_attention, :initial => true
+    state :read
+    state :closed
+    state :awaiting_response
+    state :junk
 
-  aasm_state :needs_attention
-  aasm_state :read
-  aasm_state :closed
-  aasm_state :awaiting_response
-  aasm_state :junk
+    event :new_message do
+    end
 
-  aasm_event :new_message do
-  end
-
-  aasm_event :view do
-    transitions :to => :read, :from => [:needs_attention]
-  end
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
 
-  aasm_event :reply do
-  end
+    event :reply do
+    end
 
-  aasm_event :close do
-    transitions :to => :closed, :from => [:read, :awaiting_response]
-  end
+    event :close do
+      transitions :to => :closed, :from => [:read, :awaiting_response]
+    end
 
-  aasm_event :junk do
-    transitions :to => :junk, :from => [:read]
-  end
+    event :junk do
+      transitions :to => :junk, :from => [:read]
+    end
 
-  aasm_event :unjunk do
+    event :unjunk do
+    end
   end
 
   def initialize(persister)

data/spec/models/silencer.rb

@@ -0,0 +1,17 @@
+class Silencer
+  include AASM
+
+  aasm :whiny_transitions => false do
+    state :silent, :initial => true
+    state :crying
+    state :smiling
+
+    event :cry do
+      transitions :from => :silent, :to => :crying
+    end
+    event :smile do
+      transitions :from => :crying, :to => :smiling
+    end
+  end
+
+end

data/spec/spec_helpers/models_spec_helper.rb

@@ -2,16 +2,17 @@ Dir[File.dirname(__FILE__) + "/../models/*.rb"].each { |f| require File.expand_p
 
 class Foo
   include AASM
-  aasm_initial_state :open
-  aasm_state :open, :exit => :exit
-  aasm_state :closed, :enter => :enter
+  aasm do
+    state :open, :initial => true, :exit => :exit
+    state :closed, :enter => :enter
 
-  aasm_event :close, :success => :success_callback do
-    transitions :to => :closed, :from => [:open]
-  end
+    event :close, :success => :success_callback do
+      transitions :to => :closed, :from => [:open]
+    end
 
-  aasm_event :null do
-    transitions :to => :closed, :from => [:open], :guard => :always_false
+    event :null do
+      transitions :to => :closed, :from => [:open], :guard => :always_false
+    end
   end
 
   def always_false
@@ -29,17 +30,21 @@ end
 
 class FooTwo < Foo
   include AASM
-  aasm_state :foo
+  aasm do
+    state :foo
+  end
 end
 
 class Bar
   include AASM
 
-  aasm_state :read
-  aasm_state :ended
+  aasm do
+    state :read
+    state :ended
 
-  aasm_event :foo do
-    transitions :to => :ended, :from => [:read]
+    event :foo do
+      transitions :to => :ended, :from => [:read]
+    end
   end
 end
 
@@ -48,9 +53,11 @@ end
 
 class Banker
   include AASM
+  aasm do
+    state :retired
+    state :selling_bad_mortgages
+  end
   aasm_initial_state  Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
-  aasm_state          :retired
-  aasm_state          :selling_bad_mortgages
   RICH = 1_000_000
   attr_accessor :balance
   def initialize(balance = 0); self.balance = balance; end
@@ -59,12 +66,13 @@ end
 
 class Argument
   include AASM
-  aasm_initial_state :invalid
-  aasm_state :invalid
-  aasm_state :valid
+  aasm do
+    state :invalid, :initial => true
+    state :valid
 
-  aasm_event :valid do
-    transitions :to => :valid, :from => [:invalid]
+    event :valid do
+      transitions :to => :valid, :from => [:invalid]
+    end
   end
 end
 
@@ -73,39 +81,39 @@ class AuthMachine
 
   attr_accessor :activation_code, :activated_at, :deleted_at
 
-  aasm_initial_state :pending
-
-  aasm_state :passive
-  aasm_state :pending, :enter => :make_activation_code
-  aasm_state :active,  :enter => :do_activate
-  aasm_state :suspended
-  aasm_state :deleted, :enter => :do_delete, :exit => :do_undelete
-
-  aasm_event :register do
-    transitions :from => :passive, :to => :pending, :guard => Proc.new {|u| u.can_register? }
-  end
-
-  aasm_event :activate do
-    transitions :from => :pending, :to => :active
-  end
-
-  aasm_event :suspend do
-    transitions :from => [:passive, :pending, :active], :to => :suspended
-  end
-
-  aasm_event :delete do
-    transitions :from => [:passive, :pending, :active, :suspended], :to => :deleted
-  end
-
-  # a dummy event that can never happen
-  aasm_event :unpassify do
-    transitions :from => :passive, :to => :active, :guard => Proc.new {|u| false }
-  end
+  aasm do
+    state :passive
+    state :pending, :initial => true, :enter => :make_activation_code
+    state :active,  :enter => :do_activate
+    state :suspended
+    state :deleted, :enter => :do_delete, :exit => :do_undelete
+
+    event :register do
+      transitions :from => :passive, :to => :pending, :guard => Proc.new {|u| u.can_register? }
+    end
+
+    event :activate do
+      transitions :from => :pending, :to => :active
+    end
+
+    event :suspend do
+      transitions :from => [:passive, :pending, :active], :to => :suspended
+    end
+
+    event :delete do
+      transitions :from => [:passive, :pending, :active, :suspended], :to => :deleted
+    end
+
+    # a dummy event that can never happen
+    event :unpassify do
+      transitions :from => :passive, :to => :active, :guard => Proc.new {|u| false }
+    end
   
-  aasm_event :unsuspend do
-    transitions :from => :suspended, :to => :active,  :guard => Proc.new {|u| u.has_activated? }
-    transitions :from => :suspended, :to => :pending, :guard => Proc.new {|u| u.has_activation_code? }
-    transitions :from => :suspended, :to => :passive
+    event :unsuspend do
+      transitions :from => :suspended, :to => :active,  :guard => Proc.new {|u| u.has_activated? }
+      transitions :from => :suspended, :to => :pending, :guard => Proc.new {|u| u.has_activation_code? }
+      transitions :from => :suspended, :to => :passive
+    end
   end
 
   def initialize
@@ -147,30 +155,33 @@ end
 class ThisNameBetterNotBeInUse
   include AASM
 
-  aasm_state :initial
-  aasm_state :symbol
-  aasm_state :string
-  aasm_state :array
-  aasm_state :proc
+  aasm do
+    state :initial
+    state :symbol
+    state :string
+    state :array
+    state :proc
+  end
 end
 
 class ChetanPatil
   include AASM
-  aasm_initial_state :sleeping
-  aasm_state :sleeping
-  aasm_state :showering
-  aasm_state :working
-  aasm_state :dating
-  aasm_state :prettying_up
-
-  aasm_event :wakeup do
-    transitions :from => :sleeping, :to => [:showering, :working]
-  end
-
-  aasm_event :dress do
-    transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
-    transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
-    transitions :from => :showering, :to => :prettying_up, :on_transition => [:condition_hair, :fix_hair]
+  aasm do
+    state :sleeping, :initial => true
+    state :showering
+    state :working
+    state :dating
+    state :prettying_up
+
+    event :wakeup do
+      transitions :from => :sleeping, :to => [:showering, :working]
+    end
+
+    event :dress do
+      transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
+      transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
+      transitions :from => :showering, :to => :prettying_up, :on_transition => [:condition_hair, :fix_hair]
+    end
   end
 
   def wear_clothes(shirt_color, trouser_type)