aasm 4.5.1 → 4.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0308a8cef74abb6ac913b1dd31bc8673951a837
-  data.tar.gz: aef81a4c7f1f4045cd9e5202e65e7fd3562a1db2
+  metadata.gz: 497994639dac4183fdf996cafad384f308784855
+  data.tar.gz: 731e388e865ffb526e4cbb3c20443659aab8605a
 SHA512:
-  metadata.gz: f9d0dcf0e16ccf7ecf050163cdee8f6f8e993f17890a73508e64f48e519970810d3df30fef5bec877bb5cd6dd311570c6cf6ccd77b779c4f0220ceee660a8ebf
-  data.tar.gz: 852dd93351612a60d03472b8ff4a043ffe488d89e620fedc498c5d9895c6260b83aaf182d5b50a9bdd4929a09ba68f704a152aa4cd3134d904e3c4b1e5f061b6
+  metadata.gz: b3572795abc66917c392e8736afc6d8ea882b12f0fdfcb15cd8046ae0f1977e8dd01b2eeab5d2fcb7e659295c3f45b6aa438aa008c61c8707370be7b27b40e31
+  data.tar.gz: 42a4dc5b04c7a13e2a15e745a42b960a80cb4a90f4f62e1eb51c09b4493565314c85ae4aeeb1dd985fc85094706b440fc14ec11dbb7e7275c641e64309b7106d

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 4.5.2
+
+ * fix arity difference between Procs and lambdas (see [issue #293](https://github.com/aasm/aasm/issues/293) for details)
+
 ## 4.5.1
 
  * make sure to use override configuration options if state machine is defined more than once (see [issue #287](https://github.com/aasm/aasm/issues/287) for details)

data/lib/aasm/core/transition.rb

@@ -55,7 +55,7 @@ module AASM::Core
         arity = record.send(:method, code.to_sym).arity
         arity == 0 ? record.send(code) : record.send(code, *args)
       when Proc
-        code.arity == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
+        code.parameters.size == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
       when Array
         if options[:guard]
           # invoke guard callbacks

data/lib/aasm/persistence/active_record_persistence.rb

@@ -57,16 +57,12 @@ module AASM
 
           success = if aasm_skipping_validations(name)
             value = aasm_raw_attribute_value(state, name)
-            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm(name).attribute_name => value) == 1
+            aasm_update_column(name, value)
           else
             self.save
           end
-          unless success
-            write_attribute(self.class.aasm(name).attribute_name, old_value)
-            return false
-          end
 
-          true
+          success ? true : aasm_rollback(name, old_value)
         end
 
         # Writes <tt>state</tt> to the state column, but does not persist it to the database
@@ -86,6 +82,16 @@ module AASM
         end
 
       private
+
+        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
+        end
+
+        def aasm_rollback(name, old_value)
+          write_attribute(self.class.aasm(name).attribute_name, old_value)
+          false
+        end
+
         def aasm_enum(name=:default)
           case AASM::StateMachine[self.class][name].config.enum
             when false then nil
@@ -120,7 +126,7 @@ module AASM
         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 before validation on create
         #
         #   foo = Foo.new
         #   foo.aasm_state # => nil
@@ -138,12 +144,17 @@ module AASM
           AASM::StateMachine[self.class].keys.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 attribute_names.include?(self.class.aasm(state_machine_name).attribute_name.to_s) && send(self.class.aasm(state_machine_name).attribute_name).blank?
+            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).blank?
+        end
+
         def aasm_fire_event(state_machine_name, name, options, *args, &block)
           success = options[:persist] ? self.class.transaction(:requires_new => requires_new?(state_machine_name)) { super } : super
 
@@ -162,12 +173,16 @@ module AASM
         def aasm_validate_states
           AASM::StateMachine[self.class].keys.each do |state_machine_name|
             unless aasm_skipping_validations(state_machine_name)
-              if aasm(state_machine_name).current_state && !aasm(state_machine_name).states.include?(aasm(state_machine_name).current_state)
+              if aasm_invalid_state?(state_machine_name)
                 self.errors.add(AASM::StateMachine[self.class][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

data/lib/aasm/persistence/base.rb

@@ -55,35 +55,62 @@ module AASM
     # make sure to create a (named) scope for each state
     def state_with_scope(name, *args)
       state_without_scope(name, *args)
-      if @state_machine.config.create_scopes && !@klass.respond_to?(name)
+      create_scope(name) if create_scope?(name)
+    end
+    alias_method :state_without_scope, :state
+    alias_method :state, :state_with_scope
 
-        if @klass.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
-          conditions = {"#{@klass.table_name}.#{@klass.aasm(@name).attribute_name}" => name.to_s}
-          if ActiveRecord::VERSION::MAJOR >= 3
-            @klass.class_eval do
-              scope name, lambda { where(conditions) }
-            end
-          else
-            @klass.class_eval do
-              named_scope name, :conditions => conditions
-            end
-          end
-        elsif @klass.ancestors.map {|klass| klass.to_s}.include?("Mongoid::Document")
-          klass = @klass
-          state_machine_name = @name
-          scope_options = lambda {
-            klass.send(:where, {klass.aasm(state_machine_name).attribute_name.to_sym => name.to_s})
-          }
-          @klass.send(:scope, name, scope_options)
-        elsif @klass.ancestors.map {|klass| klass.to_s}.include?("MongoMapper::Document")
-          conditions = { @klass.aasm(@name).attribute_name.to_sym => name.to_s }
-          @klass.scope(name, lambda { @klass.where(conditions) })
-        end
+    private
+
+    def create_scope?(name)
+      @state_machine.config.create_scopes && !@klass.respond_to?(name)
+    end
 
+    def create_scope(name)
+      if ancestors_include?("ActiveRecord::Base")
+        create_for_active_record(name)
+      elsif ancestors_include?("Mongoid::Document")
+        create_for_mongoid(name)
+      elsif ancestors_include?("MongoMapper::Document")
+        create_for_mongomapper(name)
       end
     end
-    alias_method :state_without_scope, :state
-    alias_method :state, :state_with_scope
+
+    def ancestors_include?(class_name)
+      @klass.ancestors.map { |klass| klass.to_s }.include?(class_name)
+    end
+
+    def create_for_active_record(name)
+      conditions = {
+        "#{@klass.table_name}.#{@klass.aasm(@name).attribute_name}" => name.to_s
+      }
+      if ActiveRecord::VERSION::MAJOR >= 3
+        @klass.class_eval do
+          scope name, lambda { where(conditions) }
+        end
+      else
+        @klass.class_eval do
+          named_scope name, :conditions => conditions
+        end
+      end
+    end
+
+    def create_for_mongoid(name)
+      klass = @klass
+      state_machine_name = @name
+      scope_options = lambda {
+        klass.send(
+          :where,
+          { klass.aasm(state_machine_name).attribute_name.to_sym => name.to_s }
+        )
+      }
+      @klass.send(:scope, name, scope_options)
+    end
+
+    def create_for_mongomapper(name)
+      conditions = { @klass.aasm(@name).attribute_name.to_sym => name.to_s }
+      @klass.scope(name, lambda { @klass.where(conditions) })
+    end
   end # Base
 
 end # AASM

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.5.1"
+  VERSION = "4.5.2"
 end

data/spec/models/guardian.rb

@@ -1,6 +1,9 @@
 class Guardian
   include AASM
 
+  def inner_guard(options={})
+  end
+
   aasm do
     state :alpha, :initial => true
     state :beta
@@ -12,6 +15,13 @@ class Guardian
       transitions :from => :alpha, :to => :beta, :guard => :fail
     end
 
+    event :use_proc_guard_with_params do
+      transitions :from => :alpha, :to => :beta, :guard => Proc.new { |options={}| inner_guard(options) }
+    end
+    event :use_lambda_guard_with_params do
+      transitions :from => :alpha, :to => :beta, :guard => lambda { |options={}| inner_guard(options) }
+    end
+
     event :use_guards_that_succeed do
       transitions :from => :alpha, :to => :beta, :guards => [:succeed, :another_succeed]
     end

data/spec/unit/guard_spec.rb

@@ -27,6 +27,18 @@ describe "per-transition guards" do
     expect { guardian.use_guards_where_the_second_fails! }.to raise_error(AASM::InvalidTransition)
     expect(guardian).to be_alpha
   end
+
+  describe "with params" do
+    it "using a Proc" do
+      expect(guardian).to receive(:inner_guard).with({:flag => true}).and_return(true)
+      guardian.use_proc_guard_with_params(:flag => true)
+    end
+
+    it "using a lambda" do
+      expect(guardian).to receive(:inner_guard).with({:flag => true}).and_return(true)
+      guardian.use_lambda_guard_with_params(:flag => true)
+    end
+  end
 end
 
 describe "event guards" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aasm
 version: !ruby/object:Gem::Version
-  version: 4.5.1
+  version: 4.5.2
 platform: ruby
 authors:
 - Scott Barron
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-08 00:00:00.000000000 Z
+date: 2016-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake