pretty-fsm 0.1

data/Manifest

@@ -0,0 +1,10 @@
+Manifest
+README
+Rakefile
+examples/door.rb
+examples/timed_door.rb
+lib/pretty-fsm.rb
+lib/pretty-fsm/fsm.rb
+lib/pretty-fsm/timed_event.rb
+nbproject/project.properties
+nbproject/project.xml

data/README

@@ -0,0 +1,7 @@
+= Usage and examples
+
+  Look under the +examples+ directory
+
+= License
+
+This ruby module is licensed under the GPLv2

data/Rakefile

@@ -0,0 +1,24 @@
+# -*- ruby -*-
+require 'rubygems'
+require 'rake'
+require 'echoe'
+#require 'yard'
+
+Echoe.new('pretty-fsm') do |p|
+  p.author = 'v01d'
+  p.summary = "Finite State Machine class with intuitive integration"
+  p.url = "http://github.com/v01d/pretty-fsm"
+  p.version = "0.1"
+#  p.dependencies = ['yard']
+#  p.eval = proc { s.has_rdoc = 'yard' }
+end
+
+#Rake::TaskManager.class_eval do
+#  def remove_task(task)
+#    @tasks.delete(task.to_s)
+#  end
+#end
+
+#Rake.application.remove_task(:docs)
+#YARD::Rake::YardocTask.new(:docs) {|t| t.options = ['--verbose','--no-private','--hide-void']}
+

data/examples/door.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby -w
+require 'pretty-fsm'
+
+class Door
+  include PrettyFSM::Abbreviate
+  
+  attr_reader(:fsm)
+
+  def initialize
+    @fsm = PrettyFSM::FSM.new(self, :open) do
+      transition :from => :open, :to => :close, :if => :can_close?
+      transition :from => :close, :to => :open, :if => :can_open?
+    end
+  end
+  
+  def run
+    loop do
+      @fsm.advance
+      sleep(0.25)
+    end
+  end
+  
+  def start_open
+    puts "Openned door"
+    @counter = 10
+  end
+  
+  def while_open
+    @counter -= 1
+    puts @counter.to_s
+  end
+  
+  def can_close?
+    @counter == 0
+  end
+  
+  def start_close
+    puts "Closed door"
+  end
+  
+  def while_close
+    @counter += 1
+    puts @counter.to_s
+  end
+  
+  def can_open?
+    @counter == 10
+  end  
+end
+
+Door.new.run

data/examples/timed_door.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby -w
+require 'pretty-fsm'
+
+class Door
+  include PrettyFSM::Abbreviate
+  
+  attr_reader(:fsm)
+  
+  def initialize
+    @fsm = PrettyFSM::FSM.new(self, :open)
+    @close_timer = PrettyFSM::TimedEvent.new(5)
+    @open_timer = PrettyFSM::TimedEvent.new(3)
+  end
+  
+  def run
+    loop do
+      @fsm.advance
+      sleep(0.25)
+    end
+  end
+  
+  def start_open
+    puts "Openned door, will close on #{@close_timer.duration} seconds"
+  end
+  
+  def while_open
+    puts "Waiting to be closed"
+    @close_timer.try { start(:close) }    
+  end
+    
+  def start_close
+    puts "Closed door, will close on #{@open_timer.duration} seconds"
+  end
+  
+  def while_close
+    puts "Waiting to be opened"
+    @close_timer.try { start(:open) }    
+  end
+end
+
+Door.new.run

data/lib/pretty-fsm/fsm.rb

@@ -0,0 +1,55 @@
+module PrettyFSM
+  class FSM
+    # This will be nil if the FSM hasn't made the initial transition yet.
+    attr_reader :state
+    attr_accessor :object
+    
+    # _object_ is an instance where all messages regarding transitions and states are sent. States are named with
+    # Symbol instances. The prefixes, are the prefixes to the message names that _object_ will receive (if it responds to them).
+    def initialize(object, initial_state, while_prefix = 'while_', start_prefix = 'start_', end_prefix = 'end_')
+      @object = object
+      @while_prefix,@start_prefix,@end_prefix = while_prefix,start_prefix,end_prefix
+      @initial_state = initial_state
+      @state = nil
+      @transitions = Hash.new {|k,v| []}
+      if (block_given?) then self.instance_eval(&Proc.new) end
+    end
+    
+    # This method should be called periodically. It will act as a timestepper.
+    # 'while' methods will be called here.
+    def advance
+      if (@state.nil?) then start(@initial_state) end
+      call_fsm_method(@while_prefix)
+
+      possible_next_state, = @transitions[@state].find {|state,condition| puts state,condition; @object.send(condition)}
+      start(possible_next_state) unless possible_next_state.nil?
+    end
+
+    # Adds a transition definition. Only necessary if you want the FSM to advance itself from a state
+    def transition(options)
+      @transitions[options[:from]].push([ options[:to], options[:if] ])
+    end
+    
+    # Transitions the FSM into the specified state, calling the 'end' and 'start' method, of the old and new states, respectively.
+    # Any additional parameter passed to this method will be received by the corresponding 'start' method.
+    def start(new_state, *args)
+      call_fsm_method(@end_prefix) unless @state.nil?
+      @state = new_state
+      call_fsm_method(@start_prefix, args)
+    end
+    
+  private
+    def call_fsm_method(prefix, args = [])
+      method_name = (prefix + @state.to_s).to_sym
+      if (@object.respond_to?(method_name)) then @object.send(method_name, *args) end
+    end
+  end
+  
+  # You can use this mixin to abbreviate your calls to FSM#start
+  module Abbreviate
+    # calls self.fsm.start
+    def start(new_state, *args)
+      self.fsm.start(new_state, *args)
+    end
+  end
+end

data/lib/pretty-fsm/timed_event.rb

@@ -0,0 +1,28 @@
+module FSM
+  # This class is useful to "register" actions to be performed after certain time. You would normally use this
+  # in a FSM state, to switch to another state after a while.
+  # The notion of 'time' (the _now_ and _duration_ parameters) can be arbitrary, it could be any number for example (as long as it makes sense).
+  class TimedEvent
+    attr_accessor :duration
+    
+    # Create a TimedEvent that will fire after _duration_ seconds (can be a fractional number) starting from _now_.
+    def initialize(duration)
+      self.reset
+      @duration = duration
+    end
+    
+    # Resets the timer, to fire after #duration seconds after _now_
+    def reset(now = Time.now)
+      @time = now
+    end
+    
+    # This method should be called periodically with a block. If #duration seconds have passed since last reset, it will
+    # call the passed block.
+    def try(now = Time.now)
+      if ((now - @time) >= @duration)
+        yield
+        self.reset
+      end
+    end
+  end
+end

data/lib/pretty-fsm.rb

@@ -0,0 +1,2 @@
+require 'pretty-fsm/fsm'
+require 'pretty-fsm/timed_event'

data/nbproject/project.properties

@@ -0,0 +1,7 @@
+file.reference.fsm-examples=examples
+file.reference.fsm-lib=lib
+javac.classpath=
+main.file=door.rb
+source.encoding=ISO-8859-1
+src.examples.dir=examples
+src.lib.dir=lib

data/nbproject/project.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>fsm</name>
+            <source-roots>
+                <root id="src.lib.dir"/>
+                <root id="src.examples.dir"/>
+            </source-roots>
+            <test-roots/>
+        </data>
+    </configuration>
+</project>

data/pretty-fsm.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pretty-fsm}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["v01d"]
+  s.date = %q{2010-03-26}
+  s.description = %q{Finite State Machine class with intuitive integration}
+  s.email = %q{}
+  s.extra_rdoc_files = ["README", "lib/pretty-fsm.rb", "lib/pretty-fsm/fsm.rb", "lib/pretty-fsm/timed_event.rb"]
+  s.files = ["Manifest", "README", "Rakefile", "examples/door.rb", "examples/timed_door.rb", "lib/pretty-fsm.rb", "lib/pretty-fsm/fsm.rb", "lib/pretty-fsm/timed_event.rb", "nbproject/project.properties", "nbproject/project.xml", "pretty-fsm.gemspec"]
+  s.homepage = %q{http://github.com/v01d/pretty-fsm}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Pretty-fsm", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{pretty-fsm}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Finite State Machine class with intuitive integration}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: pretty-fsm
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- v01d
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-26 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: Finite State Machine class with intuitive integration
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- lib/pretty-fsm.rb
+- lib/pretty-fsm/fsm.rb
+- lib/pretty-fsm/timed_event.rb
+files: 
+- Manifest
+- README
+- Rakefile
+- examples/door.rb
+- examples/timed_door.rb
+- lib/pretty-fsm.rb
+- lib/pretty-fsm/fsm.rb
+- lib/pretty-fsm/timed_event.rb
+- nbproject/project.properties
+- nbproject/project.xml
+- pretty-fsm.gemspec
+has_rdoc: true
+homepage: http://github.com/v01d/pretty-fsm
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Pretty-fsm
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: pretty-fsm
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Finite State Machine class with intuitive integration
+test_files: []
+