alexrevin-aasm_numerical 2.3.1

data/lib/alexrevin-aasm_numerical/state_machine.rb

@@ -0,0 +1,31 @@
+class AASM::StateMachine
+  def self.[](clazz)
+    (@machines ||= {})[clazz.to_s]
+  end
+  
+  def self.[]=(clazz, machine)
+    (@machines ||= {})[clazz.to_s] = machine
+  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 clone
+    klone = super
+    klone.states = states.clone
+    klone.events = events.clone
+    klone
+  end
+
+  def create_state(name, options)
+    @states << AASM::SupportingClasses::State.new(name, options) unless @states.include?(name)
+  end
+end

data/lib/alexrevin-aasm_numerical/state_transition.rb

@@ -0,0 +1,46 @@
+class AASM::SupportingClasses::StateTransition
+  attr_reader :from, :to, :opts
+  alias_method :options, :opts
+
+  def initialize(opts)
+    @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
+    @opts = opts
+  end
+
+  def perform(obj, *args)
+    case @guard
+      when Symbol, String
+        obj.send(@guard, *args)
+      when Proc
+        @guard.call(obj, *args)
+      else
+        true
+    end
+  end
+
+  def execute(obj, *args)
+    @on_transition.is_a?(Array) ?
+            @on_transition.each {|ot| _execute(obj, ot, *args)} :
+            _execute(obj, @on_transition, *args)
+  end
+
+  def ==(obj)
+    @from == obj.from && @to == obj.to
+  end
+
+  def from?(value)
+    @from == value
+  end
+
+  private
+
+  def _execute(obj, on_transition, *args)
+    case on_transition
+    when Proc
+      on_transition.arity == 0 ? on_transition.call : on_transition.call(obj, *args)
+    when Symbol, String
+      obj.send(:method, on_transition.to_sym).arity == 0 ? obj.send(on_transition) : obj.send(on_transition, *args)
+    end
+  end
+
+end

data/lib/alexrevin-aasm_numerical/supporting_classes.rb

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

data/lib/alexrevin-aasm_numerical/version.rb

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

data/spec/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: spec/aasm.sqlite3.db

data/spec/en.yml

@@ -0,0 +1,10 @@
+en:
+  activerecord:
+    events:
+      localizer_test_model:
+        close: "Let's close it!"
+
+    attributes:
+      localizer_test_model:
+        aasm_state:
+          open: "It's opened now!"

data/spec/functional/conversation.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'alexrevin-aasm_numerical')
+
+class Conversation
+  include AASM
+
+  aasm_initial_state :needs_attention
+
+  aasm_state :needs_attention
+  aasm_state :read
+  aasm_state :closed
+  aasm_state :awaiting_response
+  aasm_state :junk
+
+  aasm_event :new_message do
+  end
+
+  aasm_event :view do
+    transitions :to => :read, :from => [:needs_attention]
+  end
+
+  aasm_event :reply do
+  end
+
+  aasm_event :close do
+    transitions :to => :closed, :from => [:read, :awaiting_response]
+  end
+
+  aasm_event :junk do
+    transitions :to => :junk, :from => [:read]
+  end
+
+  aasm_event :unjunk do
+  end
+
+  def initialize(persister)
+    @persister = persister
+  end
+
+
+  private
+  def aasm_read_state
+    @persister.read_state
+  end
+
+  def aasm_write_state(state)
+    @persister.write_state(state)
+  end
+
+end

data/spec/functional/conversation_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'conversation'))
+
+describe Conversation, 'description' do
+  it '.aasm_states should contain all of the states' do
+    Conversation.aasm_states.should == [:needs_attention, :read, :closed, :awaiting_response, :junk]
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,7 @@
+ActiveRecord::Schema.define(:version => 0) do
+
+  %w{gates readers writers transients simples thieves localizer_test_models}.each do |table_name|
+    create_table table_name, :force => true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'alexrevin-aasm_numerical'
+
+require 'rspec'
+require 'rspec/autorun'
+
+# require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
+# require 'ruby-debug/completion'
+
+def load_schema
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+  ActiveRecord::Base.establish_connection(config['sqlite3'])
+  load(File.dirname(__FILE__) + "/schema.rb")
+end

data/spec/unit/aasm_spec.rb

@@ -0,0 +1,462 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+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
+
+
+describe AASM, '- class level definitions' do
+  it 'should define a class level aasm_initial_state() method on its including class' do
+    Foo.should respond_to(:aasm_initial_state)
+  end
+
+  it 'should define a class level aasm_state() method on its including class' do
+    Foo.should respond_to(:aasm_state)
+  end
+
+  it 'should define a class level aasm_event() method on its including class' do
+    Foo.should respond_to(:aasm_event)
+  end
+
+  it 'should define a class level aasm_states() method on its including class' do
+    Foo.should respond_to(:aasm_states)
+  end
+
+  it 'should define a class level aasm_states_for_select() method on its including class' do
+    Foo.should respond_to(:aasm_states_for_select)
+  end
+
+  it 'should define a class level aasm_events() method on its including class' do
+    Foo.should respond_to(:aasm_events)
+  end
+
+end
+
+
+describe AASM, '- subclassing' do
+  it 'should have the parent states' do
+    Foo.aasm_states.each do |state|
+      FooTwo.aasm_states.should include(state)
+    end
+  end
+
+  it 'should not add the child states to the parent machine' do
+    Foo.aasm_states.should_not include(:foo)
+  end
+end
+
+
+describe AASM, '- aasm_states_for_select' do
+  it "should return a select friendly array of states in the form of [['Friendly name', 'state_name']]" do
+    Foo.aasm_states_for_select.should == [['Open', 'open'], ['Closed', 'closed']]
+  end
+end
+
+describe AASM, '- instance level definitions' do
+  before(:each) do
+    @foo = Foo.new
+  end
+
+  it 'should define a state querying instance method on including class' do
+    @foo.should respond_to(:open?)
+  end
+
+  it 'should define an event! inance method' do
+    @foo.should respond_to(:close!)
+  end
+end
+
+describe AASM, '- initial states' do
+  before(:each) do
+    @foo = Foo.new
+    @bar = Bar.new
+  end
+
+  it 'should set the initial state' do
+    @foo.aasm_current_state.should == :open
+  end
+
+  it '#open? should be initially true' do
+    @foo.open?.should be_true
+  end
+
+  it '#closed? should be initially false' do
+    @foo.closed?.should be_false
+  end
+
+  it 'should use the first state defined if no initial state is given' do
+    @bar.aasm_current_state.should == :read
+  end
+
+  it 'should determine initial state from the Proc results' do
+    Banker.new(Banker::RICH - 1).aasm_current_state.should == :selling_bad_mortgages
+    Banker.new(Banker::RICH + 1).aasm_current_state.should == :retired
+  end
+end
+
+describe AASM, '- event firing with persistence' do
+  it 'should fire the Event' do
+    foo = Foo.new
+
+    Foo.aasm_events[:close].should_receive(:fire).with(foo)
+    foo.close!
+  end
+
+  it 'should update the current state' do
+    foo = Foo.new
+    foo.close!
+
+    foo.aasm_current_state.should == :closed
+  end
+
+  it 'should call the success callback if one was provided' do
+    foo = Foo.new
+
+    foo.should_receive(:success_callback)
+
+    foo.close!
+  end
+
+  it 'should attempt to persist if aasm_write_state is defined' do
+    foo = Foo.new
+
+    def foo.aasm_write_state
+    end
+
+    foo.should_receive(:aasm_write_state)
+
+    foo.close!
+  end
+
+  it 'should return true if aasm_write_state is defined and returns true' do
+    foo = Foo.new
+
+    def foo.aasm_write_state(state)
+      true
+    end
+
+    foo.close!.should be_true
+  end
+
+  it 'should return false if aasm_write_state is defined and returns false' do
+    foo = Foo.new
+
+    def foo.aasm_write_state(state)
+      false
+    end
+
+    foo.close!.should be_false
+  end
+
+  it "should not update the aasm_current_state if the write fails" do
+    foo = Foo.new
+
+    def foo.aasm_write_state
+      false
+    end
+
+    foo.should_receive(:aasm_write_state)
+
+    foo.close!
+    foo.aasm_current_state.should == :open
+  end
+end
+
+describe AASM, '- event firing without persistence' do
+  it 'should fire the Event' do
+    foo = Foo.new
+
+    Foo.aasm_events[:close].should_receive(:fire).with(foo)
+    foo.close
+  end
+
+  it 'should update the current state' do
+    foo = Foo.new
+    foo.close
+
+    foo.aasm_current_state.should == :closed
+  end
+
+  it 'should attempt to persist if aasm_write_state is defined' do
+    foo = Foo.new
+
+    def foo.aasm_write_state
+    end
+
+    foo.should_receive(:aasm_write_state_without_persistence).twice
+
+    foo.close
+  end
+end
+
+describe AASM, '- persistence' do
+  it 'should read the state if it has not been set and aasm_read_state is defined' do
+    foo = Foo.new
+    def foo.aasm_read_state
+    end
+
+    foo.should_receive(:aasm_read_state)
+
+    foo.aasm_current_state
+  end
+end
+
+describe AASM, '- getting events for a state' do
+  it '#aasm_events_for_current_state should use current state' do
+    foo = Foo.new
+    foo.should_receive(:aasm_current_state)
+    foo.aasm_events_for_current_state
+  end
+
+  it '#aasm_events_for_current_state should use aasm_events_for_state' do
+    foo = Foo.new
+    foo.stub!(:aasm_current_state).and_return(:foo)
+    foo.should_receive(:aasm_events_for_state).with(:foo)
+    foo.aasm_events_for_current_state
+  end
+end
+
+describe AASM, '- event callbacks' do
+  describe "with an error callback defined" do
+    before do
+      class Foo
+        aasm_event :safe_close, :success => :success_callback, :error => :error_callback do
+          transitions :to => :closed, :from => [:open]
+        end
+      end
+
+      @foo = Foo.new
+    end
+
+    it "should run error_callback if an exception is raised and error_callback defined" do
+      def @foo.error_callback(e)
+      end
+      @foo.stub!(:enter).and_raise(e=StandardError.new)
+      @foo.should_receive(:error_callback).with(e)
+      @foo.safe_close!
+    end
+
+    it "should raise NoMethodError if exceptionis raised and error_callback is declared but not defined" do
+      @foo.stub!(:enter).and_raise(StandardError)
+      lambda{@foo.safe_close!}.should raise_error(NoMethodError)
+    end
+    
+    it "should propagate an error if no error callback is declared" do
+        @foo.stub!(:enter).and_raise("Cannot enter safe")
+        lambda{@foo.close!}.should raise_error(StandardError, "Cannot enter safe")  
+    end
+  end
+
+  describe "with aasm_event_fired defined" do
+    before do
+      @foo = Foo.new
+      def @foo.aasm_event_fired(event, from, to)
+      end
+    end
+
+    it 'should call it for successful bang fire' do
+      @foo.should_receive(:aasm_event_fired).with(:close, :open, :closed)
+      @foo.close!
+    end
+
+    it 'should call it for successful non-bang fire' do
+      @foo.should_receive(:aasm_event_fired)
+      @foo.close
+    end
+
+    it 'should not call it for failing bang fire' do
+      @foo.stub!(:set_aasm_current_state_with_persistence).and_return(false)
+      @foo.should_not_receive(:aasm_event_fired)
+      @foo.close!
+    end
+  end
+
+  describe "with aasm_event_failed defined" do
+    before do
+      @foo = Foo.new
+      def @foo.aasm_event_failed(event, from)
+      end
+    end
+
+    it 'should call it when transition failed for bang fire' do
+      @foo.should_receive(:aasm_event_failed).with(:null, :open)
+      @foo.null!
+    end
+
+    it 'should call it when transition failed for non-bang fire' do
+      @foo.should_receive(:aasm_event_failed).with(:null, :open)
+      @foo.null
+    end
+
+    it 'should not call it if persist fails for bang fire' do
+      @foo.stub!(:set_aasm_current_state_with_persistence).and_return(false)
+      @foo.should_receive(:aasm_event_failed)
+      @foo.close!
+    end
+  end
+end
+
+describe AASM, '- state actions' do
+  it "should call enter when entering state" do
+    foo = Foo.new
+    foo.should_receive(:enter)
+
+    foo.close
+  end
+
+  it "should call exit when exiting state" do
+    foo = Foo.new
+    foo.should_receive(:exit)
+
+    foo.close
+  end
+end
+
+
+describe Baz do
+  it "should have the same states as it's parent" do
+    Baz.aasm_states.should == Bar.aasm_states
+  end
+
+  it "should have the same events as it's parent" do
+    Baz.aasm_events.should == Bar.aasm_events
+  end
+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
+
+
+describe ChetanPatil do
+  it 'should transition to specified next state (sleeping to showering)' do
+    cp = ChetanPatil.new
+    cp.wakeup! :showering
+
+    cp.aasm_current_state.should == :showering
+  end
+
+  it 'should transition to specified next state (sleeping to working)' do
+    cp = ChetanPatil.new
+    cp.wakeup! :working
+
+    cp.aasm_current_state.should == :working
+  end
+
+  it 'should transition to default (first or showering) state' do
+    cp = ChetanPatil.new
+    cp.wakeup!
+
+    cp.aasm_current_state.should == :showering
+  end
+
+  it 'should transition to default state when on_transition invoked' do
+    cp = ChetanPatil.new
+    cp.dress!(nil, 'purple', 'dressy')
+
+    cp.aasm_current_state.should == :working
+  end
+
+  it 'should call on_transition method with args' do
+    cp = ChetanPatil.new
+    cp.wakeup! :showering
+
+    cp.should_receive(:wear_clothes).with('blue', 'jeans')
+    cp.dress! :working, 'blue', 'jeans'
+  end
+
+  it 'should call on_transition proc' do
+    cp = ChetanPatil.new
+    cp.wakeup! :showering
+
+    cp.should_receive(:wear_clothes).with('purple', 'slacks')
+    cp.dress!(:dating, 'purple', 'slacks')
+  end
+
+  it 'should call on_transition with an array of methods' do
+    cp = ChetanPatil.new
+    cp.wakeup! :showering
+    cp.should_receive(:condition_hair)
+    cp.should_receive(:fix_hair)
+    cp.dress!(:prettying_up)
+  end
+end