openhood-simple_state_machine 1.0.1 → 2.0.0

data/.gitignore

@@ -0,0 +1,8 @@
+._*
+.DS_Store
+*.orig
+Thumbs.db
+*.sqlite3.db
+*.log
+coverage/*
+log/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in simple_state_machine.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    openhood-simple_state_machine (2.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.9)
+    arel (2.0.10)
+    bson (1.3.1)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    mongo (1.3.1)
+      bson (>= 1.3.1)
+    mongo_mapper (0.9.1)
+      activemodel (~> 3.0)
+      activesupport (~> 3.0)
+      plucky (~> 0.3.8)
+    plucky (0.3.8)
+      mongo (~> 1.3)
+    rake (0.8.7)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    sqlite3 (1.3.3)
+    tzinfo (0.3.28)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3.0.0)
+  mongo_mapper (~> 0.9.0)
+  openhood-simple_state_machine!
+  rake (~> 0.8.7)
+  rspec (~> 2.6.0)
+  sqlite3

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Joseph HALTER
+
+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/README.textile

@@ -0,0 +1,50 @@
+h2. State Machine
+
+Allow an Active Record or MongoMapper model to act as a finite state machine just as the popular plugin acts_as_state_machine but with many enhancements such as the possibility to have multiple states per object.
+
+It can work together with the classic act_as_state_machine on the same project but both cannot be used at the same time for one given Active Record model. Moreover, simple_state_machine work standalone and doesn't require acts_as_state_machine.
+
+You also get magic methods to check current state and a way to revert to previous state in database (or initial value for a new record) if something went wrong.
+
+h3. Example for ActiveRecord
+
+  require "simple_state_machine/active_record"
+  
+  class Chicken < ActiveRecord::Base
+    state_machine :user_state, [:pending, :active, :removed, :on_hold]
+    state_machine :validation_state, [:waiting, :reviewed, :validated, :invalid]
+    def user_activate!
+      return false if !user_state_pending?
+      self.user_state = :active
+      save! rescue user_state_revert
+      user_state_active?
+    end       
+  end
+
+And then you can do:
+
+  c = Chicken.create # c.user_state = :pending
+  c.user_activate! # c.user_state = :active
+  
+h3. Example for MongoMapper
+
+  require "simple_state_machine/mongo_mapper"
+
+  class Chicken
+    include MongoMapper::Document
+    plugin SimpleStateMachine::MongoMapper
+
+    state_machine :user_state, [:pending, :active, :removed, :on_hold]
+    state_machine :validation_state, [:waiting, :reviewed, :validated, :invalid]
+    def user_activate!
+      return false if !user_state_pending?
+      self.user_state = :active
+      save! rescue user_state_revert
+      user_state_active?
+    end       
+  end
+
+And then you can do:
+
+  c = Chicken.create # c.user_state = :pending
+  c.user_activate! # c.user_state = :active

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/init.rb

@@ -0,0 +1 @@
+require "simple_state_machine/active_record"

data/lib/simple_state_machine/active_record.rb

@@ -0,0 +1,61 @@
+require "active_record"
+
+module SimpleStateMachine
+  module ActiveRecord
+    extend ActiveSupport::Concern
+    
+    included do |base|
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def state_machine(column, states)
+        create_empty_state_machine unless inheritable_attributes.key? :states
+        inheritable_attributes[:states][column.to_sym] = states
+        validates_inclusion_of column, :in => states
+        # should also override getter/setter to convert to strings
+        self.class_eval <<-eos
+          def #{column.to_s}=(value)
+            self[:#{column.to_s}] = value.to_s
+          end
+          def #{column.to_s}
+            self[:#{column.to_s}].to_sym
+          end
+          def #{column.to_s}_revert
+            self[:#{column.to_s}] = self.new_record? ? states[:#{column.to_s}].first.to_s : self.#{column.to_s}_was
+          end
+        eos
+
+        # define a method {state_column}_{state}? for each state
+        states.each do |state|
+          self.class_eval <<-eos
+            def #{column.to_s}_#{state.to_s}?
+              self[:#{column.to_s}] === "#{state.to_s}"
+            end
+          eos
+        end
+
+      end
+
+    private
+
+      def create_empty_state_machine
+        write_inheritable_attribute :states, {} # add a class variable
+        class_inheritable_reader    :states     # make it read-only
+    
+        after_initialize :set_initial_states
+        self.class_eval do
+          def set_initial_states
+            states.each {|column, states|
+              self[column] = states.first.to_s
+            } if new_record?
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include SimpleStateMachine::ActiveRecord
+end

data/lib/simple_state_machine/mongo_mapper.rb

@@ -0,0 +1,55 @@
+module SimpleStateMachine
+  module MongoMapper
+    extend ActiveSupport::Concern
+
+    included do
+      class_eval do
+        write_inheritable_attribute :states, {}
+        class_inheritable_reader :states
+      end
+    end
+
+    module ClassMethods
+      def state_machine(column, column_states)
+        inheritable_attributes[:states][column.to_sym] = column_states
+
+        key column, String
+        validates_inclusion_of column, :in => column_states
+
+        define_method :"#{column}_revert" do
+          write_key column, new? ? states[column].first : send(:"#{column}_was")
+        end
+
+        # define a method {state_column}_{state}? for each state
+        column_states.each do |state|
+          define_method :"#{column}_#{state}?" do
+            send(column) === state
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      def initialize(*args)
+        super(*args)
+        set_initial_state
+      end
+
+    private
+      def write_key(key, value)
+        super(key, states.keys.include?(key) ? value.to_s : value)
+      end
+
+      def read_key(key)
+        value = super(key)
+        value && states.keys.include?(key) ? value.to_sym : value
+      end
+
+      def set_initial_state
+        states.each do |column, states|
+          write_key column, states.first
+        end if new?
+      end
+    end
+  end
+end

data/lib/simple_state_machine/version.rb

@@ -0,0 +1,3 @@
+module SimpleStateMachine
+  VERSION = "2.0.0"
+end

data/lib/simple_state_machine.rb

@@ -1,63 +1,5 @@
 module SimpleStateMachine
-  
-  def self.included(base)
-    base.extend Macro
-  end
-  
-  module Macro
-    def state_machine(column, states)
-      create_empty_state_machine unless inheritable_attributes.key? :states
-      inheritable_attributes[:states][column.to_sym] = states
-      validates_inclusion_of column, :in => states
-      # should also override getter/setter to convert to strings
-      self.class_eval <<-eos
-        def #{column.to_s}=(value)
-          self[:#{column.to_s}] = value.to_s
-        end
-        def #{column.to_s}
-          self[:#{column.to_s}].to_sym
-        end
-        def #{column.to_s}_revert
-          self[:#{column.to_s}] = self.new_record? ? states[:#{column.to_s}].first.to_s : self.#{column.to_s}_was
-        end
-      eos
-
-      # define a method {state_column}_{state}? for each state
-      states.each do |state|
-        self.class_eval <<-eos
-          def #{column.to_s}_#{state.to_s}?
-            self[:#{column.to_s}] === "#{state.to_s}"
-          end
-        eos
-      end
-
-    end
-
-  private
-
-    def create_empty_state_machine
-      write_inheritable_attribute :states, {} # add a class variable
-      class_inheritable_reader    :states     # make it read-only
-      
-      # set initial states on new objects
-      if(!instance_methods.include?("after_initialize") && ActiveRecord::VERSION::MAJOR < 3)
-        self.class_eval do
-          def after_initialize # ActiveRecord::Base requires explicit definition of this function to use the callback
-          end
-        end
-      end
-      after_initialize :set_initial_states
-      self.class_eval do
-        def set_initial_states
-          states.each {|column, states|
-            self[column] = states.first.to_s
-          } if new_record?
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.class_eval do
-  include SimpleStateMachine
+  autoload :ActiveRecord, "simple_state_machine/active_record"
+  autoload :MongoMapper, "simple_state_machine/mongo_mapper"
+  autoload :Version, "simple_state_machine/version"
 end

data/simple_state_machine.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simple_state_machine/version"
+
+Gem::Specification.new do |s|
+  s.name        = "openhood-simple_state_machine"
+  s.version     = SimpleStateMachine::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joseph HALTER", "Jonathan TRON"]
+  s.email       = "team@openhood.com"
+  s.homepage    = "http://github.com/openhood/simple_state_machine"
+  s.summary     = %q{Same as acts_as_state_machine but on multiple columns and with more strict validation, allow creation of complex events with parameters, used successfully on critical financial applications for quite a long time}
+  s.description = s.summary
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("rake", ["~> 0.8.7"])
+  s.add_development_dependency("rspec", ["~> 2.6.0"])
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("activerecord", [">= 3.0.0"])
+  s.add_development_dependency("mongo_mapper", ["~> 0.9.0"])
+end

data/spec/db/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :chickens, :force => true do |t|
+    t.string :name
+    t.integer :age
+    t.string :user_state
+    t.string :validation_state
+  end
+end

data/spec/simple_state_machine/active_record_spec.rb

@@ -0,0 +1,133 @@
+require "spec_helper"
+
+class Chicken < ActiveRecord::Base
+  state_machine :user_state, [:pending, :active, :removed, :on_hold]
+  state_machine :validation_state, [:waiting, :reviewed, :validated, :invalid]
+  def user_activate!
+    return false if !user_state_pending?
+    self.user_state = :active
+    save! rescue user_state_revert
+    user_state_active?
+  end       
+end
+
+describe Chicken do
+
+  it "should set initial user_state" do
+    c = Chicken.new
+    c.user_state.should === :pending
+  end
+
+  it "should set initial validation_state" do
+    c = Chicken.new
+    c.validation_state.should === :waiting
+  end
+
+  it "should store state value as string" do
+    c = Chicken.new
+    c[:user_state].should === 'pending'
+  end
+
+  it "should also accept strings as state values" do
+    c = Chicken.new
+    c.user_state = 'active'
+    c.user_state.should === :active
+  end
+
+  it "should validate user_state stay inside possible states" do
+    c = Chicken.new
+    c.valid?.should === true
+    c.user_state = 'waiting'
+    c.valid?.should === false
+  end
+
+  it "should show all possible states in .states method" do
+    Chicken.states.should === {
+      :user_state => [:pending, :active, :removed, :on_hold],
+      :validation_state => [:waiting, :reviewed, :validated, :invalid]
+    }
+  end
+
+  it "should return be able to return to previous state" do
+    c = Chicken.new
+    c.user_state.should === :pending
+    c.user_state = 'active'
+    c.user_state.should === :active
+    c.user_state_revert
+    c.user_state.should === :pending
+  end
+
+  describe "custom event user_activate!" do
+
+    it "should return true if on pending state" do
+      c = Chicken.new
+      c.user_activate!.should === true
+    end
+
+    it "should effectively change user_state" do
+      c = Chicken.new
+      c.user_activate!
+      c.user_state.should === :active
+    end
+
+    it "should not affect validation_state" do
+      c = Chicken.new
+      c.user_activate!
+      c.validation_state.should === :waiting
+    end
+
+    it "should return false if user_state is not pending" do
+      c = Chicken.new
+      c.user_state = :on_hold
+      c.user_activate!.should === false
+    end
+
+  end
+
+  describe "magic methods to test current state" do
+
+    it "should handle the user_state_pending? method" do
+      c = Chicken.new
+      lambda {c.user_state_pending?}.should_not raise_error(NoMethodError)
+    end
+
+    it "should evaluate user_state_pending? to true initially" do
+      c = Chicken.new
+      c.user_state_pending?.should === true
+    end
+
+    it "should evaluate user_state_pending? to false after activation" do
+      c = Chicken.new
+      c.user_activate!
+      c.user_state_pending?.should === false
+    end
+
+    it "should evaluate user_state_active? to false initially" do
+      c = Chicken.new
+      c.user_state_active?.should === false
+    end
+
+    it "should evaluate user_state_active? to true after activation" do
+      c = Chicken.new
+      c.user_activate!
+      c.user_state_active?.should === true
+    end
+
+    it "should not catch user_state_invalid?" do
+      c = Chicken.new
+      lambda {c.user_state_invalid?}.should raise_error(NoMethodError)
+    end
+
+    it "should handle validation_state_waiting?" do
+      c = Chicken.new
+      lambda {c.validation_state_waiting?}.should_not raise_error(NoMethodError)
+    end
+
+    it "should evaluate validation_state_waiting? to true initially" do
+      c = Chicken.new
+      c.validation_state_waiting?.should === true
+    end
+
+  end
+
+end

data/spec/simple_state_machine/mongo_mapper_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe SimpleStateMachine::MongoMapper do
+  before do
+    @doc = Doc("Order") do
+      plugin SimpleStateMachine::MongoMapper
+    end
+  end
+
+  describe ".state_machine" do
+    it "should be defined" do
+      @doc.should respond_to(:state_machine)
+    end
+    it "should take 2 arguments" do
+      lambda do
+        @doc.state_machine
+      end.should raise_error(ArgumentError)
+      lambda do
+        @doc.state_machine :state, [:initial]
+      end.should_not raise_error(ArgumentError)
+      lambda do
+        @doc.state_machine 1, 1, 1
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "when defining a state machine with :state, [:initial, :final]" do
+    before do
+      @doc.class_eval do
+        state_machine :state, [:initial, :final]
+      end
+    end
+    subject { @doc.new }
+    it "should allow accessing states via states[:state]" do
+      subject.states[:state].should == [:initial, :final]
+    end
+    it "should add a :state key of type String on model" do
+      subject.key_names.should include("state")
+      subject.keys["state"].type.should == String
+    end
+    it "should set state on object initialization with first state" do
+      subject.state.should == :initial
+    end
+    it do
+      subject.should be_state_initial
+    end
+    it do
+      subject.should_not be_state_final
+    end
+    it "should allow reverting to previous state" do
+      subject.state = :final
+      subject.should be_state_final
+      subject.state_revert
+      subject.should be_state_initial
+    end
+    it "should allow setting state via a String" do
+      subject.state = "final"
+      subject.should be_state_final
+    end
+    it "should allow setting state via a Symbol" do
+      subject.state = :final
+      subject.should be_state_final
+    end
+    it "should return a symbol for state" do
+      subject.state = "final"
+      subject.state.should == :final
+      subject.state = :final
+      subject.state.should == :final
+    end
+    it "should validate state is included in allowed state" do
+      subject.state = :unknown_state
+      subject.valid?
+      subject.errors[:state].should == ["is not included in the list"]
+      subject.state = :final
+      subject.valid?
+      subject.errors[:state].should == []
+    end
+    
+    describe "when defining a second state machine with :delivery_state, [:initial, :final]" do
+      before do
+        @doc.class_eval do
+          state_machine :delivery_state, [:initial, :final]
+        end
+      end
+      subject { @doc.new }
+      it "should allow accessing states via states[:delivery_state]" do
+        subject.states[:delivery_state].should == [:initial, :final]
+      end
+      it "should add a :delivery_state key of type String on model" do
+        subject.key_names.should include("delivery_state")
+        subject.keys["delivery_state"].type.should == String
+      end
+      it "should set delivery_state on object initialization with first delivery_state" do
+        subject.delivery_state.should == :initial
+      end
+      it do
+        subject.should be_delivery_state_initial
+      end
+      it do
+        subject.should_not be_delivery_state_final
+      end
+      it "should allow reverting to previous state" do
+        subject.delivery_state = :final
+        subject.should be_delivery_state_final
+        subject.delivery_state_revert
+        subject.should be_delivery_state_initial
+      end
+      it "should not revert other state machine on reverting to previous state" do
+        subject.state = :final
+        subject.delivery_state = :final
+        subject.should be_state_final
+        subject.should be_delivery_state_final
+        subject.delivery_state_revert
+        subject.should be_state_final
+        subject.should be_delivery_state_initial
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require "active_record"
+require "mongo_mapper"
+require "simple_state_machine"
+require "simple_state_machine/active_record"
+require "simple_state_machine/mongo_mapper"
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].each{|f| require f}
+
+log_dir = File.expand_path('../../log', __FILE__)
+FileUtils.mkdir_p(log_dir) unless File.exist?(log_dir)
+logger = Logger.new(log_dir + '/test.log')
+
+ActiveRecord::Base.logger = logger
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+load File.expand_path("../db/schema.rb", __FILE__)
+
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => logger)
+MongoMapper.database = "simple_state_machine_test"
+
+RSpec.configure do |config|
+  config.before(:each) do
+    MongoMapper.database.collections.each { |c| c.drop_indexes }
+  end
+  config.include SimpleStateMachine::RSpec::Helpers
+end

data/spec/support/mongo_mapper_helper.rb

@@ -0,0 +1,268 @@
+module SimpleStateMachine
+  module RSpec
+    module Helpers
+      def Doc(name=nil, &block)
+        klass = Class.new do
+          include ::MongoMapper::Document
+          set_collection_name "test#{rand(20)}"
+
+          if name
+            class_eval "def self.name; '#{name}' end"
+            class_eval "def self.to_s; '#{name}' end"
+          end
+        end
+
+        klass.class_eval(&block) if block_given?
+        klass.collection.remove
+        klass
+      end
+
+      def EDoc(name=nil, &block)
+        klass = Class.new do
+          include ::MongoMapper::EmbeddedDocument
+
+          if name
+            class_eval "def self.name; '#{name}' end"
+            class_eval "def self.to_s; '#{name}' end"
+          end
+        end
+
+        klass.class_eval(&block) if block_given?
+        klass
+      end
+
+      ::RSpec::Matchers.define :have_timestamps do |name, states = []|
+        description { "have keys created_at/updated_at of type Time" }
+        match do |actual|
+          keys = actual.keys.select{|key_name, key| ["created_at", "updated_at"].include?(key_name) && key.type==Time}
+          keys.size == 2
+        end
+      end
+
+      ::RSpec::Matchers.define :have_simple_state_machine do |name, states = []|
+        description { "define a state machine \"#{name}\" with #{states.join(",")} states" }
+        match do |actual|
+          actual.states[name].eql?(states)
+        end
+      end
+
+      ::RSpec::Matchers.define :have_scope do |name, options = {}|
+        query = Plucky::Query.new(actual.class, options)
+        description do
+          s = "have a scope #{name} with"
+          s << " #{query.criteria.source} criterias" if query.criteria.source.present?
+          s << " and " if query.criteria.source.present? && query.options.source.present?
+          s << " #{query.options.source.inspect} options" if query.options.source.present?
+          s
+        end
+        match do |actual|
+          actual.class.scopes[name] && 
+          actual.class.scopes[name].call.criteria == query.criteria && 
+          actual.class.scopes[name].call.options == query.options
+        end
+      end
+
+      ::RSpec::Matchers.define :have_key do |name, klass, options = {}|
+        description do
+          s = "have key #{name} of class #{klass.name}"
+          s << " with #{options[:default]} as default value" if options.has_key?(:default)
+          s
+        end
+        match do |actual|
+          key = actual.keys.detect{|key_name, key| key_name==name.to_s && key.type==klass}
+          valid = !!key
+          valid &&= key.last.default_value.eql?(options[:default]) if options.has_key?(:default)
+          valid
+        end
+      end
+
+      ::RSpec::Matchers.define :have_index do |*keys|
+        description{ "have an index on #{keys.join(", ")}" }
+        match do |actual|
+          indexes = actual.collection.index_information.values.collect{|h| h["key"].keys}
+          indexes.include? keys.collect(&:to_s)
+        end
+      end
+
+      ::RSpec::Matchers.define :have_many do |name, options = {}|
+        description do
+          s = "have many "
+          s << "embedded " if options[:embedded]
+          s << "#{name}"
+          s << " of class #{options[:class].name}" if options[:class]
+          s << " ordered by '#{options[:order]}'" if options[:order]
+          s
+        end
+        match do |actual, matcher|
+          actual.associations.one? do |association_name, assocation|
+            valid = association_name==name.to_s && assocation.type==:many
+            valid &&= assocation.klass==options[:class] if options[:class]
+            valid &&= !!options[:embedded]==actual.embedded_associations.include?(assocation)
+            valid &&= !!options[:order]==assocation.query_options[:order] if options[:order]
+            valid
+          end
+        end
+      end
+
+      ::RSpec::Matchers.define :have_one do |name, options = {}|
+        description do
+          s = "have one "
+          s << "embedded " if options[:embedded]
+          s << "#{name}"
+          s << " of class #{options[:class].name}" if options[:class]
+          s
+        end
+        match do |actual, matcher|
+          actual.associations.one? do |association_name, assocation|
+            valid = association_name==name.to_s && assocation.type==:one
+            valid &&= assocation.klass==options[:class] if options[:class]
+            valid &&= !!options[:embedded]==actual.embedded_associations.include?(assocation)
+            valid
+          end
+        end
+      end
+
+      ::RSpec::Matchers.define :belong_to do |name, options = {}|
+        description do
+          s = "belong to #{name}"
+          s << " of class #{options[:class].name}" if options[:class]
+          s
+        end
+        match do |actual, matcher|
+          actual.associations.one? do |association_name, assocation|
+            valid = association_name==name.to_s && assocation.type==:belongs_to
+            valid &&= assocation.klass==options[:class] if options[:class]
+            valid
+          end
+        end
+      end
+
+      ::RSpec::Matchers.define :validate_presence_of do |field, options = {}|
+        description do
+          s = "validate presence of #{field}"
+          s << " while still allowing nil" if options[:allow_nil]
+          s << " for #{options[:groups]} validations" if options[:groups]
+          s
+        end
+        match do |actual, matcher|
+          validation_method = options[:groups] ? :"valid_for_#{options[:groups]}?" : :valid?
+          actual.send "#{field}=", ""
+          actual.send validation_method
+          valid = !actual.errors[field].empty?
+          if actual.keys[field] && actual.keys[field].default_value.nil?
+            actual.send "#{field}=", nil
+            actual.send validation_method
+            valid && !!options[:allow_nil]==actual.errors[field].empty?
+          end
+          valid
+        end
+      end
+
+      ::RSpec::Matchers.define :validate_length_of do |field, options = {}|
+        min, max = options[:within].first, options[:within].last
+        description do
+          "validate length of #{field} within #{min}..#{max}"
+        end
+        match do |actual, matcher|
+          actual.send "#{field}=", min.times.collect{"a"}.join
+          actual.valid?
+          valid = !actual.errors[field].include?("is invalid")
+          actual.send "#{field}=", (min-1).times.collect{"a"}.join
+          actual.valid?
+          valid &&= actual.errors[field].include?("is invalid")
+          actual.send "#{field}=", (max+1).times.collect{"a"}.join
+          actual.valid?
+          valid &&= actual.errors[field].include?("is invalid")
+          valid
+        end
+      end
+
+      ::RSpec::Matchers.define :validate_inclusion_of do |field, options = {}|
+        min, max = options[:within].first, options[:within].last
+        description do
+          "validate inclusion of #{field} within #{min}..#{max}"
+        end
+        match do |actual, matcher|
+          actual.send "#{field}=", min
+          actual.valid?
+          valid = !actual.errors[field].include?("is not in the list")
+          actual.send "#{field}=", min.pred
+          actual.valid?
+          valid &&= actual.errors[field].include?("is not in the list")
+          actual.send "#{field}=", max.succ
+          actual.valid?
+          valid && actual.errors[field].include?("is not in the list")
+        end
+      end
+
+      ::RSpec::Matchers.define :validate_confirmation_of do |field|
+        description { "validate confirmation of #{field}" }
+        match do |actual, matcher|
+          field_confirmation = "#{field}_confirmation"
+          actual.send "#{field}=", "aaaa"
+          actual.send "#{field_confirmation}=", "aaaa"
+          actual.valid?
+          valid = !actual.errors[field].include?("doesn't match confirmation")
+          actual.send "#{field}=", "aaaa"
+          actual.send "#{field}=", "bbbb"
+          actual.valid?
+          valid && actual.errors[field].include?("doesn't match confirmation")
+        end
+      end
+
+      ::RSpec::Matchers.define :validate_uniqueness_of do |field, options = {}|
+        description do 
+          s = "validate uniqueness of #{field}"
+          s << " case sensitive" if options[:case_sensitive]
+          s << " case insensitive" unless options[:case_sensitive]
+          s << " allowing blank value" if options[:allow_blank]
+          s << " allowing nil value" if options[:allow_nil]
+          s
+        end
+        match do |actual, matcher|
+          existing = actual.class.first
+          raise "you need to create at least one record before we can check for uniqueness" unless existing
+          actual.attributes = existing.attributes.reject{|k,v| k == "_id" }
+          actual.valid?
+          valid = actual.errors[field].include?("has already been taken")
+          actual.send "#{field}=", actual.send(field).swapcase
+          actual.valid?
+          if options[:case_sensitive]
+            valid &&= !actual.errors[field].include?("has already been taken")
+          else
+            valid &&= actual.errors[field].include?("has already been taken")
+          end
+          if options[:allow_blank]
+            actual.send "#{field}=", ""
+            actual.valid?
+            valid &&= !actual.errors[field].include?("has already been taken")
+          end
+          if options[:allow_nil]
+            actual.send "#{field}=", nil
+            actual.valid?
+            valid &&= !actual.errors[field].include?("has already been taken")
+          end
+          valid
+        end
+      end
+
+      ::RSpec::Matchers.define :validate_config_with do |key, klass|
+        description{ "validate presence of #{key} of class #{klass} in config" }
+        match do |actual, matcher|
+          actual.config.delete key
+          actual.valid?
+          valid = actual.errors[:config].include? "#{key} is required"
+          actual.config[key] = Class.new
+          actual.valid?
+          valid &&= actual.errors[:config].include? "#{key} should be #{klass}"
+          value = mock
+          value.stub(:kind_of?).with(klass).and_return true
+          actual.config[key] = value
+          actual.valid?
+          valid &&= actual.errors[:config].none?{|error| error.starts_with?("#{key} ")}
+          valid
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,75 +1,128 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: openhood-simple_state_machine
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 1
-  version: 1.0.1
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
 platform: ruby
-authors: 
-- Joseph Halter
+authors:
+- Joseph HALTER
+- Jonathan TRON
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-11-24 00:00:00 +01:00
+date: 2011-06-22 00:00:00.000000000 +02:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2161201240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *2161201240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2161198760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2161198760
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2161197360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161197360
+- !ruby/object:Gem::Dependency
   name: activerecord
+  requirement: &2161195840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2161195840
+- !ruby/object:Gem::Dependency
+  name: mongo_mapper
+  requirement: &2161188280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 2
-        - 2
-        version: 2.2.2
-  type: :runtime
-  version_requirements: *id001
-description: Same as acts_as_state_machine but on multiple columns and with more strict validation, allow creation of complex events with parameters, used successfully on critical financial applications for quite a long time
+  version_requirements: *2161188280
+description: Same as acts_as_state_machine but on multiple columns and with more strict
+  validation, allow creation of complex events with parameters, used successfully
+  on critical financial applications for quite a long time
 email: team@openhood.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.textile
+- Rakefile
+- init.rb
 - lib/simple_state_machine.rb
+- lib/simple_state_machine/active_record.rb
+- lib/simple_state_machine/mongo_mapper.rb
+- lib/simple_state_machine/version.rb
+- simple_state_machine.gemspec
+- spec/db/schema.rb
+- spec/simple_state_machine/active_record_spec.rb
+- spec/simple_state_machine/mongo_mapper_spec.rb
+- spec/spec_helper.rb
+- spec/support/mongo_mapper_helper.rb
 has_rdoc: true
 homepage: http://github.com/openhood/simple_state_machine
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Same as acts_as_state_machine but on multiple columns and with more strict validation, allow creation of complex events with parameters, used successfully on critical financial applications for quite a long time
-test_files: []
-
+summary: Same as acts_as_state_machine but on multiple columns and with more strict
+  validation, allow creation of complex events with parameters, used successfully
+  on critical financial applications for quite a long time
+test_files:
+- spec/db/schema.rb
+- spec/simple_state_machine/active_record_spec.rb
+- spec/simple_state_machine/mongo_mapper_spec.rb
+- spec/spec_helper.rb
+- spec/support/mongo_mapper_helper.rb