aasm 3.0.16 → 3.0.17

data/lib/aasm/persistence/read_state.rb

@@ -1,40 +0,0 @@
-module AASM
-  module Persistence
-    module ReadState
-
-      # Returns the value of the aasm_column - called from <tt>aasm_current_state</tt>
-      #
-      # If it's a new record, and the aasm state column is blank it returns the initial state
-      # (example provided here for ActiveRecord, but it's true for Mongoid as well):
-      #
-      #   class Foo < ActiveRecord::Base
-      #     include AASM
-      #     aasm_column :status
-      #     aasm_state :opened
-      #     aasm_state :closed
-      #   end
-      #
-      #   foo = Foo.new
-      #   foo.current_state # => :opened
-      #   foo.close
-      #   foo.current_state # => :closed
-      #
-      #   foo = Foo.find(1)
-      #   foo.current_state # => :opened
-      #   foo.aasm_state = nil
-      #   foo.current_state # => nil
-      #
-      # NOTE: intended to be called from an event
-      #
-      # 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? ? 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
-      end
-
-    end # ReadState
-  end # Persistence
-end # AASM

data/lib/aasm/supporting_classes/event.rb

@@ -1,146 +0,0 @@
-module AASM
-  module SupportingClasses
-    class Event
-      attr_reader :name, :success, :options
-
-      def initialize(name, options = {}, &block)
-        @name = name
-        @transitions = []
-        update(options, &block)
-      end
-
-      # a neutered version of fire - it doesn't actually fire the event, it just
-      # executes the transition guards to determine if a transition is even
-      # an option given current conditions.
-      def may_fire?(obj, to_state=nil, *args)
-        _fire(obj, true, to_state, *args) # true indicates test firing
-      end
-
-      def fire(obj, to_state=nil, *args)
-        _fire(obj, false, to_state, *args) # false indicates this is not a test (fire!)
-      end
-
-      def transitions_from_state?(state)
-        transitions_from_state(state).any?
-      end
-
-      def transitions_from_state(state)
-        @transitions.select { |t| t.from == state }
-      end
-
-      def transitions_to_state?(state)
-        transitions_to_state(state).any?
-      end
-
-      def transitions_to_state(state)
-        @transitions.select { |t| t.to == state }
-      end
-
-      def all_transitions
-        @transitions
-      end
-
-      def fire_callbacks(action, record)
-        action = @options[action]
-        action.is_a?(Array) ?
-                action.each {|a| _fire_callbacks(a, record)} :
-                _fire_callbacks(action, record)
-      end
-
-      def ==(event)
-        if event.is_a? Symbol
-          name == event
-        else
-          name == event.name
-        end
-      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 execute_error_callback(obj, error, error_callback=nil)
-        callback = error_callback || @error
-        raise error unless callback
-        case(callback)
-          when String, Symbol
-            raise NoMethodError unless obj.respond_to?(callback.to_sym)
-            obj.send(callback, error)
-          when Proc
-            callback.call(obj, error)
-          when Array
-            callback.each{|meth|self.execute_error_callback(obj, error, meth)}
-        end
-      end
-
-    private
-
-      def update(options = {}, &block)
-        if options.key?(:success) then
-          @success = options[:success]
-        end
-        if options.key?(:error) then
-          @error = options[:error]
-        end
-        if block then
-          instance_eval(&block)
-        end
-        @options = options
-        self
-      end
-
-      # Execute if test? == false, otherwise return true/false depending on whether it would fire
-      def _fire(obj, test, to_state=nil, *args)
-        if @transitions.map(&:from).any?
-          transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
-          return nil if transitions.size == 0
-        else
-          transitions = @transitions
-        end
-
-        result = test ? false : nil
-        transitions.each do |transition|
-          next if to_state and !Array(transition.to).include?(to_state)
-          if transition.perform(obj, *args)
-            if test
-              result = true
-            else
-              result = to_state || Array(transition.to).first
-              transition.execute(obj, *args)
-            end
-
-            break
-          end
-        end
-        result
-      end
-
-      def _fire_callbacks(action, record)
-        case action
-          when Symbol, String
-            record.send(action)
-          when Proc
-            action.call(record)
-        end
-      end
-
-      def transitions(trans_opts)
-        # Create a separate transition for each from state to the given state
-        Array(trans_opts[:from]).each do |s|
-          @transitions << AASM::SupportingClasses::StateTransition.new(trans_opts.merge({:from => s.to_sym}))
-        end
-        # Create a transition if to is specified without from (transitions from ANY state)
-        @transitions << AASM::SupportingClasses::StateTransition.new(trans_opts) if @transitions.empty? && trans_opts[:to]
-      end
-
-    end
-  end # SupportingClasses
-end # AASM

data/lib/aasm/supporting_classes/localizer.rb

@@ -1,56 +0,0 @@
-module AASM
-  module SupportingClasses
-    class Localizer
-      def human_event_name(klass, event)
-        checklist = ancestors_list(klass).inject([]) do |list, ancestor|
-          list << :"#{i18n_scope(klass)}.events.#{i18n_klass(ancestor)}.#{event}"
-          list
-        end
-        translate_queue(checklist) || I18n.translate(checklist.shift, :default => event.to_s.humanize)
-      end
-
-      def human_state_name(klass, state)
-        checklist = ancestors_list(klass).inject([]) do |list, ancestor|
-          list << item_for(klass, state, ancestor)
-          list << item_for(klass, state, ancestor, :old_style => true)
-          list
-        end
-        translate_queue(checklist) || I18n.translate(checklist.shift, :default => state.to_s.humanize)
-      end
-
-    private
-
-      def item_for(klass, state, ancestor, options={})
-        separator = options[:old_style] ? '.' : '/'
-        :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm_column}#{separator}#{state}"
-      end
-
-      def translate_queue(checklist)
-        (0...(checklist.size-1)).each do |i|
-          begin
-            return I18n.translate(checklist.shift, :raise => true)
-          rescue I18n::MissingTranslationData
-            # that's okay
-          end
-        end
-        nil
-      end
-
-      # added for rails 2.x compatibility
-      def i18n_scope(klass)
-        klass.respond_to?(:i18n_scope) ? klass.i18n_scope : :activerecord
-      end
-
-      # added for rails < 3.0.3 compatibility
-      def i18n_klass(klass)
-        klass.model_name.respond_to?(:i18n_key) ? klass.model_name.i18n_key : klass.name.underscore
-      end
-
-      def ancestors_list(klass)
-        klass.ancestors.select do |ancestor|
-          ancestor.respond_to?(:model_name) unless ancestor == ActiveRecord::Base
-        end
-      end
-    end
-  end # SupportingClasses
-end # AASM

data/lib/aasm/supporting_classes/state.rb

@@ -1,80 +0,0 @@
-module AASM
-  module SupportingClasses
-    class State
-      attr_reader :name, :options
-
-      def initialize(name, clazz, options={})
-        @name = name
-        @clazz = clazz
-        update(options)
-      end
-
-      def ==(state)
-        if state.is_a? Symbol
-          name == state
-        else
-          name == state.name
-        end
-      end
-
-      def <=>(state)
-        if state.is_a? Symbol
-          name <=> state
-        else
-          name <=> state.name
-        end
-      end
-
-      def to_s
-        name.to_s
-      end
-
-      def fire_callbacks(action, record)
-        action = @options[action]
-        catch :halt_aasm_chain do
-          action.is_a?(Array) ?
-                  action.each {|a| _fire_callbacks(a, record)} :
-                  _fire_callbacks(action, record)
-        end
-      end
-
-      def display_name
-        @display_name ||= begin
-          if Module.const_defined?(:I18n)
-            localized_name
-          else
-            name.to_s.gsub(/_/, ' ').capitalize
-          end
-        end
-      end
-
-      def localized_name
-        AASM::SupportingClasses::Localizer.new.human_state_name(@clazz, self)
-      end
-
-      def for_select
-        [display_name, name.to_s]
-      end
-
-    private
-
-      def update(options = {})
-        if options.key?(:display) then
-          @display_name = options.delete(:display)
-        end
-        @options = options
-        self
-      end
-
-      def _fire_callbacks(action, record)
-        case action
-          when Symbol, String
-            record.send(action)
-          when Proc
-            action.call(record)
-        end
-      end
-
-    end
-  end # SupportingClasses
-end # AASM

data/lib/aasm/supporting_classes/state_transition.rb

@@ -1,51 +0,0 @@
-module AASM
-  module SupportingClasses
-    class 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
-
-      # TODO: should be named allowed? or similar
-      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
-  end # SupportingClasses
-end # AASM

data/spec/spec_helpers/models_spec_helper.rb

@@ -1,64 +0,0 @@
-Dir[File.dirname(__FILE__) + "/../models/*.rb"].sort.each { |f| require File.expand_path(f) }
-
-class Foo
-  include AASM
-  aasm do
-    state :open, :initial => true, :exit => :exit
-    state :closed, :enter => :enter
-
-    event :close, :success => :success_callback do
-      transitions :to => :closed, :from => [:open]
-    end
-
-    event :null do
-      transitions :to => :closed, :from => [:open], :guard => :always_false
-    end
-  end
-
-  def always_false
-    false
-  end
-
-  def success_callback
-  end
-
-  def enter
-  end
-  def exit
-  end
-end
-
-class FooTwo < Foo
-  include AASM
-  aasm do
-    state :foo
-  end
-end
-
-class Bar
-  include AASM
-
-  aasm do
-    state :read
-    state :ended
-
-    event :foo do
-      transitions :to => :ended, :from => [:read]
-    end
-  end
-end
-
-class Baz < Bar
-end
-
-class ThisNameBetterNotBeInUse
-  include AASM
-
-  aasm do
-    state :initial
-    state :symbol
-    state :string
-    state :array
-    state :proc
-  end
-end

data/spec/unit/supporting_classes/event_spec.rb

@@ -1,203 +0,0 @@
-require 'spec_helper'
-
-describe 'adding an event' do
-  let(:event) do
-    AASM::SupportingClasses::Event.new(:close_order, {:success => :success_callback}) do
-      transitions :to => :closed, :from => [:open, :received]
-    end
-  end
-
-  it 'should set the name' do
-    event.name.should == :close_order
-  end
-
-  it 'should set the success callback' do
-    event.success.should == :success_callback
-  end
-
-  it 'should create transitions' do
-    transitions = event.all_transitions
-    transitions[0].from.should == :open
-    transitions[0].to.should == :closed
-    transitions[1].from.should == :received
-    transitions[1].to.should == :closed
-  end
-end
-
-describe 'transition inspection' do
-  let(:event) do
-    AASM::SupportingClasses::Event.new(:run) do
-      transitions :to => :running, :from => :sleeping
-    end
-  end
-
-  it 'should support inspecting transitions from other states' do
-    event.transitions_from_state(:sleeping).map(&:to).should == [:running]
-    event.transitions_from_state?(:sleeping).should be_true
-
-    event.transitions_from_state(:cleaning).map(&:to).should == []
-    event.transitions_from_state?(:cleaning).should be_false
-  end
-
-  it 'should support inspecting transitions to other states' do
-    event.transitions_to_state(:running).map(&:from).should == [:sleeping]
-    event.transitions_to_state?(:running).should be_true
-
-    event.transitions_to_state(:cleaning).map(&:to).should == []
-    event.transitions_to_state?(:cleaning).should be_false
-  end
-end
-
-describe 'firing an event' do
-  it 'should return nil if the transitions are empty' do
-    obj = mock('object')
-    obj.stub!(:aasm_current_state)
-
-    event = AASM::SupportingClasses::Event.new(:event)
-    event.fire(obj).should be_nil
-  end
-
-  it 'should return the state of the first matching transition it finds' do
-    event = AASM::SupportingClasses::Event.new(:event) do
-      transitions :to => :closed, :from => [:open, :received]
-    end
-
-    obj = mock('object')
-    obj.stub!(:aasm_current_state).and_return(:open)
-
-    event.fire(obj).should == :closed
-  end
-
-  it 'should call the guard with the params passed in' do
-    event = AASM::SupportingClasses::Event.new(:event) do
-      transitions :to => :closed, :from => [:open, :received], :guard => :guard_fn
-    end
-
-    obj = mock('object')
-    obj.stub!(:aasm_current_state).and_return(:open)
-    obj.should_receive(:guard_fn).with('arg1', 'arg2').and_return(true)
-
-    event.fire(obj, nil, 'arg1', 'arg2').should == :closed
-  end
-
-end
-
-describe 'executing the success callback' do
-
-  it "should send the success callback if it's a symbol" do
-    ThisNameBetterNotBeInUse.instance_eval {
-      aasm_event :with_symbol, :success => :symbol_success_callback do
-        transitions :to => :symbol, :from => [:initial]
-      end
-    }
-
-    model = ThisNameBetterNotBeInUse.new
-    model.should_receive(:symbol_success_callback)
-    model.with_symbol!
-  end
-
-  it "should send the success callback if it's a string" do
-    ThisNameBetterNotBeInUse.instance_eval {
-      aasm_event :with_string, :success => 'string_success_callback' do
-        transitions :to => :string, :from => [:initial]
-      end
-    }
-
-    model = ThisNameBetterNotBeInUse.new
-    model.should_receive(:string_success_callback)
-    model.with_string!
-  end
-
-  it "should call each success callback if passed an array of strings and/or symbols" do
-    ThisNameBetterNotBeInUse.instance_eval {
-      aasm_event :with_array, :success => [:success_callback1, 'success_callback2'] do
-        transitions :to => :array, :from => [:initial]
-      end
-    }
-
-    model = ThisNameBetterNotBeInUse.new
-    model.should_receive(:success_callback1)
-    model.should_receive(:success_callback2)
-    model.with_array!
-  end
-
-  it "should call each success callback if passed an array of strings and/or symbols and/or procs" do
-    ThisNameBetterNotBeInUse.instance_eval {
-      aasm_event :with_array_including_procs, :success => [:success_callback1, 'success_callback2', lambda { |obj| obj.proc_success_callback }] do
-        transitions :to => :array, :from => [:initial]
-      end
-    }
-
-    model = ThisNameBetterNotBeInUse.new
-    model.should_receive(:success_callback1)
-    model.should_receive(:success_callback2)
-    model.should_receive(:proc_success_callback)
-    model.with_array_including_procs!
-  end
-
-  it "should call the success callback if it's a proc" do
-    ThisNameBetterNotBeInUse.instance_eval {
-      aasm_event :with_proc, :success => lambda { |obj| obj.proc_success_callback } do
-        transitions :to => :proc, :from => [:initial]
-      end
-    }
-
-    model = ThisNameBetterNotBeInUse.new
-    model.should_receive(:proc_success_callback)
-    model.with_proc!
-  end
-end
-
-describe 'parametrised events' do
-  let(:pe) {ParametrisedEvent.new}
-
-  it 'should transition to specified next state (sleeping to showering)' do
-    pe.wakeup!(:showering)
-    pe.aasm_current_state.should == :showering
-  end
-
-  it 'should transition to specified next state (sleeping to working)' do
-    pe.wakeup!(:working)
-    pe.aasm_current_state.should == :working
-  end
-
-  it 'should transition to default (first or showering) state' do
-    pe.wakeup!
-    pe.aasm_current_state.should == :showering
-  end
-
-  it 'should transition to default state when on_transition invoked' do
-    pe.dress!(nil, 'purple', 'dressy')
-    pe.aasm_current_state.should == :working
-  end
-
-  it 'should call on_transition method with args' do
-    pe.wakeup!(:showering)
-    pe.should_receive(:wear_clothes).with('blue', 'jeans')
-    pe.dress!(:working, 'blue', 'jeans')
-  end
-
-  it 'should call on_transition proc' do
-    pe.wakeup!(:showering)
-    pe.should_receive(:wear_clothes).with('purple', 'slacks')
-    pe.dress!(:dating, 'purple', 'slacks')
-  end
-
-  it 'should call on_transition with an array of methods' do
-    pe.wakeup!(:showering)
-    pe.should_receive(:condition_hair)
-    pe.should_receive(:fix_hair)
-    pe.dress!(:prettying_up)
-  end
-end
-
-describe 'event firing without persistence' do
-  it 'should attempt to persist if aasm_write_state is defined' do
-    foo = Foo.new
-    def foo.aasm_write_state; end
-    foo.should be_open
-
-    foo.should_receive(:aasm_write_state_without_persistence)
-    foo.close
-  end
-end