aasm 4.12.0 → 4.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fedd52d9c93d911e324c5c3594910d7fb7b33db2
-  data.tar.gz: a0334890f17ce24960567a8f95e0cafd03375a9f
+  metadata.gz: 51fca1a6911cbe2585301606192b2d0a467ae7e7
+  data.tar.gz: c4bdfee904a029cec8329eb024c608f225a3b746
 SHA512:
-  metadata.gz: 91bec3c1dfd3c450fb0565794026c0dcba137db1c42e5fb79a63544e4071c7ece69e36a2c42b9a5e45cf8790a1fca769c25ce6dc9f9050819a4c7dae7216bb5f
-  data.tar.gz: 20e8f730c627d53ad7558240d808c2ac42e0540b57e0e78814e560668e80af18c0c83014eefb3d335356dd8bb58ff27425f412f0a8054921171e206cff6a88cf
+  metadata.gz: 7ce9707a179a75f5e75c038ae8102956503564bca475151a6c64dfad9862b313382fc6b7f3ddc2c8e928dfbb666667b171be5abc7bf7d569e5e72cd4ee59467e
+  data.tar.gz: e2c030b9c239c3ced525745ed32f192712ed946fff5f5ed45c8c2710fe3da2aa8291f41faf351b9241c1eb7e6ecf4bb4ad72aace93aeb6f91e0b8af58d253f73

data/.travis.yml

@@ -22,10 +22,14 @@ gemfile:
 
 before_script:
   - mkdir /tmp/dynamodb
-  - wget -O - http://dynamodb-local.s3-website-us-west-2.amazonaws.com/dynamodb_local_latest.tar.gz | tar xz --directory /tmp/dynamodb
+  - wget -O - https://s3-ap-southeast-1.amazonaws.com/dynamodb-local-singapore/dynamodb_local_latest.tar.gz | tar xz --directory /tmp/dynamodb
   - java -Djava.library.path=/tmp/dynamodb/DynamoDBLocal_lib -jar /tmp/dynamodb/DynamoDBLocal.jar -inMemory -delayTransientStatuses -port 30180 &
   - mongod --version
 
+script:
+  - bundle exec rspec spec
+  - bundle exec rake test
+
 matrix:
   exclude:
     - rvm: 1.9.3

data/Appraisals

@@ -24,6 +24,7 @@ appraise 'rails_4.2' do
   gem 'sequel'
   gem 'dynamoid', '~> 1',                 :platforms => :ruby
   gem 'aws-sdk', '~>2',                   :platforms => :ruby
+  gem 'redis-objects'
 end
 
 appraise 'rails_4.2_mongoid_5' do
@@ -41,4 +42,5 @@ appraise 'rails_5.0' do
   # gem 'dynamoid', '~> 1',                 :platforms => :ruby
 
   gem 'aws-sdk', '~>2',                   :platforms => :ruby
+  gem 'redis-objects'
 end

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## unreleased
 
+## 4.12.1
+
+* DRY-up Mongoid and ActiveRecord Persistence, Add Sequel transactions and locking #475, thanks to [@Aryk] (https://github.com/Aryk)
+* Add aliases for event methods #476, thanks to [@Aryk] (https://github.com/Aryk)
+* Support Minitest spec expectations (#387), thanks to [@faragorn] (https://github.com/faragorn)
 ## 4.12.0
 
  * Fix thread safe issue with concurrent-ruby gem [see [pull-request #422](https://github.com/aasm/aasm/pull/442), thanks to [@reidmorrison](https://github.com/reidmorrison)

data/Gemfile

@@ -4,4 +4,4 @@ gemspec
 
 gem 'sqlite3',                          :platforms => :ruby
 gem 'activerecord-jdbcsqlite3-adapter', :platforms => :jruby
-gem 'rails', '5.0.0'
+gem 'rails', '5.0.2'

data/README.md

@@ -210,6 +210,14 @@ Note that when passing arguments to a state transition, the first argument must
 In case of an error during the event processing the error is rescued and passed to `:error`
 callback, which can handle it or re-raise it for further propagation.
 
+Also, you can define a method that will be called if any event fails:
+
+```
+def aasm_event_failed(event_name, old_state_name)
+  # use custom exception/messages, report metrics, etc
+end
+```
+
 During the transition's `:after` callback (and reliably only then, or in the global
 `after_all_transitions` callback) you can access the originating state (the from-state)
 and the target state (the to state), like this:
@@ -456,9 +464,6 @@ example.aasm(:work).current_state #=> :processing
 example.aasm(:question).current_state #=> :asked
 ```
 
-*Final note*: Support for multiple state machines per class is a pretty new feature
-(since version `4.3`), so please bear with us in case it doesn't work as expected.
-
 ### Auto-generated Status Constants
 
 AASM automatically [generates constants](https://github.com/aasm/aasm/pull/60)
@@ -715,8 +720,10 @@ end
 
 ### Redis
 
-AASM also supports persistence in Redis.
-Make sure to include Redis::Objects before you include AASM.
+AASM also supports persistence in Redis via
+[Redis::Objects](https://github.com/nateware/redis-objects).
+Make sure to include Redis::Objects before you include AASM. Note that non-bang
+events will work as bang events, persisting the changes on every call.
 
 ```ruby
 class User
@@ -896,6 +903,9 @@ class Job < ActiveRecord::Base
     ...
   end
 
+  aasm :another_state_machine, column: 'second_state' do
+    ...
+  end
 end
 ```
 
@@ -1006,8 +1016,6 @@ class Job
 end
 ```
 
-Be aware though, that this is not yet released. It will be part of _AASM_ version `4.11.0`.
-
 ### RubyMotion support
 
 Now supports [CodeDataQuery](https://github.com/infinitered/cdq.git) !
@@ -1022,7 +1030,9 @@ the 'instance method symbol / string' way whenever possible when defining guardi
 
 ### Testing
 
-AASM provides some matchers for [RSpec](http://rspec.info): `transition_from`, `have_state`, `allow_event` and `allow_transition_to`. Add `require 'aasm/rspec'` to your `spec_helper.rb` file and use them like this
+#### RSpec
+
+AASM provides some matchers for [RSpec](http://rspec.info): `transition_from`, `have_state`, `allow_event` and `allow_transition_to`. Add `require 'aasm/rspec'` to your `spec_helper.rb` file and use them like this:
 
 ```ruby
 # classes with only the default state machine
@@ -1058,6 +1068,90 @@ expect(multiple).to allow_transition_to(:processing).on(:move)
 expect(multiple).to_not allow_transition_to(:sleeping).on(:move)
 ```
 
+#### Minitest
+
+AASM provides assertions and rspec-like expectations for [Minitest](https://github.com/seattlerb/minitest).
+
+##### Assertions
+
+List of supported assertions: `assert_have_state`, `refute_have_state`, `assert_transitions_from`, `refute_transitions_from`, `assert_event_allowed`, `refute_event_allowed`, `assert_transition_to_allowed`, `refute_transition_to_allowed`.
+
+Add `require 'aasm/minitest' to your `test_helper.rb` file and use them like this:
+
+```ruby
+# classes with only the default state machine
+job = Job.new
+assert_transitions_from job, :sleeping, to: :running, on_event: :run
+refute_transitions_from job, :sleeping, to: :cleaning, on_event: :run
+assert_have_state job, :sleeping
+refute_have_state job, :running
+assert_event_allowed job, :run
+refute_event_allowed job, :clean
+assert_transition_to_allowed job, :running
+refute_transition_to_allowed job, :cleaning
+# on_event also accept arguments
+assert_transitions_from job, :sleeping, :defragmentation, to: :running, on_event: :run
+
+# classes with multiple state machine
+multiple = SimpleMultipleExample.new
+assert_transitions_from multiple, :standing, to: :walking, on_event: :walk, on: :move
+refute_transitions_from multiple, :standing, to: :running, on_event: :walk, on: :move
+assert_have_state multiple, :standing, on: :move
+refute_have_state multiple, :walking, on: :move
+assert_event_allowed multiple, :walk, on: :move
+refute_event_allowed multiple, :hold, on: :move
+assert_transition_to_allowed multiple, :walking, on: :move
+refute_transition_to_allowed multiple, :running, on: :move
+assert_transitions_from multiple, :sleeping, to: :processing, on_event: :start, on: :work
+refute_transitions_from multiple, :sleeping, to: :sleeping, on_event: :start, on: :work
+assert_have_state multiple, :sleeping, on: :work
+refute_have_state multiple, :processing, on: :work
+assert_event_allowed multiple, :start, on: :move
+refute_event_allowed multiple, :stop, on: :move
+assert_transition_to_allowed multiple, :processing, on: :move
+refute_transition_to_allowed multiple, :sleeping, on: :move
+```
+
+##### Expectations
+
+List of supported expectations: `must_transition_from`, `wont_transition_from`, `must_have_state`, `wont_have_state`, `must_allow_event`, `wont_allow_event`, `must_allow_transition_to`, `wont_allow_transition_to`.
+
+Add `require 'aasm/minitest_spec'` to your `test_helper.rb` file and use them like this:
+
+```ruby
+# classes with only the default state machine
+job = Job.new
+job.must_transition_from :sleeping, to: :running, on_event: :run
+job.wont_transition_from :sleeping, to: :cleaning, on_event: :run
+job.must_have_state :sleeping
+job.wont_have_state :running
+job.must_allow_event :run
+job.wont_allow_event :clean
+job.must_allow_transition_to :running
+job.wont_allow_transition_to :cleaning
+# on_event also accept arguments
+job.must_transition_from :sleeping, :defragmentation, to: :running, on_event: :run
+
+# classes with multiple state machine
+multiple = SimpleMultipleExample.new
+multiple.must_transition_from :standing, to: :walking, on_event: :walk, on: :move
+multiple.wont_transition_from :standing, to: :running, on_event: :walk, on: :move
+multiple.must_have_state :standing, on: :move
+multiple.wont_have_state :walking, on: :move
+multiple.must_allow_event :walk, on: :move
+multiple.wont_allow_event :hold, on: :move
+multiple.must_allow_transition_to :walking, on: :move
+multiple.wont_allow_transition_to :running, on: :move
+multiple.must_transition_from :sleeping, to: :processing, on_event: :start, on: :work
+multiple.wont_transition_from :sleeping, to: :sleeping, on_event: :start, on: :work
+multiple.must_have_state :sleeping, on: :work
+multiple.wont_have_state :processing, on: :work
+multiple.must_allow_event :start, on: :move
+multiple.wont_allow_event :stop, on: :move
+multiple.must_allow_transition_to :processing, on: :move
+multiple.wont_allow_transition_to :sleeping, on: :move
+```
+
 ## <a id="installation">Installation ##
 
 ### Manually from RubyGems.org ###

data/gemfiles/rails_4.2.gemfile

@@ -11,5 +11,6 @@ gem "mongoid", "~>4.0"
 gem "sequel"
 gem "dynamoid", "~> 1", :platforms => :ruby
 gem "aws-sdk", "~>2", :platforms => :ruby
+gem "redis-objects"
 
 gemspec :path => "../"

data/gemfiles/rails_5.0.gemfile

@@ -8,5 +8,6 @@ gem "rails", "5.0.0"
 gem "mongoid", "~>6.0"
 gem "sequel"
 gem "aws-sdk", "~>2", :platforms => :ruby
+gem "redis-objects"
 
 gemspec :path => "../"

data/lib/aasm/base.rb

@@ -130,6 +130,14 @@ module AASM
         aasm(aasm_name).current_event = event
         aasm_fire_event(aasm_name, event, {:persist => false}, *args, &block)
       end
+
+      # Create aliases for the event methods. Keep the old names to maintain backwards compatibility.
+      if namespace?
+        klass.send(:alias_method, "may_#{name}_#{namespace}?", "may_#{name}?")
+        klass.send(:alias_method, "#{name}_#{namespace}!", "#{name}!")
+        klass.send(:alias_method, "#{name}_#{namespace}", name)
+      end
+
     end
 
     def after_all_transitions(*callbacks, &block)

data/lib/aasm/core/event.rb

@@ -96,7 +96,7 @@ module AASM::Core
           @transitions << AASM::Core::Transition.new(self, attach_event_guards(definitions.merge(:from => s.to_sym)), &block)
         end
         # Create a transition if :to is specified without :from (transitions from ANY state)
-        if @transitions.empty? && definitions[:to]
+        if !definitions[:from] && definitions[:to]
           @transitions << AASM::Core::Transition.new(self, attach_event_guards(definitions), &block)
         end
       end

data/lib/aasm/core/transition.rb

@@ -69,7 +69,7 @@ module AASM::Core
 
       case code
       when Symbol, String
-        result = (record.__send__(:method, code.to_sym).arity == 0 ? record.__send__(code) : record.__send__(code, *args))
+        result = (record.__send__(:method, code.to_sym).arity != 0 ? record.__send__(code, *args) : record.__send__(code))
         failures << code unless result
         result
       when Proc

data/lib/aasm/instance_base.rb

@@ -14,7 +14,6 @@ module AASM
 
     def current_state=(state)
       @instance.aasm_write_state_without_persistence(state, @name)
-      # @current_state = state
     end
 
     def enter_initial_state
@@ -22,7 +21,6 @@ module AASM
       state_object = state_object_for_name(state_name)
 
       state_object.fire_callbacks(:before_enter, @instance)
-      # state_object.fire_callbacks(:enter, @instance)
       self.current_state = state_name
       state_object.fire_callbacks(:after_enter, @instance)
 

data/lib/aasm/minitest.rb

@@ -0,0 +1,5 @@
+Minitest = MiniTest unless defined? Minitest
+# relative-require all minitest_spec files
+Dir[File.dirname(__FILE__) + '/minitest/*.rb'].each do |file|
+  require 'aasm/minitest/' + File.basename(file, File.extname(file))
+end

data/lib/aasm/minitest/allow_event.rb

@@ -0,0 +1,13 @@
+module Minitest::Assertions
+  def assert_event_allowed(object, event, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    assert object.aasm(state_machine_name).may_fire_event?(event),
+          "Expected that the event :#{event} would be allowed (on :#{state_machine_name})"
+  end
+
+  def refute_event_allowed(object, event, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    refute object.aasm(state_machine_name).may_fire_event?(event),
+          "Expected that the event :#{event} would not be allowed (on :#{state_machine_name})"
+  end
+end

data/lib/aasm/minitest/allow_transition_to.rb

@@ -0,0 +1,13 @@
+module Minitest::Assertions
+  def assert_transition_to_allowed(object, to_state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    assert object.aasm(state_machine_name).states(permitted: true).include?(to_state),
+           "Expected that the state :#{to_state} would be reachable (on :#{state_machine_name})"
+  end
+
+  def refute_transition_to_allowed(object, to_state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    refute object.aasm(state_machine_name).states(permitted: true).include?(to_state),
+           "Expected that the state :#{to_state} would be reachable (on :#{state_machine_name})"
+  end
+end

data/lib/aasm/minitest/have_state.rb

@@ -0,0 +1,13 @@
+module Minitest::Assertions
+  def assert_have_state(object, state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    assert object.aasm(state_machine_name).current_state == state,
+         "Expected that :#{object.aasm(state_machine_name).current_state} would be :#{state} (on :#{state_machine_name})"
+  end
+
+  def refute_have_state(object, state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    refute object.aasm(state_machine_name).current_state == state,
+         "Expected that :#{object.aasm(state_machine_name).current_state} would be :#{state} (on :#{state_machine_name})"
+  end
+end

data/lib/aasm/minitest/transition_from.rb

@@ -0,0 +1,21 @@
+module Minitest::Assertions
+  def assert_transitions_from(object, from_state, *args)
+    options = args.first
+    options[:on] ||= :default
+    assert _transitions_from?(object, from_state, args, options),
+          "Expected transition state to :#{options[:to]} from :#{from_state} on event :#{options[:on_event]}, (on :#{options[:on]})"
+  end
+
+  def refute_transitions_from(object, from_state, *args)
+    options = args.first
+    options[:on] ||= :default
+    refute _transitions_from?(object, from_state, args, options),
+          "Expected transition state to :#{options[:to]} from :#{from_state} on event :#{options[:on_event]}, (on :#{options[:on]})"
+  end
+
+  def _transitions_from?(object, from_state, args, options)
+    state_machine_name = options[:on]
+    object.aasm(state_machine_name).current_state = from_state.to_sym
+    object.send(options[:on_event], *args) && options[:to].to_sym == object.aasm(state_machine_name).current_state
+  end
+end

data/lib/aasm/minitest_spec.rb

@@ -0,0 +1,15 @@
+require 'aasm/minitest'
+
+module Minitest::Expectations
+  AASM.infect_an_assertion :assert_transitions_from, :must_transition_from, :do_not_flip
+  AASM.infect_an_assertion :refute_transitions_from, :wont_transition_from, :do_not_flip
+
+  AASM.infect_an_assertion :assert_transition_to_allowed, :must_allow_transition_to, :do_not_flip
+  AASM.infect_an_assertion :refute_transition_to_allowed, :wont_allow_transition_to, :do_not_flip
+
+  AASM.infect_an_assertion :assert_have_state, :must_have_state, :do_not_flip
+  AASM.infect_an_assertion :refute_have_state, :wont_have_state, :do_not_flip
+
+  AASM.infect_an_assertion :assert_event_allowed, :must_allow_event, :do_not_flip
+  AASM.infect_an_assertion :refute_event_allowed, :wont_allow_event, :do_not_flip
+end

data/lib/aasm/persistence/active_record_persistence.rb

@@ -1,3 +1,4 @@
+require 'aasm/persistence/orm'
 module AASM
   module Persistence
     module ActiveRecordPersistence
@@ -28,6 +29,7 @@ module AASM
       #
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
         base.send(:include, AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
         base.extend AASM::Persistence::ActiveRecordPersistence::ClassMethods
 
@@ -56,67 +58,41 @@ module AASM
 
       module InstanceMethods
 
-        # Writes <tt>state</tt> to the state column and persists it to the database
-        #
-        #   foo = Foo.find(1)
-        #   foo.aasm.current_state # => :opened
-        #   foo.close!
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state(state, name=:default)
-          old_value = read_attribute(self.class.aasm(name).attribute_name)
-          aasm_write_attribute state, name
-
-          success = if aasm_skipping_validations(name)
-            value = aasm_raw_attribute_value(state, name)
-            aasm_update_column(name, value)
-          else
-            self.save
-          end
+        private
 
-          unless success
-            aasm_rollback(name, old_value)
-            raise ActiveRecord::RecordInvalid.new(self) if aasm_whiny_persistence(name)
-          end
+        def aasm_raise_invalid_record
+          raise ActiveRecord::RecordInvalid.new(self)
+        end
 
-          success
+        def aasm_save
+          self.save
         end
 
-        # Writes <tt>state</tt> to the state column, but does not persist it to the database
-        #
-        #   foo = Foo.find(1)
-        #   foo.aasm.current_state # => :opened
-        #   foo.close
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :opened
-        #   foo.save
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence(state, name=:default)
-          aasm_write_attribute(state, name)
+        def aasm_update_column(attribute_name, value)
+          self.class.unscoped.where(self.class.primary_key => self.id).update_all(attribute_name => value) == 1
         end
 
-      private
+        def aasm_read_attribute(name)
+          read_attribute(name)
+        end
 
-        def aasm_update_column(name, value)
-          self.class.unscoped.where(self.class.primary_key => self.id).update_all(self.class.aasm(name).attribute_name => value) == 1
+        def aasm_write_attribute(name, value)
+          write_attribute(name, value)
         end
 
-        def aasm_rollback(name, old_value)
-          write_attribute(self.class.aasm(name).attribute_name, old_value)
-          false
+        def aasm_transaction(requires_new, requires_lock)
+          self.class.transaction(:requires_new => requires_new) do
+            lock!(requires_lock) if requires_lock
+            yield
+          end
         end
 
         def aasm_enum(name=:default)
           case AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
-            when false then nil
-            when true then aasm_guess_enum_method(name)
-            when nil then aasm_guess_enum_method(name) if aasm_column_looks_like_enum(name)
-            else AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
+          when false then nil
+          when true then aasm_guess_enum_method(name)
+          when nil then aasm_guess_enum_method(name) if aasm_column_looks_like_enum(name)
+          else AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
           end
         end
 
@@ -131,23 +107,11 @@ module AASM
           self.class.aasm(name).attribute_name.to_s.pluralize.to_sym
         end
 
-        def aasm_skipping_validations(state_machine_name)
-          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
-        end
-
-        def aasm_whiny_persistence(state_machine_name)
-          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.whiny_persistence
-        end
-
-        def aasm_write_attribute(state, name=:default)
-          write_attribute(self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name))
-        end
-
         def aasm_raw_attribute_value(state, name=:default)
           if aasm_enum(name)
             self.class.send(aasm_enum(name))[state]
           else
-            state.to_s
+            super
           end
         end
 
@@ -179,46 +143,6 @@ module AASM
           attribute_names.include?(attribute_name.to_s) && send(attribute_name).blank?
         end
 
-        def aasm_fire_event(state_machine_name, name, options, *args, &block)
-          event = self.class.aasm(state_machine_name).state_machine.events[name]
-
-          if options[:persist]
-            event.fire_callbacks(:before_transaction, self, *args)
-            event.fire_global_callbacks(:before_all_transactions, self, *args)
-          end
-
-          begin
-            success = if options[:persist]
-              self.class.transaction(:requires_new => requires_new?(state_machine_name)) do
-                lock!(requires_lock?(state_machine_name)) if requires_lock?(state_machine_name)
-                super
-              end
-            else
-              super
-            end
-
-            if options[:persist] && success
-              event.fire_callbacks(:after_commit, self, *args)
-              event.fire_global_callbacks(:after_all_commits, self, *args)
-            end
-          ensure
-            if options[:persist]
-              event.fire_callbacks(:after_transaction, self, *args)
-              event.fire_global_callbacks(:after_all_transactions, self, *args)
-            end
-          end
-
-          success
-        end
-
-        def requires_new?(state_machine_name)
-          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_new_transaction
-        end
-
-        def requires_lock?(state_machine_name)
-          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_lock
-        end
-
         def aasm_validate_states
           AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
             unless aasm_skipping_validations(state_machine_name)