simpler_state_machine 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Elad Meidar
+
+MIT License
+
+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.md

@@ -0,0 +1,98 @@
+# Note:
+
+This code used to contain some offensive wording as part of our test suite that was not removed or at least moderated while
+moving this project from private to public status. the people that worked on this project and myself especially are sincerely sorry and we absolutely 100% didn't mean
+to offend anyone. sorry. :(
+
+# SimplerStateMachine
+
+__SimplerStateMachine__ is a simple (suprisingly) state machine aimed to provide a simpler implementation and setup for ruby based state machines.
+It supports:
+
+* States as enum
+* Events / Callbacks
+* Transitions
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'simpler_state_machine'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_state_machine
+
+## Usage
+
+__SimplerStateMachine__ provides an easy interface to add states and transitions:
+
+
+### Declaration
+
+    Class Elad
+
+      include SimpleStateMachine
+
+      state_machine do |sm|
+        sm.initial_state "happy"
+        sm.state_field "status"
+        sm.add_state "mad", :before_enter => :kill_miki, 
+                            :after_enter => :kiss_miki, 
+                            :before_leave => :kick_miki, 
+                            :after_leave => :keep_miki,
+                            :on_error => :tell_mom
+        sm.add_state 'calm', :after_enter => :kiss_miki
+        sm.add_transition :get_angry, :from => "happy", :to => "mad"
+        sm.add_transition :calmate, :from => ["happy", "mad"], :to => "calm"
+      end
+    end
+
+### Configuration Options
+
+* `initial_state`: Sets up the initial state the class will get when instantiating a new instance.
+* `state_field`: the field / attribute that keeps the status enum (defaults to "status")
+* `add_state`: adding a state, accepts a state name and a list of callbacks.
+* `add_transition`: defines a transtions with destination state and source state (or multiple in an array)
+* `persistency_method`: __SimpleStateMachine__ doesn't rely on the existance of a persistency layer (ActiveRecord for example), so if you want to have this option you'll need to specify the persistency method to use (in ActiveRecord's case, use "save" or "save!")
+
+### Accessing States
+
+__SimplerStateMachine__ will save the state's enum value as integer to the defined attribute, in order to access the string / constant representation of the state use `#enum_state`:
+
+    > elad = Elad.new
+    > elad.status
+    0
+    > elad.human_status_name
+    "happy"
+
+### Callbacks / Events
+
+__SimplerStateMachine__ makes several callbacks available when defining a state and will fire them when a state transtion is made.
+The available callbacks are:
+
+* `:before_enter`: runs before the state is entered.
+* `:after_enter`: runs after the state transition is completed
+* `:before_leave`: runs before a transition to another state starts
+* `:after_leave`: runs after a transition to another state runs
+* `:on_error`: runs when the transition fails
+
+The order in which the callbacks are called is:
+
+    before_leave (of the current state)
+    before_enter (of the destination state)
+    <transition>
+    after_leave (of the current state)
+    after_enter (of the destination state)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,28 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = "--format documentation --color"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+require 'rdoc/task'
+require 'simple_state_machine/version'
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Simple State Machine #{SimpleStateMachine::VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :spec

data/lib/simple_state_machine/base.rb

@@ -0,0 +1,169 @@
+module SimpleStateMachine
+  class Base
+
+    attr_reader :states,                # Holds the state enum
+                :events,                # Hash of hashes, holds the callbacks list from each state when the state name is the key
+                :transitions,           # Hash of hashes, holds the list of available transitions for each state.
+                :initial_state,         # Define the initial state.
+                :state_field,           # The attribute that will store the status integer representation
+                :persistency_method,    # a method to ensure some persistency on a record. refer to the readme.
+                :states_constant_name   # the name of the constant to be defined with the states enum
+
+    attr_accessor :clazz
+
+    def initialize(clazz)      
+      @clazz = clazz
+      @_states = []
+      @events = {}
+      @transitions = {}
+      @state_field = "status"
+      @states_constant_name = "STATES"
+      @persistency_method = nil
+    end
+
+    # A #clone callback. we ensure that even the sub elements are cloned - 'deep copy'
+    def initialize_copy(orig)
+      super
+      @states = orig.states.clone
+      @_states = orig.instance_variable_get("@_states").clone
+      @events = orig.events.clone
+      @transitions = orig.transitions.clone
+      @initial_state = orig.initial_state.clone
+      @state_field = orig.state_field
+      @persistency_method = orig.persistency_method.clone unless @persistency_method.nil?
+      @states_constant_name = orig.states_constant_name.clone      
+    end
+
+    def states_constant_name(constant_name = nil)
+      if constant_name.nil?
+        @states_constant_name
+      else
+        @states_constant_name = constant_name.upcase
+      end
+    end
+
+    def persistency_method(method_name = nil)
+      if method_name.nil?
+        @persistency_method
+      else
+        @persistency_method = method_name
+      end
+    end
+
+    def state_field(state_field = nil)
+      if state_field.nil?
+        @state_field
+      else
+        @state_field = state_field
+      end
+    end
+
+    def initial_state(initial_state = nil)
+      if initial_state.nil?
+        @initial_state
+      else
+        add_state(initial_state)
+        @initial_state = initial_state
+      end
+    end
+
+    # Add a new state
+    def add_state(state_name, options = {})
+
+      # Fill in missing with callbacks with empty procs.
+      options =  { :before_enter => Proc.new { true },
+                    :after_enter => Proc.new { true },
+                    :before_leave => Proc.new { true },
+                    :after_leave => Proc.new { true },
+                    :on_error => Proc.new { |error| true } }.merge(options)
+
+      # Append to the states arry
+      @_states << human_state_name(state_name)
+
+      # Register events
+      @events[human_state_name(state_name)] = options.dup
+
+      @clazz.instance_eval do
+
+        # define a "#state?" method on the object instance
+        define_method("#{state_name}?") do
+          self.send(self.class.state_machine.state_field) == self.class.state_machine.states[state_name].to_i
+        end
+      end
+    end
+
+    # Add transition
+    def add_transition(transition_name, options = {})
+
+      # Convert from states to array
+      options[:from] = options[:from].is_a?(Array) ? options[:from] : options[:from].to_a
+
+      # Register transactions
+      @transitions[transition_name.to_s] = options
+      @clazz.instance_eval do
+
+        # Define the transition method
+        define_method("#{transition_name}") do |*args|
+
+          persist = args.first if args.any?
+          persist |= false
+
+          # check if the transition is available to the current state
+          if self.class.state_machine.transitions[transition_name.to_s] && self.class.state_machine.transitions[transition_name.to_s][:from].include?(self.enum_status.to_sym.to_s)
+            
+            # Get the current state events
+            current_state_events = self.class.state_machine.events[self.enum_status.to_sym.to_s]
+            next_state_events = self.class.state_machine.events[self.class.state_machine.transitions[transition_name.to_s][:to]]
+
+            begin
+              # Fire events and perform transition (and persistence if needed)
+              fire_state_machine_event(current_state_events[:before_leave])
+              fire_state_machine_event(next_state_events[:before_enter])
+              self.send("#{self.class.state_machine.state_field}=", self.class.state_machine.states[self.class.state_machine.transitions[transition_name.to_s][:to]].to_i)
+              self.send(self.class.state_machine.persistency_method) if self.class.state_machine.persistent_mode? && persist == true
+              fire_state_machine_event(current_state_events[:after_leave])
+              fire_state_machine_event(next_state_events[:after_enter])
+            rescue Exception => e
+              fire_state_machine_event(current_state_events[:on_error])
+            end
+            return true
+          else
+            return false
+          end
+        end
+
+        # Define a transition method with a shebang
+        define_method("#{transition_name}!") do
+          if !(self.send(transition_name, true))
+            raise Exceptions::InvalidTransition, "Could not transit '#{self.enum_status.to_sym.to_s}' to '#{options[:to]}'"
+          else
+            return true
+          end
+        end        
+      end
+    end
+
+
+    # Transform the states array to enum
+    def enumize!
+      @states = Enum.new(*@_states)
+    end
+
+    # Persistency method
+    def persistent_mode?
+      !(@persistency_method.nil?)
+    end
+
+    def states
+      @states
+    end
+    
+    protected 
+
+    private 
+
+    def human_state_name(state)
+      state.to_s.downcase
+    end
+  end
+end

data/lib/simple_state_machine/enum.rb

@@ -0,0 +1,29 @@
+class Enum < Hash
+
+  def initialize(*members)
+    super()
+    @rev = {}
+    members.each_with_index {|m,i| self[i] = m }
+  end
+
+  def [](k)
+     super || @rev[k]
+  end
+
+  def []=(k,v)
+    @rev[v] = k
+    super
+  end
+end
+
+class StrictEnum < Hash
+
+  module Exceptions
+    class MemberNotFound < ArgumentError; end
+  end
+
+  def [](k)
+     super || raise(Exceptions::MemberNotFound, "index/memeber '#{k}' not found in enum")
+  end
+
+end

data/lib/simple_state_machine/errors.rb

@@ -0,0 +1,6 @@
+module SimpleStateMachine
+
+  module Exceptions
+    class InvalidTransition < RuntimeError; end
+  end
+end

data/lib/simple_state_machine/event.rb

@@ -0,0 +1,5 @@
+# FFU
+module SimpleStateMachine
+  class Event
+  end
+end

data/lib/simple_state_machine/simple_state_machine.rb

@@ -0,0 +1,86 @@
+=begin
+SimpleStateMachine
+==================
+
+This module should be mixed in to a class that needs a state machine implementation. refer to the readme.
+=end
+module SimpleStateMachine
+
+  def self.included(base) #:nodoc:
+    base.class_eval do
+      extend ClassMethods
+      include InstanceMethods
+
+      # Alias the enum reference method for the confused end user.
+      alias :enum_state :enum_status
+
+    end
+  end
+
+  module ClassMethods
+
+    # When inherited - duplicate the state machine from the parent class and allow the extend it
+    def inherited(child)
+      me = self
+      child.class_eval do
+        @sm = me.state_machine.clone
+        @sm.clazz = self
+      end
+    end
+
+    # Create or return a state machine
+    def state_machine(&block)
+      return @sm if !(@sm.nil?) && !(block_given?)
+      @sm ||= SimpleStateMachine::Base.new(self)
+      @sm.instance_eval(&block) if block_given?
+      @sm.enumize!
+      self.const_set(@sm.states_constant_name,@sm.states).freeze
+      return @sm
+    end
+  end
+
+  module InstanceMethods
+
+    # Set the initial status value
+    def initialize(*args)      
+      self.send("#{self.class.state_machine.state_field}=", self.class.state_machine.states[self.class.state_machine.initial_state].to_i)            
+
+      begin
+        super
+      rescue ArgumentError # Catch in case the super does not get parameters
+        super()
+      end
+    end
+
+    # Return the enum status
+    def enum_status
+      self.class.state_machine.states[self.current_state]
+    end
+
+    # Return the current state
+    def current_state
+      self.send(self.class.state_machine.state_field)
+    end
+
+    # human name for status
+    def human_status_name
+      enum_status
+    end
+
+    private
+
+    # Fire a callback, support a symbol, string or an array of symbols / strings
+    def fire_state_machine_event(event)
+      case event.class.name
+      when "Proc"
+        event.call
+      when "Symbol", "String"
+        self.send(event)
+      when "Array"
+        event.each do |e|
+          fire_state_machine_event(e)
+        end
+      end
+    end
+  end
+end

data/lib/simple_state_machine/transition.rb

@@ -0,0 +1,13 @@
+# FFU
+module SimpleStateMachine #:nodoc 
+  class Transition
+
+    attr_accessor :to, :from
+
+    def initialize(options = {})
+      options.assert_valid_keys :from, :to
+      @to = options[:to]
+      @from = options[:from]
+    end
+  end
+end

data/lib/simple_state_machine/version.rb

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

data/lib/simple_state_machine.rb

@@ -0,0 +1,9 @@
+# Require all the files
+require File.join(File.dirname(__FILE__), 'simple_state_machine', 'version')
+require File.join(File.dirname(__FILE__), 'simple_state_machine', 'simple_state_machine')
+require File.join(File.dirname(__FILE__), 'simple_state_machine', 'base')
+require File.join(File.dirname(__FILE__), 'simple_state_machine', 'event')
+require File.join(File.dirname(__FILE__), 'simple_state_machine', 'enum')
+require File.join(File.dirname(__FILE__), 'simple_state_machine', 'errors')
+require File.join(File.dirname(__FILE__), 'simple_state_machine', 'transition')
+

data/simpler_state_machine.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/simple_state_machine/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Elad Meidar"]
+  gem.email         = ["elad@eizesus.com"]
+  gem.description   = "A simple state machine that supports enum"
+  gem.summary       = "A simple lightweight state machine that uses an enum type to store states"
+  gem.homepage      = "http://devandpencil.herokuapp.com/blog/2013/01/30/simplestatemachine-a-simple-enum-based-state-machine-for-ruby/"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "simpler_state_machine"
+  gem.require_paths = ["lib"]
+  gem.version       = SimpleStateMachine::VERSION
+
+  gem.add_development_dependency 'activerecord'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'sdoc'
+  gem.add_development_dependency 'rspec', '~> 2.0'
+  gem.add_development_dependency 'rr'
+  gem.add_development_dependency 'shoulda'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'ruby-debug'
+  gem.add_development_dependency 'ruby-debug-completion'
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: spec/simple_state_machine.sqlite3.db

data/spec/models/express_gate.rb

@@ -0,0 +1,21 @@
+class ExpressGate < Gate
+  
+  attr_accessor :new_express_record
+
+  state_machine do |sm|
+    sm.initial_state "express_beginner"    
+    sm.add_state "express_expert", :after_enter => :add_prize
+    sm.add_state "miki_level", :after_enter => :add_prize
+
+    #sm.add_state "expert", :after_enter => :add_express_prize
+
+    sm.add_transition :make_express_beginner, :from => "expert", :to => "express_beginner"
+    sm.add_transition :demote_express_beginner, :from => "express_beginner", :to => "expert"
+    sm.add_transition :make_express_expert, :from => "express_beginner", :to => "express_expert"
+    sm.add_transition :make_miki, :from => "express_expert", :to => "miki_level"    
+  end  
+
+  def initialize(initial_status = nil)    
+    super
+  end
+end

data/spec/models/gate.rb

@@ -0,0 +1,33 @@
+class Gate
+  include SimpleStateMachine
+
+  attr_accessor :prize_won, :status, :new_record
+
+  state_machine do |sm|
+    sm.initial_state "beginner"
+    sm.add_state "novice", :after_enter => :add_prize
+    sm.add_state "expert", :after_enter => :add_prize
+    sm.add_transition :make_novice, :from => ["beginner", "expert"], :to => "novice"
+    sm.add_transition :make_expert, :from => "novice", :to => "expert"
+  end
+
+  def add_prize
+    self.prize_won ||= ""
+    self.prize_won += "*"
+  end
+
+  def dummy_save
+    @new_record = false
+  end
+
+  def new_record?
+    @new_record
+  end
+
+  def initialize(initial_status = nil)    
+    @status = initial_status
+    @new_record = true
+    @prize_won = ""
+    super
+  end
+end

data/spec/models/king_gate.rb

@@ -0,0 +1,14 @@
+class KingGate < Gate
+
+  state_machine do |sm|
+    sm.initial_state "king_beginner"
+    sm.add_state "king_novice", :after_enter => :add_prize
+    sm.add_state "king_expert", :after_enter => :add_prize
+    sm.add_transition :make_king_novice, :from => "king_beginner", :to => "king_novice"
+    sm.add_transition :make_king_expert, :from => "king_novice", :to => "king_expert"
+  end  
+
+  def initialize(initial_status = nil)        
+    super
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,9 @@
+ActiveRecord::Schema.define(:version => 0) do
+
+  %w{gates readers writers transients simples simple_new_dsls thieves localizer_test_models}.each do |table_name|
+    create_table table_name, :force => true do |t|
+      t.string "status"
+      t.string "better_status"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'simple_state_machine'
+
+require 'rspec'
+require 'rspec/autorun'
+
+# require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
+# require 'ruby-debug/completion'
+
+# Requiring custom spec helpers
+Dir[File.dirname(__FILE__) + "/spec_helpers/**/*.rb"].sort.each { |f| require File.expand_path(f) }
+#Dir[File.dirname(__FILE__) + "/models/*.rb"].each { |f| require File.expand_path(f) }
+require "models/gate"
+require 'models/express_gate'
+require 'models/king_gate'

data/spec/unit/simple_state_machine_spec.rb

@@ -0,0 +1,297 @@
+require 'spec_helper'
+require 'ruby-debug'
+
+describe SimpleStateMachine do
+  describe "- Normal state machine" do
+    before(:each) do
+      @gate = Gate.new    
+      @gate.should respond_to(:status)
+    end
+
+    describe "- Basic operations" do
+
+      it "Should allow accessible methods to check if certain state is active on the including class" do
+        @gate.methods.should include("beginner?")
+        @gate.methods.should include("novice?")
+        @gate.methods.should include("expert?")
+      end
+
+      it "should have a state_machine reference" do
+        @gate.class.should respond_to(:state_machine)
+      end
+
+      it "should respond to the default state field" do
+        @gate.should respond_to(Gate.state_machine.state_field)
+      end
+
+      it "should set the default state field to 'status'" do
+        Gate.state_machine.state_field.should eql("status")
+      end
+
+      it "should set an initial status" do
+        @gate.status.should eql(Gate.state_machine.states["beginner"].to_i)
+      end
+
+      it "should force an initial status even if one specified by a default class constructor" do
+        @gate = Gate.new("bogus_status")        
+        @gate.beginner?.should be_true
+      end
+    end
+
+    describe "- Transitions" do
+
+      it "should allow a gate to transition from 'beginner' to 'novice', normal method" do
+        lambda {
+            @gate.make_novice.should be_true
+          }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+        @gate.novice?.should be_true
+      end
+
+      it "should allow a gate to transition from 'beginner' to 'novice', with shebang" do
+        lambda {
+            @gate.make_novice!
+          }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+        @gate.novice?.should be_true
+      end
+
+      it "should not allow a gate to transition from 'beginner' to 'expert'" do
+        lambda {
+            @gate.make_expert.should be_false
+          }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+        @gate.beginner?.should be_true
+      end
+
+      it "should raise an exception if a gate tries to transition from 'beginner' to 'expert' with a shebang" do
+        lambda {
+            @gate.make_expert!
+          }.should raise_error(SimpleStateMachine::Exceptions::InvalidTransition, "Could not transit 'beginner' to 'expert'")
+
+        @gate.beginner?.should be_true
+      end
+
+      it "should allow a gate to transtition from 'expert' back to 'novice', normal method" do
+        @gate.status = Gate.state_machine.states["expert"]
+        lambda {
+            @gate.make_novice.should be_true
+          }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+        @gate.novice?.should be_true
+      end
+      
+      it "should allow a gate to transtition from 'expert' back to 'novice', with shebang" do
+        @gate.status = Gate.state_machine.states["expert"]
+        lambda {
+            @gate.make_novice!
+          }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+        @gate.novice?.should be_true
+      end
+
+    end
+
+    describe "- Persistency" do
+      before(:all) do
+        Gate.state_machine.persistency_method(:dummy_save)
+      end
+
+      it "should persist on a shebang persistency transition method" do
+        @gate.new_record?.should be_true
+        @gate.make_novice!
+        @gate.new_record?.should be_false
+        @gate.novice?.should be_true
+      end
+
+      it "should not persist on a non-shebang persistency transition method" do
+        @gate.new_record?.should be_true
+        @gate.make_novice.should be_true
+        @gate.new_record?.should be_true
+        @gate.novice?.should be_true
+      end
+    end
+
+    describe "- Events" do
+      it "should add prizes to the gate when transitioning from 'beginner' to 'novice'" do
+        @gate.prize_won.should be_empty
+        @gate.make_novice.should be_true
+        @gate.prize_won.should eql("*")
+        @gate.novice?.should be_true
+      end
+    end
+  end
+
+  describe "- Inheritence" do
+    describe "- parent class state machine" do
+      before(:each) do
+        #create both KingGate & ExpressGate to fail class level attributes integrity        
+        @kinggate = KingGate.new        
+        @gate = ExpressGate.new    
+        @gate.should respond_to(:status)        
+      end
+
+      describe "- Basic operations" do
+        it "Should allow accessible constants on the including class" do
+          ExpressGate.constants.should include("STATES")
+          ExpressGate::STATES["beginner"].should_not be_nil
+          ExpressGate::STATES["novice"].should_not be_nil
+          ExpressGate::STATES["expert"].should_not be_nil
+          ExpressGate::STATES["express_beginner"].should_not be_nil
+          ExpressGate::STATES["express_expert"].should_not be_nil
+          ExpressGate::STATES["miki_level"].should_not be_nil
+        end        
+        
+        it "Should allow accessible methods to check if certain state is active on the including class for parent class' states" do
+          @gate.methods.should include("beginner?")
+          @gate.methods.should include("novice?")
+          @gate.methods.should include("expert?")
+        end
+
+        it "Should allow accessible methods to check if certain state is active on the including class for child class' states" do
+          @gate.methods.should include("express_beginner?")
+          @gate.methods.should include("express_expert?")
+          @gate.methods.should include("miki_level?")
+        end
+
+        it "should have a state_machine reference" do
+          @gate.class.should respond_to(:state_machine)
+        end
+
+        it "should respond to the default state field" do
+          @gate.should respond_to(ExpressGate.state_machine.state_field)
+        end
+
+        it "should set the default state field to 'status'" do
+          ExpressGate.state_machine.state_field.should eql("status")
+        end
+
+        it "should set an initial status" do          
+          @gate.status.should eql(ExpressGate.state_machine.states["express_beginner"].to_i)
+        end
+
+        it "should force an initial status even if one specified by a default class constructor" do          
+          @gate = ExpressGate.new("bogus_status")
+          @gate.express_beginner?.should be_true
+        end
+      end
+
+      describe "- Transitions" do
+
+        it "should allow a gate to transition from a state that comes from parent 'expert' to 'express_beginner', normal method" do
+          lambda {
+              @gate.status = ExpressGate.state_machine.states["expert"]
+              @gate.make_express_beginner.should be_true
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+          @gate.express_beginner?.should be_true
+        end
+
+        it "should allow a gate to transition from a state that comes from parent 'expert' to 'express_beginner', shebang method" do
+          lambda {
+              @gate.status = ExpressGate.state_machine.states["expert"]
+              @gate.make_express_beginner!
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+          @gate.express_beginner?.should be_true
+        end
+
+        it "should not allow a gate to transition from a state that comes from parent 'beginner' to 'express_beginner', normal method" do
+          @gate.status = ExpressGate.state_machine.states["beginner"]
+          lambda {
+              @gate.make_express_beginner.should be_false
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+          @gate.beginner?.should be_true
+        end      
+
+        it "should not allow a gate to transition from a state that comes from parent 'beginner' to 'express_beginner', shebang method" do
+          @gate.status = ExpressGate.state_machine.states["beginner"]
+          lambda {
+              @gate.make_express_beginner!
+            }.should raise_error(SimpleStateMachine::Exceptions::InvalidTransition, "Could not transit 'beginner' to 'express_beginner'")
+
+          @gate.beginner?.should be_true
+        end
+
+        it "should allow a gate to transition from 'express_beginner' to 'express_expert', normal method" do
+          lambda {
+              @gate.make_express_expert.should be_true
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+          @gate.express_expert?.should be_true
+        end
+
+        it "should allow a gate to transition from 'express_beginner' to 'express_expert', with shebang" do
+          lambda {
+              @gate.make_express_expert!
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+          @gate.express_expert?.should be_true
+        end
+
+        it "should not allow a gate to transition from 'express_beginner' to 'miki_level'" do
+          lambda {
+              @gate.make_miki.should be_false
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+          @gate.express_beginner?.should be_true
+        end
+
+        it "should raise an exception if a gate tries to transition from 'express_beginner' to 'miki_level' with a shebang" do
+          lambda {
+              @gate.make_miki!
+            }.should raise_error(SimpleStateMachine::Exceptions::InvalidTransition, "Could not transit 'express_beginner' to 'miki_level'")
+
+          @gate.express_beginner?.should be_true
+        end
+
+        it "should allow a gate to transition from a state that comes from child 'express_beginner' to 'expert', normal method" do
+          @gate.status = ExpressGate.state_machine.states["express_beginner"]         
+          lambda {
+              @gate.demote_express_beginner.should be_true
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)  
+          @gate.expert?.should be_true
+        end
+
+        it "should allow a gate to transition from a state that comes from child 'express_beginner' to state from parent 'expert', shebang method" do
+          @gate.status = ExpressGate.state_machine.states["express_beginner"]   
+          lambda {
+              @gate.demote_express_beginner!
+            }.should_not raise_error(SimpleStateMachine::Exceptions::InvalidTransition)
+
+          @gate.expert?.should be_true
+        end
+      end
+
+      describe "- Persistency" do
+        before(:all) do
+          ExpressGate.state_machine.persistency_method(:dummy_save)
+        end
+
+        it "should persist on a shebang transition method" do
+          @gate.new_record?.should be_true
+          @gate.make_express_expert!
+          @gate.new_record?.should be_false
+          @gate.express_expert?.should be_true
+        end
+
+        it "should not persist on a non-shebang transition method" do
+          @gate.new_record?.should be_true
+          @gate.make_express_expert
+          @gate.new_record?.should be_true
+          @gate.express_expert?.should be_true
+        end
+      end
+
+      describe "- Events" do
+        it "should add prizes to the gate when transitioning from 'beginner' to 'novice'" do
+          @gate.prize_won.should be_empty
+          @gate.make_express_expert
+          @gate.prize_won.should eql("*")
+          @gate.express_expert?.should be_true
+        end
+      end
+    end    
+  end
+end

metadata

@@ -0,0 +1,227 @@
+--- !ruby/object:Gem::Specification
+name: simpler_state_machine
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Elad Meidar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-debug
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-debug-completion
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple state machine that supports enum
+email:
+- elad@eizesus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/simple_state_machine.rb
+- lib/simple_state_machine/base.rb
+- lib/simple_state_machine/enum.rb
+- lib/simple_state_machine/errors.rb
+- lib/simple_state_machine/event.rb
+- lib/simple_state_machine/simple_state_machine.rb
+- lib/simple_state_machine/transition.rb
+- lib/simple_state_machine/version.rb
+- simpler_state_machine.gemspec
+- spec/database.yml
+- spec/models/express_gate.rb
+- spec/models/gate.rb
+- spec/models/king_gate.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/unit/simple_state_machine_spec.rb
+homepage: http://devandpencil.herokuapp.com/blog/2013/01/30/simplestatemachine-a-simple-enum-based-state-machine-for-ruby/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.8.25
+signing_key: 
+specification_version: 3
+summary: A simple lightweight state machine that uses an enum type to store states
+test_files: []