transitions 0.1.5 → 0.1.6

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 1.0.6
+
+* (troessner) Revert 'Fixing set_initial_state with Mongoid' because of https://github.com/troessner/transitions/issues/76
+* (divins) Multiple success callbacks
+* (cstrahan) Pass additional args to guard function
+* (cmw) Support for configurable column names
+
 # 1.0.5
 
 * (troessner) Fix unhelpful error message when event can not be fired.

data/README.rdoc

@@ -44,7 +44,7 @@ This goes into your Gemfile:
    end
  end
 
-In this example we assume that you are in a rails project using Bundler, which would automitcally require `transitions`.
+In this example we assume that you are in a rails project using Bundler, which would automatically require `transitions`.
 If this is not the case for you you have to add
 
  require 'transitions'
@@ -98,6 +98,17 @@ you can use this feature a la:
   >> Order.pick_line_items
   => [#<Order id: 3, state: "pick_line_items", description: nil, created_at: "2011-08-23 15:48:46", updated_at: "2011-08-23 15:48:46">]
 
+==== Using <tt>guard</tt>
+
+Each event definition takes an optional "guard" argument, which acts as a predicate for the transition.
+You can pass in a Symbol, a String, or a Proc like this:
+
+  event :discontinue do
+    transitions :to => :discontinued, :from => [:available, :out_of_stock], :guard => :can_discontinue
+  end
+
+Any arguments passed to the event method will be passed on to the <tt>guard</tt> predicate.
+
 ==== Using <tt>on_transition</tt>
 
 Each event definition takes an optional "on_transition" argument, which allows you to execute methods on transition.
@@ -107,6 +118,8 @@ You can pass in a Symbol, a String, a Proc or an Array containing method names a
     transitions :to => :discontinued, :from => [:available, :out_of_stock], :on_transition => [:do_discontinue, :notify_clerk]
   end
 
+Any arguments passed to the event method will be passed on to the <tt>on_transition</tt> callback.
+
 ==== Using <tt>success</tt>
 
 In case you need to trigger a method call after a successful transition you can use <tt>success</tt>:
@@ -122,6 +135,12 @@ perfom some more complex success callbacks:
     transitions :to => :discontinued, :from => [:available, :out_of_stock]
   end
 
+If you need it, you can even call multiple methods or lambdas just passing an array:
+
+  event :discontinue, :success => [:notify_admin, lambda { |order| AdminNotifier.notify_about_discontinued_order(order) }] do
+    transitions :to => :discontinued, :from => [:available, :out_of_stock]
+  end
+
 ==== Timestamps
 
 If you'd like to note the time of a state change, Transitions comes with timestamps free!
@@ -167,6 +186,20 @@ You can easily get a listing of all available states:
     state :closed
   end
 
+=== Configuring a different column name with ActiveRecord
+
+To use a different column than <tt>state</tt> to track it's value simply do this:
+
+  class Product < ActiveRecord::Base
+    include Transitions
+    
+    state_machine :attribute_name => :different_column do
+    
+      ...
+    
+    end
+  end
+
 === Documentation, Guides & Examples
 
 - {Online API Documentation}[http://rdoc.info/github/troessner/transitions/master/Transitions]

data/lib/active_model/transitions.rb

@@ -25,9 +25,31 @@ module ActiveModel
     extend ActiveSupport::Concern
 
     included do
+      class ::Transitions::Machine
+        unless instance_methods.include?(:new_initialize) || instance_methods.include?(:new_update)
+          attr_reader :attribute_name
+          alias :old_initialize :initialize
+          alias :old_update :update
+
+          def new_initialize(*args, &block)
+            @attribute_name = :state
+            old_initialize(*args, &block)
+          end
+
+          def new_update(options = {}, &block)
+            @attribute_name = options[:attribute_name] if options.key?(:attribute_name)
+            old_update(options, &block)
+          end
+
+          alias :initialize :new_initialize
+          alias :update :new_update
+        else
+          puts "WARNING: Transitions::Machine#new_update or Transitions::Machine#new_initialize already defined. This can possibly break ActiveModel::Transitions."
+        end
+      end
       include ::Transitions
       after_initialize :set_initial_state
-      validates_presence_of :state
+      validate :state_presence
       validate :state_inclusion
     end
     
@@ -43,6 +65,10 @@ module ActiveModel
 
     protected
 
+    def transitions_state_column_name
+      self.class.state_machine.attribute_name
+    end
+
     def write_state(state)
       prev_state = current_state
       write_state_without_persistence(state)
@@ -55,22 +81,27 @@ module ActiveModel
     def write_state_without_persistence(state)
       ivar = self.class.get_state_machine.current_state_variable
       instance_variable_set(ivar, state)
-      self.state = state.to_s
+      self[transitions_state_column_name] = state.to_s
     end
 
     def read_state
-      self.state && self.state.to_sym
+      self[transitions_state_column_name] && self[transitions_state_column_name].to_sym
     end
 
     def set_initial_state
-      self.state ||= self.class.get_state_machine.initial_state.to_s if self.respond_to?(:state=)
+      self[transitions_state_column_name] ||= self.class.get_state_machine.initial_state.to_s if self.has_attribute?(transitions_state_column_name)
+    end
+
+    def state_presence
+      unless self[transitions_state_column_name].present?
+        self.errors.add(transitions_state_column_name, :presence)
+      end
     end
 
     def state_inclusion
-      unless self.class.get_state_machine.states.map{|s| s.name.to_s }.include?(self.state.to_s)
-        self.errors.add(:state, :inclusion, :value => self.state)
+      unless self.class.get_state_machine.states.map{|s| s.name.to_s }.include?(self[transitions_state_column_name].to_s)
+        self.errors.add(transitions_state_column_name, :inclusion, :value => self[transitions_state_column_name])
       end
     end
   end
 end
-

data/lib/transitions/event.rb

@@ -49,7 +49,7 @@ module Transitions
       next_state = nil
       transitions.each do |transition|
         next if to_state && !Array(transition.to).include?(to_state)
-        if transition.perform(obj)
+        if transition.perform(obj, *args)
           next_state = to_state || Array(transition.to).first
           transition.execute(obj, *args)
           break
@@ -78,7 +78,7 @@ module Transitions
     end
 
     def update(options = {}, &block)
-      @success       = build_sucess_callback(options[:success]) if options.key?(:success)
+      @success       = build_success_callback(options[:success]) if options.key?(:success)
       self.timestamp = options[:timestamp] if options[:timestamp]
       instance_eval(&block) if block
       self
@@ -129,12 +129,18 @@ module Transitions
       end
     end
 
-    def build_sucess_callback(callback_symbol_or_proc)
-      case callback_symbol_or_proc
+    def build_success_callback(callback_names)
+      case callback_names
+      when Array
+        lambda do |record|
+          callback_names.each do |callback|
+            build_success_callback(callback).call(record)
+          end
+        end
       when Proc
-        callback_symbol_or_proc
+        callback_names
       when Symbol
-        lambda { |record| record.send(callback_symbol_or_proc) }
+        lambda { |record| record.send(callback_names) }
       end
     end
 

data/lib/transitions/state_transition.rb

@@ -29,12 +29,12 @@ module Transitions
       @options = opts
     end
 
-    def perform(obj)
+    def perform(obj, *args)
       case @guard
       when Symbol, String
-        obj.send(@guard)
+        obj.send(@guard, *args)
       when Proc
-        @guard.call(obj)
+        @guard.call(obj, *args)
       else
         true
       end

data/lib/transitions/version.rb

@@ -1,3 +1,3 @@
 module Transitions
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

data/test/active_record/test_active_record.rb

@@ -11,6 +11,17 @@ end
 
 set_up_db CreateTrafficLights
 
+class CreateDifferentTrafficLights < ActiveRecord::Migration
+  def self.up
+    create_table(:different_traffic_lights) do |t|
+      t.string :different_state
+      t.string :name
+    end
+  end
+end
+
+set_up_db CreateDifferentTrafficLights
+
 class TrafficLight < ActiveRecord::Base
   include ActiveModel::Transitions
 
@@ -147,3 +158,148 @@ class TestActiveRecord < Test::Unit::TestCase
     assert_equal "red", @light.reload.state
   end
 end
+
+class TestNewActiveRecord < TestActiveRecord
+
+  def setup
+    set_up_db CreateTrafficLights
+    @light = TrafficLight.new
+  end
+
+  test "new active records defaults current state to the initial state" do
+    assert_equal :off, @light.current_state
+  end
+
+end
+
+class TestScopes < Test::Unit::TestCase
+  test "scope returns correct object" do
+    @light = TrafficLight.create!
+    assert_respond_to TrafficLight, :off
+    assert_equal TrafficLight.off.first, @light
+    assert TrafficLight.red.empty?
+  end
+
+  test "scopes exist" do
+    assert_respond_to TrafficLight, :off
+    assert_respond_to TrafficLight, :red
+    assert_respond_to TrafficLight, :green
+    assert_respond_to TrafficLight, :yellow
+  end
+
+  test 'scopes are only generated if we explicitly say so' do
+    assert_not_respond_to LightBulb, :off
+    assert_not_respond_to LightBulb, :on
+  end
+
+  test 'scope generation raises an exception if we try to overwrite an existing method' do
+    assert_raise(Transitions::InvalidMethodOverride) {
+      class Light < ActiveRecord::Base
+        include ActiveModel::Transitions
+
+        state_machine :auto_scopes => true do
+          state :new
+          state :broken
+        end
+      end
+    }
+  end
+end
+
+class DifferentTrafficLight < ActiveRecord::Base
+  include ActiveModel::Transitions
+
+  state_machine :attribute_name => :different_state, :auto_scopes => true do
+    state :off
+
+    state :red
+    state :green
+    state :yellow
+
+    event :red_on do
+      transitions :to => :red, :from => [:yellow]
+    end
+
+    event :green_on do
+      transitions :to => :green, :from => [:red]
+    end
+
+    event :yellow_on do
+      transitions :to => :yellow, :from => [:green]
+    end
+
+    event :reset do
+      transitions :to => :red, :from => [:off]
+    end
+  end
+end
+
+class TestActiveRecordWithDifferentColumnName < Test::Unit::TestCase
+  def setup
+    set_up_db CreateDifferentTrafficLights
+    @light = DifferentTrafficLight.create!
+  end
+
+  test "new record has the initial state set" do
+    @light = DifferentTrafficLight.new
+    assert_equal "off", @light.different_state
+  end
+
+  test "states initial state" do
+    assert @light.off?
+    assert_equal :off, @light.current_state
+  end
+
+  test "transition to a valid state" do
+    @light.reset
+    assert @light.red?
+    assert_equal :red, @light.current_state
+
+    @light.green_on
+    assert @light.green?
+    assert_equal :green, @light.current_state
+  end
+
+  test "transition does not persist state" do
+    @light.reset
+    assert_equal :red, @light.current_state
+    @light.reload
+    assert_equal "off", @light.different_state
+  end
+
+  test "transition does persists state" do
+    @light.reset!
+    assert_equal :red, @light.current_state
+    @light.reload
+    assert_equal "red", @light.different_state
+  end
+
+  test "transition to an invalid state" do
+    assert_raise(Transitions::InvalidTransition) { @light.yellow_on }
+    assert_equal :off, @light.current_state
+  end
+
+  test "transition with wrong state will not validate" do
+    for s in @light.class.state_machine.states
+      @light.different_state = s.name
+      assert @light.valid?
+    end
+    @light.different_state = "invalid_one"
+    assert_false @light.valid?
+  end
+
+  test "reloading model resets current state" do
+    @light.reset
+    assert @light.red?
+    @light.update_attribute(:different_state, 'green')
+    assert @light.reload.green?, "reloaded state should come from database, not instance variable"
+  end
+  
+  test "calling non-bang event updates state attribute" do
+    @light.reset!
+    assert @light.red?
+    @light.green_on
+    assert_equal "green", @light.different_state
+    assert_equal "red", @light.reload.different_state
+  end
+end

data/test/event/test_event.rb

@@ -5,6 +5,7 @@ class TestEvent < Test::Unit::TestCase
     @state_name = :close_order
     @success_as_symbol = :success_callback
     @success_as_lambda = lambda { |record| record.success_callback }
+    @success_as_array  = [@success_as_symbol, @success_as_lambda]
   end
 
   def event_with_symbol_success_callback
@@ -20,6 +21,12 @@ class TestEvent < Test::Unit::TestCase
     end
   end
 
+  def event_with_array_success_callback
+    @event = Transitions::Event.new(nil, @state_name, {:success => @success_as_array}) do
+      transitions :to => :closed, :from => [:open, :received]
+    end
+  end
+
   test "should set the name" do
     assert_equal @state_name, new_event.name
   end
@@ -39,6 +46,24 @@ class TestEvent < Test::Unit::TestCase
     assert_respond_to event_with_lambda_success_callback.success, :call
   end
 
+  test "should build a block which calls the given success_callback lambda on the passed record instance" do
+    record = mock("SomeRecordToGetCalled")
+    record.expects(:success_callback)
+
+    event_with_lambda_success_callback.success.call(record)
+  end
+
+  test "should set the success callback with an array" do
+    assert_respond_to event_with_array_success_callback.success, :call
+  end
+
+  test "should build a block which calls the given success_callback array on the passed record instance for each callback" do
+    record = mock("SomeRecordToGetCalled")
+    record.expects(:success_callback).twice
+
+    event_with_array_success_callback.success.call(record)
+  end
+
   test "should create StateTransitions" do
     Transitions::StateTransition.expects(:new).with(:to => :closed, :from => :open)
     Transitions::StateTransition.expects(:new).with(:to => :closed, :from => :received)

data/test/state_transition/test_state_transition_guard_check.rb

@@ -1,11 +1,13 @@
 require "helper"
 
 class TestStateTransitionGuardCheck < Test::Unit::TestCase
+  args = [:foo, "bar"]
+
   test "should return true of there is no guard" do
     opts = {:from => "foo", :to => "bar"}
       st = Transitions::StateTransition.new(opts)
 
-    assert st.perform(nil)
+    assert st.perform(nil, *args)
   end
 
   test "should call the method on the object if guard is a symbol" do
@@ -13,9 +15,9 @@ class TestStateTransitionGuardCheck < Test::Unit::TestCase
     st = Transitions::StateTransition.new(opts)
 
     obj = stub
-    obj.expects(:test_guard)
+    obj.expects(:test_guard).with(*args)
 
-    st.perform(obj)
+    st.perform(obj, *args)
   end
 
   test "should call the method on the object if guard is a string" do
@@ -23,18 +25,18 @@ class TestStateTransitionGuardCheck < Test::Unit::TestCase
     st = Transitions::StateTransition.new(opts)
 
     obj = stub
-    obj.expects(:test_guard)
+    obj.expects(:test_guard).with(*args)
 
-    st.perform(obj)
+    st.perform(obj, *args)
   end
 
   test "should call the proc passing the object if the guard is a proc" do
-    opts = {:from => "foo", :to => "bar", :guard => Proc.new {|o| o.test_guard}}
+    opts = {:from => "foo", :to => "bar", :guard => Proc.new {|o, *args| o.test_guard(*args)}}
     st = Transitions::StateTransition.new(opts)
 
     obj = stub
-    obj.expects(:test_guard)
+    obj.expects(:test_guard).with(*args)
 
-    st.perform(obj)
+    st.perform(obj, *args)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: transitions
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-28 00:00:00.000000000 Z
+date: 2013-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -179,7 +179,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1071042129
+      hash: -1024202641
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: