simple_state_machine 0.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Marek de Heus & Petrik de Heus
+
+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.rdoc

@@ -0,0 +1,73 @@
+= SimpleStateMachine
+
+A Ruby Statemachine that focuses on events instead of states.
+
+A state machine should help you:
+- Encapsulate state,
+- Guard state transitions,
+- Make it trivial to add state transitions to any method.
+
+Instead of using a DSL to define events, we use a different approach.
+We have a very simple DSL to decorate existing methods with logic that guards 
+state transitions.
+
+==== example
+
+  def activate_account(activation_code)
+    if activation_code_invalid?(activation_code)
+      errors.add(:activation_code, 'Invalid')
+    end
+  end
+  event :activate_account, :pending => :active
+
+
+This has a couple of advantages:
+- Arguments can be passed to 'events',
+- 'events' can return a value, remember, it's just a method,
+- Validation errors can be set on the model if you are using ActiveRecord / ActiveModel,
+- Encapsulate state transitions (no need for :guards).
+
+To use the code, you need to do 3 things:
+- extend SimpleStateMachine,
+- set the initial state,
+- decorate a method with the event DSL
+
+==== Example usage
+
+  class Lamp
+
+    extend SimpleStateMachine
+
+    def initialize
+      self.state = :off
+    end
+
+    def push_button1
+      puts "click1: #{state}"
+    end
+    event :push_button1, :off => :on,
+                         :on  => :off
+
+    def push_button2
+      puts "click1: #{state}"
+    end
+    event :push_button2, :off => :on,
+                         :on  => :off
+
+  end
+
+This code was just released, we do not claim it to be stable.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Marek & Petrik. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "simple_state_machine"
+    gem.summary = %Q{A statemachine that focuses on events instead of states}
+    gem.description = %Q{A simple DSL to decorate existing methods with logic that guards state transitions.}
+    gem.email = ["FIX@example.com"]
+    gem.homepage = "http://github.com/p8/simple_state_machine"
+    gem.authors = ["Marek de Heus", "Petrik de Heus"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "simple_state_machine #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/examples/conversation.rb

@@ -0,0 +1,34 @@
+# Implementation of the AASM Conversation
+#
+# class Conversation
+#   include AASM
+# 
+#   aasm_column :current_state # defaults to aasm_state
+# 
+#   aasm_initial_state :unread
+# 
+#   aasm_state :unread
+#   aasm_state :read
+#   aasm_state :closed
+# 
+#   aasm_event :view do
+#     transitions :to => :read, :from => [:unread]
+#   end
+# 
+#   aasm_event :close do
+#     transitions :to => :closed, :from => [:read, :unread]
+#   end
+# end
+
+class Conversation
+  extend SimpleStateMachine
+
+  def initialize
+    self.state = 'unread'
+  end
+
+  event :view,  :unread => :read
+  event :close, :unread => :closed,
+                :read   => :closed
+
+end

data/examples/lamp.rb

@@ -0,0 +1,21 @@
+class Lamp
+      
+  extend SimpleStateMachine
+
+  def initialize
+    self.state = 'off'
+  end
+  
+  def push_button1
+    puts "click1: #{state}"
+  end
+  event :push_button1, :off => :on, 
+                       :on  => :off
+  
+  def push_button2
+    puts "click2: #{state}"
+  end
+  event :push_button2, :off => :on,
+                       :on  => :off
+
+end

data/examples/relationship.rb

@@ -0,0 +1,87 @@
+# Implementation of the AASM Conversation
+#
+# class Relationship
+#   include AASM
+# 
+#   aasm_column :status
+# 
+#   aasm_initial_state Proc.new { |relationship| relationship.strictly_for_fun? ? :intimate : :dating }
+# 
+#   aasm_state :dating,   :enter => :make_happy,        :exit => :make_depressed
+#   aasm_state :intimate, :enter => :make_very_happy,   :exit => :never_speak_again
+#   aasm_state :married,  :enter => :give_up_intimacy,  :exit => :buy_exotic_car_and_wear_a_combover
+# 
+#   aasm_event :get_intimate do
+#     transitions :to => :intimate, :from => [:dating], :guard => :drunk?
+#   end
+# 
+#   aasm_event :get_married do
+#     transitions :to => :married, :from => [:dating, :intimate], :guard => :willing_to_give_up_manhood?
+#   end
+# 
+#   def strictly_for_fun?; end
+#   def drunk?; end
+#   def willing_to_give_up_manhood?; end
+#   def make_happy; end
+#   def make_depressed; end
+#   def make_very_happy; end
+#   def never_speak_again; end
+#   def give_up_intimacy; end
+#   def buy_exotic_car_and_wear_a_combover; end
+# end
+
+class Relationship
+  extend SimpleStateMachine
+  
+  def initialize
+    self.state = relationship.strictly_for_fun? ? get_intimate : start_dating
+  end
+
+  def start_dating
+    make_happy
+    # make_depressed not called on exit
+  end
+  event :start_dating, nil => :dating
+
+  def get_intimate
+    # exit if drunk?
+    make_very_happy
+    # never_speak_again not called on exit
+  end
+  event :get_intimate, :dating => :intimate
+
+  def get_married
+    give_up_intimacy
+    #exit unless willing_to_give_up_manhood?
+    # buy_exotic_car_and_wear_a_combover not called on exit
+  end
+  event :get_married, :dating   => :married,
+                      :intimate => :married
+
+  # extra event added
+  def stop_dating
+    make_depressed
+  end
+  event :stop_dating, :dating => nil
+
+  def dump
+    never_speak_again
+  end
+  event :dump, :intimate => :dump
+
+  def divorce
+    buy_exotic_car_and_wear_a_combover
+  end
+  event :divorce, :married => :divorced
+
+
+  def strictly_for_fun?; end
+  def drunk?; end
+  def willing_to_give_up_manhood?; end
+  def make_happy; end
+  def make_depressed; end
+  def make_very_happy; end
+  def never_speak_again; end
+  def give_up_intimacy; end
+  def buy_exotic_car_and_wear_a_combover; end
+end

data/examples/traffic_light.rb

@@ -0,0 +1,17 @@
+class TrafficLight
+  
+  extend SimpleStateMachine
+  
+  def initialize
+    self.state = 'green'
+  end
+
+  # state machine events
+  def change_state
+    puts "#{state} => #{@next_state}"
+  end
+
+  event :change_state, :green  => :orange,
+                       :orange => :red,
+                       :red    => :green
+end

data/examples/user.rb

@@ -0,0 +1,37 @@
+require 'digest/sha1'
+class User < ActiveRecord::Base
+  
+  validates_presence_of :name
+  
+  extend SimpleStateMachine
+
+  def after_initialize
+    self.state ||= 'new'
+  end
+
+  def invite
+    self.activation_code = Digest::SHA1.hexdigest("salt #{Time.now.to_f}")
+    send_activation_email(self.activation_code)
+  end
+  event :invite, :new => :invited
+
+  def confirm_invitation activation_code
+    if activation_code != self.activation_code
+      errors.add(:activation_code, 'Invalid')
+    end
+  end
+  event :confirm_invitation, :invited => :active
+
+  #event :log_send_activation_code_failed, :new => :send_activation_code_failed
+  # 
+  # def reset_password(new_password)
+  #   self.password = new_password
+  # end
+  # # do not change state, but ensure that we are in proper state
+  # event :reset_password, :active => :active
+  
+  def send_activation_email(code)
+    true
+  end
+
+end

data/lib/simple_state_machine.rb

@@ -0,0 +1 @@
+require 'simple_state_machine/simple_state_machine'

data/lib/simple_state_machine/simple_state_machine.rb

@@ -0,0 +1,209 @@
+module SimpleStateMachine
+  
+  def event event_name, state_transitions
+    @state_machine_definition ||= StateMachineDefinition.new self
+    @state_machine_definition.define_event event_name, state_transitions
+  end
+  
+  def state_machine_definition
+    @state_machine_definition
+  end
+  
+  class StateMachineDefinition
+    
+    attr_reader :events
+
+    def initialize subject
+      @events = {}
+      @decorator = if inherits_from_active_record_base?(subject)
+        Decorator::ActiveRecord.new(subject)
+      else
+        Decorator::Base.new(subject)
+      end
+    end
+    
+    def define_event event_name, state_transitions
+      @events[event_name.to_s] ||= {}
+      state_transitions.each do |from, to|
+        @events[event_name.to_s][from.to_s] = to.to_s
+        @decorator.decorate(event_name, from, to)
+      end
+    end
+
+    def inherits_from_active_record_base?(subject)
+      subject.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
+    end
+
+  end
+  
+  module StateMachine
+    
+    class Base
+      def initialize(subject)
+        @subject = subject
+      end
+    
+      def next_state(event_name)
+        @subject.class.state_machine_definition.events[event_name.to_s][@subject.state]
+      end
+    
+      def transition(event_name)
+        if to = next_state(event_name)
+          result = yield
+          @subject.state = to
+          return result
+        else
+          illegal_event_callback event_name
+        end
+      end
+    
+      private
+
+        def illegal_event_callback event_name
+          # override with your own implementation, like setting errors in your model
+          raise "You cannot '#{event_name}' when state is '#{@subject.state}'"
+        end
+    
+    end
+
+    class ActiveRecord < Base
+      
+      def next_state(event_name)
+        if event_name =~ /\!$/
+          event_name = event_name.chop
+        end
+        super event_name
+      end
+
+      def transition(event_name)
+        if to = next_state(event_name)
+          if with_error_counting { yield } > 0 || @subject.invalid?
+            if event_name =~ /\!$/
+              raise ::ActiveRecord::RecordInvalid.new(@subject)
+            else
+              return false
+            end
+          else
+            @subject.state = to
+            if event_name =~ /\!$/
+              @subject.save! #TODO maybe save_without_validation!
+            else
+              @subject.save
+            end
+          end
+        else
+          illegal_event_callback event_name
+        end
+      end
+
+      private
+
+        def with_error_counting
+          original_errors_size =  @subject.errors.size
+          yield
+          @subject.errors.size - original_errors_size
+        end
+
+    end
+
+  end
+
+  module Decorator
+    class Base
+
+      def initialize(subject)
+        @subject = subject
+        define_state_machine_method
+        define_state_getter_method
+        define_state_setter_method
+      end
+
+      def decorate event_name, from, to
+        define_state_helper_method(from)
+        define_state_helper_method(to)
+        define_event_method(event_name)
+        decorate_event_method(event_name)
+      end
+
+      private
+
+        def define_state_machine_method
+          @subject.send(:define_method, "state_machine") do
+            @state_machine ||= StateMachine::Base.new(self)
+          end
+        end
+
+        def define_state_helper_method state
+          unless @subject.method_defined?("#{state.to_s}?")
+            @subject.send(:define_method, "#{state.to_s}?") do
+              self.state == state.to_s
+            end
+          end
+        end
+
+        def define_event_method event_name
+          unless @subject.method_defined?("#{event_name}")
+            @subject.send(:define_method, "#{event_name}") {}
+          end
+        end
+
+        def decorate_event_method event_name
+          # TODO put in transaction for activeRecord?
+          unless @subject.method_defined?("with_managed_state_#{event_name}")
+            @subject.send(:define_method, "with_managed_state_#{event_name}") do |*args|
+              return state_machine.transition(event_name) do
+                send("without_managed_state_#{event_name}", *args)
+              end
+            end
+            @subject.send :alias_method, "without_managed_state_#{event_name}", event_name
+            @subject.send :alias_method, event_name, "with_managed_state_#{event_name}"
+          end
+        end
+
+        def define_state_setter_method
+          unless @subject.method_defined?('state=')
+            @subject.send(:define_method, 'state=') do |new_state|
+              @state = new_state.to_s
+            end
+          end
+        end
+
+        def define_state_getter_method
+          unless @subject.method_defined?('state')
+            @subject.send(:define_method, 'state') do
+              @state
+            end
+          end
+        end
+
+    end
+    
+    class ActiveRecord < Base
+
+      def decorate event_name, from, to
+        super event_name, from, to
+        unless @subject.method_defined?("#{event_name}!")
+          @subject.send(:define_method, "#{event_name}!") do |*args|
+            send "#{event_name}", *args
+          end
+        end
+        decorate_event_method("#{event_name}!")
+      end
+      
+      private
+      
+      def define_state_machine_method
+        @subject.send(:define_method, "state_machine") do
+          @state_machine ||= StateMachine::ActiveRecord.new(self)
+        end
+      end
+
+      def define_state_setter_method; end
+
+      def define_state_getter_method; end
+
+    end
+    
+  end
+
+end

data/simple_state_machine.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{simple_state_machine}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marek de Heus", "Petrik de Heus"]
+  s.date = %q{2010-06-28}
+  s.description = %q{A simple DSL to decorate existing methods with logic that guards state transitions.}
+  s.email = ["FIX@example.com"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/conversation.rb",
+     "examples/lamp.rb",
+     "examples/relationship.rb",
+     "examples/traffic_light.rb",
+     "examples/user.rb",
+     "lib/simple_state_machine.rb",
+     "lib/simple_state_machine/simple_state_machine.rb",
+     "simple_state_machine.gemspec",
+     "spec/active_record_spec.rb",
+     "spec/decorator_spec.rb",
+     "spec/examples_spec.rb",
+     "spec/simple_state_machine_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/p8/simple_state_machine}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A statemachine that focuses on events instead of states}
+  s.test_files = [
+    "spec/active_record_spec.rb",
+     "spec/decorator_spec.rb",
+     "spec/examples_spec.rb",
+     "spec/simple_state_machine_spec.rb",
+     "spec/spec_helper.rb",
+     "examples/conversation.rb",
+     "examples/lamp.rb",
+     "examples/relationship.rb",
+     "examples/traffic_light.rb",
+     "examples/user.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/spec/active_record_spec.rb

@@ -0,0 +1,128 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'rubygems'
+gem 'activerecord', '>= 1.15.4.7794'
+require 'active_record'
+require 'examples/user'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do    
+    create_table :users do |t|
+      t.column :id, :integer
+      t.column :name, :string
+      t.column :state, :string
+      t.column :activation_code, :string
+      t.column :created_at, :datetime
+      t.column :updated_at, :datetime
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+describe User do
+  
+  before do
+    setup_db
+  end
+  
+  after do
+    teardown_db
+  end
+  
+  it "has a default state" do
+    User.new.should be_new
+  end
+  
+  describe "events" do
+    it "persists transitions" do
+      user = User.create!(:name => 'name')
+      user.invite.should == true
+      User.find(user.id).should be_invited
+      User.find(user.id).activation_code.should_not be_nil
+    end
+
+    it "persists transitions with !" do
+      user = User.create!(:name => 'name')
+      user.invite!.should == true
+      User.find(user.id).should be_invited
+      User.find(user.id).activation_code.should_not be_nil
+    end
+
+    it "raises an error if an invalid state_transition is called" do
+      user = User.create!(:name => 'name')
+      l = lambda { user.confirm_invitation 'abc' }
+      l.should raise_error(RuntimeError, "You cannot 'confirm_invitation' when state is 'new'")
+    end
+
+    it "returns false if event called and record is invalid" do
+      user = User.new
+      user.should_not be_valid
+      user.invite.should == false
+    end
+
+    it "keeps state if event called and record is invalid" do
+      user = User.new
+      user.should_not be_valid
+      user.invite.should == false
+      user.should be_new
+    end
+
+    it "raises a RecordInvalid event if called with ! and record is invalid" do
+      user = User.new
+      user.should_not be_valid
+      l = lambda { user.invite! }
+      l.should raise_error(ActiveRecord::RecordInvalid, "Validation failed: Name can't be blank")
+    end
+
+    it "keeps state if event! called and record is invalid" do
+      user = User.new
+      user.should_not be_valid
+      begin
+        user.invite!
+      rescue ActiveRecord::RecordInvalid;end
+      user.should be_new
+    end
+
+    it "returns falls if record is valid but event adds errors" do
+      user = User.create!(:name => 'name')
+      user.invite!
+      user.should be_valid
+      r = user.confirm_invitation('x').should == false      
+    end
+
+    it "keeps state if record is valid but event adds errors" do
+      user = User.create!(:name => 'name')
+      user.invite!
+      user.should be_valid
+      user.confirm_invitation('x')
+      user.should be_invited
+    end
+
+    it "raises a RecordInvalid if record is valid but event adds errors" do
+      user = User.create!(:name => 'name')
+      user.invite!
+      user.should be_valid
+      l = lambda { user.confirm_invitation!('x') }
+      l.should raise_error(ActiveRecord::RecordInvalid, "Validation failed: Activation code Invalid")
+    end
+
+    it "keeps state if record is valid but event adds errors" do
+      user = User.create!(:name => 'name')
+      user.invite!
+      user.should be_valid
+      begin
+        user.confirm_invitation!('x')
+      rescue ActiveRecord::RecordInvalid;end
+      user.should be_invited
+    end
+
+  end
+
+end

data/spec/decorator_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class WithoutEventMethods
+  extend SimpleStateMachine
+
+  def initialize
+    self.state = 'unread'
+  end
+  event :view, :unread => :read
+  
+end
+
+class WithPredefinedStateHelperMethods
+  extend SimpleStateMachine
+
+  def initialize
+    self.state = 'unread'
+  end
+  event :view, :unread => :read
+
+  def unread?
+    raise "blah"
+  end
+end
+
+
+describe SimpleStateMachine::Decorator do
+
+  it "defines state_helper_methods for all states" do
+    TrafficLight.new.green?.should == true
+    TrafficLight.new.orange?.should == false
+    TrafficLight.new.red?.should == false
+  end
+  
+  it "does not define an state_helper_method if it already exists" do
+    l = lambda { WithPredefinedStateHelperMethods.new.unread? }
+    l.should raise_error(RuntimeError, 'blah')
+  end
+  
+  it "defines an event method if it doesn't exist" do
+    WithoutEventMethods.new.view
+  end
+
+end

data/spec/examples_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Examples" do
+  describe "TrafficLight" do
+    it "changes to the next state" do
+      tl = TrafficLight.new
+      tl.should be_green
+      tl.change_state
+      tl.should be_orange
+      tl.change_state
+      tl.should be_red
+      tl.change_state
+      tl.should be_green
+    end
+  end
+  
+  describe "Lamp" do
+    it "changes between :on and :off" do
+      lamp = Lamp.new
+      lamp.should be_off
+      lamp.push_button1
+      lamp.should be_on
+      lamp.push_button2
+      lamp.should be_off
+      lamp.push_button2
+      lamp.should be_on
+      lamp.push_button1
+      lamp.should be_off
+    end
+  end
+  
+  describe "Conversation" do
+    it "is :unread by default" do
+      conversation = Conversation.new
+      conversation.should be_unread
+    end
+    
+    it "changes to read on view" do
+      conversation = Conversation.new
+      conversation.view
+      conversation.should be_read
+    end
+
+    it "changes to closed on close" do
+      conversation = Conversation.new
+      conversation.close
+      conversation.should be_closed
+    end
+
+    it "changes to closed on close if :read" do
+      conversation = Conversation.new
+      conversation.view
+      conversation.close
+      conversation.should be_closed
+    end
+  end
+
+end
+

data/spec/simple_state_machine_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class SimpleExample
+  extend SimpleStateMachine
+  attr_reader :event2_called
+  def initialize
+    self.state = 'state1'
+  end
+  event :event1, :state1 => :state2
+  def event2
+    @event2_called = true
+    'event2'
+  end
+  event :event2, :state2 => :state3
+end
+
+describe SimpleStateMachine do
+  
+  it "has a default state" do
+    SimpleExample.new.state.should == 'state1'
+  end
+
+  describe "events" do
+    it "raise an error if an invalid state_transition is called" do
+      example = SimpleExample.new
+      lambda { example.event2 }.should raise_error(RuntimeError, "You cannot 'event2' when state is 'state1'")
+    end
+
+    it "return nil" do
+      example = SimpleExample.new
+      example.event1.should == nil
+      example.event2.should == 'event2'
+    end
+
+    it "calls existing methods" do
+      example = SimpleExample.new
+      example.event1
+      example.event2
+      example.event2_called.should == true
+    end
+
+  end
+
+  describe "state_machine" do
+    it "has a next_state method" do
+      example = SimpleExample.new
+      example.state_machine.next_state('event1').should == 'state2'
+      example.state_machine.next_state('event2').should be_nil
+    end
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--debugger
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'simple_state_machine'
+require 'spec'
+require 'spec/autorun'
+
+require 'examples/conversation'
+require 'examples/lamp'
+require 'examples/traffic_light'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: simple_state_machine
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Marek de Heus
+- Petrik de Heus
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-28 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: A simple DSL to decorate existing methods with logic that guards state transitions.
+email: 
+- FIX@example.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/conversation.rb
+- examples/lamp.rb
+- examples/relationship.rb
+- examples/traffic_light.rb
+- examples/user.rb
+- lib/simple_state_machine.rb
+- lib/simple_state_machine/simple_state_machine.rb
+- simple_state_machine.gemspec
+- spec/active_record_spec.rb
+- spec/decorator_spec.rb
+- spec/examples_spec.rb
+- spec/simple_state_machine_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/p8/simple_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: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A statemachine that focuses on events instead of states
+test_files: 
+- spec/active_record_spec.rb
+- spec/decorator_spec.rb
+- spec/examples_spec.rb
+- spec/simple_state_machine_spec.rb
+- spec/spec_helper.rb
+- examples/conversation.rb
+- examples/lamp.rb
+- examples/relationship.rb
+- examples/traffic_light.rb
+- examples/user.rb