statemachine 0.5.0 → 0.5.1

data/README.rdoc

@@ -14,7 +14,7 @@ Where to start:
 == Documentation
 
 Some documentation is available here in this RDOC documentation.  
-You may also find useful documentation on the Statemachine website: http://statemachine.rubyforge.org
+You may also find useful documentation on the Statemachine website: http://slagyr.github.com/statemachine
 
 A detailed tutorial and overview of Finite State Machines and this library can be found
 at http://blog.8thlight.com/articles/2006/11/17/understanding-statemachines-part-1-states-and-transitions.

data/lib/statemachine/builder.rb

@@ -261,6 +261,20 @@ module Statemachine
       @statemachine.context = a_context
       a_context.statemachine = @statemachine if a_context.respond_to?(:statemachine=)
     end
+
+    # Stubs the context.  This makes statemachine immediately useable, even if functionless.
+    # The stub will print all the actions called so it's nice for trial runs.
+    #
+    #   sm = Statemachine.build do
+    #     ...
+    #     stub_context :verbose => true
+    #   end
+    #
+    # Statemachine.context may also be used.
+    def stub_context(options={})
+      require 'statemachine/stub_context'
+      context StubContext.new(options)
+    end
   end
   
 end

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

@@ -42,8 +42,6 @@ module Statemachine
         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|
@@ -59,6 +57,8 @@ module Statemachine
             add_action(actions, state.exit_action)
           end
           @action_names = actions.uniq.map {|e| e.to_s.camalized(:lower)}.sort
+
+          @startstate = @sm.get_state(@sm.startstate).resolve_startstate
         end
 
         def add_action(actions, action)
@@ -72,7 +72,8 @@ module Statemachine
           src << "public class #{@classname}" << endl
           begin_scope(src)
 
-          add_state_instances(src)
+          add_instance_variables(src)
+          add_constructor(src)
           add_statemachine_boilerplate_code(src)
           add_event_delegation(src)
           add_statemachine_exception(src)
@@ -83,20 +84,42 @@ module Statemachine
           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
+        def add_instance_variables (src)
+          src << "// Instance variables" << endl
+          concrete_states = @sm.states.values.reject { |state| state.id.nil? || !state.concrete? }.sort { |a, b| a.id <=> b.id }
+          concrete_states.each do |state|
+            name = state.id.to_s.camalized
+            src << "public final State #{name.upcase} = new #{name}State(this);" << endl
           end
-          src << "private State state = #{default_state_name};" << endl
+          superstates = @sm.states.values.reject { |state| state.concrete? }.sort { |a, b| a.id <=> b.id }
+          superstates.each do |superstate|
+            startstate = superstate.resolve_startstate
+            src << "public final State #{superstate.id.to_s.upcase} = #{startstate.id.to_s.upcase};" << endl
+          end
+          src << "private State state = #{@startstate.id.to_s.upcase};" << endl
+          src << endl
+          src << "private #{@context_classname} context;" << endl
           src << endl
         end
 
+        def add_constructor(src)
+          src << "// Statemachine constructor" << endl
+          add_method(src, nil, @classname, "#{@context_classname} context") do
+            src << "this.context = context;" << endl
+            entered_states = []
+            entry_state = @startstate
+            while entry_state != @sm.root
+              entered_states << entry_state
+              entry_state = entry_state.superstate
+            end
+            entered_states.reverse.each do |state|
+              src << "context.#{state.entry_action.to_s.camalized(:lower)}();" << endl if state.entry_action
+            end
+          end
+        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")
@@ -115,7 +138,7 @@ module Statemachine
           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
+          src << "super(\"Missing transition from '\" + state.getClass().getSimpleName() + \"' with the '\" + event + \"' event.\");" << endl
           end_scope(src)
           end_scope(src)
           src << endl
@@ -137,34 +160,41 @@ module Statemachine
 
         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
+          @sm.states.keys.reject{|k| k.nil? }.sort.each do |state_id|
+            state = @sm.states[state_id]
+            state_name = state.id.to_s.camalized
+            base_class = state.superstate == @sm.root ? "State" : state.superstate.id.to_s.camalized
+
+            add_concrete_state_class(src, state, state_name, base_class) if state_id
           end
         end
 
-        def add_state_class(src, state_id)
-          state = @sm.states[state_id]
-          state_name = state_id.to_s.camalized
+        def add_concrete_state_class(src, state, state_name, base_class)
           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)
+            transition = state.transitions[event_id]
+            add_state_event_handler(transition, src)
           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)
+        def add_state_event_handler(transition, src)
+          event_name = transition.event.to_s.camalized(:lower)
+          exits, entries = transition.exits_and_entries(@sm.get_state(transition.origin_id), @sm.get_state(transition.destination_id))
           add_method(src, "void", event_name, nil) do
-            if transition.action
-              src << "statemachine.getContext().#{transition.action.to_s.camalized(:lower)}();" << endl
+            exits.each do |exit|
+              src << "statemachine.getContext().#{exit.exit_action.to_s.camalized(:lower)}();" << endl if exit.exit_action
             end
+            src << "statemachine.getContext().#{transition.action.to_s.camalized(:lower)}();" << endl if transition.action
             src << "statemachine.setState(statemachine.#{transition.destination_id.to_s.upcase});" << endl
+            entries.each do |entry|
+              src << "statemachine.getContext().#{entry.entry_action.to_s.camalized(:lower)}();" << endl if entry.entry_action              
+            end
           end
         end
 
@@ -175,7 +205,7 @@ module Statemachine
         end
 
         def add_method(src, return_type, name, params)
-          src << "public #{return_type} #{name}(#{params})".sub('  ', ' ') << endl
+          src << "public #{return_type} #{name}(#{params})".sub(' ' * 2, ' ') << endl
           begin_scope(src)
           yield
           end_scope(src)
@@ -191,10 +221,6 @@ module Statemachine
           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

data/lib/statemachine/state.rb

@@ -54,9 +54,13 @@ module Statemachine
       @statemachine.state = self
     end
     
-    def is_concrete?
+    def concrete?
       return true
     end
+
+    def resolve_startstate
+      return self
+    end
     
     def reset
     end

data/lib/statemachine/statemachine.rb

@@ -50,7 +50,7 @@ module Statemachine
     # Resets the statemachine back to its starting state.
     def reset
       @state = get_state(@root.startstate_id)
-      while @state and not @state.is_concrete?
+      while @state and not @state.concrete?
         @state = get_state(@state.startstate_id)
       end
       raise StatemachineException.new("The state machine doesn't know where to start. Try setting the startstate.") if @state == nil
@@ -106,7 +106,7 @@ module Statemachine
       elsif(is_history_state_id?(id))
         superstate_id = base_id(id)
         superstate = @states[superstate_id]
-        raise StatemachineException.new("No history exists for #{superstate} since it is not a super state.") if superstate.is_concrete?
+        raise StatemachineException.new("No history exists for #{superstate} since it is not a super state.") if superstate.concrete?
         return load_history(superstate)
       else
         state = State.new(id, @root, self)
@@ -162,7 +162,7 @@ module Statemachine
       100.times do
         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?
+        if history.concrete?
           return history
         else
           superstate = history

data/lib/statemachine/stub_context.rb

@@ -0,0 +1,24 @@
+module Statemachine
+
+  class StubContext
+
+    def initialize(options = {})
+      @verbose = options[:verbose]
+    end
+
+    attr_accessor :statemachine
+
+    def method(name)
+      super(name)
+    rescue
+      self.class.class_eval "def #{name}(*args, &block); __generic_method(:#{name}, *args, &block); end"
+      return super(name)
+    end
+
+    def __generic_method(name, *args)
+      puts "action invoked: #{name}(#{args.join(", ")}) #{block_given? ? "with block" : ""}" if @verbose      
+    end
+
+  end
+
+end

data/lib/statemachine/superstate.rb

@@ -11,10 +11,18 @@ module Statemachine
       @history_id = nil
     end
     
-    def is_concrete?
+    def concrete?
       return false
     end
-    
+
+    def startstate
+      return @statemachine.get_state(@startstate_id)
+    end
+
+    def resolve_startstate
+      return startstate.resolve_startstate
+    end
+
     def substate_exiting(substate)
       @history_id = substate.id
     end

data/lib/statemachine/transition.rb

@@ -19,20 +19,16 @@ module Statemachine
       
       origin.statemachine.invoke_action(@action, args, "transition action from #{origin} invoked by '#{@event}' event") if @action
       
-      terminal_state = destination
-      while terminal_state and not terminal_state.is_concrete?
-        terminal_state = statemachine.get_state(terminal_state.startstate_id)
-        entries << terminal_state
-      end
+      terminal_state = entries.last
       terminal_state.activate if terminal_state
 
       entries.each { |entered_state| entered_state.enter(args) }
     end
     
     def exits_and_entries(origin, destination)
+      return [], [] if origin == destination
       exits = []
       entries = exits_and_entries_helper(exits, origin, destination)
-      
       return exits, entries.reverse
     end
   
@@ -52,8 +48,9 @@ module Statemachine
     end
     
     def entries_to_destination(exit_state, destination)
+      return nil if destination.nil?
       entries = []
-      state = destination
+      state = destination.resolve_startstate
       while state    
         entries << state
         return entries if exit_state == state.superstate

data/lib/statemachine/version.rb

@@ -3,7 +3,7 @@ module Statemachine
     unless defined? MAJOR
       MAJOR  = 0
       MINOR  = 5
-      TINY   = 0
+      TINY   = 1
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')

data/spec/generate/java/java_statemachine_spec.rb

@@ -20,26 +20,58 @@ describe Statemachine::Statemachine, "(Java)" do
     @sm.to_java(:output => @output, :name => "JavaTurnstile", :package => "test.turnstile")
   end
 
+  def generate_complex_turnstile_sm
+    @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 => true
+    end
+
+    @sm.to_java(:output => @output, :name => "JavaTurnstile", :package => "test.turnstile")
+  end
+
+  def load_lines(*segs)
+    filename = File.join(*segs)
+    File.should exist( filename)
+    return IO.read(filename).split("\n")
+  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
+    return load_lines(@output, "test", "blank", "JavaTest.java")
   end
 
-  def sm_lines
+  def turnstile_lines
     generate_turnstile_sm
-    filename = File.join(@output, "test", "turnstile", "JavaTurnstile.java")
-    File.should exist( filename)
-    return IO.read(filename).split("\n")
+    return load_lines(@output, "test", "turnstile", "JavaTurnstile.java")
   end
 
-  def context_lines
+  def turnstile_context_lines
     generate_turnstile_sm
-    filename = File.join(@output, "test", "turnstile", "JavaTurnstileContext.java")
-    File.should exist( filename)
-    return IO.read(filename).split("\n")
+    return load_lines(@output, "test", "turnstile", "JavaTurnstileContext.java")
+  end
+
+  def complex_turnstile_lines
+    generate_complex_turnstile_sm
+    return load_lines(@output, "test", "turnstile", "JavaTurnstile.java")
   end
 
   def find_lines_after(lines, goose)
@@ -78,17 +110,19 @@ describe Statemachine::Statemachine, "(Java)" do
     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")
+  it "should generate the constructor" do
+    lines = find_lines_after(empty_sm_lines, "// Statemachine constructor")
 
-    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 == ""
+  end
+
+  it "should generate sm boilerplate code" do
+    lines = find_lines_after(empty_sm_lines, "// The following is boiler plate code standard to all statemachines")
+
     lines.shift.should == "  public JavaTestContext getContext()"
     lines.shift.should == "  {"
     lines.shift.should == "    return context;"
@@ -113,9 +147,9 @@ describe Statemachine::Statemachine, "(Java)" do
     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 == "      super(\"Missing transition from '\" + state.getClass().getSimpleName() + \"' with the '\" + event + \"' event.\");"
     lines.shift.should == "    }"
-    lines.shift.should == "  }"    
+    lines.shift.should == "  }"
   end
 
   it "should generate base state" do
@@ -136,7 +170,7 @@ describe Statemachine::Statemachine, "(Java)" do
 
   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")
@@ -153,15 +187,17 @@ describe Statemachine::Statemachine, "(Java)" do
   end
 
   it "should generate the state instance variables" do
-    lines = find_lines_after(sm_lines, "// State instances")
+    lines = find_lines_after(turnstile_lines, "// Instance variables")
 
     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;"
+    lines.shift.should == ""
+    lines.shift.should == "  private JavaTurnstileContext context;"
   end
 
   it "should generate all the sm event handlers" do
-    lines = find_lines_after(sm_lines, "// Event delegation")
+    lines = find_lines_after(turnstile_lines, "// Event delegation")
 
     lines.shift.should == "  public void coin()"
     lines.shift.should == "  {"
@@ -176,7 +212,7 @@ describe Statemachine::Statemachine, "(Java)" do
   end
 
   it "should generate all the default event handlers" do
-    lines = find_lines_after(sm_lines, "// The base state")
+    lines = find_lines_after(turnstile_lines, "// The base state")
 
     lines.shift.should == "  public static abstract class State"
     lines.shift.should == "  {"
@@ -201,7 +237,7 @@ describe Statemachine::Statemachine, "(Java)" do
   end
 
   it "should generate state classes" do
-    lines = find_lines_after(sm_lines, "// State implementations")
+    lines = find_lines_after(turnstile_lines, "// State implementations")
 
     lines.shift.should == "  public static class LockedState extends State"
     lines.shift.should == "  {"
@@ -248,7 +284,7 @@ describe Statemachine::Statemachine, "(Java)" do
   end
 
   it "should generate all the context methods" do
-    lines = find_lines_after(context_lines, "// Actions")
+    lines = find_lines_after(turnstile_context_lines, "// Actions")
 
     lines.shift.should == "  void alarm();"
     lines.shift.should == "  void lock();"
@@ -256,4 +292,57 @@ describe Statemachine::Statemachine, "(Java)" do
     lines.shift.should == "  void unlock();"
   end
 
+  it "should generate complext state instances" do
+    lines = find_lines_after(complex_turnstile_lines, "// Instance variables")
+
+    lines.shift.should == "  public final State DIAGNOSTICS = new DiagnosticsState(this);"
+    lines.shift.should == "  public final State LOCKED = new LockedState(this);"
+    lines.shift.should == "  public final State UNLOCKED = new UnlockedState(this);"
+    lines.shift.should == "  public final State OPERATIONAL = LOCKED;"
+    lines.shift.should == "  private State state = LOCKED;"
+  end
+
+  it "should generate entry actions on startup" do
+    lines = find_lines_after(complex_turnstile_lines, "// Statemachine constructor")
+
+    lines.shift.should == "  public JavaTurnstile(JavaTurnstileContext context)"
+    lines.shift.should == "  {"
+    lines.shift.should == "    this.context = context;"
+    lines.shift.should == "    context.operate();"
+    lines.shift.should == "    context.lock();"
+    lines.shift.should == "  }"
+    lines.shift.should == ""
+  end
+
+  it "should add entry/exit actions to each transition" do
+    lines = find_lines_after(complex_turnstile_lines, "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.setState(statemachine.UNLOCKED);"
+    lines.shift.should == "      statemachine.getContext().unlock();"
+    lines.shift.should == "    }"
+    lines.shift.should == ""
+    lines.shift.should == "    public void diagnose()"
+    lines.shift.should == "    {"
+    lines.shift.should == "      statemachine.getContext().beep();"
+    lines.shift.should == "      statemachine.setState(statemachine.DIAGNOSTICS);"
+    lines.shift.should == "      statemachine.getContext().disable();"
+    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 == "  }"
+  end
+
 end

data/spec/transition_spec.rb

@@ -17,8 +17,8 @@ describe "Transition Calculating Exits and Entries" do
   it "to itself" do
     @a = Statemachine::State.new("a", nil, nil)
     exits, entries = @transition.exits_and_entries(@a, @a)
-    exits.to_s.should eql([@a].to_s)
-    entries.to_s.should eql([@a].to_s)
+    exits.should == []
+    entries.should == []
   end
 
   it "to friend" do

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: statemachine
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Micah Martin
@@ -9,7 +14,7 @@ autorequire: statemachine
 bindir: bin
 cert_chain: []
 
-date: 2010-03-24 00:00:00 -05:00
+date: 2010-03-25 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +40,7 @@ files:
 - lib/statemachine/generate/util.rb
 - lib/statemachine/state.rb
 - lib/statemachine/statemachine.rb
+- lib/statemachine/stub_context.rb
 - lib/statemachine/superstate.rb
 - lib/statemachine/transition.rb
 - lib/statemachine/version.rb
@@ -65,21 +71,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: statemachine
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Statemachine-0.5.0 - Statemachine Library for Ruby http://slagyr.github.com/statemachine
+summary: Statemachine-0.5.1 - Statemachine Library for Ruby http://slagyr.github.com/statemachine
 test_files: 
 - spec/action_invokation_spec.rb
 - spec/builder_spec.rb