aasm 3.0.13 → 3.0.14

data/lib/aasm/persistence/base.rb

@@ -0,0 +1,46 @@
+module AASM
+  module Persistence
+    module Base
+
+      module ClassMethods
+        # Maps to the aasm_column in the database.  Defaults to "aasm_state".  You can write
+        # (example provided here for ActiveRecord, but it's true for Mongoid as well):
+        #
+        #   create_table :foos do |t|
+        #     t.string :name
+        #     t.string :aasm_state
+        #   end
+        #
+        #   class Foo < ActiveRecord::Base
+        #     include AASM
+        #   end
+        #
+        # OR:
+        #
+        #   create_table :foos do |t|
+        #     t.string :name
+        #     t.string :status
+        #   end
+        #
+        #   class Foo < ActiveRecord::Base
+        #     include AASM
+        #     aasm_column :status
+        #   end
+        #
+        # This method is both a getter and a setter
+        def aasm_column(column_name=nil)
+          if column_name
+            AASM::StateMachine[self].config.column = column_name.to_sym
+            # @aasm_column = column_name.to_sym
+          else
+            AASM::StateMachine[self].config.column ||= :aasm_state
+            # @aasm_column ||= :aasm_state
+          end
+          # @aasm_column
+          AASM::StateMachine[self].config.column
+        end
+      end
+
+    end # Base
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -34,15 +34,16 @@ module AASM
       #   end
       #
       def self.included(base)
+        base.extend AASM::Persistence::Base::ClassMethods
         base.extend AASM::Persistence::MongoidPersistence::ClassMethods
         base.send(:include, AASM::Persistence::MongoidPersistence::InstanceMethods)
-        base.send(:include, AASM::Persistence::MongoidPersistence::ReadState) unless base.method_defined?(:aasm_read_state)
+        base.send(:include, AASM::Persistence::ReadState) unless base.method_defined?(:aasm_read_state)
         base.send(:include, AASM::Persistence::MongoidPersistence::WriteState) unless base.method_defined?(:aasm_write_state)
         base.send(:include, AASM::Persistence::MongoidPersistence::WriteStateWithoutPersistence) unless base.method_defined?(:aasm_write_state_without_persistence)
 
         # if base.respond_to?(:named_scope)
         #   base.extend(AASM::Persistence::MongoidPersistence::NamedScopeMethods)
-        # 
+        #
         #   base.class_eval do
         #     class << self
         #       unless method_defined?(:aasm_state_without_named_scope)
@@ -59,60 +60,6 @@ module AASM
       end
 
       module ClassMethods
-        # Maps to the aasm_column in the database.  Deafults to "aasm_state".  You can write:
-        #
-        #   class Foo
-        #     include Mongoid::Document
-        #     include AASM
-        #     field :aasm_state
-        #   end
-        #
-        # OR:
-        #
-        #   class Foo
-        #     include Mongoid::Document
-        #     include AASM
-        #     field :status
-        #     aasm_column :status
-        #   end
-        #
-        # This method is both a getter and a setter
-        def aasm_column(column_name=nil)
-          if column_name
-            AASM::StateMachine[self].config.column = column_name.to_sym
-            # @aasm_column = column_name.to_sym
-          else
-            AASM::StateMachine[self].config.column ||= :aasm_state
-            # @aasm_column ||= :aasm_state
-          end
-          # @aasm_column
-          AASM::StateMachine[self].config.column
-        end
-
-        # def find_in_state(number, state, *args)
-        #   with_state_scope state do
-        #     find(number, *args)
-        #   end
-        # end
-        # 
-        # def count_in_state(state, *args)
-        #   with_state_scope state do
-        #     count(*args)
-        #   end
-        # end
-        # 
-        # def calculate_in_state(state, *args)
-        #   with_state_scope state do
-        #     calculate(*args)
-        #   end
-        # end
-
-        protected
-        def with_state_scope(state)
-          with_scope :find => {:conditions => ["#{table_name}.#{aasm_column} = ?", state.to_s]} do
-            yield if block_given?
-          end
-        end
       end
 
       module InstanceMethods
@@ -200,42 +147,6 @@ module AASM
         end
       end
 
-      module ReadState
-
-        # Returns the value of the aasm_column - called from <tt>aasm_current_state</tt>
-        #
-        # If it's a new record, and the aasm state column is blank it returns the initial state:
-        #
-        #   class Foo
-        #     include Mongoid::Document
-        #     include AASM
-        #     aasm_column :status
-        #     aasm_state :opened
-        #     aasm_state :closed
-        #   end
-        #
-        #   foo = Foo.new
-        #   foo.current_state # => :opened
-        #   foo.close
-        #   foo.current_state # => :closed
-        #
-        #   foo = Foo.find(1)
-        #   foo.current_state # => :opened
-        #   foo.aasm_state = nil
-        #   foo.current_state # => nil
-        #
-        # NOTE: intended to be called from an event
-        #
-        # This allows for nil aasm states - be sure to add validation to your model
-        def aasm_read_state
-          if new_record?
-            send(self.class.aasm_column).blank? ? aasm_determine_state_name(self.class.aasm_initial_state) : send(self.class.aasm_column).to_sym
-          else
-            send(self.class.aasm_column).nil? ? nil : send(self.class.aasm_column).to_sym
-          end
-        end
-      end
-
       module NamedScopeMethods
         def aasm_state_with_named_scope name, options = {}
           aasm_state_without_named_scope name, options

data/lib/aasm/persistence/read_state.rb

@@ -0,0 +1,40 @@
+module AASM
+  module Persistence
+    module ReadState
+
+      # Returns the value of the aasm_column - called from <tt>aasm_current_state</tt>
+      #
+      # If it's a new record, and the aasm state column is blank it returns the initial state
+      # (example provided here for ActiveRecord, but it's true for Mongoid as well):
+      #
+      #   class Foo < ActiveRecord::Base
+      #     include AASM
+      #     aasm_column :status
+      #     aasm_state :opened
+      #     aasm_state :closed
+      #   end
+      #
+      #   foo = Foo.new
+      #   foo.current_state # => :opened
+      #   foo.close
+      #   foo.current_state # => :closed
+      #
+      #   foo = Foo.find(1)
+      #   foo.current_state # => :opened
+      #   foo.aasm_state = nil
+      #   foo.current_state # => nil
+      #
+      # NOTE: intended to be called from an event
+      #
+      # This allows for nil aasm states - be sure to add validation to your model
+      def aasm_read_state
+        if new_record?
+          send(self.class.aasm_column).blank? ? aasm_determine_state_name(self.class.aasm_initial_state) : send(self.class.aasm_column).to_sym
+        else
+          send(self.class.aasm_column).nil? ? nil : send(self.class.aasm_column).to_sym
+        end
+      end
+
+    end # ReadState
+  end # Persistence
+end # AASM

data/lib/aasm/supporting_classes/event.rb

@@ -15,19 +15,23 @@ module AASM
       def may_fire?(obj, to_state=nil, *args)
         _fire(obj, true, to_state, *args) # true indicates test firing
       end
-  
+
       def fire(obj, to_state=nil, *args)
         _fire(obj, false, to_state, *args) # false indicates this is not a test (fire!)
       end
 
       def transitions_from_state?(state)
-        @transitions.any? { |t| t.from == state }
+        transitions_from_state(state).any?
       end
 
       def transitions_from_state(state)
         @transitions.select { |t| t.from == state }
       end
 
+      def transitions_to_state?(state)
+        transitions_to_state(state).any?
+      end
+
       def transitions_to_state(state)
         @transitions.select { |t| t.to == state }
       end

data/lib/aasm/supporting_classes/localizer.rb

@@ -6,23 +6,27 @@ module AASM
           list << :"#{i18n_scope(klass)}.events.#{i18n_klass(ancestor)}.#{event}"
           list
         end
-        (0...(checklist.size-1)).each do |i|
-          begin
-            return I18n.translate(checklist.shift, :raise => true)
-          rescue I18n::MissingTranslationData
-            # that's okay
-          end
-        end
-        I18n.translate(checklist.shift, :default => event.to_s.humanize)
+        translate_queue(checklist) || I18n.translate(checklist.shift, :default => event.to_s.humanize)
       end
 
       def human_state(obj)
         klass = obj.class
         checklist = ancestors_list(klass).inject([]) do |list, ancestor|
-          list << :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm_column}/#{obj.aasm_current_state}"
-          list << :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm_column}.#{obj.aasm_current_state}"
+          list << item_for(obj, klass, ancestor)
+          list << item_for(obj, klass, ancestor, :old_style => true)
           list
         end
+        translate_queue(checklist) || I18n.translate(checklist.shift, :default => obj.aasm_current_state.to_s.humanize)
+      end
+
+    private
+
+      def item_for(obj, klass, ancestor, options={})
+        separator = options[:old_style] ? '.' : '/'
+        :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm_column}#{separator}#{obj.aasm_current_state}"
+      end
+
+      def translate_queue(checklist)
         (0...(checklist.size-1)).each do |i|
           begin
             return I18n.translate(checklist.shift, :raise => true)
@@ -30,11 +34,9 @@ module AASM
             # that's okay
           end
         end
-        I18n.translate(checklist.shift, :default => obj.aasm_current_state.to_s.humanize)
+        nil
       end
 
-      private
-
       # added for rails 2.x compatibility
       def i18n_scope(klass)
         klass.respond_to?(:i18n_scope) ? klass.i18n_scope : :activerecord

data/lib/aasm/supporting_classes/state.rb

@@ -16,6 +16,14 @@ module AASM
         end
       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

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "3.0.13"
+  VERSION = "3.0.14"
 end

data/spec/models/auth_machine.rb

@@ -0,0 +1,84 @@
+class AuthMachine
+  include AASM
+
+  attr_accessor :activation_code, :activated_at, :deleted_at
+
+  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
+    state :waiting
+
+    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
+
+    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
+
+    event :wait do
+      transitions :from => :suspended, :to => :waiting, :guard => :if_polite?
+    end
+  end
+
+  def initialize
+    # the AR backend uses a before_validate_on_create :aasm_ensure_initial_state
+    # lets do something similar here for testing purposes.
+    aasm_enter_initial_state
+  end
+
+  def make_activation_code
+    @activation_code = 'moo'
+  end
+
+  def do_activate
+    @activated_at = Time.now
+    @activation_code = nil
+  end
+
+  def do_delete
+    @deleted_at = Time.now
+  end
+
+  def do_undelete
+    @deleted_at = false
+  end
+
+  def can_register?
+    true
+  end
+
+  def has_activated?
+    !!@activated_at
+  end
+
+  def has_activation_code?
+    !!@activation_code
+  end
+
+  def if_polite?(phrase = nil)
+    phrase == :please
+  end
+end

data/spec/models/callback_new_dsl.rb

@@ -0,0 +1,38 @@
+class CallbackNewDsl
+  include AASM
+
+  aasm do
+    state :open, :initial => true,
+      :before_enter => :before_enter_open,
+      :after_enter  => :after_enter_open,
+      :before_exit  => :before_exit_open,
+      :after_exit   => :after_exit_open
+
+    state :closed,
+      :before_enter => :before_enter_closed,
+      :after_enter  => :after_enter_closed,
+      :before_exit  => :before_exit_closed,
+      :after_exit   => :after_exit_closed
+
+    event :close, :before => :before, :after => :after do
+      transitions :to => :closed, :from => [:open]
+    end
+
+    event :open, :before => :before, :after => :after do
+      transitions :to => :open, :from => :closed
+    end
+  end
+
+  def before_enter_open; end
+  def before_exit_open; end
+  def after_enter_open; end
+  def after_exit_open; end
+
+  def before_enter_closed; end
+  def before_exit_closed; end
+  def after_enter_closed; end
+  def after_exit_closed; end
+
+  def before; end
+  def after; end
+end

data/spec/models/callback_old_dsl.rb

@@ -0,0 +1,36 @@
+class CallbackOldDsl
+  include AASM
+
+  aasm_initial_state :open
+  aasm_state :open,
+    :before_enter => :before_enter_open,
+    :before_exit => :before_exit_open,
+    :after_enter => :after_enter_open,
+    :after_exit => :after_exit_open
+  aasm_state :closed,
+    :before_enter => :before_enter_closed,
+    :before_exit => :before_exit_closed,
+    :after_enter => :after_enter_closed,
+    :after_exit => :after_exit_closed
+
+  aasm_event :close, :before => :before, :after => :after do
+    transitions :to => :closed, :from => [:open]
+  end
+
+  aasm_event :open, :before => :before, :after => :after do
+    transitions :to => :open, :from => :closed
+  end
+
+  def before_enter_open; end
+  def before_exit_open; end
+  def after_enter_open; end
+  def after_exit_open; end
+
+  def before_enter_closed; end
+  def before_exit_closed; end
+  def after_enter_closed; end
+  def after_exit_closed; end
+
+  def before; end
+  def after; end
+end