mongoid_state_machine 0.1

data/.gitignore

@@ -0,0 +1,6 @@
+!log*.rb
+*.log
+.DS_Store
+*.db
+rdoc/*
+pkg/*

data/Gemfile

@@ -0,0 +1,3 @@
+source :gemcutter
+
+gemspec

data/README.rdoc

@@ -0,0 +1,64 @@
+= Acts As State Machine for Mongoid
+
+It's a customized plugin from http://github.com/omghax/acts_as_state_machine that works smoothly through Mongoid.
+
+I only removed the Class Methods that were using the method with_scope (ActiveRecord) because it's not supported in Mongoid (not a problem for me)
+
+== Installation
+
+Add the gem into your Gemfile
+
+  gem "mongoid_state_machine", :require => "mongoid/state_machine"
+  
+And run `bundle install`
+
+== Example
+
+ class Order
+   include Mongoid::Document
+
+   include Mongoid::StateMachine
+
+   state_machine :initial => :opened
+
+   state :opened
+   state :closed, :enter => Proc.new {|o| Mailer.send_notice(o)}
+   state :returned
+
+   event :close do
+     transitions :to => :closed, :from => :opened
+   end
+
+   event :return do
+     transitions :to => :returned, :from => :closed
+   end
+ end
+
+ o = Order.create
+ o.close! # notice is sent by mailer
+ o.return!
+
+== Acknowledge
+This project was originally developed by Scott Barron
+
+== License
+Copyright (c) 2010 Bruno Azisaka Maciel
+
+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

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/TODO.rdoc

@@ -0,0 +1,11 @@
+* Currently invalid events are ignored, create an option so that they can be
+  ignored or raise an exception.
+
+* Query for a list of possible next states.
+
+* Make listing states optional since they can be inferred from the events.
+  Only required to list a state if you want to define a transition block for it.
+
+* Real transition actions
+
+* Default states

data/lib/mongoid/state_machine.rb

@@ -0,0 +1,231 @@
+module Mongoid
+  module StateMachine              #:nodoc:
+    
+    VERSION = "0.1"
+    
+    class InvalidState < Exception #:nodoc:
+    end
+    class NoInitialState < Exception #:nodoc:
+    end
+
+    def self.included(base)        #:nodoc:
+      base.extend ActMacro
+    end
+
+    module SupportingClasses
+      # Default transition action.  Always returns true.
+      NOOP = lambda { |o| true }
+
+      class State
+        attr_reader :name, :value
+
+        def initialize(name, options)
+          @name  = name.to_sym
+          @value = (options[:value] || @name).to_s
+          @after = Array(options[:after])
+          @enter = options[:enter] || NOOP
+          @exit  = options[:exit] || NOOP
+        end
+
+        def entering(record)
+          record.send(:run_transition_action, @enter)
+        end
+
+        def entered(record)
+          @after.each { |action| record.send(:run_transition_action, action) }
+        end
+
+        def exited(record)
+          record.send(:run_transition_action, @exit)
+        end
+      end
+
+      class StateTransition
+        attr_reader :from, :to, :opts
+
+        def initialize(options)
+          @from  = options[:from].to_s
+          @to    = options[:to].to_s
+          @guard = options[:guard] || NOOP
+          @opts  = options
+        end
+
+        def guard(obj)
+          @guard ? obj.send(:run_transition_action, @guard) : true
+        end
+
+        def perform(record)
+          return false unless guard(record)
+          loopback = record.current_state.to_s == to
+          states = record.class.read_inheritable_attribute(:states)
+          next_state = states[to]
+          old_state = states[record.current_state.to_s]
+
+          next_state.entering(record) unless loopback
+
+          next_state.entered(record) unless loopback
+          old_state.exited(record) unless loopback
+
+          record.send("#{record.class.state_column}=", next_state.value)
+          record.save
+        end
+
+        def ==(obj)
+          @from == obj.from && @to == obj.to
+        end
+      end
+
+      class Event
+        attr_reader :name
+        attr_reader :transitions
+        attr_reader :opts
+
+        def initialize(name, opts, transition_table, &block)
+          @name = name.to_sym
+          @transitions = transition_table[@name] = []
+          instance_eval(&block) if block
+          @opts = opts
+          @opts.freeze
+          @transitions.freeze
+          freeze
+        end
+
+        def next_states(record)
+          @transitions.select { |t| t.from == record.current_state.to_s }
+        end
+
+        def fire(record)
+          next_states(record).each do |transition|
+            break true if transition.perform(record)
+          end
+        end
+
+        def transitions(trans_opts)
+          Array(trans_opts[:from]).each do |s|
+            @transitions << SupportingClasses::StateTransition.new(trans_opts.merge({:from => s.to_sym}))
+          end
+        end
+      end
+    end
+
+    module ActMacro
+      # Configuration options are
+      #
+      # * +column+ - specifies the column name to use for keeping the state (default: state)
+      # * +initial+ - specifies an initial state for newly created objects (required)
+      def state_machine(options = {})
+        class_eval do
+          extend ClassMethods
+          include InstanceMethods
+
+          raise NoInitialState unless options[:initial]
+
+          write_inheritable_attribute :states, {}
+          write_inheritable_attribute :initial_state, options[:initial]
+          write_inheritable_attribute :transition_table, {}
+          write_inheritable_attribute :event_table, {}
+          write_inheritable_attribute :state_column, options[:column] || 'state'
+
+          class_inheritable_reader    :initial_state
+          class_inheritable_reader    :state_column
+          class_inheritable_reader    :transition_table
+          class_inheritable_reader    :event_table
+
+          before_create               :set_initial_state
+          after_create                :run_initial_state_actions
+        end
+      end
+    end
+
+    module InstanceMethods
+      def set_initial_state #:nodoc:
+        send("#{self.class.state_column}=", self.class.initial_state.to_s)
+      end
+
+      def run_initial_state_actions
+        initial = self.class.read_inheritable_attribute(:states)[self.class.initial_state.to_s]
+        initial.entering(self)
+        initial.entered(self)
+      end
+
+      # Returns the current state the object is in, as a Ruby symbol.
+      def current_state
+        self.send(self.class.state_column).to_sym
+      end
+
+      # Returns what the next state for a given event would be, as a Ruby symbol.
+      def next_state_for_event(event)
+        ns = next_states_for_event(event)
+        ns.empty? ? nil : ns.first.to.to_sym
+      end
+
+      def next_states_for_event(event)
+        self.class.read_inheritable_attribute(:transition_table)[event.to_sym].select do |s|
+          s.from == current_state.to_s
+        end
+      end
+
+      def run_transition_action(action)
+        Symbol === action ? self.method(action).call : action.call(self)
+      end
+      private :run_transition_action
+    end
+
+    module ClassMethods
+      # Returns an array of all known states.
+      def states
+        read_inheritable_attribute(:states).keys.collect { |state| state.to_sym }
+      end
+
+      # Define an event.  This takes a block which describes all valid transitions
+      # for this event.
+      #
+      # Example:
+      #
+      # class Order
+      #   acts_as_state_machine :initial => :open
+      #
+      #   state :open
+      #   state :closed
+      #
+      #   event :close_order do
+      #     transitions :to => :closed, :from => :open
+      #   end
+      # end
+      #
+      # +transitions+ takes a hash where <tt>:to</tt> is the state to transition
+      # to and <tt>:from</tt> is a state (or Array of states) from which this
+      # event can be fired.
+      #
+      # This creates an instance method used for firing the event.  The method
+      # created is the name of the event followed by an exclamation point (!).
+      # Example: <tt>order.close_order!</tt>.
+      def event(event, opts={}, &block)
+        tt = read_inheritable_attribute(:transition_table)
+
+        e = SupportingClasses::Event.new(event, opts, tt, &block)
+        write_inheritable_hash(:event_table, event.to_sym => e)
+        define_method("#{event.to_s}!") { e.fire(self) }
+      end
+
+      # Define a state of the system. +state+ can take an optional Proc object
+      # which will be executed every time the system transitions into that
+      # state.  The proc will be passed the current object.
+      #
+      # Example:
+      #
+      # class Order
+      #   acts_as_state_machine :initial => :open
+      #
+      #   state :open
+      #   state :closed, Proc.new { |o| Mailer.send_notice(o) }
+      # end
+      def state(name, opts={})
+        state = SupportingClasses::State.new(name, opts)
+        write_inheritable_hash(:states, state.value => state)
+
+        define_method("#{state.name}?") { current_state.to_s == state.value }
+      end
+    end
+  end
+end

data/mongoid_state_machine.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path("../lib/mongoid/state_machine", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "mongoid_state_machine"
+  s.version     = Mongoid::StateMachine::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bruno Azisaka Maciel"]
+  s.email       = ["bruno@azisaka.com.br"]
+  s.homepage    = "https://github.com/azisaka/mongoid_state_machine"
+  s.summary     = "A fork from the original State Machine to run on top of Mongoid"
+  s.description = "A fork from the original State Machine to run on top of Mongoid"
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.add_dependency "mongoid", ">= 2.0.0.beta.19"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rake", ">= 0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+
+  s.rdoc_options = ["--charset=UTF-8"]
+end

data/test/mongoid/test_state_machine.rb

@@ -0,0 +1,489 @@
+require "rubygems"
+require "test/unit"
+
+$:.unshift File.dirname(__FILE__) + "/../../lib"
+require "init"
+
+connection = Mongo::Connection.new
+Mongoid.database = connection.db('state_machine_test')
+
+class Conversation
+  include Mongoid::Document
+  include Mongoid::StateMachine
+
+  attr_writer   :can_close
+  attr_accessor :read_enter, :read_exit,
+                :needs_attention_enter, :needs_attention_after,
+                :read_after_first, :read_after_second,
+                :closed_after
+
+  field :state
+  field :state_machine
+
+  # How's THAT for self-documenting? ;-)
+  def always_true
+    true
+  end
+
+  def can_close?
+    !!@can_close
+  end
+
+  def read_enter_action
+    self.read_enter = true
+  end
+
+  def read_after_first_action
+    self.read_after_first = true
+  end
+
+  def read_after_second_action
+    self.read_after_second = true
+  end
+
+  def closed_after_action
+    self.closed_after = true
+  end
+end
+
+class Mongoid::StateMachineTest < Test::Unit::TestCase
+  include Mongoid::StateMachine
+
+  def after
+    Conversation.destroy_all
+  end
+
+  def teardown
+    Conversation.class_eval do
+      write_inheritable_attribute :states, {}
+      write_inheritable_attribute :initial_state, nil
+      write_inheritable_attribute :transition_table, {}
+      write_inheritable_attribute :event_table, {}
+      write_inheritable_attribute :state_column, "state"
+
+      # Clear out any callbacks that were set by state_machine.
+      write_inheritable_attribute :before_create, []
+      write_inheritable_attribute :after_create, []
+    end
+  end
+
+  def test_no_initial_value_raises_exception
+    assert_raises(NoInitialState) do
+      Conversation.class_eval do
+        state_machine
+      end
+    end
+  end
+
+  def test_state_column
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention, :column => "state_machine"
+      state :needs_attention
+    end
+
+    assert_equal "state_machine", Conversation.state_column
+  end
+
+  def test_initial_state_value
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+    end
+
+    assert_equal :needs_attention, Conversation.initial_state
+  end
+
+  def test_initial_state
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+    end
+
+    c = Conversation.create!
+    assert_equal :needs_attention, c.current_state
+    assert c.needs_attention?
+  end
+
+  def test_states_were_set
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+      state :junk
+    end
+
+    [:needs_attention, :read, :closed, :awaiting_response, :junk].each do |state|
+      assert Conversation.states.include?(state)
+    end
+  end
+
+  def test_query_methods_created
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+      state :junk
+    end
+
+    c = Conversation.create!
+    [:needs_attention?, :read?, :closed?, :awaiting_response?, :junk?].each do |query|
+      assert c.respond_to?(query)
+    end
+  end
+
+  def test_event_methods_created
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+      state :junk
+
+      event(:new_message) {}
+      event(:view) {}
+      event(:reply) {}
+      event(:close) {}
+      event(:junk, :note => "finished") {}
+      event(:unjunk) {}
+    end
+
+    c = Conversation.create!
+    [:new_message!, :view!, :reply!, :close!, :junk!, :unjunk!].each do |event|
+      assert c.respond_to?(event)
+    end
+  end
+
+  def test_transition_table
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+      state :junk
+
+      event :new_message do
+        transitions :to => :needs_attention, :from => [:read, :closed, :awaiting_response]
+      end
+    end
+
+    tt = Conversation.transition_table
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :read, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :closed, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :awaiting_response, :to => :needs_attention))
+  end
+
+  def test_next_state_for_event
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    assert_equal :read, c.next_state_for_event(:view)
+  end
+
+  def test_change_state
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    c.view!
+    assert c.read?
+  end
+
+  def test_can_go_from_read_to_closed_because_guard_passes
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+
+      event :reply do
+        transitions :to => :awaiting_response, :from => [:read, :closed]
+      end
+
+      event :close do
+        transitions :to => :closed, :from => [:read, :awaiting_response], :guard => lambda { |o| o.can_close? }
+      end
+    end
+
+    c = Conversation.create!
+    c.can_close = true
+    c.view!
+    c.reply!
+    c.close!
+    assert_equal :closed, c.current_state
+  end
+
+  def test_cannot_go_from_read_to_closed_because_of_guard
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+
+      event :reply do
+        transitions :to => :awaiting_response, :from => [:read, :closed]
+      end
+
+      event :close do
+        transitions :to => :closed, :from => [:read, :awaiting_response], :guard => lambda { |o| o.can_close? }
+        transitions :to => :read, :from => [:read, :awaiting_response], :guard => :always_true
+      end
+    end
+
+    c = Conversation.create!
+    c.can_close = false
+    c.view!
+    c.reply!
+    c.close!
+    assert_equal :read, c.current_state
+  end
+
+  def test_ignore_invalid_events
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+      state :junk
+
+      event :new_message do
+        transitions :to => :needs_attention, :from => [:read, :closed, :awaiting_response]
+      end
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+
+      event :junk, :note => "finished" do
+        transitions :to => :junk, :from => [:read, :closed, :awaiting_response]
+      end
+    end
+
+    c = Conversation.create
+    c.view!
+    c.junk!
+
+    # This is the invalid event
+    c.new_message!
+    assert_equal :junk, c.current_state
+  end
+
+  def test_entry_action_executed
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read, :enter => :read_enter_action
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    c.read_enter = false
+    c.view!
+    assert c.read_enter
+  end
+
+  def test_after_actions_executed
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :closed, :after => :closed_after_action
+      state :read, :enter => :read_enter_action,
+      :exit  => Proc.new { |o| o.read_exit = true },
+      :after => [:read_after_first_action, :read_after_second_action]
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+
+      event :close do
+        transitions :to => :closed, :from => [:read, :awaiting_response]
+      end
+    end
+
+    c = Conversation.create!
+
+    c.read_after_first = false
+    c.read_after_second = false
+    c.closed_after = false
+
+    c.view!
+    assert c.read_after_first
+    assert c.read_after_second
+
+    c.can_close = true
+    c.close!
+
+    assert c.closed_after
+    assert_equal :closed, c.current_state
+  end
+
+  def test_after_actions_not_run_on_loopback_transition
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :closed, :after => :closed_after_action
+      state :read, :after => [:read_after_first_action, :read_after_second_action]
+
+      event :view do
+        transitions :to => :read, :from => :needs_attention
+      end
+
+      event :close do
+        transitions :to => :closed, :from => :read
+      end
+    end
+
+    c = Conversation.create!
+
+    c.view!
+    c.read_after_first = false
+    c.read_after_second = false
+    c.view!
+
+    assert !c.read_after_first
+    assert !c.read_after_second
+
+    c.can_close = true
+
+    c.close!
+    c.closed_after = false
+    c.close!
+
+    assert !c.closed_after
+  end
+
+  def test_exit_action_executed
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :junk
+      state :needs_attention
+      state :read, :exit => lambda { |o| o.read_exit = true }
+
+      event :view do
+        transitions :to => :read, :from => :needs_attention
+      end
+
+      event :junk, :note => "finished" do
+        transitions :to => :junk, :from => :read
+      end
+    end
+
+    c = Conversation.create!
+    c.read_exit = false
+    c.view!
+    c.junk!
+    assert c.read_exit
+  end
+
+  def test_entry_and_exit_not_run_on_loopback_transition
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read, :exit => lambda { |o| o.read_exit = true }
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    c.view!
+    c.read_enter = false
+    c.read_exit  = false
+    c.view!
+    assert !c.read_enter
+    assert !c.read_exit
+  end
+
+  def test_entry_and_after_actions_called_for_initial_state
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention
+      state :needs_attention, :enter => lambda { |o| o.needs_attention_enter = true },
+      :after => lambda { |o| o.needs_attention_after = true }
+    end
+
+    c = Conversation.create!
+    assert c.needs_attention_enter
+    assert c.needs_attention_after
+  end
+
+  def test_run_transition_action_is_private
+    Conversation.class_eval do
+
+      state_machine :initial => :needs_attention
+      state :needs_attention
+    end
+
+    c = Conversation.create!
+    assert_raises(NoMethodError) { c.run_transition_action :foo }
+  end
+
+  def test_can_access_events_via_event_table
+    Conversation.class_eval do
+      state_machine :initial => :needs_attention, :column => "state_machine"
+      state :needs_attention
+      state :junk
+
+      event :junk, :note => "finished" do
+        transitions :to => :junk, :from => :needs_attention
+      end
+    end
+
+    event = Conversation.event_table[:junk]
+    assert_equal :junk, event.name
+    assert_equal "finished", event.opts[:note]
+  end
+
+  def test_custom_state_values
+    Conversation.class_eval do
+      state_machine :initial => "NEEDS_ATTENTION", :column => "state_machine"
+      state :needs_attention, :value => "NEEDS_ATTENTION"
+      state :read, :value => "READ"
+
+      event :view do
+        transitions :to => "READ", :from => ["NEEDS_ATTENTION", "READ"]
+      end
+    end
+
+    c = Conversation.create!
+    assert_equal "NEEDS_ATTENTION", c.state_machine
+    assert c.needs_attention?
+    c.view!
+    assert_equal "READ", c.state_machine
+    assert c.read?
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: mongoid_state_machine
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Bruno Azisaka Maciel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-26 00:00:00 -02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 62196421
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 19
+        version: 2.0.0.beta.19
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A fork from the original State Machine to run on top of Mongoid
+email: 
+- bruno@azisaka.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- TODO.rdoc
+- lib/mongoid/state_machine.rb
+- mongoid_state_machine.gemspec
+- test/mongoid/test_state_machine.rb
+has_rdoc: true
+homepage: https://github.com/azisaka/mongoid_state_machine
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A fork from the original State Machine to run on top of Mongoid
+test_files: []
+