aasm 4.11.1 → 4.12.1

data/gemfiles/rails_5.0.gemfile

@@ -1,21 +1,13 @@
+# This file was generated by Appraisal
+
 source "https://rubygems.org"
 
-gem "sqlite3",                          :platforms => :ruby
-gem 'rubysl',                           :platforms => :rbx
-gem 'rubinius-developer_tools',         :platforms => :rbx
-gem "jruby-openssl",                    :platforms => :jruby
+gem "sqlite3", :platforms => :ruby
 gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
-
-gem "rails", "5.0.0.beta4"
-
-# mongoid is not yet Rails 5 compatible
-# gem 'mongoid', '~>4.0' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
-
-gem 'sequel'
-
-# dynamoid is not yet Rails 5 compatible
-# gem 'dynamoid', '~> 1',                 :platforms => :ruby
-
-gem 'aws-sdk', '~>2',                   :platforms => :ruby
+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/aasm.rb

@@ -42,7 +42,7 @@ module AASM
 
       raise ArgumentError, "The class #{aasm_klass} must inherit from AASM::Base!" unless aasm_klass.ancestors.include?(AASM::Base)
 
-      @aasm ||= {}
+      @aasm ||= Concurrent::Map.new
       if @aasm[state_machine_name]
         # make sure to use provided options
         options.each do |key, value|
@@ -67,12 +67,12 @@ module AASM
     unless AASM::StateMachineStore.fetch(self.class, true).machine(name)
       raise AASM::UnknownStateMachineError.new("There is no state machine with the name '#{name}' defined in #{self.class.name}!")
     end
-    @aasm ||= {}
+    @aasm ||= Concurrent::Map.new
     @aasm[name.to_sym] ||= AASM::InstanceBase.new(self, name.to_sym)
   end
 
   def initialize_dup(other)
-    @aasm = {}
+    @aasm = Concurrent::Map.new
     super
   end
 
@@ -150,6 +150,7 @@ private
       persist_successful = aasm(state_machine_name).set_current_state_with_persistence(new_state_name)
       if persist_successful
         yield if block_given?
+        event.fire_callbacks(:before_success, self)
         event.fire_transition_callbacks(self, *process_args(event, old_state.name, *args))
         event.fire_callbacks(:success, self)
       end
@@ -158,6 +159,11 @@ private
       yield if block_given?
     end
 
+    binding_event = event.options[:binding_event]
+    if binding_event
+      __send__("#{binding_event}#{'!' if persist}")
+    end
+
     if persist_successful
       old_state.fire_callbacks(:after_exit, self,
         *process_args(event, aasm(state_machine_name).current_state, *args))

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)
@@ -208,7 +216,9 @@ module AASM
              klass.defined_enums.values.any?{ |methods|
                  methods.keys{| enum | enum + '?' == method_name }
              })
-         @state_machine.config.logger.warn "#{klass.name}: overriding method '#{method_name}'!"
+        unless AASM::Configuration.hide_warnings
+          @state_machine.config.logger.warn "#{klass.name}: overriding method '#{method_name}'!"
+        end
       end
 
       klass.send(:define_method, method_name, method_definition)

data/lib/aasm/configuration.rb

@@ -34,5 +34,9 @@ module AASM
 
     # Configure a logger, with default being a Logger to STDERR
     attr_accessor :logger
+
+    class << self
+      attr_accessor :hide_warnings
+    end
   end
 end

data/lib/aasm/core/event.rb

@@ -22,10 +22,21 @@ module AASM::Core
         :before_transaction,
         :ensure,
         :error,
+        :before_success,
         :success,
       ], &block) if block
     end
 
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @transitions = @transitions.collect { |transition| transition.clone }
+      @guards      = @guards.dup
+      @unless      = @unless.dup
+      @options     = {}
+      orig.options.each_pair { |name, setting| @options[name] = setting.is_a?(Hash) || setting.is_a?(Array) ? setting.dup : setting }
+    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.
@@ -85,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
@@ -122,16 +133,19 @@ module AASM::Core
           args.unshift(to_state)
           to_state = nil
         end
+      else
+        args.unshift(nil) if args.nil? || args.empty? # If single arg given which is nil, push it back to args
       end
 
       transitions.each do |transition|
         next if to_state and !Array(transition.to).include?(to_state)
-        if (options.key?(:may_fire) && Array(transition.to).include?(options[:may_fire])) ||
+        if (options.key?(:may_fire) && transition.eql?(options[:may_fire])) ||
            (!options.key?(:may_fire) && transition.allowed?(obj, *args))
-          result = to_state || Array(transition.to).first
+
           if options[:test_only]
-            # result = true
+            result = transition
           else
+            result = to_state || Array(transition.to).first
             Array(transition.to).each {|to| @valid_transitions[to] = transition }
             transition.execute(obj, *args)
           end

data/lib/aasm/core/state.rb

@@ -9,6 +9,13 @@ module AASM::Core
       update(options)
     end
 
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @options = {}
+      orig.options.each_pair { |name, setting| @options[name] = setting.is_a?(Hash) || setting.is_a?(Array) ? setting.dup : setting }
+    end
+
     def ==(state)
       if state.is_a? Symbol
         name == state

data/lib/aasm/core/transition.rb

@@ -28,6 +28,15 @@ module AASM::Core
       @opts = opts
     end
 
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @guards = @guards.dup
+      @unless = @unless.dup
+      @opts   = {}
+      orig.opts.each_pair { |name, setting| @opts[name] = setting.is_a?(Hash) || setting.is_a?(Array) ? setting.dup : setting }
+    end
+
     def allowed?(obj, *args)
       invoke_callbacks_compatible_with_guard(@guards, obj, args, :guard => true) &&
       invoke_callbacks_compatible_with_guard(@unless, obj, args, :unless => true)
@@ -60,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/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.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_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.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)

data/lib/aasm/persistence/base.rb

@@ -34,13 +34,17 @@ module AASM
       # This allows for nil aasm states - be sure to add validation to your model
       def aasm_read_state(name=:default)
         state = send(self.class.aasm(name).attribute_name)
-        if new_record?
-          state.blank? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : state.to_sym
+        if state.blank?
+          aasm_new_record? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : nil
         else
-          state.blank? ? nil : state.to_sym
+          state.to_sym
         end
       end
 
+      def aasm_new_record?
+        new_record?
+      end
+
       module ClassMethods
         def aasm_column(attribute_name=nil)
           warn "[DEPRECATION] aasm_column is deprecated. Use aasm.attribute_name instead"

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -1,3 +1,4 @@
+require 'aasm/persistence/orm'
 module AASM
   module Persistence
     module MongoidPersistence
@@ -30,6 +31,7 @@ module AASM
       #
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
         base.send(:include, AASM::Persistence::MongoidPersistence::InstanceMethods)
         base.extend AASM::Persistence::MongoidPersistence::ClassMethods
 
@@ -50,45 +52,37 @@ module AASM
 
       module InstanceMethods
 
-        # Writes <tt>state</tt> to the state column and persists it to the database
-        # using update_attribute (which bypasses validation)
-        #
-        #   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)
-          write_attribute(self.class.aasm(name).attribute_name, state.to_s)
+        private
+
+        def aasm_save
+          self.save
+        end
+
+        def aasm_raise_invalid_record
+          raise Mongoid::Errors::Validations.new(self)
+        end
 
-          unless self.save(:validate => false)
-            write_attribute(self.class.aasm(name).attribute_name, old_value)
-            return false
+        def aasm_supports_transactions?
+          false
+        end
+
+        def aasm_update_column(attribute_name, value)
+          if Mongoid::VERSION.to_f >= 4
+            set(Hash[attribute_name, value])
+          else
+            set(attribute_name, value)
           end
 
           true
         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)
-          write_attribute(self.class.aasm(name).attribute_name, state.to_s)
+        def aasm_read_attribute(name)
+          read_attribute(name)
         end
 
-      private
+        def aasm_write_attribute(name, value)
+          write_attribute(name, value)
+        end
 
         # Ensures that if the aasm_state column is nil and the record is new
         # that the initial state gets populated before validation on create