rubyist-aasm 2.0.5 → 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.'
@@ -34,7 +34,7 @@ rd = Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.title    = 'AASM'
   rdoc.options << '--line-numbers' << '--inline-source' <<  '--main' << 'README.rdoc' << '--title' << 'AASM'
   rdoc.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'TODO', 'CHANGELOG')
-  rdoc.rdoc_files.include('lib/**/*.rb', 'doc/**/*.rdoc')
+  rdoc.rdoc_files.include('lib/*.rb', 'lib/**/*.rb', 'doc/**/*.rdoc')
 end
 
 if !defined?(Gem)
@@ -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

@@ -0,0 +1,185 @@
+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
+  def self.Version
+    '2.1.1'
+  end
+
+  class InvalidTransition < RuntimeError
+  end
+
+  class UndefinedState < RuntimeError
+  end
+
+  def self.included(base) #:nodoc:
+    base.extend AASM::ClassMethods
+    AASM::Persistence.set_persistence(base)
+    unless AASM::StateMachine[base]
+      AASM::StateMachine[base] = AASM::StateMachine.new('')
+    end
+  end
+
+  module ClassMethods
+    def inherited(klass)
+      AASM::StateMachine[klass] = AASM::StateMachine[self].clone
+      super
+    end
+
+    def aasm_initial_state(set_state=nil)
+      if set_state
+        AASM::StateMachine[self].initial_state = set_state
+      else
+        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)
+      sm.initial_state = name unless sm.initial_state
+
+      define_method("#{name.to_s}?") do
+        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
+
+      define_method("#{name.to_s}!") do |*args|
+        aasm_fire_event(name, true, *args)
+      end
+
+      define_method("#{name.to_s}") do |*args|
+        aasm_fire_event(name, false, *args)
+      end
+    end
+
+    def aasm_states
+      AASM::StateMachine[self].states
+    end
+
+    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
+  def aasm_current_state
+    return @aasm_current_state if @aasm_current_state
+
+    if self.respond_to?(:aasm_read_state) || self.private_methods.include?('aasm_read_state')
+      @aasm_current_state = aasm_read_state
+    end
+    return @aasm_current_state if @aasm_current_state
+    aasm_determine_state_name(self.class.aasm_initial_state)
+  end
+
+  def aasm_events_for_current_state
+    aasm_events_for_state(aasm_current_state)
+  end
+
+  def aasm_events_for_state(state)
+    events = self.class.aasm_events.values.select {|event| event.transitions_from_state?(state) }
+    events.map {|event| event.name}
+  end
+
+  private
+  def set_aasm_current_state_with_persistence(state)
+    save_success = true
+    if self.respond_to?(:aasm_write_state) || self.private_methods.include?('aasm_write_state')
+      save_success = aasm_write_state(state)
+    end
+    self.aasm_current_state = state if save_success
+
+    save_success
+  end
+
+  def aasm_current_state=(state)
+    if self.respond_to?(:aasm_write_state_without_persistence) || self.private_methods.include?('aasm_write_state_without_persistence')
+      aasm_write_state_without_persistence(state)
+    end
+    @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?
+    obj
+  end
+
+  def aasm_fire_event(name, persist, *args)
+    old_state = aasm_state_object_for_state(aasm_current_state)
+    event = self.class.aasm_events[name]
+
+    old_state.call_action(:exit, self)
+
+    # 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)
+    
+      # 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_name)
+        event.execute_success_callback(self) if persist_successful
+      else
+        self.aasm_current_state = new_state_name
+      end
+
+      if persist_successful 
+        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, 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, old_state.name)
+      end
+
+      false
+    end
+  end
+end

data/lib/{event.rb → 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
-        when String, Symbol:
-          obj.send(success)
-        when Array:
-          success.each { |meth| obj.send(meth) }
-        when Proc:
-          success.call(obj)
+
+      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(callback)
+        when Proc
+          callback.call(obj)
+        when Array
+          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
+          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/{persistence → 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/{persistence.rb → 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/{state.rb → 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/{state_machine.rb → 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/{state_transition.rb → aasm/state_transition.rb}

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

data/lib/aasm.rb

@@ -1,159 +1 @@
-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
-  def self.Version
-    '2.0.5'
-  end
-
-  class InvalidTransition < RuntimeError
-  end
-
-  class UndefinedState < RuntimeError
-  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('')
-  end
-
-  module ClassMethods
-    def inherited(klass)
-      AASM::StateMachine[klass] = AASM::StateMachine[self].clone
-      super
-    end
-
-    def aasm_initial_state(set_state=nil)
-      if set_state
-        AASM::StateMachine[self].initial_state = set_state
-      else
-        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)
-      sm.initial_state = name unless sm.initial_state
-
-      define_method("#{name.to_s}?") do
-        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
-
-      define_method("#{name.to_s}!") do |*args|
-        aasm_fire_event(name, true, *args)
-      end
-
-      define_method("#{name.to_s}") do |*args|
-        aasm_fire_event(name, false, *args)
-      end
-    end
-
-    def aasm_states
-      AASM::StateMachine[self].states
-    end
-
-    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
-  def aasm_current_state
-    return @aasm_current_state if @aasm_current_state
-
-    if self.respond_to?(:aasm_read_state) || self.private_methods.include?('aasm_read_state')
-      @aasm_current_state = aasm_read_state
-    end
-    return @aasm_current_state if @aasm_current_state
-    self.class.aasm_initial_state
-  end
-
-  def aasm_events_for_current_state
-    aasm_events_for_state(aasm_current_state)
-  end
-
-  def aasm_events_for_state(state)
-    events = self.class.aasm_events.values.select {|event| event.transitions_from_state?(state) }
-    events.map {|event| event.name}
-  end
-
-  private
-  def set_aasm_current_state_with_persistence(state)
-    save_success = true
-    if self.respond_to?(:aasm_write_state) || self.private_methods.include?('aasm_write_state')
-      save_success = aasm_write_state(state)
-    end
-    self.aasm_current_state = state if save_success
-
-    save_success
-  end
-
-  def aasm_current_state=(state)
-    if self.respond_to?(:aasm_write_state_without_persistence) || self.private_methods.include?('aasm_write_state_without_persistence')
-      aasm_write_state_without_persistence(state)
-    end
-    @aasm_current_state = state
-  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?
-    obj
-  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)
-      
-      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
-      else
-        self.aasm_current_state = new_state
-      end
-
-      if persist_successful 
-        self.aasm_event_fired(self.aasm_current_state, new_state) if self.respond_to?(:aasm_event_fired)
-      else
-        self.aasm_event_failed(name) if self.respond_to?(:aasm_event_failed)
-      end
-
-      persist_successful
-    else
-      if self.respond_to?(:aasm_event_failed)
-        self.aasm_event_failed(name)
-      end
-      
-      false
-    end
-  end
-end
+require File.join(File.dirname(__FILE__), 'aasm', 'aasm')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyist-aasm
 version: !ruby/object:Gem::Version 
-  version: 2.0.5
+  version: 2.1.1
 platform: ruby
 authors: 
 - Scott Barron
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-22 00:00:00 -08:00
+date: 2009-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,16 +31,17 @@ files:
 - README.rdoc
 - TODO
 - lib/aasm.rb
-- lib/event.rb
-- lib/persistence/active_record_persistence.rb
-- lib/persistence.rb
-- lib/state.rb
-- lib/state_machine.rb
-- lib/state_transition.rb
-- lib/version.rb
+- lib/aasm/aasm.rb
+- lib/aasm/event.rb
+- lib/aasm/persistence/active_record_persistence.rb
+- lib/aasm/persistence.rb
+- lib/aasm/state.rb
+- lib/aasm/state_machine.rb
+- lib/aasm/state_transition.rb
 - doc/jamis.rb
 has_rdoc: true
 homepage: http://github.com/rubyist/aasm
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -66,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: State machine mixin for Ruby objects