aasm 5.0.8

data/lib/aasm/localizer.rb

@@ -0,0 +1,54 @@
+module AASM
+  class Localizer
+    def human_event_name(klass, event)
+      checklist = ancestors_list(klass).inject([]) do |list, ancestor|
+        list << :"#{i18n_scope(klass)}.events.#{i18n_klass(ancestor)}.#{event}"
+        list
+      end
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => event.to_s.humanize)
+    end
+
+    def human_state_name(klass, state)
+      checklist = ancestors_list(klass).inject([]) do |list, ancestor|
+        list << item_for(klass, state, ancestor)
+        list << item_for(klass, state, ancestor, :old_style => true)
+        list
+      end
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => state.to_s.humanize)
+    end
+
+  private
+
+    def item_for(klass, state, ancestor, options={})
+      separator = options[:old_style] ? '.' : '/'
+      :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm(state.state_machine.name).attribute_name}#{separator}#{state}"
+    end
+
+    def translate_queue(checklist)
+      (0...(checklist.size-1)).each do |i|
+        begin
+          return I18n.translate(checklist.shift, :raise => true)
+        rescue I18n::MissingTranslationData
+          # that's okay
+        end
+      end
+      nil
+    end
+
+    # added for rails 2.x compatibility
+    def i18n_scope(klass)
+      klass.respond_to?(:i18n_scope) ? klass.i18n_scope : :activerecord
+    end
+
+    # added for rails < 3.0.3 compatibility
+    def i18n_klass(klass)
+      klass.model_name.respond_to?(:i18n_key) ? klass.model_name.i18n_key : klass.name.underscore
+    end
+
+    def ancestors_list(klass)
+      klass.ancestors.select do |ancestor|
+        ancestor.respond_to?(:model_name) unless ancestor.name == 'ActiveRecord::Base'
+      end
+    end
+  end
+end # AASM

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.rb

@@ -0,0 +1,54 @@
+module AASM
+  module Persistence
+    class << self
+
+      def load_persistence(base)
+        # Use a fancier auto-loading thingy, perhaps.  When there are more persistence engines.
+        hierarchy = base.ancestors.map {|klass| klass.to_s}
+
+        if hierarchy.include?("ActiveRecord::Base")
+          require_persistence :active_record
+          include_persistence base, :active_record
+        elsif hierarchy.include?("Mongoid::Document")
+          require_persistence :mongoid
+          include_persistence base, :mongoid
+        elsif hierarchy.include?("NoBrainer::Document")
+          require_persistence :no_brainer
+          include_persistence base, :no_brainer
+        elsif hierarchy.include?("Sequel::Model")
+          require_persistence :sequel
+          include_persistence base, :sequel
+        elsif hierarchy.include?("Dynamoid::Document")
+          require_persistence :dynamoid
+          include_persistence base, :dynamoid
+        elsif hierarchy.include?("Redis::Objects")
+          require_persistence :redis
+          include_persistence base, :redis
+        elsif hierarchy.include?("CDQManagedObject")
+          include_persistence base, :core_data_query
+        else
+          include_persistence base, :plain
+        end
+      end
+
+      private
+
+      def require_persistence(type)
+        require File.join(File.dirname(__FILE__), 'persistence', "#{type}_persistence")
+      end
+
+      def include_persistence(base, type)
+        base.send(:include, constantize("#{capitalize(type)}Persistence"))
+      end
+
+      def capitalize(string_or_symbol)
+        string_or_symbol.to_s.split('_').map {|segment| segment[0].upcase + segment[1..-1]}.join('')
+      end
+
+      def constantize(string)
+        AASM::Persistence.const_get(string)
+      end
+
+    end # class << self
+  end
+end # AASM

data/lib/aasm/persistence/active_record_persistence.rb

@@ -0,0 +1,165 @@
+require 'aasm/persistence/orm'
+module AASM
+  module Persistence
+    module ActiveRecordPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   after_initialize :aasm_ensure_initial_state
+      #
+      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
+      #
+      #   class Foo < ActiveRecord::Base
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #     include AASM
+      #   end
+      #
+      #   class Foo < ActiveRecord::Base
+      #     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::ActiveRecordPersistence::InstanceMethods)
+        base.extend AASM::Persistence::ActiveRecordPersistence::ClassMethods
+
+        base.after_initialize :aasm_ensure_initial_state
+
+        # ensure state is in the list of states
+        base.validate :aasm_validate_states
+      end
+
+      module ClassMethods
+        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
+            conditions = {
+              table_name => { aasm(state_machine_name).attribute_name => scope_name.to_s }
+            }
+            class_eval do
+              named_scope scope_name, :conditions => conditions
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+
+        private
+
+        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 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
+          end
+        end
+
+        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
+
+        def aasm_guess_enum_method(name=:default)
+          self.class.aasm(name).attribute_name.to_s.pluralize.to_sym
+        end
+
+        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
+        # then the initial state gets populated after initialization
+        #
+        #   foo = Foo.new
+        #   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|
+            # 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
+
+        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
+
+        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
+        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 # InstanceMethods
+
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/base.rb

@@ -0,0 +1,78 @@
+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 { |name| create_scope(name) if create_scope?(name) }
+    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)
+    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