aasm 2.3.1 → 2.4.0

data/.gitignore

@@ -9,3 +9,4 @@ Gemfile.lock
 spec/debug.log
 spec/*.db
 TODO
+.rvmrc

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# CHANGELOG
+
+## 2.4.0 
+
+ * supporting new DSL (which is much shorter)
+
+## 2.3.1
+
+ * bugfix: avoid naming conflict with i18n
+
+## 2.3.0
+
+ * supporting i18n
+ * supporting regular expressions for hash values and strings
+

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Scott Barron
+Copyright (c) 2008-2011 Scott Barron
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -32,21 +32,21 @@ The callback chain & order on a successful event looks like:
     (*) marks old callbacks
 
 
-## Download ##
-
-The latest AASM can currently be pulled from the git repository on github.
-
-* http://github.com/rubyist/aasm/tree/master
-
-
 ## Installation ##
 
-### From RubyGems.org ###
+### Manually from RubyGems.org ###
 
 ```sh
 % gem install aasm
 ```
 
+### Or if you are using Bundler ###
+
+```ruby
+# Gemfile
+gem 'aasm'
+```
+
 ### Building your own gems ###
 
 ```sh
@@ -133,13 +133,17 @@ This example uses a few of the more complex features available.
   end
 ```
 
+## Changelog ##
 
-# Other Stuff #
+Look at the [CHANGELOG](https://github.com/rubyist/aasm/blob/master/CHANGELOG.md) for details.
+
+
+## Authors ##
+
+* [Scott Barron](https://github.com/rubyist)
+* [Travis Tilley](https://github.com/ttilley)
+* [Thorsten Böttger](http://github.com/alto),
 
-Author::  Scott Barron <scott at elitists dot net>
-License:: Original code Copyright 2006, 2007, 2008 by Scott Barron.
-          Released under an MIT-style license.  See the LICENSE  file
-          included in the distribution.
 
 ## Warranty ##
 
@@ -147,3 +151,26 @@ This software is provided "as is" and without any express or
 implied warranties, including, without limitation, the implied
 warranties of merchantibility and fitness for a particular
 purpose.
+
+## License ##
+
+Copyright (c) 2006-2011 Scott Barron
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -13,8 +13,6 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-task :default => :test
-
 require 'rdoc/task'
 require 'aasm/version'
 require 'sdoc'
@@ -25,3 +23,5 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :default => :spec

data/lib/aasm/aasm.rb

@@ -21,61 +21,49 @@ module AASM
       super
     end
 
+    def aasm(options={}, &block)
+      @aasm ||= AASM::Base.new(self, options)
+      @aasm.instance_eval(&block) if block
+      @aasm
+    end
+
     def aasm_initial_state(set_state=nil)
       if set_state
+        # deprecated
         AASM::StateMachine[self].initial_state = set_state
       else
         AASM::StateMachine[self].initial_state
       end
     end
 
+    # deprecated
     def aasm_initial_state=(state)
       AASM::StateMachine[self].initial_state = state
     end
 
+    # deprecated
     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
+      aasm.state(name, options)
     end
     
+    # deprecated
     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
-
-      # 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.
-      define_method("may_#{name.to_s}?") do |*args|
-        aasm_test_event(name, *args)
-      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
+      aasm.event(name, options, &block)
     end
 
+    # deprecated
     def aasm_states
-      AASM::StateMachine[self].states
+      aasm.states
     end
 
+    # deprecated
     def aasm_events
-      AASM::StateMachine[self].events
+      aasm.events
     end
 
+    # deprecated
     def aasm_states_for_select
-      AASM::StateMachine[self].states.map { |state| state.for_select }
+      aasm.states_for_select
     end
 
     def human_event_name(event)
@@ -126,7 +114,7 @@ module AASM
     AASM::Localizer.new.human_state(self)
   end
 
-  private
+private
 
   def set_aasm_current_state_with_persistence(state)
     save_success = true

data/lib/aasm/base.rb

@@ -0,0 +1,56 @@
+module AASM
+  class Base
+    def initialize(clazz, options={}, &block)
+      @clazz = clazz
+      sm = AASM::StateMachine[@clazz]
+      sm.config.column = options[:column].to_sym if options[:column]
+    end
+
+    def state(name, options={})
+      # @clazz.aasm_state(name, options)
+      sm = AASM::StateMachine[@clazz]
+      sm.create_state(name, options)
+      sm.initial_state = name if options[:initial] || !sm.initial_state
+
+      @clazz.send(:define_method, "#{name.to_s}?") do
+        aasm_current_state == name
+      end
+    end
+
+    def event(name, options={}, &block)
+      # @clazz.aasm_event(name, options, &block)
+      sm = AASM::StateMachine[@clazz]
+
+      unless sm.events.has_key?(name)
+        sm.events[name] = AASM::SupportingClasses::Event.new(name, options, &block)
+      end
+
+      # 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|
+        aasm_test_event(name, *args)
+      end
+
+      @clazz.send(:define_method, "#{name.to_s}!") do |*args|
+        aasm_fire_event(name, true, *args)
+      end
+
+      @clazz.send(:define_method, "#{name.to_s}") do |*args|
+        aasm_fire_event(name, false, *args)
+      end
+    end
+
+    def states
+      AASM::StateMachine[@clazz].states
+    end
+
+    def events
+      AASM::StateMachine[@clazz].events
+    end
+
+    def states_for_select
+      states.map { |state| state.for_select }
+    end
+  end
+end

data/lib/aasm/supporting_classes.rb

@@ -1,6 +1,7 @@
 module AASM::SupportingClasses
 end
 
+require File.join(File.dirname(__FILE__), 'base')
 require File.join(File.dirname(__FILE__), 'state_transition')
 require File.join(File.dirname(__FILE__), 'event')
 require File.join(File.dirname(__FILE__), 'state')

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "2.3.1"
+  VERSION = "2.4.0"
 end

data/spec/{functional → models}/conversation.rb

@@ -1,5 +1,3 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'aasm')
-
 class Conversation
   include AASM
 

data/{test/models → spec/models/not_auto_loaded}/process.rb

@@ -16,3 +16,4 @@ module Models
 
   end
 end
+

data/spec/models/process_with_new_dsl.rb

@@ -0,0 +1,31 @@
+class ProcessWithNewDsl
+  include AASM
+
+  def self.state(*args)
+    raise "wrong state method"
+  end
+
+  attr_accessor :flagged
+
+  aasm do
+    state :sleeping, :initial => true
+    state :running, :after_enter => :flag
+    state :suspended
+
+    event :start do
+      transitions :from => :sleeping, :to => :running
+    end
+    event :stop do
+      transitions :from => :running, :to => :suspended
+    end
+  end
+
+  def flag
+    self.flagged = true
+  end
+
+  def self.event(*args)
+    raise "wrong event method"
+  end
+
+end

data/spec/spec_helper.rb

@@ -14,3 +14,6 @@ def load_schema
   ActiveRecord::Base.establish_connection(config['sqlite3'])
   load(File.dirname(__FILE__) + "/schema.rb")
 end
+
+# Requiring custom spec helpers
+Dir[File.dirname(__FILE__) + "/spec_helpers/**/*.rb"].sort.each { |f| require File.expand_path(f) }

data/spec/spec_helpers/models_spec_helper.rb

@@ -0,0 +1,184 @@
+Dir[File.dirname(__FILE__) + "/../models/*.rb"].each { |f| require File.expand_path(f) }
+
+class Foo
+  include AASM
+  aasm_initial_state :open
+  aasm_state :open, :exit => :exit
+  aasm_state :closed, :enter => :enter
+
+  aasm_event :close, :success => :success_callback do
+    transitions :to => :closed, :from => [:open]
+  end
+
+  aasm_event :null do
+    transitions :to => :closed, :from => [:open], :guard => :always_false
+  end
+
+  def always_false
+    false
+  end
+
+  def success_callback
+  end
+
+  def enter
+  end
+  def exit
+  end
+end
+
+class FooTwo < Foo
+  include AASM
+  aasm_state :foo
+end
+
+class Bar
+  include AASM
+
+  aasm_state :read
+  aasm_state :ended
+
+  aasm_event :foo do
+    transitions :to => :ended, :from => [:read]
+  end
+end
+
+class Baz < Bar
+end
+
+class Banker
+  include AASM
+  aasm_initial_state  Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
+  aasm_state          :retired
+  aasm_state          :selling_bad_mortgages
+  RICH = 1_000_000
+  attr_accessor :balance
+  def initialize(balance = 0); self.balance = balance; end
+  def rich?; self.balance >= RICH; end
+end
+
+class Argument
+  include AASM
+  aasm_initial_state :invalid
+  aasm_state :invalid
+  aasm_state :valid
+
+  aasm_event :valid do
+    transitions :to => :valid, :from => [:invalid]
+  end
+end
+
+class AuthMachine
+  include AASM
+
+  attr_accessor :activation_code, :activated_at, :deleted_at
+
+  aasm_initial_state :pending
+
+  aasm_state :passive
+  aasm_state :pending, :enter => :make_activation_code
+  aasm_state :active,  :enter => :do_activate
+  aasm_state :suspended
+  aasm_state :deleted, :enter => :do_delete, :exit => :do_undelete
+
+  aasm_event :register do
+    transitions :from => :passive, :to => :pending, :guard => Proc.new {|u| u.can_register? }
+  end
+
+  aasm_event :activate do
+    transitions :from => :pending, :to => :active
+  end
+
+  aasm_event :suspend do
+    transitions :from => [:passive, :pending, :active], :to => :suspended
+  end
+
+  aasm_event :delete do
+    transitions :from => [:passive, :pending, :active, :suspended], :to => :deleted
+  end
+
+  # a dummy event that can never happen
+  aasm_event :unpassify do
+    transitions :from => :passive, :to => :active, :guard => Proc.new {|u| false }
+  end
+  
+  aasm_event :unsuspend do
+    transitions :from => :suspended, :to => :active,  :guard => Proc.new {|u| u.has_activated? }
+    transitions :from => :suspended, :to => :pending, :guard => Proc.new {|u| u.has_activation_code? }
+    transitions :from => :suspended, :to => :passive
+  end
+
+  def initialize
+    # the AR backend uses a before_validate_on_create :aasm_ensure_initial_state
+    # lets do something similar here for testing purposes.
+    aasm_enter_initial_state
+  end
+
+  def make_activation_code
+    @activation_code = 'moo'
+  end
+
+  def do_activate
+    @activated_at = Time.now
+    @activation_code = nil
+  end
+
+  def do_delete
+    @deleted_at = Time.now
+  end
+
+  def do_undelete
+    @deleted_at = false
+  end
+
+  def can_register?
+    true
+  end
+
+  def has_activated?
+    !!@activated_at
+  end
+
+  def has_activation_code?
+    !!@activation_code
+  end
+end
+
+class ThisNameBetterNotBeInUse
+  include AASM
+
+  aasm_state :initial
+  aasm_state :symbol
+  aasm_state :string
+  aasm_state :array
+  aasm_state :proc
+end
+
+class ChetanPatil
+  include AASM
+  aasm_initial_state :sleeping
+  aasm_state :sleeping
+  aasm_state :showering
+  aasm_state :working
+  aasm_state :dating
+  aasm_state :prettying_up
+
+  aasm_event :wakeup do
+    transitions :from => :sleeping, :to => [:showering, :working]
+  end
+
+  aasm_event :dress do
+    transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
+    transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
+    transitions :from => :showering, :to => :prettying_up, :on_transition => [:condition_hair, :fix_hair]
+  end
+
+  def wear_clothes(shirt_color, trouser_type)
+  end
+
+  def condition_hair
+  end
+
+  def fix_hair
+  end
+end