rubyist-aasm 2.0.0 → 2.0.1

data/CHANGELOG

@@ -1,5 +1,15 @@
+* In AR persistence, move state column from class level variables into the StateMachine object for the class
+
+* allowed :to array and :on_transition callback [Kevin Triplett]
+
+* Support enter and exit actions on states
+
+* Use named_scope in AR persistence layer, if available [Jan De Poorter]
+
 * Incremented version number
+
 * Cleaned up aasm_states_for_select to return the value as a string
+
 * Specs and bug fixes for the ActiveRecordPersistence, keeping persistence columns in sync
   Allowing for nil values in states for active record
   Only set state to default state before_validation_on_create

data/README.rdoc

@@ -63,6 +63,8 @@ Author::  Scott Barron <scott at elitists dot net>
 License:: Copyright 2006, 2007, 2008 by Scott Barron.
           Released under an MIT-style license.  See the LICENSE  file
           included in the distribution.
+Bugs::    http://rubyist.lighthouseapp.com/projects/13207-aasm/
+GitHub::  http://github.com/rubyist/aasm/tree/master
 
 == Warranty
 

data/Rakefile

@@ -71,7 +71,7 @@ else
   Spec::Rake::SpecTask.new('cruise') do |t|
     t.spec_files = FileList['spec/**/*.rb']
     t.rcov = true
-    t.rcov_opts = ['--exclude', 'spec']
+    t.rcov_opts = ['--exclude', 'spec', '--exclude', 'Library']
   end
 
   desc "Run all examples"

data/TODO

@@ -1,10 +1,8 @@
 Before Next Release:
 
-* Add state actions (enter, exit, after)
 * Add #aasm_next_state_for_event
 * Add #aasm_next_states_for_event
 
-
 Cool ideas from users:
 
 * Support multiple state machines on one object (Chris Nelson)

data/lib/aasm.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), 'event')
 require File.join(File.dirname(__FILE__), 'state')
+require File.join(File.dirname(__FILE__), 'state_machine')
 require File.join(File.dirname(__FILE__), 'persistence')
 
 module AASM
@@ -7,26 +8,37 @@ module AASM
   end
   
   def self.included(base) #:nodoc:
+    # TODO - need to ensure that a machine is being created because
+    # AASM was either included or arrived at via inheritance.  It
+    # cannot be both.
     base.extend AASM::ClassMethods
     AASM::Persistence.set_persistence(base)
+    AASM::StateMachine[base] = AASM::StateMachine.new('')
+
+    base.class_eval do
+      def base.inherited(klass)
+        AASM::StateMachine[klass] = AASM::StateMachine[self].dup
+      end
+    end
   end
 
   module ClassMethods
     def aasm_initial_state(set_state=nil)
       if set_state
-        aasm_initial_state = set_state
+        AASM::StateMachine[self].initial_state = set_state
       else
-        @aasm_initial_state
+        AASM::StateMachine[self].initial_state
       end
     end
     
     def aasm_initial_state=(state)
-      @aasm_initial_state = state
+      AASM::StateMachine[self].initial_state = state
     end
     
     def aasm_state(name, options={})
-      aasm_states << name unless aasm_states.include?(name)
-      self.aasm_initial_state = name unless self.aasm_initial_state
+      sm = AASM::StateMachine[self]
+      sm.create_state(name, options)
+      sm.initial_state = name unless sm.initial_state
 
       define_method("#{name.to_s}?") do
         aasm_current_state == name
@@ -34,61 +46,31 @@ module AASM
     end
     
     def aasm_event(name, options = {}, &block)
-      unless aasm_events.has_key?(name)
-        aasm_events[name] = AASM::SupportingClasses::Event.new(name, options, &block)
+      sm = AASM::StateMachine[self]
+      
+      unless sm.events.has_key?(name)
+        sm.events[name] = AASM::SupportingClasses::Event.new(name, options, &block)
       end
 
-      define_method("#{name.to_s}!") do
-        new_state = self.class.aasm_events[name].fire(self)
-        unless new_state.nil?
-          if self.respond_to?(:aasm_event_fired)
-            self.aasm_event_fired(self.aasm_current_state, new_state)
-          end
-          
-          self.aasm_current_state_with_persistence = new_state
-
-          self.send(self.class.aasm_events[name].success) if self.class.aasm_events[name].success
-
-          true
-        else
-          if self.respond_to?(:aasm_event_failed)
-            self.aasm_event_failed(name)
-          end
-          
-          false
-        end
+      define_method("#{name.to_s}!") do |*args|
+        aasm_fire_event(name, true, *args)
       end
 
-      define_method("#{name.to_s}") do
-        new_state = self.class.aasm_events[name].fire(self)
-        unless new_state.nil?
-          if self.respond_to?(:aasm_event_fired)
-            self.aasm_event_fired(self.aasm_current_state, new_state)
-          end
-          
-          self.aasm_current_state = new_state
-          true
-        else
-          if self.respond_to?(:aasm_event_failed)
-            self.aasm_event_failed(name)
-          end
-          
-          false
-        end
+      define_method("#{name.to_s}") do |*args|
+        aasm_fire_event(name, false, *args)
       end
-
     end
 
     def aasm_states
-      @aasm_states ||= []
+      AASM::StateMachine[self].states
     end
 
     def aasm_events
-      @aasm_events ||= {}
+      AASM::StateMachine[self].events
     end
     
     def aasm_states_for_select
-      aasm_states.collect { |state| [state.to_s.gsub(/_/, ' ').capitalize, state.to_s] }
+      AASM::StateMachine[self].states.map { |state| state.for_select }
     end
     
   end
@@ -128,4 +110,36 @@ module AASM
     @aasm_current_state = state
   end
 
+  def aasm_state_object_for_state(name)
+    self.class.aasm_states.find {|s| s == name}
+  end
+
+  def aasm_fire_event(name, persist, *args)
+    aasm_state_object_for_state(aasm_current_state).call_action(:exit, self)
+
+    new_state = self.class.aasm_events[name].fire(self, *args)
+    
+    unless new_state.nil?
+      aasm_state_object_for_state(new_state).call_action(:enter, self)
+      
+      if self.respond_to?(:aasm_event_fired)
+        self.aasm_event_fired(self.aasm_current_state, new_state)
+      end
+
+      if persist
+        self.aasm_current_state_with_persistence = new_state
+        self.send(self.class.aasm_events[name].success) if self.class.aasm_events[name].success
+      else
+        self.aasm_current_state = new_state
+      end
+
+      true
+    else
+      if self.respond_to?(:aasm_event_failed)
+        self.aasm_event_failed(name)
+      end
+      
+      false
+    end
+  end
 end

data/lib/event.rb

@@ -12,14 +12,16 @@ module AASM
         instance_eval(&block) if block
       end
 
-      def fire(obj)
+      def fire(obj, to_state=nil, *args)
         transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
         raise AASM::InvalidTransition if transitions.size == 0
 
         next_state = nil
         transitions.each do |transition|
+          next if to_state and !Array(transition.to).include?(to_state)
           if transition.perform(obj)
-            next_state = transition.to
+            next_state = to_state || Array(transition.to).first
+            transition.execute(obj, *args)
             break
           end
         end

data/lib/persistence/active_record_persistence.rb

@@ -36,7 +36,19 @@ module AASM
         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)        
+        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
+              alias_method :aasm_state_without_named_scope, :aasm_state
+              alias_method :aasm_state, :aasm_state_with_named_scope
+            end
+          end
+        end
+        
         base.before_validation_on_create :aasm_ensure_initial_state
       end
 
@@ -67,13 +79,40 @@ module AASM
         # This method is both a getter and a setter
         def aasm_column(column_name=nil)
           if column_name
-            @aasm_column = column_name.to_sym
+            AASM::StateMachine[self].config.column = column_name.to_sym
+            # @aasm_column = column_name.to_sym
           else
-            @aasm_column ||= :aasm_state
+            AASM::StateMachine[self].config.column ||= :aasm_state
+            # @aasm_column ||= :aasm_state
           end
-          @aasm_column
+          # @aasm_column
+          AASM::StateMachine[self].config.column
         end
 
+        def find_in_state(number, state, *args)
+          with_state_scope state do
+            find(number, *args)
+          end
+        end
+
+        def count_in_state(state, *args)
+          with_state_scope state do
+            count(*args)
+          end
+        end
+
+        def calculate_in_state(state, *args)
+          with_state_scope state do
+            calculate(*args)
+          end
+        end
+
+        protected
+        def with_state_scope(state)
+          with_scope :find => {:conditions => ["#{table_name}.#{aasm_column} = ?", state.to_s]} do
+            yield if block_given?
+          end
+        end
       end
 
       module InstanceMethods
@@ -187,6 +226,13 @@ module AASM
           end
         end
       end
+
+      module NamedScopeMethods
+        def aasm_state_with_named_scope name, options = {}
+          aasm_state_without_named_scope name, options
+          self.named_scope name, :conditions => {self.aasm_column => name.to_s} unless self.scopes.include?(name)
+        end       
+      end
     end
   end
 end

data/lib/state.rb

@@ -7,22 +7,26 @@ module AASM
         @name, @options = name, options
       end
 
-      def entering(record)
-        enteract = @options[:enter]
-        record.send(:run_transition_action, enteract) if enteract
+      def ==(state)
+        if state.is_a? Symbol
+          name == state
+        else
+          name == state.name
+        end
       end
 
-      def entered(record)
-        afteractions = @options[:after]
-        return unless afteractions
-        Array(afteractions).each do |afteract|
-          record.send(:run_transition_action, afteract)
+      def call_action(action, record)
+        action = @options[action]
+        case action
+        when Symbol, String
+          record.send(action)
+        when Proc
+          action.call(record)
         end
       end
 
-      def exited(record)
-        exitact  = @options[:exit]
-        record.send(:run_transition_action, exitact) if exitact
+      def for_select
+        [name.to_s.gsub(/_/, ' ').capitalize, name.to_s]
       end
     end
   end

data/lib/state_machine.rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+
+module AASM
+  class StateMachine
+    def self.[](*args)
+      (@machines ||= {})[args]
+    end
+
+    def self.[]=(*args)
+      val = args.pop
+      (@machines ||= {})[args] = val
+    end
+    
+    attr_accessor :states, :events, :initial_state, :config
+    attr_reader :name
+    
+    def initialize(name)
+      @name   = name
+      @initial_state = nil
+      @states = []
+      @events = {}
+      @config = OpenStruct.new
+    end
+
+    def create_state(name, options)
+      @states << AASM::SupportingClasses::State.new(name, options) unless @states.include?(name)
+    end
+  end
+end

data/lib/state_transition.rb

@@ -4,7 +4,7 @@ module AASM
       attr_reader :from, :to, :opts
 
       def initialize(opts)
-        @from, @to, @guard = opts[:from], opts[:to], opts[:guard]
+        @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
         @opts = opts
       end
 
@@ -19,6 +19,15 @@ module AASM
         end
       end
       
+      def execute(obj, *args)
+        case @on_transition
+        when Symbol, String
+          obj.send(@on_transition, *args)
+        when Proc
+          @on_transition.call(obj, *args)
+        end
+      end
+
       def ==(obj)
         @from == obj.from && @to == obj.to
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyist-aasm
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors: 
 - Scott Barron
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-14 00:00:00 -07:00
+date: 2008-07-08 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - lib/persistence/active_record_persistence.rb
 - lib/persistence.rb
 - lib/state.rb
+- lib/state_machine.rb
 - lib/state_transition.rb
 - lib/version.rb
 - doc/jamis.rb
@@ -65,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: State machine mixin for Ruby objects