baby_bots 0.0.6 → 0.0.7

data/lib/baby_bots.rb

@@ -1,3 +1,4 @@
 require 'baby_bots/version'
-require 'baby_bots/baby_bot'
 require 'baby_bots/state'
+require 'baby_bots/baby_bot'
+

data/lib/baby_bots/baby_bot.rb

@@ -1,10 +1,5 @@
-# A tiny finite-state automata library.
-#
-# Author:: Justin Hamilton (mailto:justinanthonyhamilton@gmail.com)
-# Copyright :: BSD2 (see LICENSE for more details)
-
 module BabyBots
-
+  
   # Error to handle attempts to transition to a state that does not exist.
   class NoSuchStateException < Exception
   end
@@ -13,24 +8,33 @@ module BabyBots
   class NoSuchTransitionException < Exception
   end
 
-  # # Error to handle incorrect arity on the post_state methods.
-  # class PostMethodArgumentError < ArgumentError
-  # end
-
   # A tiny finite-state automata class.
   class BabyBot
-    attr_accessor :curr, :states, :start
+    attr_accessor :curr, :start
 
     # Accepts an optional hash of states.
     def initialize(states={})
       # Hash of state names to state objects
       @states = {}
       if !states.empty? then build states end
+
+      # Add our default error state to provide user-based 'error' handling.
+      add_state(ERRSTATE)
+      
       # Initial state
       @start = nil
       # Current state
       @curr = nil
     end
+    
+    # Provides the states, minus the default error state (because it isn't
+    # really a state in the true sense). Note that this is NOT a reference
+    # to the BabyBot's actual states, but rather a duplicate.
+    def states
+      new_states = @states.dup
+      new_states.delete(ERR)
+      return new_states
+    end
 
     # Adds a new state to the finite-state automata, also accepts
     # an optional start flag, which will set the supplied state as the initial
@@ -51,6 +55,12 @@ module BabyBots
       end
     end
 
+    # Since we implement a default error state, this empty will check
+    # if there are any other states aside from that one.
+    def empty?
+      @states.keys.find_all { |k| k != ERR }.empty?
+    end
+
     # Build up this machine's states with a given state table. The format of
     # this table is assumed to be {state_name => {event1 => transition1, ...}}.
     # build assumes that the first state provided is the start state, although
@@ -79,6 +89,11 @@ module BabyBots
       @curr.state
     end
 
+    # Return the name of the current state
+    def state_name
+      @curr.state.state
+    end
+
     # Process the finite state automata with the given event.
     # This will first see if the finite state automata has a defined method
     # named "pre_{current_state}", and if so "cook" the input event with this
@@ -113,23 +128,30 @@ module BabyBots
       # if the event is nil, and there is no :else clause,
       # throw an exception
       if next_state.nil?
-        raise NoSuchTransitionException,
-        "No valid transition #{event} for #{@curr.state}"
+        transition_error(event, @curr.state)
       end
-
-      # check if we need to postprocess the event, this will act
+      
+      # first, check if we need to handle an error function for this state,
+      # then check if we need to postprocess the event, this will act
       # as the "return" from any state transition (even self-looping transitions)
-      if respond_to?("post_#{@curr.state}")
+      if next_state == ERRSTATE
+        if respond_to?("error_#{@curr.state}")
+          ret_val = my_send("error_#{@curr.state}", event)
+        else
+          raise NoSuchTransitionException,
+          "No valid transition #{event} for #{@curr.state}"
+        end
+      elsif respond_to?("post_#{@curr.state}")
         ret_val = my_send("post_#{@curr.state}", event)
       elsif respond_to?("post_cooked_#{curr.state}")
         ret_val = my_send("post_#{@curr.state}", cooked_event)
       end
       
       # actually transition, and make sure such a transition exists
-      @curr = next_state
+      @curr = next_state unless next_state == ERRSTATE
+
       if @curr.nil?
-        raise NoSuchStateException,
-        "No valid state #{@curr} for transition #{event} from #{curr_state}"
+        transition_error(event, @curr.state)
       end
 
       return ret_val
@@ -154,8 +176,23 @@ module BabyBots
       return true
     end
 
+    # Check if a method call is checking that state name.
+    def method_missing(m, *a, &b)
+      if m =~ /^([a-zA-Z_]+)\?$/
+        state == m.to_s.gsub("?","").to_sym
+      else
+        raise NoMethodError
+      end
+    end
+
     private
 
+    # Wrapper for our NoSuchTransitionException
+    def transition_error(event, state)
+      raise NoSuchTransitionException,
+      "No valid transition #{event} for #{state}"
+    end
+
     # A wrapper around send, using the arity restrictions assumed by BabyBots.
     def my_send(method_name, event=nil)
       m_arity = method(method_name).arity

data/lib/baby_bots/state.rb

@@ -2,6 +2,9 @@ module BabyBots
   # Transition state used to remove events from a transition table.
   NOWHERE = :nowhere__
 
+  # Defualt Error Transition
+  ERR     = :err__
+
   # The state contained within the BabyBots Finite State Automata.
   # States have an event that transitions to a new state. They may also
   # have an event named :else which will be the transition used by the
@@ -50,4 +53,6 @@ module BabyBots
     end
   end
 
+  ERRSTATE = State.new(:err__)
+
 end

data/lib/baby_bots/version.rb

@@ -1,4 +1,4 @@
 module BabyBots
   # Current development version
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/baby_bot_spec.rb

@@ -6,8 +6,25 @@ $run     = BabyBots::State.new(:run,     {:else => :run})
                                
 
 TEST_MACHINE1 = { :loading => {1 => :ready, :else => :loading},
-                                   :ready   => {1 => :run, :else => :loading},
-                                   :run     => {:else => :run} }
+  :ready   => {1 => :run, :else => :loading},
+  :run     => {:else => :run} }
+
+class ERRTEST < BabyBots::BabyBot
+  def initialize
+    super
+    build({ :loading => {1 => :ready, :else => BabyBots::ERR},
+            :ready   => {0 => :loading, 1 => :run, :else => BabyBots::ERR},
+            :run     => {:else => :run} })
+  end
+
+  def error_loading
+    "Error loading"
+  end
+
+  def error_ready
+    "Error ready"
+  end
+end
 
 class BB < BabyBots::BabyBot
   def initialize
@@ -52,117 +69,144 @@ end
 
 
 describe BabyBots::BabyBot do
+  before(:each) do
+    @test  = nil
+    @test2 = nil
+  end
+
+  after(:each) do
+    @test  = nil
+    @test2 = nil
+  end
+  
   it "should be able to be initiated with no additional initialization" do
-    test = BabyBots::BabyBot.new
-    test.states.should == {}
+    @test = BabyBots::BabyBot.new
+    @test.empty?.should == true
+    @test = nil
   end
 
   it "should be able to be initialized with a state table" do
-    test = BabyBots::BabyBot.new(TEST_MACHINE1)
-    test.states.should == {:loading => $loading, :ready => $ready, :run => $run}
+    @test = BabyBots::BabyBot.new(TEST_MACHINE1)
+    @test.states.should == {:loading => $loading, :ready => $ready, :run => $run}
   end
 
   it "should have states be able to be added using add_state" do
-    test = BabyBots::BabyBot.new
-    test.add_state($loading)
-    test.states.should == {:loading => $loading}
-    test.add_state($ready)
-    test.states.should == {:loading => $loading, :ready => $ready}
-    test.add_state($run)
-    test.states.should == {:loading => $loading, :ready => $ready, :run => $run}
+    @test = BabyBots::BabyBot.new
+    @test.add_state($loading)
+    @test.states.should == {:loading => $loading}
+    @test.add_state($ready)
+    @test.states.should == {:loading => $loading, :ready => $ready}
+    @test.add_state($run)
+    @test.states.should == {:loading => $loading, :ready => $ready, :run => $run}
   end
 
   it "should be able to have states built using the build method" do
-    test = BabyBots::BabyBot.new
-    test.build(TEST_MACHINE1)
+    @test = BabyBots::BabyBot.new
+    @test.build(TEST_MACHINE1)
   end
 
   it "should allow states to be overwritten using build" do
-    test = BabyBots::BabyBot.new(TEST_MACHINE1)
-    test.build({ :loading => {1 => :run, 2 => :loading} })
+    @test = BabyBots::BabyBot.new(TEST_MACHINE1)
+    @test.build({ :loading => {1 => :run, 2 => :loading} })
 
-    test2 = BabyBots::BabyBot.new({ :loading => {1 => :run, 2 => :loading},
+    @test2 = BabyBots::BabyBot.new({ :loading => {1 => :run, 2 => :loading},
                                    :ready   => {1 => :run, :else => :loading},
                                    :run     => {:else => :run} })
-    test.states.should == test2.states
+    @test.states.should == @test2.states
   end
 
-  it "should run the example, with the starting state being loading" do
-    test = BB.new
-    test.start.state.should == :loading
+  it "should provide state-based error handling" do
+    @test = ERRTEST.new
+    msg = @test.process(42)
+    msg.should == "Error loading"
+    @test.state.should == :loading
+    @test.process(1)
+    @test.state.should == :ready
+    msg = @test.process(42)
+    msg.should == "Error ready"
+  end 
+
+  it "should run the example, with the starting state being 'loading'" do
+    @test = BB.new
+    @test.start.state.should == :loading
   end
 
   it "should run the example, with the current state being loading" do
-    test = BB.new
-    test.state.should == :loading
+    @test = BB.new
+    @test.state.should == :loading
   end
 
   it "should run the example, iterating from loading to ready on inputs 1" do
-    test = BB.new
-    test.process(1)
-    test.state.should == :ready
+    @test = BB.new
+    @test.process(1)
+    @test.state.should == :ready
   end
 
   it "should run the example, using pre_loading to convert \"1\" to 1" do
-    test = BB.new
-    test.process("1")
-    test.state.should == :ready
+    @test = BB.new
+    @test.process("1")
+    @test.state.should == :ready
   end
 
   it "should run the example, using pre_loading to convert \"1\" to 1" do
-    test = BB.new
-    test.process("1")
-    test.state.should == :ready
+    @test = BB.new
+    @test.process("1")
+    @test.state.should == :ready
   end
 
   it "should run the example, use pre_loading to convert \"1\" to 1, but use post_loading to return \"1\"" do
-    test = BB.new
-    final_var = test.process("1")
-    test.state.should == :ready
+    @test = BB.new
+    final_var = @test.process("1")
+    @test.state.should == :ready
     final_var.should == "1"
   end
 
   it "should run the example, and be able to be reset using the restart method" do
-    test = BB.new
-    test.process(1)
-    test.state.should == :ready
-    test.restart
-    test.state.should == :loading
+    @test = BB.new
+    @test.process(1)
+    @test.state.should == :ready
+    @test.restart
+    @test.state.should == :loading
   end
 
   it "should run the example, where anything other than \"1\" or \"0\" looping in :ready" do
-    test = BB.new
-    test.process(1)
-    test.state.should == :ready
-    test.process("banana phone")
-    test.state.should == :ready
-    test.process(99)
-    test.state.should == :ready
-    test.process
-    test.state.should == :ready
+    @test = BB.new
+    @test.process(1)
+    @test.state.should == :ready
+    @test.process("banana phone")
+    @test.state.should == :ready
+    @test.process(99)
+    @test.state.should == :ready
+    @test.process
+    @test.state.should == :ready
   end
 
   it "should run the example, lacking a pre_run should not have any ill side-effects" do
-    test = BB.new
-    test.process(1)
-    test.process(1)
-    ret1 = test.process("chocolate rain")
-    ret2 = test.process("gournal")
+    @test = BB.new
+    @test.process(1)
+    @test.process(1)
+    ret1 = @test.process("chocolate rain")
+    ret2 = @test.process("gournal")
     ret1.should == ret2
     ret2.should == true
   end
 
   it "should run the example, and not have issue with a zero-arity method" do
-    test = BB2.new
-    test.process(1)
-    test.process(1)
-    test.state.should == :run
+    @test = BB2.new
+    @test.process(1)
+    @test.process(1)
+    @test.state.should == :run
   end
 
   it "should run the example, and raise an ArgumentError on arity error" do
-    test = BB3.new
-    lambda{ test.process(1)}.should raise_error ArgumentError
+    @test = BB3.new
+    lambda{ @test.process(1)}.should raise_error ArgumentError
   end
 
+  it "should allow the current state to be checked with the message {state_name}?" do
+    @test = BB.new
+    @test.loading?.should == true
+    @test.not_ready?.should == false
+  end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: baby_bots
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-07 00:00:00.000000000Z
+date: 2012-05-08 00:00:00.000000000Z
 dependencies: []
 description: A tiny finite-state automata library.
 email: justinanthonyhamilton@gmail.com