aasm 2.0.7 → 2.1.1

data/README.rdoc

@@ -11,14 +11,32 @@ AASM has the following features:
 * Events
 * Transitions
 
-== Download
+== New Callbacks
 
-The latest AASM can currently be pulled from the git repository on github.
+The callback chain & order on a successful event looks like:
+
+  oldstate:exit*
+  event:before
+  __find transition, if possible__
+  transition:on_transition*
+  oldstate:before_exit
+  newstate:before_enter
+  newstate:enter*
+  __update state__
+  event:success*
+  oldstate:after_exit
+  oldstate:after_enter
+  event:after
+  obj:aasm_event_fired*
+
+  (*) marks old callbacks
 
-* http://github.com/rubyist/aasm/tree/master
 
-A release and a gem are forthcoming.
+== Download
+
+The latest AASM can currently be pulled from the git repository on github.
 
+* http://github.com/ttilley/aasm/tree/master
 
 
 == Installation
@@ -26,12 +44,12 @@ A release and a gem are forthcoming.
 === From GitHub hosted gems
 
   % sudo gem sources -a http://gems.github.com # (you only need to do this once)
-  % sudo gem install rubyist-aasm
+  % sudo gem install ttilley-aasm
 
 === Building your own gems
 
   % rake gem
-  % sudo gem install pkg/aasm-2.0.1.gem
+  % sudo gem install pkg/aasm-2.1.gem
 
 
 == Simple Example
@@ -57,14 +75,44 @@ Here's a quick example highlighting some of the features.
     end
   end
 
+== A Slightly More Complex Example
+
+This example uses a few of the more complex features available.
+
+  class Relationship
+    include AASM
+    
+    aasm_initial_state Proc.new { |relationship| relationship.strictly_for_fun? ? :intimate : :dating }
+    
+    aasm_state :dating,   :enter => :make_happy,        :exit => :make_depressed
+    aasm_state :intimate, :enter => :make_very_happy,   :exit => :never_speak_again
+    aasm_state :married,  :enter => :give_up_intimacy,  :exit => :buy_exotic_car_and_wear_a_combover
+    
+    aasm_event :get_intimate do
+      transitions :to => :intimate, :from => [:dating], :guard => :drunk?
+    end
+    
+    aasm_event :get_married do
+      transitions :to => :married, :from => [:dating, :intimate], :guard => :willing_to_give_up_manhood?
+    end
+    
+    def strictly_for_fun?; end
+    def drunk?; end
+    def willing_to_give_up_manhood?; end
+    def make_happy; end
+    def make_depressed; end
+    def make_very_happy; end
+    def never_speak_again; end
+    def give_up_intimacy; end
+    def buy_exotic_car_and_wear_a_combover; end
+  end
+
 = Other Stuff
 
 Author::  Scott Barron <scott at elitists dot net>
-License:: Copyright 2006, 2007, 2008 by Scott Barron.
+License:: Original code 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

@@ -22,8 +22,8 @@ end
 $package_version = CURRENT_VERSION
 
 PKG_FILES = FileList['[A-Z]*',
-'lib/**/*.rb',
-'doc/**/*'
+  'lib/**/*.rb',
+  'doc/**/*'
 ]
 
 desc 'Generate documentation for the acts as state machine plugin.'
@@ -44,18 +44,19 @@ else
     s.name = 'aasm'
     s.version = $package_version
     s.summary = 'State machine mixin for Ruby objects'
-    s.description = <<-EOF
-    AASM is a continuation of the acts as state machine rails plugin, built for plain Ruby objects.
-    EOF
+    s.description = <<EOF
+AASM is a continuation of the acts as state machine rails plugin, built for plain Ruby objects.
+EOF
+
     s.files = PKG_FILES.to_a
     s.require_path = 'lib'
     s.has_rdoc = true
     s.extra_rdoc_files = rd.rdoc_files.reject {|fn| fn =~ /\.rb$/}.to_a
     s.rdoc_options = rd.options
 
-    s.author = 'Scott Barron'
-    s.email = 'scott@elitists.net'
-    s.homepage = 'http://rubyi.st/aasm'
+    s.authors = ['Scott Barron', 'Scott Petersen', 'Travis Tilley']
+    s.email = 'ttilley@gmail.com'
+    s.homepage = 'http://github.com/ttilley/aasm'
   end
 
   package_task = Rake::GemPackageTask.new(spec) do |pkg|

data/lib/aasm/aasm.rb

@@ -5,7 +5,7 @@ require File.join(File.dirname(__FILE__), 'persistence')
 
 module AASM
   def self.Version
-    '2.0.7'
+    '2.1.1'
   end
 
   class InvalidTransition < RuntimeError
@@ -13,7 +13,7 @@ module AASM
 
   class UndefinedState < RuntimeError
   end
-  
+
   def self.included(base) #:nodoc:
     base.extend AASM::ClassMethods
     AASM::Persistence.set_persistence(base)
@@ -35,11 +35,11 @@ module AASM
         AASM::StateMachine[self].initial_state
       end
     end
-    
+
     def aasm_initial_state=(state)
       AASM::StateMachine[self].initial_state = state
     end
-    
+
     def aasm_state(name, options={})
       sm = AASM::StateMachine[self]
       sm.create_state(name, options)
@@ -49,10 +49,10 @@ module AASM
         aasm_current_state == name
       end
     end
-    
+
     def aasm_event(name, options = {}, &block)
       sm = AASM::StateMachine[self]
-      
+
       unless sm.events.has_key?(name)
         sm.events[name] = AASM::SupportingClasses::Event.new(name, options, &block)
       end
@@ -73,11 +73,11 @@ module AASM
     def aasm_events
       AASM::StateMachine[self].events
     end
-    
+
     def aasm_states_for_select
       AASM::StateMachine[self].states.map { |state| state.for_select }
     end
-    
+
   end
 
   # Instance methods
@@ -88,7 +88,7 @@ module AASM
       @aasm_current_state = aasm_read_state
     end
     return @aasm_current_state if @aasm_current_state
-    self.class.aasm_initial_state
+    aasm_determine_state_name(self.class.aasm_initial_state)
   end
 
   def aasm_events_for_current_state
@@ -118,6 +118,17 @@ module AASM
     @aasm_current_state = state
   end
 
+  def aasm_determine_state_name(state)
+    case state
+    when Symbol, String
+      state
+    when Proc
+      state.call(self)
+    else
+      raise NotImplementedError, "Unrecognized state-type given.  Expected Symbol, String, or Proc."
+    end
+  end
+
   def aasm_state_object_for_state(name)
     obj = self.class.aasm_states.find {|s| s == name}
     raise AASM::UndefinedState, "State :#{name} doesn't exist" if obj.nil?
@@ -125,33 +136,49 @@ module AASM
   end
 
   def aasm_fire_event(name, persist, *args)
-    aasm_state_object_for_state(aasm_current_state).call_action(:exit, self)
+    old_state = aasm_state_object_for_state(aasm_current_state)
+    event = self.class.aasm_events[name]
+
+    old_state.call_action(:exit, self)
 
-    new_state = self.class.aasm_events[name].fire(self, *args)
+    # new event before callback
+    event.call_action(:before, self)
+
+    new_state_name = event.fire(self, *args)
+
+    unless new_state_name.nil?
+      new_state = aasm_state_object_for_state(new_state_name)
     
-    unless new_state.nil?
-      aasm_state_object_for_state(new_state).call_action(:enter, self)
+      # new before_ callbacks
+      old_state.call_action(:before_exit, self)
+      new_state.call_action(:before_enter, self)
+      
+      new_state.call_action(:enter, self)
       
       persist_successful = true
       if persist
-        persist_successful = set_aasm_current_state_with_persistence(new_state)
-        self.class.aasm_events[name].execute_success_callback(self) if persist_successful
+        persist_successful = set_aasm_current_state_with_persistence(new_state_name)
+        event.execute_success_callback(self) if persist_successful
       else
-        self.aasm_current_state = new_state
+        self.aasm_current_state = new_state_name
       end
 
       if persist_successful 
-        self.aasm_event_fired(self.aasm_current_state, new_state) if self.respond_to?(:aasm_event_fired)
+        old_state.call_action(:after_exit, self)
+        new_state.call_action(:after_enter, self)
+        event.call_action(:after, self)
+
+        self.aasm_event_fired(name, old_state.name, self.aasm_current_state) if self.respond_to?(:aasm_event_fired)
       else
-        self.aasm_event_failed(name) if self.respond_to?(:aasm_event_failed)
+        self.aasm_event_failed(name, old_state.name) if self.respond_to?(:aasm_event_failed)
       end
 
       persist_successful
     else
       if self.respond_to?(:aasm_event_failed)
-        self.aasm_event_failed(name)
+        self.aasm_event_failed(name, old_state.name)
       end
-      
+
       false
     end
   end

data/lib/aasm/event.rb

@@ -3,12 +3,13 @@ require File.join(File.dirname(__FILE__), 'state_transition')
 module AASM
   module SupportingClasses
     class Event
-      attr_reader :name, :success
+      attr_reader :name, :success, :options
       
       def initialize(name, options = {}, &block)
         @name = name
         @success = options[:success]
         @transitions = []
+        @options = options
         instance_eval(&block) if block
       end
 
@@ -31,18 +32,39 @@ module AASM
       def transitions_from_state?(state)
         @transitions.any? { |t| t.from == state }
       end
-      
-      def execute_success_callback(obj)
-        case success
+
+      def transitions_from_state(state)
+        @transitions.select { |t| t.from == state }
+      end
+
+      def execute_success_callback(obj, success = nil)
+        callback = success || @success
+        case(callback)
         when String, Symbol
-          obj.send(success)
+          obj.send(callback)
+        when Proc
+          callback.call(obj)
         when Array
-          success.each { |meth| obj.send(meth) }
+          callback.each{|meth|self.execute_success_callback(obj, meth)}
+        end
+      end
+
+      def call_action(action, record)
+        action = @options[action]
+        case action
+        when Symbol, String
+          record.send(action)
         when Proc
-          success.call(obj)
+          action.call(record)
+        when Array
+          action.each { |a| record.send(a) }
         end
       end
 
+      def all_transitions
+        @transitions
+      end
+
       private
       def transitions(trans_opts)
         Array(trans_opts[:from]).each do |s|

data/lib/aasm/persistence.rb

@@ -1,12 +1,12 @@
 module AASM
   module Persistence
-    
+
     # Checks to see this class or any of it's superclasses inherit from
     # ActiveRecord::Base and if so includes ActiveRecordPersistence
     def self.set_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 File.join(File.dirname(__FILE__), 'persistence', 'active_record_persistence')
         base.send(:include, AASM::Persistence::ActiveRecordPersistence)

data/lib/aasm/persistence/active_record_persistence.rb

@@ -43,8 +43,10 @@ module AASM
 
           base.class_eval do
             class << self
-              alias_method :aasm_state_without_named_scope, :aasm_state
-              alias_method :aasm_state, :aasm_state_with_named_scope
+              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
@@ -191,7 +193,7 @@ module AASM
           old_value = read_attribute(self.class.aasm_column)
           write_attribute(self.class.aasm_column, state.to_s)
 
-          unless self.save
+          unless self.save(false)
             write_attribute(self.class.aasm_column, old_value)
             return false
           end
@@ -228,7 +230,7 @@ module AASM
         # 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? ? self.class.aasm_initial_state : send(self.class.aasm_column).to_sym
+            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
@@ -238,7 +240,7 @@ module AASM
       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.respond_to?(name)
+          self.named_scope name, :conditions => { "#{table_name}.#{self.aasm_column}" => name.to_s} unless self.respond_to?(name)
         end
       end
     end

data/lib/aasm/state.rb

@@ -22,6 +22,8 @@ module AASM
           record.send(action)
         when Proc
           action.call(record)
+        when Array
+          action.each { |a| record.send(a) }
         end
       end
 

data/lib/aasm/state_machine.rb

@@ -10,10 +10,10 @@ module AASM
       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

data/lib/aasm/state_transition.rb

@@ -18,7 +18,7 @@ module AASM
           true
         end
       end
-      
+
       def execute(obj, *args)
         case @on_transition
         when Symbol, String

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aasm
 version: !ruby/object:Gem::Version 
-  version: 2.0.7
+  version: 2.1.1
 platform: ruby
 authors: 
 - Scott Barron