statemachine 1.2.0 → 2.0.0

data/doc/website/src/example3.page

@@ -0,0 +1,76 @@
+---
+title: Statemachine Example 3
+inMenu: true
+directoryName: 
+---
+<h2>Conditional Logic</h2>
+
+Out vending machine is a good example of when we may need conditional logic. When ever a coin is inserted, the invoked event will depend on whether the total amount of money inserted is sufficient to buy something. If enough money has been tendered, the display should suggest that the customer make a selection. If insufficient money has been inserted, the customer should be prompted to insert more.
+
+Conditional logic can be accomplished by using <b>entry actions</b>. See the diagram below.
+
+<img style="border: 1px solid black" src="images/examples/vending_machine3.png">
+<br><b>State Diagram with Conditional Logic</b>
+
+Starting in the Accept Money state, when a coin is inserted, the coin event is fired and the statemachine transitions into the Coin Inserted state. This is where it gets fun. Upon entering of the Coin Inserted state its entry event is invoked: count_amount_tendered. This method will count the money and invoke the not_paid_yet or paid event accordingly. This will cause the statemachine to transition into the appropriate state.
+
+The Coin Inserted state is unique. You wouldn’t expect to find the statemachine in the Coin Inserted state for any reason except to make this decision. Once the decision is made, the state changes. States like this are called <b>Decision States</b>.
+
+<h2>Code</h2>
+
+<pre>require 'rubygems'
+require 'statemachine'
+
+class VendingMachineContext
+
+  attr_accessor :statemachine
+
+  def initialize
+    @amount_tendered = 0
+  end
+
+  def add_coin
+    @amount_tendered = @amount_tendered + 25
+  end
+
+  def count_amount_tendered
+    if @amount_tendered >= 100
+      @statemachine.paid
+    else
+      @statemachine.not_paid_yet
+    end
+  end
+
+  def prompt_money
+    puts "$.#{@amount_tendered}: more money please"
+  end
+
+  def prompt_selection
+    puts "please make a selection"
+  end
+end
+
+vending_machine = Statemachine.build do
+  trans :accept_money, :coin, :coin_inserted, :add_coin
+  state :coin_inserted do
+    event :not_paid_yet, :accept_money, :prompt_money
+    event :paid, :await_selection, :prompt_selection
+    on_entry :count_amount_tendered
+  end
+  context VendingMachineContext.new
+end
+vending_machine.context.statemachine = vending_machine
+
+vending_machine.coin
+vending_machine.coin
+vending_machine.coin
+vending_machine.coin</pre>
+
+Output:
+
+<pre>$.25: more money please
+$.50: more money please
+$.75: more money please
+please make a selection</pre>
+
+Moving on to <a href="example4.html">Example 4</a>, we will begin to deal with superstates.

data/doc/website/src/example4.page

@@ -0,0 +1,65 @@
+---
+title: Statemachine Example 4
+inMenu: true
+directoryName: 
+---
+<h2>Superstates</h2>
+
+Often in statemachines, duplication can arise. For example, the vending machine in our examples may need periodic repairs. It’s not certain which state the vending machine will be in when the repair man arrives. So all states should have a transition into the Repair Mode state.
+
+<img style="border: 1px solid black" src="images/examples/vending_machine4b.png">
+<br><b>Diagram 1 - Without Superstates</b>
+
+In this diagram, both the Waiting and Paid states have a transition to the Repair Mode invoked by the repair event. Duplication! We can dry this up by using the <b>Superstate</b> construct. See below:
+
+<img style="border: 1px solid black" src="images/examples/vending_machine4a.png">
+<br><b>Diagram 2 - With Superstates</b>
+
+Here we introduce the Operational superstate. Both the Waiting and Paid states are contained within the superstate which implies that they inherit all of the superstate’s transitions. That means we only need one transition into the Repair Mode state from the Operational superstate to achieve the same behavior as the solution in <i>diagram 1</i>.
+
+One statemachine may have multiple superstates. And every superstate may contain other superstates. ie. Superstates can be nested.
+
+<h2>History State</h2>
+
+The solution in <i>diagram 2</i> has an advantage over <i>diagram 1</i>. In <i>diagram 1</i>, once the repair man is done he triggers the operate event and the vending machine transitions into the Waiting event. This is unfortunate. Even if the vending machine was in the Paid state before the repair man came along, it will be in the Waiting state after he leaves. Shouldn’t it go back into the Paid state?
+
+This is where use of the history state is useful. You can see the history state being use in <i>diagram 2</i>. In this solution, the history state allows the vending machine to return from a repair session into the same state it was in before, as though nothing happened at all.
+
+<h2>Code</h2>
+
+The following code builds the statemachine in <i>diagram 2</i>. Watch out for the _H. This is how the history state is denoted. If you have a superstate named foo, then it’s history state will be named foo_H.
+
+<pre>require 'rubygems'
+require 'statemachine'
+
+vending_machine = Statemachine.build do
+  superstate :operational do
+    trans :waiting, :dollar, :paid
+    trans :paid, :selection, :waiting
+    trans :waiting, :selection, :waiting
+    trans :paid, :dollar, :paid
+
+    event :repair, :repair_mode,  Proc.new { puts "Entering Repair Mode" }
+  end
+
+  trans :repair_mode, :operate, :operational_H, Proc.new { puts "Exiting Repair Mode" }
+
+  on_entry_of :waiting, Proc.new { puts "Entering Waiting State" }
+  on_entry_of :paid, Proc.new { puts "Entering Paid State" }
+end
+
+vending_machine.repair
+vending_machine.operate
+vending_machine.dollar
+vending_machine.repair
+vending_machine.operate</pre>
+
+Output:
+
+<pre>Entering Repair Mode
+Exiting Repair Mode
+Entering Waiting State
+Entering Paid State
+Entering Repair Mode
+Exiting Repair Mode
+Entering Paid State</pre>

data/doc/website/src/index.page

@@ -0,0 +1,20 @@
+---
+title: Statemachine Overview
+inMenu: true
+directoryName:
+---
+The Statemachine library is a simple yet full-featured Finite Statemachine framework. Define your statemachine in Ruby code and execute it in your system.
+
+<h2>Download and Installation</h2>
+
+To download the package or source code visit the Statemachine <a href="http://rubyforge.org/projects/statemachine/">project page.</a> For the Statemachine gem:
+
+<pre> > sudo gem install statemachine</pre>
+or just
+<pre> > gem install statemachine</pre>
+
+<h2>Documentation</h2>
+
+* <a href="documentation.html">Full descriptive documentation</a>
+* <a href="http://slagyr.github.com/statemachine/rdoc/index.html">RDoc API</a>
+* <a href="http://blog.8thlight.com/articles/2006/11/17/understanding-statemachines-part-1-states-and-transitions">Helpful tutorial</a> describing what Statemachine are and how to implement them using the statemachine library.

data/generate_tests/dot_graph/turnstile.rb

@@ -0,0 +1,29 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'statemachine'
+require 'statemachine/generate/dot_graph'
+@output = File.expand_path(File.dirname(__FILE__) + "/turnstile")
+
+def clean
+  class_files = Dir.glob("#{@output}/*.dot")
+  class_files.each { |file| system "rm #{file}" }
+end
+
+def generate
+  @sm = Statemachine.build do
+    trans :locked, :coin, :unlocked, :unlock
+    trans :unlocked, :pass, :locked, :lock
+    trans :locked, :pass, :locked, :alarm
+    trans :unlocked, :coin, :locked, :thanks
+  end
+  @sm.to_dot(:output => @output)
+end
+
+def open
+  `open #{@output}/main.dot`
+end
+
+clean
+generate
+open
+
+

data/generate_tests/dot_graph/turnstile2.rb

@@ -0,0 +1,48 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'statemachine'
+require 'statemachine/generate/dot_graph'
+@output = File.expand_path(File.dirname(__FILE__) + "/turnstile2")
+
+def clean
+  class_files = Dir.glob("#{@output}/*.dot")
+  class_files.each { |file| system "rm #{file}" }
+end
+
+def generate
+  @sm = Statemachine.build do
+    superstate :operational do
+      on_entry :operate
+      on_exit  :beep
+      state :locked do
+        on_entry :lock
+        event :coin, :unlocked
+        event :pass, :locked, :alarm
+      end
+      state :unlocked do
+        on_entry :unlock
+        event :coin, :unlocked, :thanks
+        event :pass, :locked
+      end
+      event :diagnose, :diagnostics
+    end
+    state :diagnostics do
+      on_entry :disable
+      on_exit  :beep
+      event :operate, :operational
+    end
+    stub_context :verbose => false
+  end
+
+  @sm.to_dot(:output => @output)
+end
+
+def open
+  `open #{@output}/main.dot`
+end
+
+
+clean
+generate
+open
+
+

data/generate_tests/java/turnstile.rb

@@ -0,0 +1,54 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'statemachine'
+require 'statemachine/generate/java'
+@output = File.expand_path(File.dirname(__FILE__) + "/turnstile")
+
+def clean
+  system "rm -rf #{@output}/java"
+  class_files = Dir.glob("#{@output}/*.class")
+  class_files.each { |file| system "rm #{file}" }
+  system "rm #{@output}/output.txt"
+end
+
+def generate
+  @sm = Statemachine.build do
+    trans :locked, :coin, :unlocked, :unlock
+    trans :unlocked, :pass, :locked, :lock
+    trans :locked, :pass, :locked, :alarm
+    trans :unlocked, :coin, :locked, :thanks
+  end
+  @sm.to_java(:output => @output, :name => "JavaTurnstile", :package => "thejava.turnstile")
+end
+
+def compile
+  java_files = Dir.glob("#{@output}/**/*.java")
+  command = "javac #{java_files.join(' ')}"
+  system command
+end
+
+def run
+  system "java -cp #{@output} TurnstileMain > #{@output}/output.txt"
+end
+
+def check
+  actual = IO.read("#{@output}/output.txt").strip.split("\n")
+  expected = %w{alarm unlock thanks unlock lock}
+
+  if actual == expected
+    puts "PASSED"
+  else
+    puts "FAILED"
+    puts "--------------- expected:"
+    puts expected
+    puts "--------------- actual:"
+    puts actual
+  end
+end
+
+clean
+generate
+compile
+run
+check
+
+

data/generate_tests/java/turnstile2.rb

@@ -0,0 +1,72 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'statemachine'
+require 'statemachine/generate/java'
+@output = File.expand_path(File.dirname(__FILE__) + "/turnstile2")
+
+def clean
+  system "rm -rf #{@output}/java"
+  class_files = Dir.glob("#{@output}/*.class")
+  class_files.each { |file| system "rm #{file}" }
+  system "rm #{@output}/output.txt"
+end
+
+def generate
+  @sm = Statemachine.build do
+    superstate :operational do
+      on_entry :operate
+      on_exit  :beep
+      state :locked do
+        on_entry :lock
+        event :coin, :unlocked
+        event :pass, :locked, :alarm
+      end
+      state :unlocked do
+        on_entry :unlock
+        event :coin, :unlocked, :thanks
+        event :pass, :locked
+      end
+      event :diagnose, :diagnostics
+    end
+    state :diagnostics do
+      on_entry :disable
+      on_exit  :beep
+      event :operate, :operational
+    end
+    stub_context :verbose => false
+  end
+  
+  @sm.to_java(:output => @output, :name => "JavaTurnstile", :package => "thejava.turnstile")
+end
+
+def compile
+  java_files = Dir.glob("#{@output}/**/*.java")
+  command = "javac #{java_files.join(' ')}"
+  system command
+end
+
+def run
+  system "java -cp #{@output} Turnstile2Main > #{@output}/output.txt"
+end
+
+def check
+  actual = IO.read("#{@output}/output.txt").strip.split("\n")
+  expected = %w{operate lock alarm unlock thanks lock beep disable beep operate lock unlock lock}
+
+  if actual == expected
+    puts "PASSED"
+  else
+    puts "FAILED"
+    puts "--------------- expected:"
+    puts expected
+    puts "--------------- actual:"
+    puts actual
+  end
+end
+
+clean
+generate
+compile
+run
+check
+
+

data/lib/statemachine/action_invokation.rb

@@ -43,22 +43,3 @@ module Statemachine
   end
 
 end
-
-class Object
-  
-  module InstanceExecHelper; end
-  
-  include InstanceExecHelper
-  
-  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
-    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
-    InstanceExecHelper.module_eval{ define_method(mname, &block) }
-    begin
-      ret = send(mname, *args)
-    ensure
-      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
-    end
-    ret
-  end
-  
-end

data/lib/statemachine/version.rb

@@ -1,8 +1,8 @@
 module Statemachine
   module VERSION #:nodoc:
     unless defined? MAJOR
-      MAJOR  = 1
-      MINOR  = 2
+      MAJOR  = 2
+      MINOR  = 0
       TINY   = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')

data/rails_plugin/README

@@ -0,0 +1,183 @@
+== Welcome to Rails
+
+Rails is a web-application and persistence framework that includes everything
+needed to create database-backed web-applications according to the
+Model-View-Control pattern of separation. This pattern splits the view (also
+called the presentation) into "dumb" templates that are primarily responsible
+for inserting pre-built data in between HTML tags. The model contains the
+"smart" domain objects (such as Account, Product, Person, Post) that holds all
+the business logic and knows how to persist themselves to a database. The
+controller handles the incoming requests (such as Save New Account, Update
+Product, Show Post) by manipulating the model and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in 
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails.  You can read more about Action Pack in 
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting started
+
+1. Start the web server: <tt>ruby script/server</tt> (run with --help for options)
+2. Go to http://localhost:3000/ and get "Welcome aboard: You’re riding the Rails!"
+3. Follow the guidelines to start developing your application
+
+
+== Web servers
+
+Rails uses the built-in web server in Ruby called WEBrick by default, so you don't
+have to install or configure anything to play around. 
+
+If you have lighttpd installed, though, it'll be used instead when running script/server.
+It's considerably faster than WEBrick and suited for production use, but requires additional
+installation and currently only works well on OS X/Unix (Windows users are encouraged
+to start with WEBrick). We recommend version 1.4.11 and higher. You can download it from
+http://www.lighttpd.net.
+
+If you want something that's halfway between WEBrick and lighttpd, we heartily recommend
+Mongrel. It's a Ruby-based web server with a C-component (so it requires compilation) that
+also works very well with Windows. See more at http://mongrel.rubyforge.org/.
+
+But of course its also possible to run Rails with the premiere open source web server Apache.
+To get decent performance, though, you'll need to install FastCGI. For Apache 1.3, you want
+to use mod_fastcgi. For Apache 2.0+, you want to use mod_fcgid.
+
+See http://wiki.rubyonrails.com/rails/pages/FastCGI for more information on FastCGI.
+
+== Example for Apache conf
+
+  <VirtualHost *:80>
+    ServerName rails
+    DocumentRoot /path/application/public/
+    ErrorLog /path/application/log/server.log
+  
+    <Directory /path/application/public/>
+      Options ExecCGI FollowSymLinks
+      AllowOverride all
+      Allow from all
+      Order allow,deny
+    </Directory>
+  </VirtualHost>
+
+NOTE: Be sure that CGIs can be executed in that directory as well. So ExecCGI
+should be on and ".cgi" should respond. All requests from 127.0.0.1 go
+through CGI, so no Apache restart is necessary for changes. All other requests
+go through FCGI (or mod_ruby), which requires a restart to show changes.
+
+
+== Debugging Rails
+
+Have "tail -f" commands running on both the server.log, production.log, and
+test.log files. Rails will automatically display debugging and runtime
+information to these files. Debugging info will also be shown in the browser
+on requests from 127.0.0.1.
+
+
+== Breakpoints
+
+Breakpoint support is available through the script/breakpointer client. This
+means that you can break out of execution at any point in the code, investigate
+and change the model, AND then resume execution! Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.find_all
+      breakpoint "Breaking out from the list"
+    end
+  end
+  
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the breakpointer window. Here you can do things like:
+
+Executing breakpoint "Breaking out from the list" at .../webrick_server.rb:16 in 'breakpoint'
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8 @attributes={\"title\"=>nil, \"body\"=>nil, \"id\"=>\"1\"}>, 
+       #<Post:0x14a6620 @attributes={\"title\"=>\"Rails you know!\", \"body\"=>\"Only ten..\", \"id\"=>\"2\"}>]"
+  >> @posts.first.title = "hello from a breakpoint"
+  => "hello from a breakpoint"
+
+...and even better is that you can examine how your runtime objects actually work:
+
+  >> f = @posts.first 
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you press CTRL-D
+
+
+== Console
+
+You can interact with the domain model by starting the console through script/console. 
+Here you'll have all parts of the application configured, just like it is when the
+application is running. You can inspect domain models, change values, and save to the
+database. Starting the script without arguments will launch it in the development environment.
+Passing an argument will specify a different environment, like <tt>script/console production</tt>.
+
+To reload your controllers and models after launching the console run <tt>reload!</tt>
+
+
+
+== Description of contents
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/controllers
+  Holds controllers that should be named like weblog_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb.
+  Most models will descend from ActiveRecord::Base.
+  
+app/views
+  Holds the template files for the view that should be named like
+  weblog/index.rhtml for the WeblogController#index action. All views use eRuby
+  syntax. This directory can also be used to keep stylesheets, images, and so on
+  that can be symlinked to public.
+  
+app/helpers
+  Holds view helpers that should be named like weblog_helper.rb.
+
+app/apis
+  Holds API classes for web services.
+
+config
+  Configuration files for the Rails environment, the routing map, the database, and other dependencies.
+
+components
+  Self-contained mini-applications that can bundle together controllers, models, and views.
+
+db
+  Contains the database schema in schema.rb.  db/migrate contains all
+  the sequence of Migrations for your schema.
+
+lib
+  Application specific libraries. Basically, any kind of custom code that doesn't
+  belong under controllers, models, or helpers. This directory is in the load path.
+    
+public
+  The directory available for the web server. Contains subdirectories for images, stylesheets,
+  and javascripts. Also contains the dispatchers and the default HTML files.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins subdirectory.
+  This directory is in the load path.