aasm 5.0.6 → 5.2.0

data/spec/en.yml

@@ -4,9 +4,6 @@ en:
       localizer_test_model:
         close: "Let's close it!"
 
-    attributes:
-      localizer_test_model:
-        aasm_state/opened: "It's open now!"
     errors:
       messages:
         record_invalid: "Invalid record"

data/spec/{en_deprecated_style.yml → localizer_test_model_deprecated_style.yml}

@@ -1,10 +1,13 @@
 en:
   activerecord:
-    events:
+    attributes:
       localizer_test_model:
-        close: "Let's close it!"
+        aasm_state:
+          opened: "It's open now!"
 
+fr:
+  activerecord:
     attributes:
       localizer_test_model:
         aasm_state:
-          opened: "It's open now!"
+          opened: "C'est ouvert maintenant!"

data/spec/localizer_test_model_new_style.yml

@@ -0,0 +1,11 @@
+en:
+  activerecord:
+    attributes:
+      localizer_test_model:
+        aasm_state/opened: "It's open now!"
+
+fr:
+  activerecord:
+    attributes:
+      localizer_test_model:
+        aasm_state/opened: "C'est ouvert maintenant!"

data/spec/models/active_record/active_record_callback.rb

@@ -0,0 +1,93 @@
+class ActiveRecordCallback < ActiveRecord::Base
+  include AASM
+
+  def reset_data
+    @data = []
+  end
+
+  def data
+    @data.join(' ')
+  end
+
+  aasm column: :status do
+    before_all_events       :before_all_events
+    after_all_events        :after_all_events
+    ensure_on_all_events    :ensure_on_all_events
+    after_all_transitions   :after_all_transitions
+
+    state :open, :initial => true,
+    :before_enter => :before_enter_open,
+    :enter        => :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,
+    :exit         => :exit_closed,
+    :after_exit   => :after_exit_closed
+
+    event :close,
+        :before => :before_event,
+        :after => :after_event,
+        :guard => :event_guard,
+        :before_success => :event_before_success,
+        :after_commit => :event_after_commit,
+        :ensure => :ensure_event do
+    transitions :to => :closed, :from => [:open],
+                :guard => :transition_guard,
+                :after => :after_transition,
+                :success => :success_transition
+    end
+
+    event :open, :before => :before_event, :after => :after_event  do
+    transitions :to => :open, :from => :closed
+    end
+  end
+
+  def log(text)
+    @data ||= []
+    @data << text
+    #puts text
+  end
+
+  def aasm_write_state(*args);  log('aasm_write_state'); true;  end
+  def before_enter_open;        log('before_enter_open');       end
+  def enter_open;               log('enter_open');              end
+  def before_exit_open;         log('before_exit_open');        end
+  def after_enter_open;         log('after_enter_open');        end
+  def exit_open;                log('exit_open');               end
+  def after_exit_open;          log('after_exit_open');         end
+
+  def before_enter_closed;      log('before_enter_closed'); end
+  def enter_closed;             log('enter_closed');        end
+  def before_exit_closed;       log('before_exit_closed');  end
+  def exit_closed;              log('exit_closed');         end
+  def after_enter_closed;       log('after_enter_closed');  end
+  def after_exit_closed;        log('after_exit_closed');   end
+
+  def event_guard;              log('event_guard');         !@fail_event_guard;      end
+  def transition_guard;         log('transition_guard');    !@fail_transition_guard; end
+
+  def event_before_success;     log('event_before_success'); end
+
+  def after_transition;         log('after_transition');        end
+  def after_all_transitions;    log('after_all_transitions');   end
+
+  def before_all_events;        log('before_all_events')    end
+  def before_event;             log('before_event');        end
+  def after_event;              log('after_event');         end
+  def after_all_events;         log('after_all_events');    end
+
+  def after_transition;         log('after_transition');    end
+  def success_transition;       log('transition_success');  end
+
+  def ensure_event;             log('ensure');              end
+  def ensure_on_all_events;     log('ensure');              end
+
+  def event_after_commit;       log('after_commit');        end 
+end

data/spec/models/active_record/localizer_test_model.rb

@@ -11,24 +11,32 @@ end
 
 describe 'localized state names' do
   before(:all) do
-    I18n.load_path << 'spec/en.yml'
-    I18n.default_locale = :en
+    I18n.load_path << 'spec/localizer_test_model_new_style.yml'
     I18n.reload!
   end
 
   after(:all) do
-    I18n.load_path.clear
+    I18n.load_path.delete('spec/localizer_test_model_new_style.yml')
+    I18n.backend.load_translations
   end
 
   it 'should localize' do
     state = LocalizerTestModel.aasm.states.detect {|s| s == :opened}
     expect(state.localized_name).to eq("It's open now!")
     expect(state.human_name).to eq("It's open now!")
+    expect(state.display_name).to eq("It's open now!")
+
+    I18n.with_locale(:fr) do
+      expect(state.localized_name).to eq("C'est ouvert maintenant!")
+      expect(state.human_name).to eq("C'est ouvert maintenant!")
+      expect(state.display_name).to eq("C'est ouvert maintenant!")
+    end
   end
 
   it 'should use fallback' do
     state = LocalizerTestModel.aasm.states.detect {|s| s == :closed}
     expect(state.localized_name).to eq('Closed')
     expect(state.human_name).to eq('Closed')
+    expect(state.display_name).to eq('Closed')
   end
 end

data/spec/models/active_record/namespaced.rb

@@ -0,0 +1,16 @@
+class MultipleNamespaced < ActiveRecord::Base
+  include AASM
+
+  aasm(:status, namespace: :car) do
+    state :unsold, initial: true
+    state :sold
+
+    event :sell do
+      transitions from: :unsold, to: :sold
+    end
+
+    event :return do
+      transitions from: :sold, to: :unsold
+    end
+  end
+end

data/spec/models/active_record/timestamp_example.rb

@@ -0,0 +1,16 @@
+class TimestampExample < ActiveRecord::Base
+  include AASM
+
+  aasm column: :aasm_state, timestamps: true do
+    state :opened
+    state :closed
+
+    event :open do
+      transitions to: :opened
+    end
+
+    event :close do
+      transitions to: :closed
+    end
+  end
+end

data/spec/models/default_state.rb

@@ -2,7 +2,7 @@ class DefaultState
   attr_accessor :transient_store, :persisted_store
   include AASM
   aasm do
-    state :alpha, :initial => true
+    state :alpha, :initial => true, display: 'ALPHA'
     state :beta
     state :gamma
     event :release do

data/spec/models/mongoid/timestamp_example_mongoid.rb

@@ -0,0 +1,20 @@
+class TimestampExampleMongoid
+  include Mongoid::Document
+  include AASM
+
+  field :status, type: String
+  field :opened_at, type: Time
+
+  aasm column: :status, timestamps: true do
+    state :opened
+    state :closed
+
+    event :open do
+      transitions to: :opened
+    end
+
+    event :close do
+      transitions to: :closed
+    end
+  end
+end

data/spec/models/simple_example.rb

@@ -3,11 +3,17 @@ class SimpleExample
   aasm do
     state :initialised, :initial => true
     state :filled_out
+    state :denied
     state :authorised
 
     event :fill_out do
       transitions :from => :initialised, :to => :filled_out
     end
+
+    event :deny do
+      transitions from: :initialised, to: :denied
+    end
+
     event :authorise do
       transitions :from => :filled_out, :to => :authorised
     end

data/spec/models/timestamps_example.rb

@@ -0,0 +1,19 @@
+class TimestampsExample
+  include AASM
+
+  attr_accessor :opened_at
+  attr_reader :closed_at
+
+  aasm timestamps: true do
+    state :opened
+    state :closed
+
+    event :open do
+      transitions to: :opened
+    end
+
+    event :close do
+      transitions to: :closed
+    end
+  end
+end

data/spec/models/timestamps_with_named_machine_example.rb

@@ -0,0 +1,13 @@
+class TimestampsWithNamedMachineExample
+  include AASM
+
+  attr_accessor :opened_at
+
+  aasm :my_state, timestamps: true do
+    state :opened
+
+    event :open do
+      transitions to: :opened
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib
 require 'aasm'
 require 'rspec'
 require 'aasm/rspec'
+require 'i18n'
 require 'pry'
 
 # require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
@@ -34,3 +35,7 @@ Dir[File.dirname(__FILE__) + "/spec_helpers/**/*.rb"].sort.each { |f| require Fi
 
 # example model classes
 Dir[File.dirname(__FILE__) + "/models/*.rb"].sort.each { |f| require File.expand_path(f) }
+
+I18n.load_path << 'spec/en.yml'
+I18n.enforce_available_locales = false
+I18n.default_locale = :en

data/spec/unit/api_spec.rb

@@ -13,6 +13,10 @@ if defined?(ActiveRecord)
       expect(DefaultState.new.aasm.current_state).to eql :alpha
     end
 
+    it "uses display option" do
+      expect(DefaultState.new.aasm.human_state).to eql "ALPHA"
+    end
+
     it "uses the provided method" do
       expect(ProvidedState.new.aasm.current_state).to eql :beta
     end

data/spec/unit/inspection_multiple_spec.rb

@@ -166,11 +166,15 @@ describe "special cases" do
 end
 
 describe 'aasm.states_for_select' do
-  it "should return a select friendly array of states" do
-    expect(FooMultiple.aasm(:left)).to respond_to(:states_for_select)
-    expect(FooMultiple.aasm(:left).states_for_select).to eq(
-      [['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']]
-    )
+  context 'without I18n' do
+    before { allow(Module).to receive(:const_defined?).with(:I18n).and_return(nil) }
+
+    it "should return a select friendly array of states" do
+      expect(FooMultiple.aasm(:left)).to respond_to(:states_for_select)
+      expect(FooMultiple.aasm(:left).states_for_select).to eq(
+        [['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']]
+      )
+    end
   end
 end
 

data/spec/unit/inspection_spec.rb

@@ -102,9 +102,13 @@ describe "special cases" do
 end
 
 describe 'aasm.states_for_select' do
-  it "should return a select friendly array of states" do
-    expect(Foo.aasm).to respond_to(:states_for_select)
-    expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']])
+  context 'without I18n' do
+    before { allow(Module).to receive(:const_defined?).with(:I18n).and_return(nil) }
+
+    it "should return a select friendly array of states" do
+      expect(Foo.aasm).to respond_to(:states_for_select)
+      expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']])
+    end
   end
 end
 

data/spec/unit/localizer_spec.rb

@@ -1,20 +1,18 @@
 require 'spec_helper'
 
-if defined?(ActiceRecord)
-  require 'i18n'
-
-  I18n.enforce_available_locales = false
+if defined?(ActiveRecord)
+  require 'models/active_record/localizer_test_model'
   load_schema
 
   describe AASM::Localizer, "new style" do
     before(:all) do
-      I18n.load_path << 'spec/en.yml'
-      I18n.default_locale = :en
+      I18n.load_path << 'spec/localizer_test_model_new_style.yml'
       I18n.reload!
     end
 
     after(:all) do
-      I18n.load_path.clear
+      I18n.load_path.delete('spec/localizer_test_model_new_style.yml')
+      I18n.backend.load_translations
     end
 
     let (:foo_opened) { LocalizerTestModel.new }
@@ -31,25 +29,42 @@ if defined?(ActiceRecord)
     end
 
     context 'aasm.human_event_name' do
-      it 'should return translated event name' do
-        expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+      context 'with event name' do
+        it 'should return translated event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+        end
       end
 
-      it 'should return humanized event name' do
-        expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+      context 'with event object' do
+        it 'should return translated event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :close }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :open }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Open")
+        end
       end
     end
   end
 
   describe AASM::Localizer, "deprecated style" do
     before(:all) do
-      I18n.load_path << 'spec/en_deprecated_style.yml'
-      I18n.default_locale = :en
+      I18n.load_path << 'spec/localizer_test_model_deprecated_style.yml'
       I18n.reload!
+      I18n.backend.load_translations
     end
 
     after(:all) do
-      I18n.load_path.clear
+      I18n.load_path.delete('spec/localizer_test_model_deprecated_style.yml')
+      I18n.backend.load_translations
     end
 
     let (:foo_opened) { LocalizerTestModel.new }
@@ -66,12 +81,28 @@ if defined?(ActiceRecord)
     end
 
     context 'aasm.human_event_name' do
-      it 'should return translated event name' do
-        expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+      context 'with event name' do
+        it 'should return translated event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+        end
       end
 
-      it 'should return humanized event name' do
-        expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+      context 'with event object' do
+        it 'should return translated event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :close }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :open }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Open")
+        end
       end
     end
   end