statemachine 0.4.1 → 0.5.0

data/CHANGES

@@ -1,5 +1,11 @@
 = Statemachine Changelog
 
+== Version 0.4.2
+
+Simple Fixes
+* Fixed respond_to? to handle the, what should be impossible, case when the state is nil
+* Switch history members variable to store id rather than object.
+
 == Version 0.4.1
 
 Simple Fixes

data/Rakefile

@@ -1,7 +1,6 @@
 $:.unshift('lib')
 require 'rubygems'
 require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
 require 'rake/clean'
 require 'rake/rdoctask'
 require 'spec/rake/spectask'
@@ -24,11 +23,13 @@ Spec::Rake::SpecTask.new do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
 end
 
+WEB_ROOT = File.expand_path('~/Projects/slagyr.github.com/statemachine/')
+
 desc 'Generate RDoc'
 rd = Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'doc/website/output/rdoc'
-  rdoc.options << '--title' << 'Statemachine' << '--line-numbers' << '--inline-source' << '--main' << 'README'
-  rdoc.rdoc_files.include('README', 'CHANGES', 'lib/**/*.rb')
+  rdoc.rdoc_dir = "#{WEB_ROOT}/rdoc"
+  rdoc.options << '--title' << 'Statemachine' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGES', 'lib/**/*.rb')
 end
 task :rdoc
 
@@ -72,10 +73,6 @@ task :todo do
   egrep /(FIXME|TODO|TBD)/
 end
 
-task :clobber do
-  rm_rf 'doc/output'
-end
-
 task :release => [:clobber, :verify_committed, :verify_user, :verify_password, :spec, :publish_packages, :tag, :publish_website, :publish_news]
 
 desc "Verifies that there is no uncommitted code"
@@ -94,20 +91,15 @@ task :tag do
   puts "Done!"
 end
 
+desc 'Generate HTML documentation for website'
+task :webgen do
+  system "rm -rf doc/website/out"
+  system "rm -rf doc/website/webgen.cache"
+  system "cd doc/website; webgen -v render; cp -rf out/* #{WEB_ROOT}"
+end
 
-#desc "Build the website, but do not publish it"
-#task :website => [:clobber, :verify_rcov, :webgen, :failing_examples_with_html, :spec, :examples_specdoc, :rdoc]
-
-#desc "Upload Website to RubyForge"
-#task :publish_website => [:verify_user, :website] do
-#  publisher = Rake::SshDirPublisher.new(
-#    "rspec-website@rubyforge.org",
-#    "/var/www/gforge-projects/#{PKG_NAME}",
-#    "doc/output"
-#  )
-
-#  publisher.upload
-#end
+desc "Build the website, but do not publish it"
+task :website => [:webgen, :rdoc]
 
 task :verify_user do
   raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
@@ -115,23 +107,4 @@ end
 
 task :verify_password do
   raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
-end
-
-desc "Publish gem+tgz+zip on RubyForge. You must make sure lib/version.rb is aligned with the CHANGELOG file"
-task :publish_packages => [:verify_user, :verify_password, :package] do
-  require 'meta_project'
-  require 'rake/contrib/xforge'
-  release_files = FileList[
-    "pkg/#{PKG_FILE_NAME}.gem",
-    "pkg/#{PKG_FILE_NAME}.tgz",
-    "pkg/#{PKG_FILE_NAME}.zip"
-  ]
-
-  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |xf|
-    # Never hardcode user name and password in the Rakefile!
-    xf.user_name = ENV['RUBYFORGE_USER']
-    xf.password = ENV['RUBYFORGE_PASSWORD']
-    xf.files = release_files.to_a
-    xf.release_name = "statemachine #{PKG_VERSION}"
-  end
 end

data/lib/statemachine/builder.rb

@@ -74,6 +74,10 @@ module Statemachine
       @subject.add(Transition.new(@subject.id, destination_id, event, action))
     end
     
+    def on_event(event, options)
+      self.event(event, options[:transition_to], options[:and_perform])
+    end
+    
     # Declare the entry action for the state.
     #
     #   sm = Statemachine.build do
@@ -160,6 +164,10 @@ module Statemachine
       origin = acquire_state_in(origin_id, @subject)
       origin.add(Transition.new(origin_id, destination_id, event, action))
     end
+
+    def transition_from(origin_id, options)
+      trans(origin_id, options[:on_event], options[:transition_to], options[:and_perform])
+    end
     
     # Specifies the startstate for the statemachine or superstate.  The state must 
     # exist within the scope.
@@ -205,7 +213,7 @@ module Statemachine
     #   end
     #
     def default_history(id)
-      @subject.default_history = @statemachine.get_state(id)
+      @subject.default_history = id
     end
   end
   

data/lib/statemachine/generate/java.rb

@@ -0,0 +1 @@
+require 'statemachine/generate/java/java_statemachine'

data/lib/statemachine/generate/java/java_statemachine.rb

@@ -0,0 +1,237 @@
+require 'statemachine/generate/util'
+require 'statemachine/generate/src_builder'
+
+module Statemachine
+  class Statemachine
+
+    attr_reader :states
+
+    def to_java(options = {})
+      generator = Generate::Java::JavaStatemachine.new(self, options)
+      generator.generate!
+    end
+
+  end
+
+  module Generate
+    module Java
+      class JavaStatemachine
+
+        include Generate::Util
+
+        HEADER1 = "// This file was generated by the Ruby Statemachine Library (http://slagyr.github.com/statemachine)."
+        HEADER2 = "// Generated at "
+
+        def initialize(sm, options)
+          @sm = sm
+          @output_dir = options[:output]
+          @classname = options[:name]
+          @context_classname = "#{@classname}Context"
+          @package = options[:package]
+          raise "Please specify an output directory. (:output => 'where/you/want/your/code')" if @output_dir.nil?
+          raise "Output dir '#{@output_dir}' doesn't exist." if !File.exist?(@output_dir)
+          raise "Please specify a name for the statemachine. (:name => 'SomeName')" if @classname.nil?
+        end
+
+        def generate!
+          explore_sm
+          create_file(src_file(@classname), build_statemachine_src)
+          create_file(src_file(@context_classname), build_context_src)
+        end
+
+        private ###########################################
+
+        def explore_sm
+          @state_names = @sm.states.keys.reject{|k| k.nil? }.map { |id| id.to_s.camalized }.sort
+
+          events = []
+          actions = []
+          @sm.states.values.each do |state|
+            state.transitions.values.each do |transition|
+              events << transition.event
+              add_action(actions, transition.action)
+            end
+          end
+          @event_names = events.uniq.map {|e| e.to_s.camalized(:lower)}.sort
+
+          @sm.states.values.each do |state|
+            add_action(actions, state.entry_action)
+            add_action(actions, state.exit_action)
+          end
+          @action_names = actions.uniq.map {|e| e.to_s.camalized(:lower)}.sort
+        end
+
+        def add_action(actions, action)
+          return if action.nil?
+          raise "Actions must be symbols in order to generation Java code. (#{action})" unless action.is_a?(Symbol)
+          actions << action
+        end
+
+        def build_statemachine_src
+          src = begin_src
+          src << "public class #{@classname}" << endl
+          begin_scope(src)
+
+          add_state_instances(src)
+          add_statemachine_boilerplate_code(src)
+          add_event_delegation(src)
+          add_statemachine_exception(src)
+          add_base_state(src)
+          add_state_implementations(src)
+
+          end_scope(src)
+          return src.to_s
+        end
+
+        def add_state_instances(src)
+          src << "// State instances" << endl
+          @state_names.each do |state|
+            src << "public final State #{state.upcase} = new #{state}State(this);" << endl
+          end
+          src << "private State state = #{default_state_name};" << endl
+          src << endl
+        end
+
+        def add_statemachine_boilerplate_code(src)
+          src << "// The following is boiler plate code standard to all statemachines" << endl
+          src << "private #{@context_classname} context;" << endl
+          src << endl
+          add_one_liner(src, nil, @classname, "#{@context_classname} context", "this.context = context")
+          add_one_liner(src, @context_classname, "getContext", nil, "return context")
+          add_one_liner(src, "State", "getState", nil, "return state")
+          add_one_liner(src, "void", "setState", "State newState", "state = newState")
+        end
+
+        def add_event_delegation(src)
+          src << "// Event delegation" << endl
+          @event_names.each do |event|
+            add_one_liner(src, "void", event, nil, "state.#{event}()")
+          end
+        end
+
+        def add_statemachine_exception(src)
+          src << "// Standard exception class added to all statemachines." << endl
+          src << "public static class StatemachineException extends RuntimeException" << endl
+          begin_scope(src)
+          src << "public StatemachineException(State state, String event)" << endl
+          begin_scope(src)
+          src << "super(\"Missing transition from the '\" + state.getClass().getName() + \"' state with the '\" + event + \"' event.\");" << endl
+          end_scope(src)
+          end_scope(src)
+          src << endl
+        end
+
+        def add_base_state(src)
+          src << "// The base state" << endl
+          src << "public static abstract class State" << endl
+          begin_scope(src)
+          src << "protected #{@classname} statemachine;" << endl
+          src << endl
+          add_one_liner(src, nil, "State", "#{@classname} statemachine", "this.statemachine = statemachine")
+          @event_names.each do |event|
+            add_one_liner(src, "void", event, nil, "throw new StatemachineException(this, \"#{event}\")")
+          end
+          end_scope(src)
+          src << endl
+        end
+
+        def add_state_implementations(src)
+          src << "// State implementations" << endl
+          @sm.states.keys.sort.each do |state_id|
+            add_state_class(src, state_id) if state_id
+          end
+        end
+
+        def add_state_class(src, state_id)
+          state = @sm.states[state_id]
+          state_name = state_id.to_s.camalized
+          src << "public static class #{state_name}State extends State" << endl
+          src << "{" << endl
+          src.indent!
+          add_one_liner(src, nil, "#{state_name}State", "#{@classname} statemachine", "super(statemachine)")
+          state.transitions.keys.sort.each do |event_id|
+            add_state_event_handler(event_id, src, state)
+          end
+          src.undent!
+          src << "}" << endl
+          src << endl
+        end
+
+        def add_state_event_handler(event_id, src, state)
+          transition = state.transitions[event_id]
+          event_name = event_id.to_s.camalized(:lower)
+          add_method(src, "void", event_name, nil) do
+            if transition.action
+              src << "statemachine.getContext().#{transition.action.to_s.camalized(:lower)}();" << endl
+            end
+            src << "statemachine.setState(statemachine.#{transition.destination_id.to_s.upcase});" << endl
+          end
+        end
+
+        def add_one_liner(src, return_type, name, params, body)
+          add_method(src, return_type, name, params) do
+            src << "#{body};" << endl
+          end
+        end
+
+        def add_method(src, return_type, name, params)
+          src << "public #{return_type} #{name}(#{params})".sub('  ', ' ') << endl
+          begin_scope(src)
+          yield
+          end_scope(src)
+          src << endl
+        end
+
+        def begin_scope(src)
+          src << "{" << endl
+          src.indent!
+        end
+
+        def end_scope(src)
+          src.undent! << "}" << endl
+        end
+
+        def default_state_name
+          @sm.startstate.nil? ? "null" : @sm.startstate.to_s.upcase
+        end
+
+        def build_context_src
+          src = begin_src
+          src << "public interface #{@context_classname}" << endl
+          begin_scope(src)
+          src << "// Actions" << endl
+          @action_names.each do |event|
+            src << "void #{event}();" << endl
+          end
+          end_scope(src)
+          return src.to_s
+        end
+
+        def begin_src
+          src = SrcBuilder.new
+          src << HEADER1 << endl
+          src << HEADER2 << timestamp << endl
+          src << "package #{@package};" << endl
+          src << endl
+          return src
+        end
+
+        def create_file(filename, content)
+          establish_directory(File.dirname(filename))
+          File.open(filename, 'w') do |file|
+            file.write(content)
+          end
+        end
+
+        def src_file(name)
+          path = @output_dir
+          if @package
+            @package.split(".").each { |segment| path = File.join(path, segment) }
+          end
+          return File.join(path, "#{name}.java")
+        end
+
+      end
+    end
+  end
+end

data/lib/statemachine/generate/src_builder.rb

@@ -0,0 +1,48 @@
+module Statemachine
+  module Generate
+    class SrcBuilder
+
+      def initialize
+        @src = ""
+        @is_newline = true
+        @indents = 0
+        @indent_size = 2
+      end
+
+      def <<(content)
+        if content == :endl
+          newline!
+        else
+          add_indents if @is_newline
+          @src += content.to_s
+        end
+        return self
+      end
+
+      def newline!
+        @src += "\n"
+        @is_newline = true
+      end
+
+      def to_s
+        return @src
+      end
+
+      def indent!
+        @indents += 1
+        return self
+      end
+
+      def undent!
+        @indents -= 1
+        return self
+      end
+
+      def add_indents
+        @src += (" " * (@indent_size * @indents)) 
+        @is_newline = false
+      end
+
+    end
+  end
+end

data/lib/statemachine/generate/util.rb

@@ -0,0 +1,37 @@
+require 'date'
+
+module Statemachine
+  module Generate
+    module Util
+
+      def establish_directory(path)
+        return if File.exist?(path)
+        establish_directory(File.dirname(path))
+        Dir.mkdir(path)
+      end
+
+      def timestamp
+        return DateTime.now.strftime("%H:%M:%S %B %d, %Y")
+      end
+
+      def endl
+        return :endl
+      end
+
+    end
+  end
+end
+
+class String
+  def camalized(starting_case = :upper)
+    value = self.downcase.gsub(/[_| |\-][a-z]/) { |match| match[-1..-1].upcase }
+    value = value[0..0].upcase + value[1..-1] if starting_case == :upper
+    return value
+  end
+end
+
+class Symbol
+  def <=>(other)
+    return to_s <=> other.to_s
+  end
+end

data/lib/statemachine/statemachine.rb

@@ -129,7 +129,7 @@ module Statemachine
     
     def respond_to?(message)
       return true if super(message)
-      return true if @state.transition_for(message)
+      return true if @state and @state.transition_for(message)
       return false
     end
     
@@ -160,7 +160,7 @@ module Statemachine
     
     def load_history(superstate)
       100.times do
-        history = superstate.history
+        history = superstate.history_id ? get_state(superstate.history_id) : nil
         raise StatemachineException.new("#{superstate} doesn't have any history yet.") if not history
         if history.is_concrete?
           return history

data/lib/statemachine/superstate.rb

@@ -3,12 +3,12 @@ module Statemachine
   class Superstate < State #:nodoc:
   
     attr_accessor :startstate_id
-    attr_reader :history
+    attr_reader :history_id
   
     def initialize(id, superstate, statemachine)
       super(id, superstate, statemachine)
       @startstate = nil
-      @history = nil
+      @history_id = nil
     end
     
     def is_concrete?
@@ -16,19 +16,19 @@ module Statemachine
     end
     
     def substate_exiting(substate)
-      @history = substate
+      @history_id = substate.id
     end
   
     def add_substates(*substate_ids)
       do_substate_adding(substate_ids)
     end
     
-    def default_history=(state)
-      @history = @default_history = state
+    def default_history=(state_id)
+      @history_id = @default_history_id = state_id
     end
     
     def reset
-      @history = @default_history
+      @history_id = @default_history_id
     end
 
     def to_s

data/lib/statemachine/version.rb

@@ -2,14 +2,14 @@ module Statemachine
   module VERSION #:nodoc:
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 4
-      TINY   = 1
+      MINOR  = 5
+      TINY   = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')
 
       NAME   = "Statemachine"
-      URL    = "http://statemachine.rubyforge.org/"  
+      URL    = "http://slagyr.github.com/statemachine"  
     
       DESCRIPTION = "#{NAME}-#{STRING} - Statemachine Library for Ruby\n#{URL}"
     end

data/spec/action_invokation_spec.rb

@@ -63,6 +63,4 @@ describe "Action Invokation" do
     @noodle.cooked.should equal(true)
   end
 
-  
-  
 end

data/spec/builder_spec.rb

@@ -193,5 +193,49 @@ describe "Builder" do
     widget.statemachine.should be(sm)
   end
 
+  it "should have an on_event" do
+    sm = Statemachine.build do
+      startstate :start 
+      state :start do
+        on_event :go, :transition_to => :new_state
+      end
+    end
+    sm.go
+    sm.state.should == :new_state
+  end
+  
+  it "should trigger actions using on_event" do
+    sm = Statemachine.build do
+      startstate :start
+      state :start do
+        on_event :go, :transition_to => :new_state, :and_perform => :action
+      end
+    end
+    object = mock("context")
+    sm.context = object
+    object.should_receive(:action)
+
+    sm.go
+  end
+  
+  it "should have a transition_from" do
+    sm = Statemachine.build do
+      transition_from :start, :on_event => :go, :transition_to => :new_state
+    end
+    
+    sm.go
+    sm.state.should == :new_state
+  end
+  
+  it "should trigger actions on transition_from" do
+    sm = Statemachine.build do
+      transition_from :start, :on_event => :go, :transition_to => :new_state, :and_perform => :action
+    end
+    object = mock("context")
+    sm.context = object
+    object.should_receive(:action)
+
+    sm.go
+  end
 end
 

data/spec/default_transition_spec.rb

@@ -100,6 +100,12 @@ describe "Default Transition" do
     @sm.state.should eql(:base_default)
   end
 
+  it "should be marshalable" do
+    dump = Marshal.dump(@sm)
+    loaded = Marshal.load(dump)
+    loaded.state.should eql(:default_state)
+  end
+
   
   
 end

data/spec/generate/java/java_statemachine_spec.rb

@@ -0,0 +1,259 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require 'statemachine/generate/java/java_statemachine'
+
+describe Statemachine::Statemachine, "(Java)" do
+
+  before(:each) do
+    remove_test_dir("java")
+    @output = test_dir("java")
+    @sm = Statemachine.build {}
+  end
+
+  def generate_turnstile_sm
+    @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 => "test.turnstile")
+  end
+
+  def empty_sm_lines
+    @sm.to_java(:name => "JavaTest", :output => @output, :package => "test.blank")
+    filename = File.join(@output, "test", "blank", "JavaTest.java")
+    File.should exist( filename)
+    lines = IO.read(filename).split("\n")
+    return lines
+  end
+
+  def sm_lines
+    generate_turnstile_sm
+    filename = File.join(@output, "test", "turnstile", "JavaTurnstile.java")
+    File.should exist( filename)
+    return IO.read(filename).split("\n")
+  end
+
+  def context_lines
+    generate_turnstile_sm
+    filename = File.join(@output, "test", "turnstile", "JavaTurnstileContext.java")
+    File.should exist( filename)
+    return IO.read(filename).split("\n")
+  end
+
+  def find_lines_after(lines, goose)
+    while !lines.empty?
+      return lines if lines.shift.strip == goose
+    end
+    raise "Can't find desired line: #{goose}"
+  end
+
+  it "should error if no output dir is specified" do
+    lambda { @sm.to_java }.should raise_error("Please specify an output directory. (:output => 'where/you/want/your/code')")
+  end
+
+  it "should error if output dir doesn't exist" do
+    lambda { @sm.to_java(:output => "/blah") }.should raise_error("Output dir '/blah' doesn't exist.")
+  end
+
+  it "should error if no class name is specified" do
+    lambda { @sm.to_java(:output => @output) }.should raise_error("Please specify a name for the statemachine. (:name => 'SomeName')")
+  end
+
+  it "should generate a class" do
+    @sm.to_java(:name => "JavaTest", :output => @output)
+    File.should exist(File.join(@output, "JavaTest.java"))
+  end
+
+  it "should generate a class in a package" do
+    lines = empty_sm_lines
+
+    lines.shift.should == "// This file was generated by the Ruby Statemachine Library (http://slagyr.github.com/statemachine)."
+    lines.shift.include?("// Generated at ").should == true
+    lines.shift.should == "package test.blank;"
+    lines.shift.should == ""
+    lines.shift.should == "public class JavaTest"
+    lines.shift.should == "{"
+    lines.last.should == "}"
+  end
+
+  it "should generate sm boilerplate code" do
+    lines = empty_sm_lines
+    lines = find_lines_after(lines, "// The following is boiler plate code standard to all statemachines")
+
+    lines.shift.should == "  private JavaTestContext context;"
+    lines.shift.should == ""
+    lines.shift.should == "  public JavaTest(JavaTestContext context)"
+    lines.shift.should == "  {"
+    lines.shift.should == "    this.context = context;"
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+    lines.shift.should == "  public JavaTestContext getContext()"
+    lines.shift.should == "  {"
+    lines.shift.should == "    return context;"
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+    lines.shift.should == "  public State getState()"
+    lines.shift.should == "  {"
+    lines.shift.should == "    return state;"
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+    lines.shift.should == "  public void setState(State newState)"
+    lines.shift.should == "  {"
+    lines.shift.should == "    state = newState;"
+    lines.shift.should == "  }"
+  end
+
+  it "should generate the sm exception" do
+    lines = empty_sm_lines
+    lines = find_lines_after(lines, "// Standard exception class added to all statemachines.")
+
+    lines.shift.should == "  public static class StatemachineException extends RuntimeException"
+    lines.shift.should == "  {"
+    lines.shift.should == "    public StatemachineException(State state, String event)"
+    lines.shift.should == "    {"
+    lines.shift.should == "      super(\"Missing transition from the '\" + state.getClass().getName() + \"' state with the '\" + event + \"' event.\");"
+    lines.shift.should == "    }"
+    lines.shift.should == "  }"    
+  end
+
+  it "should generate base state" do
+    lines = empty_sm_lines
+    lines = find_lines_after(lines, "// The base state")
+
+    lines.shift.should == "  public static abstract class State"
+    lines.shift.should == "  {"
+    lines.shift.should == "    protected JavaTest statemachine;"
+    lines.shift.should == ""
+    lines.shift.should == "    public State(JavaTest statemachine)"
+    lines.shift.should == "    {"
+    lines.shift.should == "      this.statemachine = statemachine;"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "  }"
+  end
+
+  it "should generate the context" do
+    @sm.to_java(:name => "JavaTest", :output => @output, :package => "com.blah")
+    
+    filename = File.join(@output, "com", "blah", "JavaTestContext.java")
+    File.should exist(filename)
+    lines = IO.read(filename).split("\n")
+
+    lines.shift.should == "// This file was generated by the Ruby Statemachine Library (http://slagyr.github.com/statemachine)."
+    lines.shift.include?("// Generated at ").should == true
+    lines.shift.should == "package com.blah;"
+    lines.shift.should == ""
+    lines.shift.should == "public interface JavaTestContext"
+    lines.shift.should == "{"
+    lines.shift.should == "  // Actions"
+    lines.shift.should == "}"
+    lines.should be_empty
+  end
+
+  it "should generate the state instance variables" do
+    lines = find_lines_after(sm_lines, "// State instances")
+
+    lines.shift.should == "  public final State LOCKED = new LockedState(this);"
+    lines.shift.should == "  public final State UNLOCKED = new UnlockedState(this);"
+    lines.shift.should == "  private State state = LOCKED;"
+  end
+
+  it "should generate all the sm event handlers" do
+    lines = find_lines_after(sm_lines, "// Event delegation")
+
+    lines.shift.should == "  public void coin()"
+    lines.shift.should == "  {"
+    lines.shift.should == "    state.coin();"
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+    lines.shift.should == "  public void pass()"
+    lines.shift.should == "  {"
+    lines.shift.should == "    state.pass();"
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+  end
+
+  it "should generate all the default event handlers" do
+    lines = find_lines_after(sm_lines, "// The base state")
+
+    lines.shift.should == "  public static abstract class State"
+    lines.shift.should == "  {"
+    lines.shift.should == "    protected JavaTurnstile statemachine;"
+    lines.shift.should == ""
+    lines.shift.should == "    public State(JavaTurnstile statemachine)"
+    lines.shift.should == "    {"
+    lines.shift.should == "      this.statemachine = statemachine;"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "    public void coin()"
+    lines.shift.should == "    {"
+    lines.shift.should == "      throw new StatemachineException(this, \"coin\");"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "    public void pass()"
+    lines.shift.should == "    {"
+    lines.shift.should == "      throw new StatemachineException(this, \"pass\");"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "  }"
+  end
+
+  it "should generate state classes" do
+    lines = find_lines_after(sm_lines, "// State implementations")
+
+    lines.shift.should == "  public static class LockedState extends State"
+    lines.shift.should == "  {"
+    lines.shift.should == "    public LockedState(JavaTurnstile statemachine)"
+    lines.shift.should == "    {"
+    lines.shift.should == "      super(statemachine);"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "    public void coin()"
+    lines.shift.should == "    {"
+    lines.shift.should == "      statemachine.getContext().unlock();"
+    lines.shift.should == "      statemachine.setState(statemachine.UNLOCKED);"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "    public void pass()"
+    lines.shift.should == "    {"
+    lines.shift.should == "      statemachine.getContext().alarm();"
+    lines.shift.should == "      statemachine.setState(statemachine.LOCKED);"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+    lines.shift.should == "  public static class UnlockedState extends State"
+    lines.shift.should == "  {"
+    lines.shift.should == "    public UnlockedState(JavaTurnstile statemachine)"
+    lines.shift.should == "    {"
+    lines.shift.should == "      super(statemachine);"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "    public void coin()"
+    lines.shift.should == "    {"
+    lines.shift.should == "      statemachine.getContext().thanks();"
+    lines.shift.should == "      statemachine.setState(statemachine.LOCKED);"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "    public void pass()"
+    lines.shift.should == "    {"
+    lines.shift.should == "      statemachine.getContext().lock();"
+    lines.shift.should == "      statemachine.setState(statemachine.LOCKED);"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+  end
+
+  it "should generate all the context methods" do
+    lines = find_lines_after(context_lines, "// Actions")
+
+    lines.shift.should == "  void alarm();"
+    lines.shift.should == "  void lock();"
+    lines.shift.should == "  void thanks();"
+    lines.shift.should == "  void unlock();"
+  end
+
+end

data/spec/history_spec.rb

@@ -31,10 +31,10 @@ describe "History States" do
   it "reseting the statemachine resets history" do
     @sm.faddle
     @sm.fiddle
-    @sm.get_state(:operate).history.id.should eql(:on)
+    @sm.get_state(:operate).history_id.should eql(:on)
     
     @sm.reset
-    @sm.get_state(:operate).history.should eql(nil)
+    @sm.get_state(:operate).history_id.should eql(nil)
   end
   
 end
@@ -64,10 +64,10 @@ describe "History Default" do
     @sm.faddle
     @sm.toggle
     @sm.fiddle
-    @sm.get_state(:operate).history.id.should eql(:off)
+    @sm.get_state(:operate).history_id.should eql(:off)
     
     @sm.reset
-    @sm.get_state(:operate).history.id.should eql(:on)
+    @sm.get_state(:operate).history_id.should eql(:on)
   end
 
 end

data/spec/sm_odds_n_ends_spec.rb

@@ -28,6 +28,12 @@ describe "State Machine Odds And Ends" do
     @sm.respond_to?(:blah).should eql(false)
   end
   
+  it "should not crash when respond_to? called when the statemachine is not in a state" do
+    @sm.instance_eval { @state = nil }
+    lambda { @sm.respond_to?(:toggle) }.should_not raise_error
+    @sm.respond_to?(:toggle).should eql(false)
+  end
+  
   it "set state with string" do
     @sm.state.should equal(:off)
     @sm.state = "on"

data/spec/spec_helper.rb

@@ -43,5 +43,19 @@ module TurnstileStatemachine
     end
     @sm.context = self
   end
-  
+
+end
+
+TEST_DIR = File.expand_path(File.dirname(__FILE__) + "/../test_dir/")
+
+def test_dir(name = nil)
+  Dir.mkdir(TEST_DIR) if !File.exist?(TEST_DIR)
+  return TEST_DIR if name.nil?
+  dir = File.join(TEST_DIR, name)
+  Dir.mkdir(dir) if !File.exist?(dir)
+  return dir
+end
+
+def remove_test_dir(name)
+  system "rm -rf #{test_dir(name)}" if File.exist?(test_dir(name))
 end

metadata

@@ -1,50 +1,48 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.1
-specification_version: 1
 name: statemachine
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
-date: 2007-05-20 00:00:00 -07:00
-summary: Statemachine-0.4.1 - Statemachine Library for Ruby http://statemachine.rubyforge.org/
-require_paths: 
-- lib
-email: statemachine-devel@rubyforge.org
-homepage: http://statemachine.rubyforge.org
-rubyforge_project: statemachine
-description: Statemachine is a ruby library for building Finite State Machines (FSM), also known as Finite State Automata (FSA).
-autorequire: statemachine
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.5.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Micah Martin
+autorequire: statemachine
+bindir: bin
+cert_chain: []
+
+date: 2010-03-24 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Statemachine is a ruby library for building Finite State Machines (FSM), also known as Finite State Automata (FSA).
+email: statemachine-devel@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
 files: 
 - CHANGES
 - LICENSE
 - Rakefile
-- README
+- README.rdoc
 - TODO
-- lib/statemachine.rb
 - lib/statemachine/action_invokation.rb
 - lib/statemachine/builder.rb
+- lib/statemachine/generate/java/java_statemachine.rb
+- lib/statemachine/generate/java.rb
+- lib/statemachine/generate/src_builder.rb
+- lib/statemachine/generate/util.rb
 - lib/statemachine/state.rb
 - lib/statemachine/statemachine.rb
 - lib/statemachine/superstate.rb
 - lib/statemachine/transition.rb
 - lib/statemachine/version.rb
+- lib/statemachine.rb
 - spec/action_invokation_spec.rb
 - spec/builder_spec.rb
 - spec/default_transition_spec.rb
+- spec/generate/java/java_statemachine_spec.rb
 - spec/history_spec.rb
 - spec/sm_action_parameterization_spec.rb
 - spec/sm_entry_exit_actions_spec.rb
@@ -54,6 +52,34 @@ files:
 - spec/sm_turnstile_spec.rb
 - spec/spec_helper.rb
 - spec/transition_spec.rb
+has_rdoc: true
+homepage: http://statemachine.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: statemachine
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Statemachine-0.5.0 - Statemachine Library for Ruby http://slagyr.github.com/statemachine
 test_files: 
 - spec/action_invokation_spec.rb
 - spec/builder_spec.rb
@@ -66,15 +92,3 @@ test_files:
 - spec/sm_super_state_spec.rb
 - spec/sm_turnstile_spec.rb
 - spec/transition_spec.rb
-rdoc_options: []
-
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
-requirements: []
-
-dependencies: []
-