aasm 4.11.1 → 5.2.0

data/lib/aasm/localizer.rb

@@ -5,7 +5,7 @@ module AASM
         list << :"#{i18n_scope(klass)}.events.#{i18n_klass(ancestor)}.#{event}"
         list
       end
-      translate_queue(checklist) || I18n.translate(checklist.shift, :default => event.to_s.humanize)
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => default_display_name(event))
     end
 
     def human_state_name(klass, state)
@@ -14,7 +14,7 @@ module AASM
         list << item_for(klass, state, ancestor, :old_style => true)
         list
       end
-      translate_queue(checklist) || I18n.translate(checklist.shift, :default => state.to_s.humanize)
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => default_display_name(state))
     end
 
   private
@@ -46,8 +46,18 @@ module AASM
     end
 
     def ancestors_list(klass)
+      has_active_record_base = defined?(::ActiveRecord::Base)
       klass.ancestors.select do |ancestor|
-        ancestor.respond_to?(:model_name) unless ancestor.name == 'ActiveRecord::Base'
+        not_active_record_base = has_active_record_base ? (ancestor != ::ActiveRecord::Base) : true
+        ancestor.respond_to?(:model_name) && not_active_record_base
+      end
+    end
+
+    def default_display_name(object) # Can use better arguement name
+      if object.respond_to?(:default_display_name)
+        object.default_display_name
+      else
+        object.to_s.gsub(/_/, ' ').capitalize
       end
     end
   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.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
 
@@ -39,14 +41,15 @@ module AASM
 
       module ClassMethods
         def aasm_create_scope(state_machine_name, scope_name)
-          conditions = {
-            table_name => { aasm(state_machine_name).attribute_name => scope_name.to_s }
-          }
           if ActiveRecord::VERSION::MAJOR >= 3
+            conditions = { aasm(state_machine_name).attribute_name => scope_name.to_s }
             class_eval do
-              scope scope_name, lambda { where(conditions) }
+              scope scope_name, lambda { where(table_name => conditions) }
             end
           else
+            conditions = {
+              table_name => { aasm(state_machine_name).attribute_name => scope_name.to_s }
+            }
             class_eval do
               named_scope scope_name, :conditions => conditions
             end
@@ -56,67 +59,59 @@ 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
+
+        def aasm_execute_after_commit
+          begin
+            require 'after_commit_everywhere'
+            raise LoadError unless Gem::Version.new(::AfterCommitEverywhere::VERSION) >= Gem::Version.new('0.1.5')
 
-          unless success
-            aasm_rollback(name, old_value)
-            raise ActiveRecord::RecordInvalid.new(self) if aasm_whiny_persistence(name)
+            self.extend ::AfterCommitEverywhere
+            after_commit do
+              yield
+            end
+          rescue LoadError
+            warn <<-MSG
+  [DEPRECATION] :after_commit AASM callback is not safe in terms of race conditions and redundant calls.
+                Please add `gem 'after_commit_everywhere', '~> 1.0'` to your Gemfile in order to fix that.
+            MSG
+            yield
           end
+        end
 
-          success
+        def aasm_raise_invalid_record
+          raise ActiveRecord::RecordInvalid.new(self)
         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_save
+          self.save
         end
 
-      private
+        def aasm_update_column(attribute_name, value)
+          self.class.unscoped.where(self.class.primary_key => self.id).update_all(attribute_name => value) == 1
+        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_read_attribute(name)
+          read_attribute(name)
         end
 
-        def aasm_rollback(name, old_value)
-          write_attribute(self.class.aasm(name).attribute_name, old_value)
-          false
+        def aasm_write_attribute(name, value)
+          write_attribute(name, value)
+        end
+
+        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 +126,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
 
@@ -176,47 +159,8 @@ module AASM
 
         def aasm_column_is_blank?(state_machine_name)
           attribute_name = self.class.aasm(state_machine_name).attribute_name
-          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
+          attribute_names.include?(attribute_name.to_s) &&
+            (send(attribute_name).respond_to?(:empty?) ? !!send(attribute_name).empty? : !send(attribute_name))
         end
 
         def aasm_validate_states

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 || state.empty?
+          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"
@@ -55,7 +59,9 @@ module AASM
     # make sure to create a (named) scope for each state
     def state_with_scope(*args)
       names = state_without_scope(*args)
-      names.each { |name| create_scope(name) if create_scope?(name) }
+      names.each do |name|
+        create_scopes(name)
+      end
     end
     alias_method :state_without_scope, :state
     alias_method :state, :state_with_scope
@@ -67,7 +73,16 @@ module AASM
     end
 
     def create_scope(name)
-      @klass.aasm_create_scope(@name, name)
+      @klass.aasm_create_scope(@name, name) if create_scope?(name)
+    end
+
+    def create_scopes(name)
+      if namespace?
+        # Create default scopes even when namespace? for backward compatibility
+        namepaced_name = "#{namespace}_#{name}"
+        create_scope(namepaced_name)
+      end
+      create_scope(name)
     end
   end # Base
 

data/lib/aasm/persistence/core_data_query_persistence.rb

@@ -77,7 +77,8 @@ module AASM
         #
         def aasm_ensure_initial_state
           AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
-            send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s) if send(self.class.aasm(state_machine_name).attribute_name).blank?
+            next if !send(self.class.aasm(state_machine_name).attribute_name) || send(self.class.aasm(state_machine_name).attribute_name).empty?
+            send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s)
           end
         end
       end # InstanceMethods

data/lib/aasm/persistence/dynamoid_persistence.rb

@@ -83,7 +83,7 @@ module AASM
         #
         def aasm_ensure_initial_state
           AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
-            aasm(state_machine_name).enter_initial_state if send(self.class.aasm(state_machine_name).attribute_name).blank?
+            aasm(state_machine_name).enter_initial_state if !send(self.class.aasm(state_machine_name).attribute_name) || send(self.class.aasm(state_machine_name).attribute_name).empty?
           end
         end
       end # InstanceMethods

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
@@ -112,7 +106,7 @@ module AASM
             # mongoid has_many relationship does not load child object attributes when
             # only ids are loaded, for example parent.child_ids will not load child object attributes.
             # This feature is introduced in mongoid > 4.
-            if attribute_names.include?(attribute_name) && attributes[attribute_name].blank?
+            if attribute_names.include?(attribute_name) && !attributes[attribute_name] || attributes[attribute_name].empty?
               # attribute_missing? is defined in mongoid > 4
               return if Mongoid::VERSION.to_f >= 4 && attribute_missing?(attribute_name)
               send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s)

data/lib/aasm/persistence/no_brainer_persistence.rb

@@ -0,0 +1,105 @@
+require 'aasm/persistence/orm'
+module AASM
+  module Persistence
+    module NoBrainerPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   before_validation :aasm_ensure_initial_state
+      #
+      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
+      #
+      #   class Foo
+      #     include NoBrainer::Document
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #     include AASM
+      #   end
+      #
+      #   class Foo
+      #     include NoBrainer::Document
+      #     include AASM
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #   end
+      #
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
+        base.send(:include, AASM::Persistence::NoBrainerPersistence::InstanceMethods)
+        base.extend AASM::Persistence::NoBrainerPersistence::ClassMethods
+
+        base.after_initialize :aasm_ensure_initial_state
+      end
+
+      module ClassMethods
+        def aasm_create_scope(state_machine_name, scope_name)
+          scope_options = lambda {
+            where(aasm(state_machine_name).attribute_name.to_sym => scope_name.to_s)
+          }
+          send(:scope, scope_name, scope_options)
+        end
+      end
+
+      module InstanceMethods
+
+        private
+
+        def aasm_save
+          self.save
+        end
+
+        def aasm_raise_invalid_record
+          raise NoBrainer::Error::DocumentInvalid.new(self)
+        end
+
+        def aasm_supports_transactions?
+          false
+        end
+
+        def aasm_update_column(attribute_name, value)
+          write_attribute(attribute_name, value)
+          save(validate: false)
+
+          true
+        end
+
+        def aasm_read_attribute(name)
+          read_attribute(name)
+        end
+
+        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
+        #
+        #   foo = Foo.new
+        #   foo.aasm_state # => nil
+        #   foo.valid?
+        #   foo.aasm_state # => "open" (where :open is the initial state)
+        #
+        #
+        #   foo = Foo.find(:first)
+        #   foo.aasm_state # => 1
+        #   foo.aasm_state = nil
+        #   foo.valid?
+        #   foo.aasm_state # => nil
+        #
+        def aasm_ensure_initial_state
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |name|
+            aasm_column = self.class.aasm(name).attribute_name
+            aasm(name).enter_initial_state if !read_attribute(aasm_column) || read_attribute(aasm_column).empty?
+          end
+        end
+      end # InstanceMethods
+    end
+  end # Persistence
+end # AASM