MINT-statemachine 1.2.2

data/CHANGES

@@ -0,0 +1,135 @@
+= Statemachine Changelog
+
+== Version 1.2.2
+
+* Transitions can fail
+
+== Version 1.2.1
+
+* Multiple actions
+
+Instead of a single action, multiple actions can be defined for a transition
+by using an array.
+
+* Redefinition of states without loosing transitions
+
+In a statemachine definition you can pass another statemachine and replace for the
+new statemachine a state with a superstate without loosing the original transitions.
+
+Each action that is called during a transaction has to return true for the transition to suceed.
+Otherwise the entire transition is assumed as failed and the statemachine remains in its origin
+state.
+
+* Support for GemBundler
+
+rake make_spec can be used to create a gemspec file that is required for GemBundler
+integration.
+
+== Version 1.1.0
+
+DotGraph
+* DotGraph generator was added to generate graphs of statemachines using Omnigraffle.
+* Fixed bug in Java generator where Statenames where not formated correctly.
+
+== Version 1.0.0
+
+Generator
+* Java generator was added.  Statemachines defined in the Ruby DSL can generate Java code.
+
+== 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
+* Fixed priority of default transitions, self defaults first, then superstate defaults.
+
+== Version 0.4.0
+
+Feature enhancements
+* enabled nested superstate history
+* TransitionMissingException's are raised when the statemachine can't respond to an event
+* Statmachine overrides respond_to? to respond to valid events.
+
+Behavior Fixes
+* fixed default transition so that superstate transitions have priority over default
+
+== Version 0.3.0
+
+Feature enhancements
+* added default transitions
+* added default history for superstates
+* the context method in the builder will set the context's statemachine variable if the context respond_to?(:statemachine=)
+
+Behavior Fixes
+* the entry action of the startstate is called when the statemachine starts or is reset.
+* resetting the statemachine will reset the history state for each superstate.
+
+== Version 0.2.2
+
+Minor plugin update
+* introduced before_event and after_event hooks for controllers
+
+== Version 0.2.1
+
+Rails Plugin.
+* Rails plugin introduced
+
+== Version 0.2.0
+
+Separation of logic from behavior.
+* Prefered builder syntax implemented
+* statemachine have a context which defines all the behavior
+* startstate can be set at any time in the builder
+* states can be declared without blocks
+* context can be set in builder
+
+== Version 0.1.0
+
+A new way to build the statemachines
+* cleaner API for running a statemachine
+* much refactoring
+* new API for building statemachine
+* process_event accepts strings
+
+== Version 0.0.4
+
+Some minor improvements
+* Proper handling of state transition implemented, such that the proper state is set for entry and exit actions.
+* can now use State objects in addition to symbols while creating a transition
+* more compliant implementation of history state
+
+== Version 0.0.3
+
+Bug fix dealing with entry and exit actions.  The state machine's state need to be set to the entered/exited state before calling the 
+exit/entry action.
+* added a couple specs in the exit_entry_spec
+* modified state.entered/exited methods to set the state
+* modifed the StateMachine.state to accept state objects.
+* removed running attribute from StateMachine because it wasn't much use
+* also removed the nil (end state)
+
+== Version 0.0.2
+
+More conventional file structure
+* nothing much to report in terms of changes.
+
+== Version 0.0.1
+
+0.0.0 didn't seem to work as a gem so maybe this one will.
+
+* nothing really, just playing with rake and release configuration
+
+== Version 0.0.0
+
+The first release.  Most finite state machine features are implemented
+* states
+* transitions
+* transition actions
+* super states
+* entry actions
+* exit actions
+* history state

data/LICENSE

@@ -0,0 +1,16 @@
+Copyright (C) 2010,2011 Sebastian Feuerstack, Jessica Colnago
+Copyright (C) 2006-2010  Micah Martin
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

data/MINT-statemachine.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{MINT-statemachine}
+  s.version = "1.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Sebastian Feuerstack}]
+  s.date = %q{2011-06-30}
+  s.description = %q{The MINT Statemachine is a ruby library for building Finite State Machines, based on the Statemachine gem by Micah Martin.}
+  s.email = %q{Sebastian@Feuerstack.org}
+  s.files = [%q{Rakefile}, %q{README.rdoc}, %q{CHANGES}, %q{TODO}, %q{LICENSE}, %q{lib/statemachine/generate/java/java_statemachine.rb}, %q{lib/statemachine/generate/src_builder.rb}, %q{lib/statemachine/generate/java.rb}, %q{lib/statemachine/generate/dot_graph.rb}, %q{lib/statemachine/generate/util.rb}, %q{lib/statemachine/generate/dot_graph/dot_graph_statemachine.rb}, %q{lib/statemachine/transition.rb}, %q{lib/statemachine/superstate.rb}, %q{lib/statemachine/version.rb}, %q{lib/statemachine/statemachine.rb}, %q{lib/statemachine/stub_context.rb}, %q{lib/statemachine/state.rb}, %q{lib/statemachine/parallelstate.rb}, %q{lib/statemachine/action_invokation.rb}, %q{lib/statemachine/builder.rb}, %q{lib/statemachine.rb}, %q{spec/sm_turnstile_spec.rb}, %q{spec/generate/java/java_statemachine_spec.rb}, %q{spec/generate/dot_graph/dot_graph_stagemachine_spec.rb}, %q{spec/sm_odds_n_ends_spec.rb}, %q{spec/noodle.rb}, %q{spec/sm_entry_exit_actions_spec.rb}, %q{spec/default_transition_spec.rb}, %q{spec/action_invokation_spec.rb}, %q{spec/sm_parallel_state_spec.rb}, %q{spec/builder_spec.rb}, %q{spec/sm_activation_spec.rb}, %q{spec/sm_super_state_spec.rb}, %q{spec/transition_spec.rb}, %q{spec/spec_helper.rb}, %q{spec/sm_simple_spec.rb}, %q{spec/sm_action_parameterization_spec.rb}, %q{spec/history_spec.rb}]
+  s.homepage = %q{http://www.multi-access.de}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{MINT-Statemachine-1.2.2 - Statemachine Library for Ruby based on statemachine from http://slagyr.github.com/statemachine http://www.multi-access.de/open-source-software/third-party-software-extensions/}
+  s.test_files = [%q{spec/sm_turnstile_spec.rb}, %q{spec/sm_odds_n_ends_spec.rb}, %q{spec/sm_entry_exit_actions_spec.rb}, %q{spec/default_transition_spec.rb}, %q{spec/action_invokation_spec.rb}, %q{spec/sm_parallel_state_spec.rb}, %q{spec/builder_spec.rb}, %q{spec/sm_activation_spec.rb}, %q{spec/sm_super_state_spec.rb}, %q{spec/transition_spec.rb}, %q{spec/sm_simple_spec.rb}, %q{spec/sm_action_parameterization_spec.rb}, %q{spec/history_spec.rb}]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/README.rdoc

@@ -0,0 +1,69 @@
+= MINT Statemachine Gem extensions
+
+This branch contains extensions that we implemented as part of the MINT project
+to run multimodal applications.
+
+It is based on the great Statemachine  Ruby Library, which enables simple creation 
+of full-features Finite Statemachines that has been originally developed by Micah Martin.
+
+To get started, please look at the documentation on the  Statemachine website: 
+http://slagyr.github.com/statemachine
+
+== Changes 
+
+=== Multiple actions
+
+Instead of a single action, multiple actions can be defined for a transition by using an
+array.
+
+  sm = Statemachine.build do |smb|
+    smb.trans :cold, :fire, :hot, [:cook, Proc.new { @tasty = true;true }, "@shape = 'fettucini'"]
+  end
+
+=== Redefinition of states without loosing transitions
+
+In a statemachine definition you can pass another statemachine and replace for the
+new statemachine a state with a superstate without loosing the original transitions.
+
+In this example the state :unlocked of @old_sm gets replaced by a super state.
+
+  @sm = Statemachine.build @old_sm do
+     superstate :unlocked do
+       trans :u1, :u, :u2
+       trans :u2, :e, :maintenance
+     end
+  end   
+
+=== Transitions can fail
+
+Each action that is called during a transaction has to return true for the transition to suceed.
+Otherwise the entire transition is assumed as failed and the statemachine remains in its origin
+state.
+
+=== Support for GemBundler
+
+rake make_spec can be used to create a gemspec file that is required for GemBundler
+integration. 
+
+== Project website
+
+http://www.multi-access.de
+	
+== License
+
+Copyright (C) 2010,2011 Sebastian Feuerstack, Jessica Colnago
+Copyright (C) 2006-2010  Micah Martin
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

data/Rakefile

@@ -0,0 +1,88 @@
+$:.unshift('lib')
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+require 'statemachine'
+
+PKG_NAME = "MINT-statemachine"
+PKG_VERSION   = Statemachine::VERSION::STRING
+PKG_TAG = Statemachine::VERSION::TAG
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*.rb', 
+  'spec/**/*.rb' 
+]
+
+task :default => :spec
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Generate RDoc'
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.options << '--title' << 'Statemachine' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGES', 'lib/**/*.rb')
+end
+task :rdoc
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = Statemachine::VERSION::DESCRIPTION
+  s.description = "The MINT Statemachine is a ruby library for building Finite State Machines, based on the Statemachine gem by Micah Martin."
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.require_path = 'lib'
+  s.author = "Sebastian Feuerstack"
+  s.email = "Sebastian@Feuerstack.org"
+  s.homepage = "http://www.multi-access.de"
+  end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+def egrep(pattern)
+  Dir['**/*.rb'].each do |fn|
+    count = 0
+    open(fn) do |f|
+      while line = f.gets
+        count += 1
+        if line =~ pattern
+          puts "#{fn}:#{count}:#{line}"
+        end
+      end
+    end
+  end
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{PKG_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc "Look for TODO and FIXME tags in the code"
+task :todo do
+  egrep /(FIXME|TODO|TBD)/
+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"
+task :verify_committed do
+  IO.popen('svn stat') do |io|
+    io.each_line do |line|
+      raise "\n!!! Do a svn commit first !!!\n\n" if line =~ /^\s*M\s*/
+    end
+  end
+end
+

data/TODO

@@ -0,0 +1,2 @@
+Maybe:
+Implement superstate endstate with automatic transition

data/lib/statemachine.rb

@@ -0,0 +1,26 @@
+#--
+# Copyright (C) 2006  Micah Martin
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+require 'statemachine/action_invokation'
+require 'statemachine/state'
+require 'statemachine/superstate'
+require 'statemachine/parallelstate'
+require 'statemachine/transition'
+require 'statemachine/statemachine'
+require 'statemachine/builder'
+require 'statemachine/version'

data/lib/statemachine/action_invokation.rb

@@ -0,0 +1,83 @@
+module Statemachine
+
+  module ActionInvokation #:nodoc:
+
+    def invoke_action(action, args, message, messenger, message_queue)
+      if !(action.is_a? Array)
+        action = [action]
+      end
+      result = true
+      action.each {|a|
+        if a.is_a? Symbol
+          result = invoke_method(a, args, message)
+        elsif a.is_a? Proc
+          result = invoke_proc(a, args, message)
+        elsif a.is_a? Array
+          result = send(a[0],a[1])
+        else
+          log("#{a}")
+          result =invoke_string(a) if not messenger
+        end
+        return false if result ==false
+       }
+      result
+    end
+
+    private
+
+    def send(target,event)
+      @message_queue.send(target, event) if @message_queue
+    end
+
+    def log(message)
+      @messenger.puts message if @messenger
+    end
+
+    def invoke_method(symbol, args, message)
+      method = @context.method(symbol)
+      raise StatemachineException.new("No method '#{symbol}' for context. " + message) if not method
+
+      parameters = params_for_block(method, args, message)
+      method.call(*parameters)
+    end
+
+    def invoke_proc(proc, args, message)
+      parameters = params_for_block(proc, args, message)
+      @context.instance_exec(*parameters, &proc)
+    end
+
+    def invoke_string(expression)
+      @context.instance_eval(expression)
+    end
+
+    def params_for_block(block, args, message)
+      arity = block.arity
+      required_params = arity < 0 ? arity.abs - 1 : arity
+
+      raise StatemachineException.new("Insufficient parameters. (#{message})") if required_params > args.length
+
+      return arity < 0 ? args : args[0...arity]
+    end
+
+  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