aasm 3.0.14 → 3.0.15

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 3.0.15
+
+ * added support for localized state names (on a class level, like Record.aasm.states.map(&:localized_name))
+
 ## 3.0.14
 
  * supporting event inspection for to-states transitions (`Event#transitions_to_state?`)

data/lib/aasm/aasm.rb

@@ -2,15 +2,14 @@ module AASM
 
   def self.included(base) #:nodoc:
     base.extend AASM::ClassMethods
-
-    unless AASM::StateMachine[base]
-      AASM::StateMachine[base] = AASM::StateMachine.new('')
-    end
+    AASM::StateMachine[base] ||= AASM::StateMachine.new('')
     AASM::Persistence.set_persistence(base)
     super
   end
 
   module ClassMethods
+
+    # make sure inheritance (aka subclassing) works with AASM
     def inherited(klass)
       AASM::StateMachine[klass] = AASM::StateMachine[self].clone
       super
@@ -18,13 +17,14 @@ module AASM
 
     def aasm(options={}, &block)
       @aasm ||= AASM::Base.new(self, options)
-      @aasm.instance_eval(&block) if block
+      @aasm.instance_eval(&block) if block # new DSL
       @aasm
     end
 
+    # TODO: maybe better: aasm.initial_state
     def aasm_initial_state(set_state=nil)
       if set_state
-        # deprecated
+        # deprecated way to set the value
         AASM::StateMachine[self].initial_state = set_state
       else
         AASM::StateMachine[self].initial_state
@@ -69,7 +69,8 @@ module AASM
       aasm.states_for_select
     end
 
-    def aasm_human_event_name(event)
+    # aasm.event(:event_name).human?
+    def aasm_human_event_name(event) # event_name?
       AASM::SupportingClasses::Localizer.new.human_event_name(self, event)
     end
   end # ClassMethods
@@ -110,7 +111,7 @@ module AASM
   end
 
   def aasm_human_state
-    AASM::SupportingClasses::Localizer.new.human_state(self)
+    AASM::SupportingClasses::Localizer.new.human_state_name(self.class, aasm_current_state)
   end
 
 private

data/lib/aasm/base.rb

@@ -1,5 +1,6 @@
 module AASM
   class Base
+
     def initialize(clazz, options={}, &block)
       @clazz = clazz
       sm = AASM::StateMachine[@clazz]
@@ -18,10 +19,14 @@ module AASM
       end
     end
 
+    def initial_state
+      AASM::StateMachine[@clazz].initial_state
+    end
+
     def state(name, options={})
       # @clazz.aasm_state(name, options)
       sm = AASM::StateMachine[@clazz]
-      sm.create_state(name, options)
+      sm.create_state(name, @clazz, options)
       sm.initial_state = name if options[:initial] || !sm.initial_state
 
       @clazz.send(:define_method, "#{name.to_s}?") do

data/lib/aasm/state_machine.rb

@@ -1,5 +1,7 @@
 module AASM
   class StateMachine
+
+    # the following two methods provide the storage of all state machines
     def self.[](clazz)
       (@machines ||= {})[clazz.to_s]
     end
@@ -11,6 +13,7 @@ module AASM
     attr_accessor :states, :events, :initial_state, :config
     attr_reader :name
 
+    # QUESTION: what's the name for? [alto, 2012-11-28]
     def initialize(name)
       @name = name
       @initial_state = nil
@@ -19,14 +22,16 @@ module AASM
       @config = OpenStruct.new
     end
 
+    # called internally by Ruby 1.9 after clone()
     def initialize_copy(orig)
       super
       @states = @states.dup
       @events = @events.dup
     end
 
-    def create_state(name, options)
-      @states << AASM::SupportingClasses::State.new(name, options) unless @states.include?(name)
+    def create_state(name, clazz, options)
+      @states << AASM::SupportingClasses::State.new(name, clazz, options) unless @states.include?(name)
     end
-  end
+
+  end # StateMachine
 end # AASM

data/lib/aasm/supporting_classes/localizer.rb

@@ -9,21 +9,20 @@ module AASM
         translate_queue(checklist) || I18n.translate(checklist.shift, :default => event.to_s.humanize)
       end
 
-      def human_state(obj)
-        klass = obj.class
+      def human_state_name(klass, state)
         checklist = ancestors_list(klass).inject([]) do |list, ancestor|
-          list << item_for(obj, klass, ancestor)
-          list << item_for(obj, klass, ancestor, :old_style => true)
+          list << item_for(klass, state, ancestor)
+          list << item_for(klass, state, ancestor, :old_style => true)
           list
         end
-        translate_queue(checklist) || I18n.translate(checklist.shift, :default => obj.aasm_current_state.to_s.humanize)
+        translate_queue(checklist) || I18n.translate(checklist.shift, :default => state.to_s.humanize)
       end
 
     private
 
-      def item_for(obj, klass, ancestor, options={})
+      def item_for(klass, state, ancestor, options={})
         separator = options[:old_style] ? '.' : '/'
-        :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm_column}#{separator}#{obj.aasm_current_state}"
+        :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm_column}#{separator}#{state}"
       end
 
       def translate_queue(checklist)

data/lib/aasm/supporting_classes/state.rb

@@ -3,8 +3,9 @@ module AASM
     class State
       attr_reader :name, :options
 
-      def initialize(name, options={})
+      def initialize(name, clazz, options={})
         @name = name
+        @clazz = clazz
         update(options)
       end
 
@@ -24,6 +25,10 @@ module AASM
         end
       end
 
+      def to_s
+        name.to_s
+      end
+
       def fire_callbacks(action, record)
         action = @options[action]
         catch :halt_aasm_chain do
@@ -34,7 +39,17 @@ module AASM
       end
 
       def display_name
-        @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
+        @display_name ||= begin
+          if Module.const_defined?(:I18n)
+            localized_name
+          else
+            name.to_s.gsub(/_/, ' ').capitalize
+          end
+        end
+      end
+
+      def localized_name
+        AASM::SupportingClasses::Localizer.new.human_state_name(@clazz, self)
       end
 
       def for_select

data/lib/aasm/version.rb

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

data/spec/en.yml

@@ -6,4 +6,4 @@ en:
 
     attributes:
       localizer_test_model:
-        aasm_state/open: "It's opened now!"
+        aasm_state/opened: "It's open now!"

data/spec/en_deprecated_style.yml

@@ -7,4 +7,4 @@ en:
     attributes:
       localizer_test_model:
         aasm_state:
-          open: "It's opened now!"
+          opened: "It's open now!"

data/spec/models/argument.rb

@@ -0,0 +1,11 @@
+class Argument
+  include AASM
+  aasm do
+    state :invalid, :initial => true
+    state :valid
+
+    event :valid do
+      transitions :to => :valid, :from => [:invalid]
+    end
+  end
+end

data/spec/models/callback_new_dsl.rb

@@ -6,10 +6,12 @@ class CallbackNewDsl
       :before_enter => :before_enter_open,
       :after_enter  => :after_enter_open,
       :before_exit  => :before_exit_open,
+      :exit         => :exit_open,
       :after_exit   => :after_exit_open
 
     state :closed,
       :before_enter => :before_enter_closed,
+      :enter        => :enter_closed,
       :after_enter  => :after_enter_closed,
       :before_exit  => :before_exit_closed,
       :after_exit   => :after_exit_closed
@@ -35,4 +37,7 @@ class CallbackNewDsl
 
   def before; end
   def after; end
+
+  def enter_closed; end
+  def exit_open; end
 end

data/spec/models/callback_old_dsl.rb

@@ -4,14 +4,16 @@ class CallbackOldDsl
   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
+    :after_enter  => :after_enter_open,
+    :before_exit  => :before_exit_open,
+    :exit         => :exit_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
+    :enter        => :enter_closed,
+    :after_enter  => :after_enter_closed,
+    :before_exit  => :before_exit_closed,
+    :after_exit   => :after_exit_closed
 
   aasm_event :close, :before => :before, :after => :after do
     transitions :to => :closed, :from => [:open]
@@ -33,4 +35,7 @@ class CallbackOldDsl
 
   def before; end
   def after; end
+
+  def enter_closed; end
+  def exit_open; end
 end

data/spec/models/parametrised_event.rb

@@ -0,0 +1,29 @@
+class ParametrisedEvent
+  include AASM
+  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)
+  end
+
+  def condition_hair
+  end
+
+  def fix_hair
+  end
+end

data/spec/spec_helpers/models_spec_helper.rb

@@ -51,31 +51,6 @@ end
 class Baz < Bar
 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 }
-  RICH = 1_000_000
-  attr_accessor :balance
-  def initialize(balance = 0); self.balance = balance; end
-  def rich?; self.balance >= RICH; end
-end
-
-class Argument
-  include AASM
-  aasm do
-    state :invalid, :initial => true
-    state :valid
-
-    event :valid do
-      transitions :to => :valid, :from => [:invalid]
-    end
-  end
-end
-
 class ThisNameBetterNotBeInUse
   include AASM
 
@@ -87,33 +62,3 @@ class ThisNameBetterNotBeInUse
     state :proc
   end
 end
-
-class ChetanPatil
-  include AASM
-  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)
-  end
-
-  def condition_hair
-  end
-
-  def fix_hair
-  end
-end

data/spec/unit/callbacks_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe 'callbacks for the old DSL' do
+  let(:callback) {CallbackOldDsl.new}
+
+  it "should get close callbacks" do
+    callback.should_receive(:exit_open).once.ordered
+    callback.should_receive(:before).once.ordered
+    callback.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    callback.should_receive(:before_enter_closed).once.ordered
+    callback.should_receive(:enter_closed).once.ordered
+    callback.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+    callback.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
+    callback.should_receive(:after_enter_closed).once.ordered
+    callback.should_receive(:after).once.ordered
+
+    callback.close!
+  end
+end
+
+describe 'callbacks for the new DSL' do
+  let(:callback) {CallbackNewDsl.new}
+
+  it "be called in order" do
+    callback.should_receive(:exit_open).once.ordered
+    callback.should_receive(:before).once.ordered
+    callback.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    callback.should_receive(:before_enter_closed).once.ordered
+    callback.should_receive(:enter_closed).once.ordered
+    callback.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+    callback.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
+    callback.should_receive(:after_enter_closed).once.ordered
+    callback.should_receive(:after).once.ordered
+
+    callback.close!
+  end
+end
+
+describe '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
+      def @foo.aasm_event_fired(event, from, to); end
+    end
+
+    it 'should call it for successful bang fire' do
+      @foo.should_receive(:aasm_event_fired).with(:close, :open, :closed)
+      @foo.close!
+    end
+
+    it 'should call it for successful non-bang fire' do
+      @foo.should_receive(:aasm_event_fired)
+      @foo.close
+    end
+
+    it 'should not call it for failing bang fire' do
+      @foo.stub!(:aasm_set_current_state_with_persistence).and_return(false)
+      @foo.should_not_receive(:aasm_event_fired)
+      @foo.close!
+    end
+  end
+
+  describe "with aasm_event_failed defined" do
+    before do
+      @foo = Foo.new
+      def @foo.aasm_event_failed(event, from); end
+    end
+
+    it 'should call it when transition failed for bang fire' do
+      @foo.should_receive(:aasm_event_failed).with(:null, :open)
+      lambda {@foo.null!}.should raise_error(AASM::InvalidTransition)
+    end
+
+    it 'should call it when transition failed for non-bang fire' do
+      @foo.should_receive(:aasm_event_failed).with(:null, :open)
+      lambda {@foo.null}.should raise_error(AASM::InvalidTransition)
+    end
+
+    it 'should not call it if persist fails for bang fire' do
+      @foo.stub!(:aasm_set_current_state_with_persistence).and_return(false)
+      @foo.should_receive(:aasm_event_failed)
+      @foo.close!
+    end
+  end
+end