ruby-state-machine 1.0.2 → 1.1.0

data/script/generate

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/generate'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
-RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -1,71 +0,0 @@
-#!/usr/bin/env ruby
-
-load File.dirname(__FILE__) + "/../Rakefile"
-require 'rubyforge'
-require 'redcloth'
-require 'syntax/convertors/html'
-require 'erb'
-
-download = "http://rubyforge.org/projects/#{$hoe.rubyforge_name}"
-version  = $hoe.version
-
-def rubyforge_project_id
-  RubyForge.new.configure.autoconfig["group_ids"][$hoe.rubyforge_name]
-end
-
-class Fixnum
-  def ordinal
-    # teens
-    return 'th' if (10..19).include?(self % 100)
-    # others
-    case self % 10
-    when 1: return 'st'
-    when 2: return 'nd'
-    when 3: return 'rd'
-    else    return 'th'
-    end
-  end
-end
-
-class Time
-  def pretty
-    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
-  end
-end
-
-def convert_syntax(syntax, source)
-  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
-end
-
-if ARGV.length >= 1
-  src, template = ARGV
-  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
-else
-  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
-  exit!
-end
-
-template = ERB.new(File.open(template).read)
-
-title = nil
-body = nil
-File.open(src) do |fsrc|
-  title_text = fsrc.readline
-  body_text_template = fsrc.read
-  body_text = ERB.new(body_text_template).result(binding)
-  syntax_items = []
-  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
-    ident = syntax_items.length
-    element, syntax, source = $1, $2, $3
-    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
-    "syntax-temp-#{ident}"
-  }
-  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
-  body = RedCloth.new(body_text).to_html
-  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
-end
-stat = File.stat(src)
-created = stat.ctime
-modified = stat.mtime
-
-$stdout << template.result(binding)

data/test/test_helper.rb

@@ -1,3 +0,0 @@
-require 'stringio'
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/ruby-state-machine'

data/test/test_state_machine.rb

@@ -1,212 +0,0 @@
-require 'test/unit'
-#require "#{File.dirname(__FILE__)}/../init"
-
-require 'ruby-state-machine/state_machine'
-
-# Fixture for testing state machine:
-class StateMachineFixture
-  include StateMachine
-  attr_accessor :test_val, :prev_test_val, :proc_val, :force_decide_nil, :name_for_decider
-  
-  
-  state_machine :states => [:a_state, :b_state, :c_state, :d_state], :events => [:w_event, :x_event, :y_event, :z_event]
-  state_transition :state=>:a_state, :event=>:w_event, :next=>{:state=>:b_state, :action=>lambda{|o, args| o.increment_value(5)} }
-  state_transition :state=>:a_state, :event=>:x_event, :next=>:c_state
-  state_transition :state=>:a_state, :event=>:y_event, :next=>:a_state
-  state_transition :state=>:a_state, :event=>:z_event, :next=>:b_state
-                                                            
-  state_transition :state=>:b_state, :event=>:w_event, :next=>:b_state
-  state_transition :state=>:b_state, :event=>:y_event, :next=>:c_state
-  state_transition :state=>:b_state, :event=>:z_event, :next=>:a_state
-                                                            
-  state_transition :state=>:c_state, :event=>:x_event, :next=>:b_state
-  state_transition :state=>:c_state, :event=>:y_event, :next=>{:state=>:a_state, :action=>lambda{|o, args| o.increment_value(-3)}}
-
-  state_transition :state=>:c_state, :event=>:w_event, :decider => :c_state_decider, 
-    :next=>[
-      {:state=>:a_state, :action=>lambda{|o, args| o.increment_value(7)} }, 
-      {:state=>:b_state, :action=>lambda{|o, args| o.increment_value(-10)} }
-    ]
-    
-  state_transition :state=>:c_state, :event=>:z_event , :decider => :named_action_decider, 
-      :next=>[
-        {:name=>"foo", :state=>:a_state, :action=>lambda{|o, args| o.increment_value(7)} }, 
-        {:name=>"bar", :state=>:d_state, :action=>lambda{|o, args| o.increment_value(-10)} }
-      ]
-  
-  state_transition :state=>:d_state, :event=>:x_event, :next=>:stay
-  
-  def initialize
-    super
-    @test_val = nil
-    @proc_val = 0
-    @force_decide_nil = false
-    @name_for_decider = "foo"
-  end
-  
-  def increment_value(by)
-    @proc_val += by
-  end
-  
-  def bush(term)
-    @prev_test_val = @test_val
-    @test_val=term
-    send_event(:w_event)
-  end
-  
-  def c_state_decider(args)
-    if @force_decide_nil
-      # Hack to test nil decider:
-      nil
-    else
-      refined = (@test_val and @prev_test_val and @test_val.index(@prev_test_val)==0)    
-      refined ? :b_state : :a_state
-    end
-  end
-  
-  def named_action_decider(args)
-    @name_for_decider
-  end
-    
-end
-
-# Test state machine:
-class StateMachineTest < Test::Unit::TestCase
-
-  def test_states
-    assert_equal(:d_state, StateMachineFixture.states.last)
-  end
-
-  def test_events
-    assert_equal(:w_event, StateMachineFixture.events.first)
-  end
-  
-  def test_next_states
-    assert_equal(:b_state, StateMachineFixture.next_state(:a_state, :w_event))
-    assert_equal(:c_state, StateMachineFixture.next_state(:a_state, :x_event))
-    assert_equal(:b_state, StateMachineFixture.next_state(:b_state, :w_event))
-    assert_equal(:a_state, StateMachineFixture.next_state(:b_state, :z_event))
-    assert_equal(:a_state, StateMachineFixture.next_state(:c_state, :y_event))
-    assert_equal(:b_state, StateMachineFixture.next_state(:c_state, :x_event))    
-    assert_nil(StateMachineFixture.next_state(:b_state, :x_event))
-  end
-  
-  def test_event_sending
-    sm = StateMachineFixture.new
-    assert_equal(:a_state, sm.current_state)
-    sm.send_event(:w_event)
-    
-    assert_equal(:b_state, sm.current_state)
-    assert_raise(StateMachine::InvalidStateError){sm.send_event(:x_event)}
-
-    sm.send_event(:w_event)    
-    assert_equal(:b_state, sm.current_state)
-
-    sm.send_event(:z_event)    
-    assert_equal(:a_state, sm.current_state)
-    
-    sm.send_event(:x_event)    
-    assert_equal(:c_state, sm.current_state)    
-  end
-  
-  def test_action_calling
-    sm = StateMachineFixture.new
-    assert_equal(0, sm.proc_val)
-    assert_equal(:a_state, sm.current_state)
-    sm.send_event(:w_event)
-    assert_equal(5, sm.proc_val)
-
-    sm.send_event(:y_event)
-    assert_equal(5, sm.proc_val)
-    
-    sm.send_event(:y_event)    
-    assert_equal(2, sm.proc_val)    
-  end
-  
-  def test_decider
-    sm = StateMachineFixture.new
-    assert_equal(:a_state, sm.current_state)
-    sm.send_event(:x_event)
-    sm.bush("foo")
-    assert_equal(:a_state, sm.current_state)
-    sm.bush("foobar")
-    assert_equal(:b_state, sm.current_state)
-    sm.send_event(:y_event)
-    sm.bush("barfoo")
-    assert_equal(:a_state, sm.current_state)    
-  end
-  
-  def test_nil_decider
-    sm = StateMachineFixture.new
-    assert_equal(:a_state, sm.current_state)
-    sm.send_event(:x_event)        
-    assert_equal(:c_state, sm.current_state)
-    sm.force_decide_nil=true
-    assert_raise(StateMachine::InvalidStateError){sm.send_event(:w_event)}    
-  end
-  
-  def test_multiple_actions_without_decider
-    assert_raise(ArgumentError) do
-      StateMachineFixture.state_transition :state=>:c_state, :event=>:z_event, #:decider => :c_state_decider, 
-        :next=>[
-          {:state=>:a_state, :action=>lambda{|o, args| o.increment_value(7)} }, 
-          {:state=>:b_state, :action=>lambda{|o, args| o.increment_value(-10)} }
-        ]
-    end    
-  end
-  
-  def test_named_actions_in_decider
-    sm = StateMachineFixture.new
-    assert_equal(:a_state, sm.current_state)
-    sm.send_event(:x_event)        
-    assert_equal(:c_state, sm.current_state)
-    sm.send_event(:z_event)            
-    
-    # Default value (foo) for named decider:
-    assert_equal(:a_state, sm.current_state)
-
-    # Back to a_state:
-    sm.send_event(:x_event)        
-    assert_equal(:c_state, sm.current_state)
-
-    # Alt value (bar) for named decider:
-    sm.name_for_decider = 'bar'
-    sm.send_event(:z_event)            
-    assert_equal(:d_state, sm.current_state)    
-  end
-  
-  def test_stay_state
-    sm = StateMachineFixture.new
-    
-    # Get to :d state:
-    sm.send_event(:x_event)        
-    sm.name_for_decider = 'bar'
-    sm.send_event(:z_event)        
-    assert_equal(:d_state, sm.current_state)
-    
-    # Send event & make sure we are still in :d state:
-    sm.send_event(:x_event)            
-    assert_equal(:d_state, sm.current_state)     
-  end
-  
-  def test_event_history
-    sm = StateMachineFixture.new
-    assert_equal(0, sm.event_history.size)     
-    sm.send_event(:x_event)        
-    assert_equal(1, sm.event_history.size)     
-    assert_equal([:x_event], sm.event_history)     
-    sm.send_event(:y_event)        
-    assert_equal(2, sm.event_history.size)     
-    assert_equal([:x_event, :y_event], sm.event_history)     
-    sm.send_event(:y_event)        
-    assert_equal(3, sm.event_history.size)     
-    assert_equal([:x_event, :y_event, :y_event], sm.event_history)
-
-    # Should max out at 10:
-    15.times{sm.send_event(:z_event)}
-    assert_equal(10, sm.event_history.size)     
-    assert_equal(Array.new(10, :z_event), sm.event_history)
-    
-  end
-  
-end

data/website/index.html

@@ -1,104 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <link rel="stylesheet" href="stylesheets/screen.css" type="text/css" media="screen" />
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  <title>
-      ruby-state-machine
-  </title>
-  <script src="javascripts/rounded_corners_lite.inc.js" type="text/javascript"></script>
-<style>
-
-</style>
-  <script type="text/javascript">
-    window.onload = function() {
-      settings = {
-          tl: { radius: 10 },
-          tr: { radius: 10 },
-          bl: { radius: 10 },
-          br: { radius: 10 },
-          antiAlias: true,
-          autoPad: true,
-          validTags: ["div"]
-      }
-      var versionBox = new curvyCorners(settings, document.getElementById("version"));
-      versionBox.applyCornersToAll();
-    }
-  </script>
-</head>
-<body>
-<div id="main">
-
-    <h1>ruby-state-machine</h1>
-    <div class="sidebar">
-      <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/ruby-state-mach"; return false'>
-        <p>Get Version</p>
-        <a href="http://rubyforge.org/projects/ruby-state-mach" class="numbers">0.0.3</a>
-      </div>
-    </div>
-    <p>An enhanced state machine gem for ruby (doesn&#8217;t require Rails). Provides more robust <span class="caps">DSL</span> state declaration syntax than other state machines. Multiple &#8220;actions&#8221; per event (i.e., next state, labmda, or a &#8220;decider&#8221;.  Fully unit-tested &amp; documented.  Has been used in production for over 2 years.</p>
-<h2>Installing</h2>
-<p><pre class='syntax'><span class="ident">sudo</span> <span class="ident">gem</span> <span class="ident">install</span> <span class="ident">ruby</span><span class="punct">-</span><span class="ident">state</span><span class="punct">-</span><span class="ident">machine</span></pre></p>
-<h2>Demonstration of usage<br />
-<pre class='syntax'>
-<span class="keyword">class </span><span class="class">SampleMachine</span>
-  <span class="ident">include</span> <span class="constant">StateMachine</span>
-  <span class="ident">state_machine</span> <span class="symbol">:states</span> <span class="punct">=&gt;</span> <span class="punct">[</span><span class="symbol">:a_state</span><span class="punct">,</span> <span class="symbol">:b_state</span><span class="punct">,</span> <span class="symbol">:c_state</span><span class="punct">,</span> <span class="symbol">:d_state</span><span class="punct">],</span> <span class="symbol">:events</span> <span class="punct">=&gt;</span> <span class="punct">[</span><span class="symbol">:w_event</span><span class="punct">,</span> <span class="symbol">:x_event</span><span class="punct">,</span> <span class="symbol">:y_event</span><span class="punct">,</span> <span class="symbol">:z_event</span><span class="punct">]</span>
-  <span class="ident">state_transition</span> <span class="symbol">:state=</span><span class="punct">&gt;</span><span class="symbol">:a_state</span><span class="punct">,</span> <span class="symbol">:event=</span><span class="punct">&gt;</span><span class="symbol">:x_event</span><span class="punct">,</span> <span class="symbol">:next=</span><span class="punct">&gt;</span><span class="symbol">:c_state</span>
-  <span class="ident">state_transition</span> <span class="symbol">:state=</span><span class="punct">&gt;</span><span class="symbol">:a_state</span><span class="punct">,</span> <span class="symbol">:event=</span><span class="punct">&gt;</span><span class="symbol">:y_event</span><span class="punct">,</span> <span class="symbol">:next=</span><span class="punct">&gt;</span><span class="symbol">:a_state</span>
-  <span class="ident">state_transition</span> <span class="symbol">:state=</span><span class="punct">&gt;</span><span class="symbol">:a_state</span><span class="punct">,</span> <span class="symbol">:event=</span><span class="punct">&gt;</span><span class="symbol">:z_event</span><span class="punct">,</span> <span class="symbol">:next=</span><span class="punct">&gt;</span><span class="symbol">:b_state</span>
-                                                            
-  <span class="ident">state_transition</span> <span class="symbol">:state=</span><span class="punct">&gt;</span><span class="symbol">:b_state</span><span class="punct">,</span> <span class="symbol">:event=</span><span class="punct">&gt;</span><span class="symbol">:w_event</span><span class="punct">,</span> <span class="symbol">:next=</span><span class="punct">&gt;</span><span class="symbol">:b_state</span>
-  <span class="ident">state_transition</span> <span class="symbol">:state=</span><span class="punct">&gt;</span><span class="symbol">:b_state</span><span class="punct">,</span> <span class="symbol">:event=</span><span class="punct">&gt;</span><span class="symbol">:y_event</span><span class="punct">,</span> <span class="symbol">:next=</span><span class="punct">&gt;</span><span class="symbol">:c_state</span>
-  <span class="ident">state_transition</span> <span class="symbol">:state=</span><span class="punct">&gt;</span><span class="symbol">:b_state</span><span class="punct">,</span> <span class="symbol">:event=</span><span class="punct">&gt;</span><span class="symbol">:z_event</span><span class="punct">,</span> <span class="symbol">:next=</span><span class="punct">&gt;</span><span class="symbol">:a_state</span>
-                                                            
-  <span class="ident">state_transition</span> <span class="symbol">:state=</span><span class="punct">&gt;</span><span class="symbol">:c_state</span><span class="punct">,</span> <span class="symbol">:event=</span><span class="punct">&gt;</span><span class="symbol">:x_event</span><span class="punct">,</span> <span class="symbol">:next=</span><span class="punct">&gt;</span><span class="symbol">:b_state</span>
-<span class="keyword">end</span>
-
-<span class="ident">sm</span> <span class="punct">=</span> <span class="constant">SampleMachine</span><span class="punct">.</span><span class="ident">new</span>
-<span class="ident">assert_equal</span><span class="punct">(</span><span class="symbol">:a_state</span><span class="punct">,</span> <span class="ident">sm</span><span class="punct">.</span><span class="ident">current_state</span><span class="punct">)</span>
-<span class="ident">sm</span><span class="punct">.</span><span class="ident">send_event</span><span class="punct">(</span><span class="symbol">:x_event</span><span class="punct">)</span>
-<span class="ident">assert_equal</span><span class="punct">(</span><span class="symbol">:c_state</span><span class="punct">,</span> <span class="ident">sm</span><span class="punct">.</span><span class="ident">current_state</span><span class="punct">)</span>
-
-</pre></h2>
-<p>For examples of other functionality, including branching, deciders, lambdas, etc, see test/test_state_machine.</p>
-<h2>Forum</h2>
-<p><a href="http://groups.google.com/group/ruby-state-machine">http://groups.google.com/group/ruby-state-machine</a></p>
-<h2>How to submit patches</h2>
-<p>Read the <a href="http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/">8 steps for fixing other people&#8217;s code</a> and for section <a href="http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/#8b-google-groups">8b: Submit patch to Google Groups</a>, use the Google Group above.</p>
-<p><span class="caps">TODO</span> &#8211; pick <span class="caps">SVN</span> or Git instructions</p>
-<p>The trunk repository is <code>svn://rubyforge.org/var/svn/ruby-state-machine/trunk</code> for anonymous access.</p>
-<p><span class="caps">OOOORRRR</span></p>
-<p>You can fetch the source from either:</p>
-<ul>
-	<li>rubyforge: <a href="http://rubyforge.org/scm/?group_id=8855">http://rubyforge.org/scm/?group_id=8855</a></li>
-</ul>
-<pre>git clone git://rubyforge.org/ruby-state-machine.git</pre>
-<ul>
-	<li>github: <a href="http://github.com/GITHUB_USERNAME/ruby-state-machine/tree/master">http://github.com/GITHUB_USERNAME/ruby-state-machine/tree/master</a></li>
-</ul>
-<pre>git clone git://github.com/GITHUB_USERNAME/ruby-state-machine.git</pre>
-<p><span class="caps">TODO</span> &#8211; add &#8220;github_username: username&#8221; to ~/.rubyforge/user-config.yml and newgem will reuse it for future projects.</p>
-<ul>
-	<li>gitorious: <a href="git://gitorious.org/ruby-state-machine/mainline.git">git://gitorious.org/ruby-state-machine/mainline.git</a></li>
-</ul>
-<pre>git clone git://gitorious.org/ruby-state-machine/mainline.git</pre>
-<h3>Build and test instructions</h3>
-<pre>cd ruby-state-machine
-rake test
-</pre>
-<h2>License</h2>
-<p>This code is free to use under the terms of the <span class="caps">MIT</span> license.</p>
-<h2>Contact</h2>
-<p>Comments are welcome. Send an email to <a href="mailto:steven.miers@gmail.com"><span class="caps">FIXME</span> full name</a> via the <a href="http://groups.google.com/group/ruby-state-machine">forum</a></p>
-    <p class="coda">
-      <a href="steven.miers@gmail.com">FIXME full name</a>, 18th August 2009<br>
-      Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
-    </p>
-</div>
-
-<!-- insert site tracking codes here, like Google Urchin -->
-
-</body>
-</html>

data/website/index.txt

@@ -1,55 +0,0 @@
-h1. ruby-state-machine
-
-An enhanced state machine gem for ruby (doesn't require Rails). Provides more robust DSL state declaration syntax than other state machines. Multiple "actions" per event (i.e., next state, labmda, or a "decider".  Fully unit-tested & documented.  Has been used in production for over 2 years.
-
-h2. Installing
-
-<pre syntax="ruby">sudo gem install ruby-state-machine</pre>
-
-h2. Demonstration of usage
-<pre syntax="ruby">
-class SampleMachine
-  include StateMachine
-  state_machine :states => [:a_state, :b_state, :c_state, :d_state], :events => [:w_event, :x_event, :y_event, :z_event]
-  state_transition :state=>:a_state, :event=>:x_event, :next=>:c_state
-  state_transition :state=>:a_state, :event=>:y_event, :next=>:a_state
-  state_transition :state=>:a_state, :event=>:z_event, :next=>:b_state
-                                                            
-  state_transition :state=>:b_state, :event=>:w_event, :next=>:b_state
-  state_transition :state=>:b_state, :event=>:y_event, :next=>:c_state
-  state_transition :state=>:b_state, :event=>:z_event, :next=>:a_state
-                                                            
-  state_transition :state=>:c_state, :event=>:x_event, :next=>:b_state
-end
-
-sm = SampleMachine.new
-assert_equal(:a_state, sm.current_state)
-sm.send_event(:x_event)
-assert_equal(:c_state, sm.current_state)
-
-</pre>
-
-For examples of other functionality, including branching, deciders, lambdas, etc, see test/test_state_machine.
-
-h2. Forum
-
-"http://groups.google.com/group/ruby-state-machine":http://groups.google.com/group/ruby-state-machine
-
-h2. How to submit patches
-
-Read the "8 steps for fixing other people's code":http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/ and for section "8b: Submit patch to Google Groups":http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/#8b-google-groups, use the Google Group above.
-
-h3. Build and test instructions
-
-<pre>cd ruby-state-machine
-rake test
-</pre>
-
-h2. License
-
-This code is free to use under the terms of the MIT license. 
-
-h2. Contact
-
-Comments are welcome. Send an email to "FIXME full name":mailto:steven.miers@gmail.com via the "forum":http://groups.google.com/group/ruby-state-machine
-