MINT-statemachine 1.2.2

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,265 @@
+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)
+          say "Statemachine generated."
+        end
+
+        private ###########################################
+
+        def explore_sm
+          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
+
+          @startstate = @sm.get_state(@sm.startstate).resolve_startstate
+        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_instance_variables(src)
+          add_constructor(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_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
+            src << "public final State #{name.upcase} = new #{name.camalized}State(this);" << endl
+          end
+          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
+          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 '\" + state.getClass().getSimpleName() + \"' 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.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_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|
+            transition = state.transitions[event_id]
+            add_state_event_handler(transition, src)
+          end
+          src.undent!
+          src << "}" << endl
+          src << endl
+        end
+
+        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
+            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
+
+        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(' ' * 2, ' ') << 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 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))
+          say "Writing to file: #{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,50 @@
+require 'date'
+
+module Statemachine
+  module Generate
+    module Util
+
+      def create_file(filename, content)
+        establish_directory(File.dirname(filename))
+        File.open(filename, 'w') do |file|
+          file.write(content)
+        end
+      end
+
+      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
+
+      def say(message)
+        if !defined?($IS_TEST)
+          puts message
+        end
+      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/parallelstate.rb

@@ -0,0 +1,196 @@
+module Statemachine
+
+  class Parallelstate< Superstate 
+  
+    attr_accessor :parallel_statemachines, :id
+    attr_reader :startstate_ids
+
+    def initialize(id, superstate, statemachine)
+      super(id, superstate, statemachine)
+      @parallel_statemachines=[]
+      @startstate_ids=[]
+    end
+
+#    def startstate_id= id
+#      if @parallel_statemachines.size>0
+#        @startstate_ids[@parallel_statemachines.size-1]= id
+#      end
+#    end
+#
+#    def startstate_id
+#      if (@parallel_statemachines.size>0 and @parallel_statemachines.size==@startstate_ids.size)
+#        return true
+#      end
+#      nil
+#    end
+
+    def context= c
+      @parallel_statemachines.each do |s|
+         s.context=c
+      end
+    end
+
+    def activate(terminal_state = nil)
+      @statemachine.state = self
+
+      @parallel_statemachines.each_with_index do |s,i|
+        s.activation = @statemachine.activation
+        s.reset(@startstate_ids[i])
+      end
+      @parallel_statemachines.each do |s|
+        next if terminal_state and s.has_state(terminal_state)
+        @statemachine.activation.call(s.state,self.abstract_states,self.states) if @statemachine.activation
+      end
+
+    end
+
+    def add_statemachine(statemachine)
+      statemachine.is_parallel=self
+      @parallel_statemachines.push(statemachine)
+      statemachine.context = @statemachine.context
+      @startstate_ids << @startstate_id
+      @startstate_id = nil
+    end
+
+    def get_statemachine_with(id)
+      @parallel_statemachines.each do |s|
+         return s if s.has_state(id)
+      end
+    end
+
+    def non_default_transition_for(event)
+      p "check parallel for #{event}"
+      transition = @transitions[event]
+      return transition if transition
+      
+      transition = transition_for(event)
+      
+      transition = @superstate.non_default_transition_for(event) if @superstate and not transition
+      return transition
+    end
+
+    def In(id)
+      @parallel_statemachines.each do |s|
+        return true if s.In(id.to_sym)
+      end
+      return false
+    end
+
+    def state= id
+     @parallel_statemachines.each do |s|
+        if s.has_state(id)
+          s.state=id
+          return true
+        end
+     end
+      return false
+    end
+
+    def has_state(id)
+      @parallel_statemachines.each do |s|
+        if s.has_state(id)
+          return true
+        end
+      end
+      return false
+    end
+
+    def get_state(id)
+#      if state = @statemachine.get_state(id)
+#        return state
+#      end
+      @parallel_statemachines.each do |s|
+        if state = s.get_state(id)
+          return state
+        end
+      end
+      return nil
+    end
+
+    def process_event(event, *args)
+      exceptions = []
+      result = false
+      #  TODO fix needed: respond_to checks superstates lying out of the parallel state as well, in case an event is
+      # defined outside the parallel statemachine it gets processed twice!
+
+      @parallel_statemachines.each_with_index do |s,i|
+          if s.respond_to? event
+            s.process_event(event,*args)
+            result = true
+          end
+      end
+      result
+     end
+
+    # Resets all of the statemachines back to theirs starting state.
+    def reset
+      @parallel_statemachines.each_with_index do |s,i|
+        s.reset(@startstate_ids[i])
+      end
+    end
+
+    def concrete?
+      return true
+    end
+
+    def startstate
+      return @statemachine.get_state(@startstate_id)
+    end
+
+    def resolve_startstate
+      return self
+    end
+
+    def substate_exiting(substate)
+      @history_id = substate.id
+    end
+  
+    def add_substates(*substate_ids)
+      do_substate_adding(substate_ids)
+    end
+    
+    def default_history=(state_id)
+      @history_id = @default_history_id = state_id
+    end
+
+    def states
+      return @parallel_statemachines.map &:state
+    end
+
+    def transition_for(event)
+      @parallel_statemachines.each do |s|
+       # puts "checke parallel #{s.id} for #{event}"
+        transition = s.get_state(s.state).non_default_transition_for(event)
+        transition = s.get_state(s.state).default_transition if not transition
+        return transition if transition
+      end
+      return @superstate.default_transition if @superstate
+
+#      super.transition_for(event)
+    end
+
+    def enter(args=[])
+     # reset
+      super(args)
+    end
+    def to_s
+      return "'#{id}' parallel"
+    end
+
+    def abstract_states
+      abstract_states=[]
+
+      if (@superstate)
+        abstract_states=@superstate.abstract_states
+      end
+      @parallel_statemachines.each do |s|
+        abstract_states += s.abstract_states
+      end
+      abstract_states.uniq
+    end
+    def is_parallel
+      true
+    end
+  end
+
+end