aasm 2.1.1 → 5.2.0

data/lib/aasm/persistence/active_record_persistence.rb

@@ -1,3 +1,4 @@
+require 'aasm/persistence/orm'
 module AASM
   module Persistence
     module ActiveRecordPersistence
@@ -6,14 +7,9 @@ module AASM
       # * extends the model with ClassMethods
       # * includes InstanceMethods
       #
-      # Unless the corresponding methods are already defined, it includes
-      # * ReadState
-      # * WriteState
-      # * WriteStateWithoutPersistence
-      #
       # Adds
       #
-      #   before_validation_on_create :aasm_ensure_initial_state
+      #   after_initialize :aasm_ensure_initial_state
       #
       # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
       #
@@ -32,119 +28,116 @@ module AASM
       #   end
       #
       def self.included(base)
-        base.extend AASM::Persistence::ActiveRecordPersistence::ClassMethods
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
         base.send(:include, AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
-        base.send(:include, AASM::Persistence::ActiveRecordPersistence::ReadState) unless base.method_defined?(:aasm_read_state)
-        base.send(:include, AASM::Persistence::ActiveRecordPersistence::WriteState) unless base.method_defined?(:aasm_write_state)
-        base.send(:include, AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence) unless base.method_defined?(:aasm_write_state_without_persistence)
-
-        if base.respond_to?(:named_scope)
-          base.extend(AASM::Persistence::ActiveRecordPersistence::NamedScopeMethods)
-
-          base.class_eval do
-            class << self
-              unless method_defined?(:aasm_state_without_named_scope)
-                alias_method :aasm_state_without_named_scope, :aasm_state
-                alias_method :aasm_state, :aasm_state_with_named_scope
-              end
-            end
-          end
-        end
+        base.extend AASM::Persistence::ActiveRecordPersistence::ClassMethods
 
-        base.before_validation_on_create :aasm_ensure_initial_state
+        base.after_initialize :aasm_ensure_initial_state
+
+        # ensure state is in the list of states
+        base.validate :aasm_validate_states
       end
 
       module ClassMethods
-        # Maps to the aasm_column in the database.  Deafults to "aasm_state".  You can write:
-        #
-        #   create_table :foos do |t|
-        #     t.string :name
-        #     t.string :aasm_state
-        #   end
-        #
-        #   class Foo < ActiveRecord::Base
-        #     include AASM
-        #   end
-        #
-        # OR:
-        #
-        #   create_table :foos do |t|
-        #     t.string :name
-        #     t.string :status
-        #   end
-        #
-        #   class Foo < ActiveRecord::Base
-        #     include AASM
-        #     aasm_column :status
-        #   end
-        #
-        # This method is both a getter and a setter
-        def aasm_column(column_name=nil)
-          if column_name
-            AASM::StateMachine[self].config.column = column_name.to_sym
-            # @aasm_column = column_name.to_sym
+        def aasm_create_scope(state_machine_name, scope_name)
+          if ActiveRecord::VERSION::MAJOR >= 3
+            conditions = { aasm(state_machine_name).attribute_name => scope_name.to_s }
+            class_eval do
+              scope scope_name, lambda { where(table_name => conditions) }
+            end
           else
-            AASM::StateMachine[self].config.column ||= :aasm_state
-            # @aasm_column ||= :aasm_state
+            conditions = {
+              table_name => { aasm(state_machine_name).attribute_name => scope_name.to_s }
+            }
+            class_eval do
+              named_scope scope_name, :conditions => conditions
+            end
           end
-          # @aasm_column
-          AASM::StateMachine[self].config.column
         end
+      end
+
+      module InstanceMethods
+
+        private
 
-        def find_in_state(number, state, *args)
-          with_state_scope state do
-            find(number, *args)
+        def aasm_execute_after_commit
+          begin
+            require 'after_commit_everywhere'
+            raise LoadError unless Gem::Version.new(::AfterCommitEverywhere::VERSION) >= Gem::Version.new('0.1.5')
+
+            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
 
-        def count_in_state(state, *args)
-          with_state_scope state do
-            count(*args)
-          end
+        def aasm_raise_invalid_record
+          raise ActiveRecord::RecordInvalid.new(self)
+        end
+
+        def aasm_save
+          self.save
+        end
+
+        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_read_attribute(name)
+          read_attribute(name)
+        end
+
+        def aasm_write_attribute(name, value)
+          write_attribute(name, value)
         end
 
-        def calculate_in_state(state, *args)
-          with_state_scope state do
-            calculate(*args)
+        def aasm_transaction(requires_new, requires_lock)
+          self.class.transaction(:requires_new => requires_new) do
+            lock!(requires_lock) if requires_lock
+            yield
           end
         end
 
-        protected
-        def with_state_scope(state)
-          with_scope :find => {:conditions => ["#{table_name}.#{aasm_column} = ?", state.to_s]} do
-            yield if block_given?
+        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
           end
         end
-      end
 
-      module InstanceMethods
+        def aasm_column_looks_like_enum(name=:default)
+          column_name = self.class.aasm(name).attribute_name.to_s
+          column = self.class.columns_hash[column_name]
+          raise NoMethodError.new("undefined method '#{column_name}' for #{self.class}") if column.nil?
+          column.type == :integer
+        end
 
-        # Returns the current aasm_state of the object.  Respects reload and
-        # any changes made to the aasm_state field directly
-        #
-        # Internally just calls <tt>aasm_read_state</tt>
-        #
-        #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :pending
-        #   foo.aasm_state = "opened"
-        #   foo.aasm_current_state # => :opened
-        #   foo.close # => calls aasm_write_state_without_persistence
-        #   foo.aasm_current_state # => :closed
-        #   foo.reload
-        #   foo.aasm_current_state # => :pending
-        #
-        def aasm_current_state
-          @current_state = aasm_read_state
+        def aasm_guess_enum_method(name=:default)
+          self.class.aasm(name).attribute_name.to_s.pluralize.to_sym
         end
 
-        private
+        def aasm_raw_attribute_value(state, name=:default)
+          if aasm_enum(name)
+            self.class.send(aasm_enum(name))[state]
+          else
+            super
+          end
+        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
+        # then the initial state gets populated after initialization
         #
         #   foo = Foo.new
-        #   foo.aasm_state # => nil
-        #   foo.valid?
         #   foo.aasm_state # => "open" (where :open is the initial state)
         #
         #
@@ -155,94 +148,36 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          send("#{self.class.aasm_column}=", self.aasm_current_state.to_s)
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
+            # checking via respond_to? does not work in Rails <= 3
+            # if respond_to?(self.class.aasm(state_machine_name).attribute_name) && send(self.class.aasm(state_machine_name).attribute_name).blank? # Rails 4
+            if aasm_column_is_blank?(state_machine_name)
+              aasm(state_machine_name).enter_initial_state
+            end
+          end
         end
 
-      end
-
-      module WriteStateWithoutPersistence
-        # 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)
-          write_attribute(self.class.aasm_column, state.to_s)
+        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).respond_to?(:empty?) ? !!send(attribute_name).empty? : !send(attribute_name))
         end
-      end
 
-      module WriteState
-        # 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)
-          old_value = read_attribute(self.class.aasm_column)
-          write_attribute(self.class.aasm_column, state.to_s)
-
-          unless self.save(false)
-            write_attribute(self.class.aasm_column, old_value)
-            return false
+        def aasm_validate_states
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
+            unless aasm_skipping_validations(state_machine_name)
+              if aasm_invalid_state?(state_machine_name)
+                self.errors.add(AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.column , "is invalid")
+              end
+            end
           end
-
-          true
         end
-      end
 
-      module ReadState
-
-        # Returns the value of the aasm_column - called from <tt>aasm_current_state</tt>
-        #
-        # If it's a new record, and the aasm state column is blank it returns the initial state:
-        #
-        #   class Foo < ActiveRecord::Base
-        #     include AASM
-        #     aasm_column :status
-        #     aasm_state :opened
-        #     aasm_state :closed
-        #   end
-        #
-        #   foo = Foo.new
-        #   foo.current_state # => :opened
-        #   foo.close
-        #   foo.current_state # => :closed
-        #
-        #   foo = Foo.find(1)
-        #   foo.current_state # => :opened
-        #   foo.aasm_state = nil
-        #   foo.current_state # => nil
-        #
-        # NOTE: intended to be called from an event
-        #
-        # This allows for nil aasm states - be sure to add validation to your model
-        def aasm_read_state
-          if new_record?
-            send(self.class.aasm_column).blank? ? aasm_determine_state_name(self.class.aasm_initial_state) : send(self.class.aasm_column).to_sym
-          else
-            send(self.class.aasm_column).nil? ? nil : send(self.class.aasm_column).to_sym
-          end
+        def aasm_invalid_state?(state_machine_name)
+          aasm(state_machine_name).current_state && !aasm(state_machine_name).states.include?(aasm(state_machine_name).current_state)
         end
-      end
+      end # InstanceMethods
 
-      module NamedScopeMethods
-        def aasm_state_with_named_scope name, options = {}
-          aasm_state_without_named_scope name, options
-          self.named_scope name, :conditions => { "#{table_name}.#{self.aasm_column}" => name.to_s} unless self.respond_to?(name)
-        end
-      end
     end
-  end
-end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/base.rb

@@ -0,0 +1,89 @@
+module AASM
+  module Persistence
+    module Base
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      # Returns the value of the aasm.attribute_name - called from <tt>aasm.current_state</tt>
+      #
+      # If it's a new record, and the aasm state column is blank it returns the initial state
+      # (example provided here for ActiveRecord, but it's true for Mongoid as well):
+      #
+      #   class Foo < ActiveRecord::Base
+      #     include AASM
+      #     aasm :column => :status do
+      #       state :opened
+      #       state :closed
+      #     end
+      #   end
+      #
+      #   foo = Foo.new
+      #   foo.current_state # => :opened
+      #   foo.close
+      #   foo.current_state # => :closed
+      #
+      #   foo = Foo.find(1)
+      #   foo.current_state # => :opened
+      #   foo.aasm_state = nil
+      #   foo.current_state # => nil
+      #
+      # NOTE: intended to be called from an event
+      #
+      # 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 !state || state.empty?
+          aasm_new_record? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : nil
+        else
+          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"
+          aasm.attribute_name(attribute_name)
+        end
+      end # ClassMethods
+
+    end # Base
+  end # Persistence
+
+  class Base
+    # make sure to create a (named) scope for each state
+    def state_with_scope(*args)
+      names = state_without_scope(*args)
+      names.each do |name|
+        create_scopes(name)
+      end
+    end
+    alias_method :state_without_scope, :state
+    alias_method :state, :state_with_scope
+
+    private
+
+    def create_scope?(name)
+      @state_machine.config.create_scopes && !@klass.respond_to?(name) && @klass.respond_to?(:aasm_create_scope)
+    end
+
+    def create_scope(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
+
+end # AASM

data/lib/aasm/persistence/core_data_query_persistence.rb

@@ -0,0 +1,94 @@
+module AASM
+  module Persistence
+    module CoreDataQueryPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   after_initialize :aasm_ensure_initial_state
+      #
+
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::CoreDataQueryPersistence::InstanceMethods)
+        base.extend AASM::Persistence::CoreDataQueryPersistence::ClassMethods
+
+        base.after_initialize :aasm_ensure_initial_state
+      end
+
+      module ClassMethods
+        def aasm_create_scope(state_machine_name, scope_name)
+          scope(scope_name.to_sym, lambda { where(aasm(state_machine_name).attribute_name.to_sym).eq(scope_name.to_s) })
+        end
+      end
+
+      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)
+          raise "Cowardly refusing to save the current CoreDataQuery context"
+          aasm_write_state_without_persistence(state, name)
+        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)
+        end
+
+      private
+
+        # 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 |state_machine_name|
+            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
+
+      # module NamedScopeMethods
+      #   def aasm_state_with_named_scope name, options = {}
+      #     aasm_state_without_named_scope name, options
+      #     self.named_scope name, :conditions => { "#{table_name}.#{self.aasm.attribute_name}" => name.to_s} unless self.respond_to?(name)
+      #   end
+      # end
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/dynamoid_persistence.rb

@@ -0,0 +1,92 @@
+module AASM
+  module Persistence
+    module DynamoidPersistence
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::DynamoidPersistence::InstanceMethods)
+
+        base.after_initialize :aasm_ensure_initial_state
+
+        # Because Dynamoid only use define_method to add attribute assignment method in Class.
+        #
+        # In AASM::Base.initialize, it redefines and calls super in this method without superclass method.
+        # We override method_missing to solve this problem.
+        #
+        base.class_eval %Q(
+          def method_missing(method_name, *arguments, &block)
+            if (AASM::StateMachineStore.fetch(self.class, true).machine_names.map { |state_machine_name| self.class.aasm(state_machine_name).attribute_name.to_s + "=" }).include? method_name.to_s
+              attribute_name = method_name.to_s.gsub("=", '')
+              write_attribute(attribute_name.to_sym, *arguments)
+            else
+              super
+            end
+          end
+        )
+      end
+
+      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)
+
+          unless self.save(:validate => false)
+            write_attribute(self.class.aasm(name).attribute_name, old_value)
+            return false
+          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)
+        end
+
+      private
+
+        # 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 |state_machine_name|
+            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
+    end
+  end # Persistence
+end # AASM