transitions 0.1.8 → 0.1.9

data/.travis.yml

@@ -1 +1,3 @@
-rvm: 1.9.3
+rvm:
+  - 2.0.0
+  - 1.9.3

data/CHANGELOG.md

@@ -1,39 +1,46 @@
-# 1.0.8
+#  0.1.9
+
+* (barelyknow) add can_transition? and cant_transition? methods
+* (barelyknow) add available_events method to class with state machine
+* (Sean Devine) fire enter on create
+* (jotto) change scopes to use proc so it works in rails 3 and 4
+
+# 0.1.8
 
 * (phillipp | Phillipp Röll) Fixes a wrong select for scopes if the state machines attribute_name is set to something other than the default
 
-# 1.0.7
+# 0.1.7
 
 * (cmw) Better prevention of name clashes when creating initializer methods
 
-# 1.0.6
+# 0.1.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
+# 0.1.5
 
 * (troessner) Fix unhelpful error message when event can not be fired.
 * (simonc) Fixing set_initial_state with Mongoid
 
-# 1.0.4
+# 0.1.4
 
 (troessner)
 
 * Raise exception if we try to overwrite existing instance methods when defining state predicate methods
 * Improve exception message if we try to overwrite existing class methods when ActiveRecord scopes
 
-# 1.0.3
+# 0.1.3
 
 (troessner) Make sure `empty?` works on symbols.
 
-# 1.0.2
+# 0.1.2
 
 (troessner) Slightly improved handling of current states.
 
-# 1.0.1
+# 0.1.1
 
 * (troessner) Remove feature:
                 `Do not override existing methods when defining state query methods but warn the user.`
@@ -41,7 +48,7 @@
               https://github.com/troessner/transitions/issues/62 for details.
 * (bnmrrs) Add helper methods to check if a given transition is possible.
 
-# 1.0.0
+# 0.1.0
 
 (troessner) Remove suppport for multipe state machines
 

data/README.md

@@ -0,0 +1,291 @@
+### Overview 
+
+[<img
+src="https://secure.travis-ci.org/troessner/transitions.png?branch=master"/>](
+http://travis-ci.org/troessner/transitions) [<img
+src="https://badge.fury.io/rb/transitions.png" alt="Gem Version"
+/>](http://badge.fury.io/rb/transitions)
+
+### Synopsis
+
+`transitions` is a ruby state machine implementation.
+
+### Compatibility
+
+Supported ruby versions:
+
+*   1.9.3
+*   2.0
+
+`transitions` does not work with ruby 1.8.7 (see [this
+issue](https://github.com/troessner/transitions/issues/86) for example).
+
+### Installation
+
+#### Rails
+
+This goes into your Gemfile:
+
+    gem "transitions", :require => ["transitions", "active_model/transitions"]
+
+… and this into your ORM model:
+
+    include ActiveModel::Transitions
+
+#### Standalone
+
+    gem install transitions
+
+### Using transitions
+
+    class Product
+      include ActiveModel::Transitions
+
+      state_machine do
+        state :available # first one is initial state
+        state :out_of_stock, :exit => :exit_out_of_stock
+        state :discontinued, :enter => lambda { |product| product.cancel_orders }
+
+        event :discontinued do
+          transitions :to => :discontinued, :from => [:available, :out_of_stock], :on_transition => :do_discontinue
+        end
+        event :out_of_stock, :success => :reorder do
+          transitions :to => :out_of_stock, :from => [:available, :discontinued]
+        end
+        event :available do
+          transitions :to => :available, :from => [:out_of_stock], :guard => lambda { |product| product.in_stock > 0 }
+        end
+      end
+    end
+
+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'
+
+wherever you load your dependencies in your application.
+
+**Known limitations:** 
+
+*   You can only use one state machine per model. While in theory you can
+    define two or more, this won't work as you would expect. Not supporting
+    this was intentional, if you're interested in the ratione look up version
+    1.0.0 in the CHANGELOG.
+
+*   Use symbols, not strings for declaring the state machine. Using strings is
+    **not** supported as is using whitespace in names (because `transitions`
+    possibly generates methods out of this).
+
+### Features
+
+#### Getting and setting the current state
+
+Use the (surprise ahead) `current_state` method - in case you didn't set a
+state explicitly you'll get back the state that you defined as initial state.
+
+    >> Product.new.current_state
+    => :available
+
+You can also set a new state explicitly via `update_current_state(new_state,
+persist = true / false)` but you should never do this unless you really know
+what you're doing and why - rather use events / state transitions (see below).
+
+Predicate methods are also available using the name of the state.
+
+    >> Product.new.available?
+    => true
+
+#### Events
+
+When you declare an event, say `discontinue`, three methods are declared for
+you: `discontinue`, `discontinue!` and `can_discontinue?`. The first two
+events will modify the `state` attribute on successful transition, but only
+the bang(!)-version will call `save!`.  The `can_discontinue?` method will not
+modify state but instead returns a boolean letting you know if a given
+transition is possible.
+
+In addition, a `can_transition?` method is added to the object that expects one or more event names as arguments. This semi-verbose method name is used to avoid collission with [https://github.com/ryanb/cancan](the authorization gem CanCan).
+
+    >> Product.new.can_transition? :out_of_stock
+    => true
+
+#### Automatic scope generation
+
+`transitions` will automatically generate scopes for you if you are using
+ActiveRecord and tell it to do so via the `auto_scopes` option:
+
+Given a model like this:
+
+    class Order < ActiveRecord::Base
+      include ActiveModel::Transitions
+      state_machine :auto_scopes => true do
+        state :pick_line_items
+        state :picking_line_items
+        event :move_cart do
+          transitions to: :pick_line_items, from: :picking_line_items
+        end
+      end
+    end
+
+you can use this feature a la:
+
+    >> Order.pick_line_items
+    => []
+    >> Order.create!
+    => #<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">
+    >> 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 `guard`
+
+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 `guard`
+predicate.
+
+#### Using `on_transition`
+
+Each event definition takes an optional `on_transition` argument, which allows
+you to execute methods on transition.
+
+You can pass in a Symbol, a String, a Proc or an Array containing method names
+as Symbol or String like this:
+
+    event :discontinue do
+      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 `on_transition` callback.
+
+`on_transition` is called after `guard` and before `enter` on the state that it is transitioning to.
+
+#### Using `enter` and `exit`
+
+If you want to trigger a method call when the object enters or exits a state regardless
+of the transition that made that happen, use `enter` and `exit`.
+
+`exit` will be called before the transition out of the state is executed. If you want the method
+to only be called if the transition is successful, then use another approach.
+
+`enter` will be called after the transition has been made but before the object is persisted. If you want
+the method to only be called after a successful transition to a new state including persistence,
+use the `success` argument to an event instead.
+
+#### Using `success`
+
+In case you need to trigger a method call after a successful transition you
+can use `success`. This will be called after the `save!` is complete (if you
+use the `state_name!` method) and should be used for any methods that require
+that the object be persisted.
+
+    event :discontinue, :success => :notfiy_admin do
+      transitions :to => :discontinued, :from => [:available, :out_of_stock]
+    end
+
+In addition to just specify the method name on the record as a symbol you can
+pass a lambda to perfom some more complex success callbacks:
+
+    event :discontinue, :success => lambda { |order| AdminNotifier.notify_about_discontinued_order(order) } do
+      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! To activate them, simply pass the `timestamp` option to the
+event definition with a value of either true or the name of the timestamp
+column. *NOTE - This should be either true, a String or a Symbol*
+
+    # This will look for an attribute called exploded_at or exploded_on (in that order)
+    # If present, it will be updated
+    event :explode, :timestamp => true do
+      transitions :from => :complete, :to => :exploded
+    end
+
+    # This will look for an attribute named repaired_on to update upon save
+    event :rebuild, :timestamp => :repaired_on do
+      transitions :from => :exploded, :to => :rebuilt
+    end
+
+#### Using `event_fired` and `event_failed`
+
+In case you define `event_fired` and / or `event_failed`, `transitions` will
+use those callbacks correspondingly.
+
+You can use those callbacks like this:
+
+    def event_fired(current_state, new_state, event)
+      MyLogger.info "Event fired #{event.inspect}"
+    end
+
+    def event_failed(event)
+      MyLogger.warn "Event failed #{event.inspect}"
+    end
+
+#### Listing all the available states and events
+
+You can easily get a listing of all available states:
+
+    Order.available_states # Uses the <tt>default</tt> state machine
+    # => [:pick_line_items, :picking_line_items]
+
+Same goes for the available events:
+
+    Order.available_events
+    # => [:move_cart]
+
+#### Explicitly setting the initial state with the `initial` option
+
+    state_machine :initial => :closed do
+      state :open
+      state :closed
+    end
+
+### Configuring a different column name with ActiveRecord
+
+To use a different column than `state` to track it's value simply do this:
+
+    class Product < ActiveRecord::Base
+      include Transitions
+
+      state_machine :attribute_name => :different_column do
+
+        ...
+
+      end
+    end
+
+### Known bugs / limitations
+
+*   Right now it seems like `transitions` does not play well with `mongoid`. A
+    possible fix had to be rolled back due to other side effects:
+    https://github.com/troessner/transitions/issues/76. Since I know virtually
+    zero about mongoid, a pull request would be highly appreciated.
+*   Multiple state machines are and will not be supported. For the rationale
+    behind this see the Changelog.
+
+
+### Documentation, Guides & Examples
+
+*   [Online API Documentation](http://rdoc.info/github/troessner/transitions/master/Transitions)
+*   [Railscasts #392: A Tour of State Machines](http://railscasts.com/episodes/392-a-tour-of-state-machines) (requires Pro subscription)
+
+
+### Copyright
+
+Copyright (c) 2010 Jakub Kuźma, Timo Rößner. See LICENSE for details.

data/lib/active_model/transitions.rb

@@ -26,7 +26,7 @@ module ActiveModel
 
     included do
       class ::Transitions::Machine
-        unless instance_methods.include?(:new_transitions_initialize) || instance_methods.include?(:new_transitions_update)
+        unless method_defined?(:new_transitions_initialize) || method_defined?(:new_transitions_update)
           attr_reader :attribute_name
           alias :old_transitions_initialize :initialize
           alias :old_transitions_update :update
@@ -88,6 +88,7 @@ module ActiveModel
 
     def set_initial_state
       self[transitions_state_column_name] ||= self.class.get_state_machine.initial_state.to_s if self.has_attribute?(transitions_state_column_name)
+      self.class.get_state_machine.state_index[self[transitions_state_column_name].to_sym].call_action(:enter, self)
     end
 
     def state_presence

data/lib/transitions.rb

@@ -51,6 +51,10 @@ module Transitions
     def available_states
       @state_machine.states.map(&:name).sort_by {|x| x.to_s}
     end
+
+    def available_events
+      @state_machine.events.keys.sort
+    end
   end
 
   def self.included(base)
@@ -68,6 +72,16 @@ module Transitions
     instance_variable_set(ivar, new_state)
   end
 
+  def can_transition?(*events)
+    events.all? do |event|
+      self.class.get_state_machine.events_for(current_state).include?(event.to_sym)
+    end
+  end
+
+  def cant_transition?(*events)
+    !can_transition?(*events)
+  end
+
   def current_state
     sm   = self.class.get_state_machine
     ivar = sm.current_state_variable

data/lib/transitions/machine.rb

@@ -102,7 +102,7 @@ module Transitions
         if @klass.respond_to?(state_name)
           raise InvalidMethodOverride, "Transitions: Can not define scope `#{state_name}` because there is already an equally named method defined - either rename the existing method or the state."
         end
-        @klass.scope state_name, @klass.where(@klass.state_machine.attribute_name => state_name)
+        @klass.scope state_name, -> { @klass.where(@klass.state_machine.attribute_name => state_name) }
       end
     end
   end

data/lib/transitions/state.rb

@@ -67,7 +67,7 @@ module Transitions
     private
     def define_state_query_method(machine)
       method_name, state_name = "#{@name}?", @name # Instance vars are out of scope when calling define_method below, so we use local variables.
-      if machine.klass.instance_methods.include?(method_name.to_sym)
+      if machine.klass.method_defined?(method_name.to_sym)
         raise InvalidMethodOverride, "Transitions: Can not define method `#{method_name}` because it is already defined - either rename the existing method or the state."
       end
       machine.klass.send :define_method, method_name do

data/lib/transitions/version.rb

@@ -1,3 +1,3 @@
 module Transitions
-  VERSION = '0.1.8'
+  VERSION = '0.1.9'
 end

data/test/active_record/test_active_record.rb

@@ -24,9 +24,10 @@ set_up_db CreateDifferentTrafficLights
 
 class TrafficLight < ActiveRecord::Base
   include ActiveModel::Transitions
+  attr_reader :power
 
   state_machine :auto_scopes => true do
-    state :off
+    state :off, enter: :turn_power_on
 
     state :red
     state :green
@@ -48,6 +49,11 @@ class TrafficLight < ActiveRecord::Base
       transitions :to => :red, :from => [:off]
     end
   end
+
+  def turn_power_on
+    raise "the power should not have been on already" if @power == :on
+    @power = :on
+  end
 end
 
 class ProtectedTrafficLight < TrafficLight
@@ -82,6 +88,11 @@ class TestActiveRecord < Test::Unit::TestCase
     assert_equal :off, @light.current_state
   end
 
+  test "calls enter when setting the initial state" do
+    @new_light = TrafficLight.new
+    assert_equal :on, @new_light.power
+  end
+
   test "transition to a valid state" do
     @light.reset
     assert @light.red?

data/test/machine/test_available_states_listing.rb

@@ -7,6 +7,10 @@ class Bender
     state :drinking
     state :smoking
     state :gambling
+
+    event :cough do
+      transitions from: :smoking, to: :gambling
+    end
   end
 end
 
@@ -14,4 +18,7 @@ class TestAvailableStatesListing < Test::Unit::TestCase
   test 'available_states should return the states for the state machine' do
     assert_equal [:drinking, :gambling, :smoking], Bender.available_states
   end
+  test 'available_events should return the events for the state machine' do
+    assert_equal [:cough], Bender.available_events
+  end
 end

data/test/machine/test_machine.rb

@@ -14,6 +14,10 @@ class MachineTestSubject
     event :timeout do
       transitions :from => :open, :to => :closed
     end
+
+    event :restart do
+      transitions :from => :closed, to: :open
+    end
   end
 end
 
@@ -32,6 +36,17 @@ class TransitionsMachineTest < Test::Unit::TestCase
     assert events.include?(:timeout)
   end
 
+  test "knows that it can use a transition when it is available" do
+    machine = MachineTestSubject.new
+    machine.restart
+    assert machine.can_transition?(:shutdown)
+  end
+
+  test "knows that it can't use a transition when it is unavailable" do
+    machine = MachineTestSubject.new
+    assert machine.cant_transition?(:shutdown)
+  end
+
   test "test fire_event" do
     pend "Implement me"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: transitions
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-14 00:00:00.000000000 Z
+date: 2013-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,7 +136,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - lib/active_model/transitions.rb
 - lib/active_record/transitions.rb
@@ -179,7 +179,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 604342113
+      hash: -611477343
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -188,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: transitions
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: State machine extracted from ActiveModel

data/README.rdoc

@@ -1,214 +0,0 @@
-=== Travis Build Status 
-
-{<img src="https://secure.travis-ci.org/troessner/transitions.png?branch=master"/>}[http://travis-ci.org/troessner/transitions]
-
-=== Synopsis
-
-<tt>transitions</tt> is a ruby state machine implementation.
-
-=== Installation
-
-==== Rails
-
-This goes into your Gemfile:
-
- gem "transitions", :require => ["transitions", "active_model/transitions"]
-
-… and this into your ORM model:
-
- include ActiveModel::Transitions
-
-==== Standalone
-
- gem install transitions
-
-=== Using transitions
-
- class Product
-   include ActiveModel::Transitions
- 
-   state_machine do
-     state :available # first one is initial state
-     state :out_of_stock, :exit => :exit_out_of_stock
-     state :discontinued, :enter => lambda { |product| product.cancel_orders }
-   
-     event :discontinued do
-       transitions :to => :discontinued, :from => [:available, :out_of_stock], :on_transition => :do_discontinue
-     end
-     event :out_of_stock do
-       transitions :to => :out_of_stock, :from => [:available, :discontinued]
-     end
-     event :available do
-       transitions :to => :available, :from => [:out_of_stock], :guard => lambda { |product| product.in_stock > 0 }
-     end
-   end
- end
-
-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'
-
-whereever you load your dependencies in your application.
-
-<b>Known limitations:</b> 
-
-* You can only use one state machine per model. While in theory you can define two or more, this won't work as you would expect. Not supporting this was intentional, if you're interested in the ratione look up version 1.0.0 in the CHANGELOG.
-
-* Use symbols, not strings for declaring the state machine. Using strings is *not* supported as is using whitespace in names (because `transitions` possibly generates methods out of this).
-
-=== Features
-
-==== Getting and setting the current state
-
-Use the (surprise ahead) `current_state` method - in case you didn't set a state explicitly you'll get back the state that you defined as initial state.
-
-  >> Product.new.current_state
-  => :available
-
-You can also set a new state explicitly via `update_current_state(new_state, persist = true / false)` but you should never do this unless you really know what you're doing and why - rather use events / state transitions (see below).
-
-==== Events
-
-When you declare an event, say <tt>discontinue</tt>, three methods are declared for
-you: <tt>discontinue</tt>, <tt>discontinue!</tt> and <tt>can_discontinue?</tt>. The first two events will modify the <tt>state</tt> attribute on successful transition,
-but only the bang(!)-version will call <tt>save!</tt>.  The <tt>can_discontinue?</tt> method will
-not modify state but instead returns a boolean letting you know if a given transition is possible.
-
-==== Automatic scope generation
-
-<tt>transitions</tt> will automatically generate scopes for you if you are using ActiveRecord and tell it to do so via the <tt>auto_scopes</tt> option:
-
-Given a model like this:
-
-  class Order < ActiveRecord::Base
-    include ActiveModel::Transitions
-    state_machine :auto_scopes => true do
-      state :pick_line_items
-      state :picking_line_items
-    end
-  end
-
-you can use this feature a la:
-
-  >> Order.pick_line_items
-  => []
-  >> Order.create!
-  => #<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">
-  >> 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.
-You can pass in a Symbol, a String, a Proc or an Array containing method names as Symbol or String like this:
-
-  event :discontinue do
-    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>:
-
-  event :discontinue, :success => :notfiy_admin do
-    transitions :to => :discontinued, :from => [:available, :out_of_stock]
-  end
-
-In addition to just specify the method name on the record as a symbol you can pass a lambda to
-perfom some more complex success callbacks:
-
-  event :discontinue, :success => lambda { |order| AdminNotifier.notify_about_discontinued_order(order) } do
-    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!
-To activate them, simply pass the :timestamp option to the event definition with a value of either true or
-the name of the timestamp column.
-*NOTE - This should be either true, a String or a Symbol*
-
-  # This will look for an attribute called exploded_at or exploded_on (in that order)
-  # If present, it will be updated
-  event :explode, :timestamp => true do
-    transitions :from => :complete, :to => :exploded
-  end
-
-  # This will look for an attribute named repaired_on to update upon save
-  event :rebuild, :timestamp => :repaired_on do
-    transitions :from => :exploded, :to => :rebuilt
-  end
-
-====  Using <tt>event_fired</tt> and <tt>event_failed</tt>
-
-In case you define `event_fired` and / or `event_failed`, `transitions` will use those callbacks correspondingly.
-You can use those callbacks like this:
-
-  def event_fired(current_state, new_state, event)
-    MyLogger.info "Event fired #{event.inspect}"
-  end
-
-  def event_failed(event)
-    MyLogger.warn "Event failed #{event.inspect}"
-  end
-
-==== Listing all the available states
-
-You can easily get a listing of all available states:
-
-  Order.available_states # Uses the <tt>default</tt> state machine
-  # => [:pick_line_items, :picking_line_items]
-
-==== Explicitly setting the initial state with the <tt>initial</tt> option
-
-  state_machine :initial => :closed do
-    state :open
-    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
-
-=== Known bugs / limitations
-
-- Right now it seems like `transitions` does not play well with `mongoid`. A possible fix had to be rolled back due to other side effects: https://github.com/troessner/transitions/issues/76. Since I know virtually zero about mongoid, a pull request would be highly appreciated.
-- Multiple state machines are and will not be supported. For the rationale behind this see the Changelog.
-
-=== Documentation, Guides & Examples
-
-- {Online API Documentation}[http://rdoc.info/github/troessner/transitions/master/Transitions]
-
-=== Copyright
-
-Copyright (c) 2010 Jakub Kuźma, Timo Rößner. See LICENSE for details.