aasm 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88085e60d048a49a0b7d88c73810dbed9e028926
-  data.tar.gz: 86b196aee05e522b0235cbf0d8ed6b2f66cde027
+  metadata.gz: 402286c5cd8a9288380d837b7faeb96429a5d5e0
+  data.tar.gz: 45868b7761fa2ed0ffc42d7ab0c7ef637e52a668
 SHA512:
-  metadata.gz: b339bead8353bed92cfe761bf0fedab3aa48ee24edb030e1f992ab0de1342ec5d8228f185ed81cd3f45519a778db110edc41baa885dc549624fe7408ea3205ac
-  data.tar.gz: 10433114be6eec38b4eb0ebc191b7f093cb25d5f45215f172354cbfbfc5cbcebc5b8e0ead5d8cc42a19731e40ee5e65ea29ac76f5a501405fac427d3ea836e67
+  metadata.gz: e5d7c42efeb5438ba6693008b2f92c9cffdcdced9982f550091e2c12b8f756d233a0d6ddb9f6517c9754bf8204c8e7ecdd96da4e9a6209b7bc3df1fd1e35c109
+  data.tar.gz: dd23c1b785e7e917334ce577cd56412c1e1f6a6a30105edf827ab89296c9e1e77394a3762aeff67996401a8fbc887240a7a21ecd86ab178157fefd792accb670

data/.gitignore

@@ -15,3 +15,5 @@ TODO
 .ruby-gemset
 alto
 .rspec
+.bundle
+

data/CHANGELOG.md

@@ -4,6 +4,15 @@
 
  * deprecated old aasm_* class methods (old-style DSL), in preparation for AASM v4.0.0
 
+## 3.3.0 (not yet released)
+
+ * support for Rails 4.1 enum fields (see [issue #124](https://github.com/aasm/aasm/issues/124), thanks to [@bkon](https://github.com/bkon))
+ * bugfix: allow lazy-evaluation for Rails 3 scopes (see [issue #144](https://github.com/aasm/aasm/issues/144), thanks to [@laurens](https://github.com/laurens))
+
+## 3.2.1
+
+ * bugfix: permissible_events and events did not contain events with an empty "from" transition (see [issue #140](https://github.com/aasm/aasm/issues/140) and [issue #141](https://github.com/aasm/aasm/issues/141), thanks to [@daniel-rikowski](https://github.com/daniel-rikowski))
+
 ## 3.2.0
 
  * support [Sequel](http://sequel.jeremyevans.net/) (see [issue #119](https://github.com/aasm/aasm/issues/119), thanks to [@godfat](https://github.com/godfat))

data/README.md

@@ -278,6 +278,40 @@ class Job < ActiveRecord::Base
 end
 ```
 
+#### ActiveRecord enums
+
+You can use
+[enumerations](http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html)
+in Rails 4.1+ for your state column:
+
+```ruby
+class Job < ActiveRecord::Base
+  include AASM
+
+  enum state {
+    sleeping: 5,
+    running: 99
+  }
+
+  aasm :column => :state, :enum => true do
+    state :sleeping, :initial => true
+    state :running
+  end
+end
+```
+
+You can explicitly pass the name of the method which provides access
+to the enumeration mapping as a value of ```enum```, or you can simply
+set it to ```true```. In the latter case AASM will try to use
+pluralized column name to access possible enum states.
+
+Furthermore, if your column has integer type (which is normally the
+case when you're working with Rails enums), you can omit ```:enum```
+setting --- AASM auto-detects this situation and enabled enum
+support. If anything goes wrong, you can disable enum functionality
+and fall back to the default behavior by setting ```:enum```
+to ```false```.
+
 ### Sequel
 
 AASM also supports [Sequel](http://sequel.jeremyevans.net/) besides _ActiveRecord_ and _Mongoid_.

data/aasm.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   # s.add_development_dependency 'mongoid' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
   s.add_development_dependency 'rake'
   s.add_development_dependency 'sdoc'
-  s.add_development_dependency 'rspec', '>= 2.14'
+  s.add_development_dependency 'rspec', '~> 2.14'
   s.add_development_dependency 'rr'
   # s.add_development_dependency 'sqlite3'
   s.add_development_dependency 'minitest'

data/lib/aasm/aasm.rb

@@ -5,7 +5,7 @@ module AASM
 
     # do not overwrite existing state machines, which could have been created by
     # inheritance, see class method inherited
-    AASM::StateMachine[base] ||= AASM::StateMachine.new('')
+    AASM::StateMachine[base] ||= AASM::StateMachine.new
 
     AASM::Persistence.load_persistence(base)
     super

data/lib/aasm/base.rb

@@ -1,9 +1,9 @@
 module AASM
   class Base
 
-    def initialize(clazz, options={}, &block)
-      @clazz = clazz
-      @state_machine = AASM::StateMachine[@clazz]
+    def initialize(klass, options={}, &block)
+      @klass = klass
+      @state_machine = AASM::StateMachine[@klass]
       @state_machine.config.column = options[:column].to_sym if options[:column]
       @options = options
 
@@ -18,6 +18,8 @@ module AASM
 
       # use requires_new for nested transactions
       configure :requires_new_transaction, true
+
+      configure :enum, nil
     end
 
     def initial_state(new_initial_state=nil)
@@ -30,15 +32,14 @@ module AASM
 
     # define a state
     def state(name, options={})
-      @state_machine.add_state(name, @clazz, options)
-      @state_machine.initial_state = name if options[:initial] || !@state_machine.initial_state
+      @state_machine.add_state(name, @klass, options)
 
-      @clazz.send(:define_method, "#{name.to_s}?") do
+      @klass.send(:define_method, "#{name.to_s}?") do
         aasm.current_state == name
       end
 
-      unless @clazz.const_defined?("STATE_#{name.to_s.upcase}")
-        @clazz.const_set("STATE_#{name.to_s.upcase}", name)
+      unless @klass.const_defined?("STATE_#{name.to_s.upcase}")
+        @klass.const_set("STATE_#{name.to_s.upcase}", name)
       end
     end
 
@@ -49,15 +50,15 @@ module AASM
       # an addition over standard aasm so that, before firing an event, you can ask
       # may_event? and get back a boolean that tells you whether the guard method
       # on the transition will let this happen.
-      @clazz.send(:define_method, "may_#{name.to_s}?") do |*args|
+      @klass.send(:define_method, "may_#{name.to_s}?") do |*args|
         aasm.may_fire_event?(name, *args)
       end
 
-      @clazz.send(:define_method, "#{name.to_s}!") do |*args, &block|
+      @klass.send(:define_method, "#{name.to_s}!") do |*args, &block|
         aasm_fire_event(name, {:persist => true}, *args, &block)
       end
 
-      @clazz.send(:define_method, "#{name.to_s}") do |*args, &block|
+      @klass.send(:define_method, "#{name.to_s}") do |*args, &block|
         aasm_fire_event(name, {:persist => false}, *args, &block)
       end
     end

data/lib/aasm/event.rb

@@ -26,7 +26,7 @@ module AASM
     end
 
     def transitions_from_state(state)
-      @transitions.select { |t| t.from == state }
+      @transitions.select { |t| t.from.nil? or t.from == state }
     end
 
     def transitions_to_state?(state)

data/lib/aasm/persistence/active_record_persistence.rb

@@ -85,10 +85,11 @@ module AASM
         # 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)
+          aasm_write_attribute state
 
-          success = if AASM::StateMachine[self.class].config.skip_validation_on_save
-            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm_column => state.to_s) == 1
+          success = if aasm_skipping_validations
+            value = aasm_raw_attribute_value state
+            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm_column => value) == 1
           else
             self.save
           end
@@ -113,10 +114,42 @@ module AASM
         #
         # NOTE: intended to be called from an event
         def aasm_write_state_without_persistence(state)
-          write_attribute(self.class.aasm_column, state.to_s)
+          aasm_write_attribute state
         end
 
       private
+        def aasm_enum
+          case AASM::StateMachine[self.class].config.enum
+            when false then nil
+            when true then aasm_guess_enum_method
+            when nil then aasm_guess_enum_method if aasm_column_looks_like_enum
+            else AASM::StateMachine[self.class].config.enum
+          end
+        end
+
+        def aasm_column_looks_like_enum
+          self.class.columns_hash[self.class.aasm_column.to_s].type == :integer
+        end
+
+        def aasm_guess_enum_method
+          self.class.aasm_column.to_s.pluralize.to_sym
+        end
+
+        def aasm_skipping_validations
+          AASM::StateMachine[self.class].config.skip_validation_on_save
+        end
+
+        def aasm_write_attribute(state)
+          write_attribute self.class.aasm_column, aasm_raw_attribute_value(state)
+        end
+
+        def aasm_raw_attribute_value(state)
+          if aasm_enum
+            value = self.class.send(aasm_enum)[state]
+          else
+            value = state.to_s
+          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

data/lib/aasm/persistence/base.rb

@@ -87,26 +87,22 @@ module AASM
     # make sure to create a (named) scope for each state
     def state_with_scope(name, *args)
       state_without_scope(name, *args)
-      if AASM::StateMachine[@clazz].config.create_scopes && !@clazz.respond_to?(name)
-        if @clazz.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
+      if AASM::StateMachine[@klass].config.create_scopes && !@klass.respond_to?(name)
+        if @klass.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
 
-          conditions = {"#{@clazz.table_name}.#{@clazz.aasm_column}" => name.to_s}
-          if ActiveRecord::VERSION::MAJOR >= 4
-            @clazz.class_eval do
+          conditions = {"#{@klass.table_name}.#{@klass.aasm_column}" => name.to_s}
+          if ActiveRecord::VERSION::MAJOR >= 3
+            @klass.class_eval do
               scope name, lambda { where(conditions) }
             end
-          elsif ActiveRecord::VERSION::MAJOR >= 3
-            @clazz.class_eval do
-              scope name, where(conditions)
-            end
           else
-            @clazz.class_eval do
+            @klass.class_eval do
               named_scope name, :conditions => conditions
             end
           end
-        elsif @clazz.ancestors.map {|klass| klass.to_s}.include?("Mongoid::Document")
-          scope_options = lambda { @clazz.send(:where, {@clazz.aasm_column.to_sym => name.to_s}) }
-          @clazz.send(:scope, name, scope_options)
+        elsif @klass.ancestors.map {|klass| klass.to_s}.include?("Mongoid::Document")
+          scope_options = lambda { @klass.send(:where, {@klass.aasm_column.to_sym => name.to_s}) }
+          @klass.send(:scope, name, scope_options)
         end
       end
     end

data/lib/aasm/state.rb

@@ -2,9 +2,9 @@ module AASM
   class State
     attr_reader :name, :options
 
-    def initialize(name, clazz, options={})
+    def initialize(name, klass, options={})
       @name = name
-      @clazz = clazz
+      @klass = klass
       update(options)
     end
 
@@ -48,7 +48,7 @@ module AASM
     end
 
     def localized_name
-      AASM::Localizer.new.human_state_name(@clazz, self)
+      AASM::Localizer.new.human_state_name(@klass, self)
     end
     alias human_name localized_name
 

data/lib/aasm/state_machine.rb

@@ -2,20 +2,17 @@ module AASM
   class StateMachine
 
     # the following two methods provide the storage of all state machines
-    def self.[](clazz)
-      (@machines ||= {})[clazz.to_s]
+    def self.[](klass)
+      (@machines ||= {})[klass.to_s]
     end
 
-    def self.[]=(clazz, machine)
-      (@machines ||= {})[clazz.to_s] = machine
+    def self.[]=(klass, machine)
+      (@machines ||= {})[klass.to_s] = machine
     end
 
     attr_accessor :states, :events, :initial_state, :config
-    attr_reader :name
 
-    # QUESTION: what's the name for? [alto, 2012-11-28]
-    def initialize(name)
-      @name = name
+    def initialize
       @initial_state = nil
       @states = []
       @events = {}
@@ -29,8 +26,15 @@ module AASM
       @events = @events.dup
     end
 
-    def add_state(name, clazz, options)
-      @states << AASM::State.new(name, clazz, options) unless @states.include?(name)
+    def add_state(name, klass, options)
+      set_initial_state(name, options)
+      @states << AASM::State.new(name, klass, options) unless @states.include?(name)
+    end
+
+    private
+
+    def set_initial_state(name, options)
+      @initial_state = name if options[:initial] || !initial_state
     end
 
   end # StateMachine

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "3.2.0"
+  VERSION = "3.3.0"
 end

data/spec/unit/event_spec.rb

@@ -58,6 +58,23 @@ describe 'transition inspection' do
   end
 end
 
+describe 'transition inspection without from' do
+  let(:event) do
+    AASM::Event.new(:run) do
+      transitions :to => :running
+    end
+  end
+
+  it 'should support inspecting transitions from other states' do
+    expect(event.transitions_from_state(:sleeping).map(&:to)).to eq([:running])
+    expect(event.transitions_from_state?(:sleeping)).to be_true
+
+    expect(event.transitions_from_state(:cleaning).map(&:to)).to eq([:running])
+    expect(event.transitions_from_state?(:cleaning)).to be_true
+  end
+
+end
+
 describe 'firing an event' do
   it 'should return nil if the transitions are empty' do
     obj = double('object', :aasm => double('aasm', :current_state => 'open'))

data/spec/unit/memory_leak_spec.rb

@@ -2,8 +2,8 @@
 
 # describe "state machines" do
 
-#   def number_of_objects(clazz)
-#     ObjectSpace.each_object(clazz) {}
+#   def number_of_objects(klass)
+#     ObjectSpace.each_object(klass) {}
 #   end
 
 #   def machines

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -23,6 +23,227 @@ describe "instance methods" do
     expect(gate).to respond_to(:aasm_write_state_without_persistence)
   end
 
+  describe "aasm_column_looks_like_enum" do
+    subject { lambda{ gate.send(:aasm_column_looks_like_enum) } }
+
+    let(:column_name) { "value" }
+    let(:columns_hash) { Hash[column_name, column] }
+
+    before :each do
+      gate.class.stub(:aasm_column).and_return(column_name.to_sym)
+      gate.class.stub(:columns_hash).and_return(columns_hash)
+    end
+
+    context "when AASM column has integer type" do
+      let(:column) { double(Object, type: :integer) }
+
+      it "returns true" do
+        expect(subject.call).to be_true
+      end
+    end
+
+    context "when AASM column has string type" do
+      let(:column) { double(Object, type: :string) }
+
+      it "returns false" do
+        expect(subject.call).to be_false
+      end
+    end
+  end
+
+  describe "aasm_guess_enum_method" do
+    subject { lambda{ gate.send(:aasm_guess_enum_method) } }
+
+    before :each do
+      gate.class.stub(:aasm_column).and_return(:value)
+    end
+
+    it "pluralizes AASM column name" do
+      expect(subject.call).to eq :values
+    end
+  end
+
+  describe "aasm_enum" do
+    subject { lambda{ gate.send(:aasm_enum) } }
+
+    context "when AASM enum setting contains an explicit enum method name" do
+      let(:enum) { :test }
+
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(enum)
+      end
+
+      it "returns whatever value was set in AASM config" do
+        expect(subject.call).to eq enum
+      end
+    end
+
+    context "when AASM enum setting is simply set to true" do
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(true)
+        Gate.stub(:aasm_column).and_return(:value)
+        gate.stub(:aasm_guess_enum_method).and_return(:values)
+      end
+
+      it "infers enum method name from pluralized column name" do
+        expect(subject.call).to eq :values
+        expect(gate).to have_received :aasm_guess_enum_method
+      end
+    end
+
+    context "when AASM enum setting is explicitly disabled" do
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(false)
+      end
+
+      it "returns nil" do
+        expect(subject.call).to be_nil
+      end
+    end
+
+    context "when AASM enum setting is not enabled" do
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(nil)
+        Gate.stub(:aasm_column).and_return(:value)
+      end
+
+      context "when AASM column looks like enum" do
+        before :each do
+          gate.stub(:aasm_column_looks_like_enum).and_return(true)
+          gate.stub(:aasm_guess_enum_method).and_return(:values)
+        end
+
+        it "infers enum method name from pluralized column name" do
+          expect(subject.call).to eq :values
+          expect(gate).to have_received :aasm_guess_enum_method
+        end
+      end
+
+      context "when AASM column doesn't look like enum'" do
+        before :each do
+          gate.stub(:aasm_column_looks_like_enum)
+            .and_return(false)
+        end
+
+        it "returns nil, as we're not using enum" do
+          expect(subject.call).to be_nil
+        end
+      end
+    end
+  end
+
+  context "when AASM is configured to use enum" do
+    let(:state_sym) { :running }
+    let(:state_code) { 2 }
+    let(:enum_name) { :states }
+    let(:enum) { Hash[state_sym, state_code] }
+
+    before :each do
+      gate
+        .stub(:aasm_enum)
+        .and_return(enum_name)
+      gate.stub(:aasm_write_attribute)
+      gate.stub(:write_attribute)
+
+      gate
+        .class
+        .stub(enum_name)
+        .and_return(enum)
+    end
+
+    describe "aasm_write_state" do
+      context "when AASM is configured to skip validations on save" do
+        before :each do
+          gate
+            .stub(:aasm_skipping_validations)
+            .and_return(true)
+        end
+
+        it "passes state code instead of state symbol to update_all" do
+          # stub_chain does not allow us to give expectations on call
+          # parameters in the middle of the chain, so we need to use
+          # intermediate object instead.
+          obj = double(Object, update_all: 1)
+          gate
+            .class
+            .stub(:where)
+            .and_return(obj)
+
+          gate.aasm_write_state state_sym
+
+          expect(obj).to have_received(:update_all)
+            .with(Hash[gate.class.aasm_column, state_code])
+        end
+      end
+
+      context "when AASM is not skipping validations" do
+        it "delegates state update to the helper method" do
+          # Let's pretend that validation is passed
+          gate.stub(:save).and_return(true)
+
+          gate.aasm_write_state state_sym
+
+          expect(gate).to have_received(:aasm_write_attribute).with(state_sym)
+          expect(gate).to_not have_received :write_attribute
+        end
+      end
+    end
+
+    describe "aasm_write_state_without_persistence" do
+      it "delegates state update to the helper method" do
+        gate.aasm_write_state_without_persistence state_sym
+
+        expect(gate).to have_received(:aasm_write_attribute).with(state_sym)
+        expect(gate).to_not have_received :write_attribute
+      end
+    end
+
+    describe "aasm_raw_attribute_value" do
+      it "converts state symbol to state code" do
+        expect(gate.send(:aasm_raw_attribute_value, state_sym))
+          .to eq state_code
+      end
+    end
+  end
+
+  context "when AASM is configured to use string field" do
+    let(:state_sym) { :running }
+
+    before :each do
+      gate
+        .stub(:aasm_enum)
+        .and_return(nil)
+    end
+
+    describe "aasm_raw_attribute_value" do
+      it "converts state symbol to string" do
+        expect(gate.send(:aasm_raw_attribute_value, state_sym))
+          .to eq state_sym.to_s
+      end
+    end
+  end
+
+  describe "aasm_write_attribute helper method" do
+    let(:sym) { :sym }
+    let(:value) { 42 }
+
+    before :each do
+      gate.stub(:write_attribute)
+      gate.stub(:aasm_raw_attribute_value)
+        .and_return(value)
+
+      gate.send(:aasm_write_attribute, sym)
+    end
+
+    it "generates attribute value using a helper method" do
+      expect(gate).to have_received(:aasm_raw_attribute_value).with(sym)
+    end
+
+    it "writes attribute to the model" do
+      expect(gate).to have_received(:write_attribute).with(:aasm_state, value)
+    end
+  end
+
   it "should return the initial state when new and the aasm field is nil" do
     expect(gate.aasm.current_state).to eq(:opened)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aasm
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Scott Barron
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-16 00:00:00.000000000 Z
+date: 2014-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -45,14 +45,14 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
 - !ruby/object:Gem::Dependency