baby_bots 0.0.4 → 0.0.5

data/README.md

@@ -5,7 +5,10 @@ A small finite-state automata library
 -------------------------------------
 
 This is a small finite-state automata library written in Ruby both for a
-project, as well as to teach me how to build gems (I'm not really much of
-a Ruby guy).
+project, as well as to teach me how to build gems, use rspec, rdoc, etc.
 
-Let me know of any improviments, thank you!
+Let me know of any improviments, thank you!
+
+Usage
+------
+There's a sample file called example.rb that you should for usage.

data/example.rb

@@ -0,0 +1,61 @@
+require 'baby_bots'
+
+class BB < BabyBots::BabyBot
+  def initialize
+    super
+    build({ :loading => {1   => :ready, :else => :loading},
+            :ready   => {"0" => :loading, "1" => :run, :else => :ready},
+            :run     => {:else => :run}})
+  end
+
+  def pre_loading(event=nil)
+    puts "In loading, converting event to an integer."
+    event.to_i
+  end
+
+  def post_loading(event=nil)
+    puts "Leaving loading, notice event is the supplied event, rather than the converted event in pre_loading."
+    puts "event: #{event}"
+    event
+  end
+
+  def pre_ready(event=nil)
+    puts "In ready, converting event to a string."
+    event.to_s
+  end
+
+  def post_ready
+    puts "Leaving ready, notice no parameter is supplied."
+  end
+
+  def pre_run(event=nil)
+    puts "Done! We'll loop here forever."
+  end
+
+  def post_run(event=nil)
+    puts "Why not return true no matter what?"
+    true
+  end
+end
+
+bb = BB.new
+
+puts "Current state should be loading."
+puts "Current state: #{bb.state}"
+
+puts "\nLet's go from loading to ready, we'll convert this event into an integer."
+bb.process("1")
+
+puts "\nLet's loop back to loading."
+bb.process(0)
+
+puts "\nLet's check that else is working."
+bb.process("99")
+
+puts "\nOk, let's go to run."
+bb.process(1)
+bb.process(1)
+
+puts "\nLet's see if it returns true."
+final_val = bb.process("anything")
+puts "final_val: #{final_val}"

data/lib/baby_bots/baby_bot.rb

@@ -13,6 +13,10 @@ 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
@@ -32,7 +36,7 @@ module BabyBots
     # state. Note that this machine may only have one start state. Additionally,
     # adding the first start state will set @curr to be this state, after this
     # has been done @curr will remain on whatever state it is currently residing
-    # on, and must be reset using the reset method.
+    # on, and must be reset using the restart method.
     def add_state(state, start=nil)
       # key on state names to the actual state object
       @states[state.state] = state
@@ -89,7 +93,7 @@ module BabyBots
 
       # check if we need to preprocess the event
       if respond_to?("pre_#{@curr.state}")
-        cooked_event = send("pre_#{@curr.state}", event)
+        cooked_event = my_send("pre_#{@curr.state}", event)
       end
 
       # calculate the next state
@@ -115,9 +119,9 @@ module BabyBots
       # 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}")
-        ret_val = send("post_#{@curr.state}", event)
+        ret_val = my_send("post_#{@curr.state}", event)
       elsif respond_to?("post_cooked_#{curr.state}")
-        ret_val = send("post_#{@curr.state}", cooked_event)
+        ret_val = my_send("post_#{@curr.state}", cooked_event)
       end
       
       # actually transition, and make sure such a transition exists
@@ -130,10 +134,25 @@ module BabyBots
       return ret_val
     end
 
-    # Reset the current state to be the start state.
+    # Restart the current state to be the start state.
     def restart
       @curr = @start
     end
+
+    private
+
+    # A wrapper around send, using the arity restrictions assumed by BabyBots.
+    def my_send(method_name, event=nil)
+      m_arity = method(method_name).arity
+      if m_arity == 0
+        ret_val = send(method_name)
+      elsif m_arity == 1 or m_arity == -1
+        ret_val = send(method_name, event)
+      else
+        raise ArgumentError
+      end
+      return ret_val
+    end
   end
 
 end

data/lib/baby_bots/version.rb

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

data/spec/baby_bot_spec.rb

@@ -9,6 +9,48 @@ TEST_MACHINE1 = { :loading => {1 => :ready, :else => :loading},
                                    :ready   => {1 => :run, :else => :loading},
                                    :run     => {:else => :run} }
 
+class BB < BabyBots::BabyBot
+  def initialize
+    super
+    build({ :loading => {1   => :ready, :else => :loading},
+            :ready   => {"0" => :loading, "1" => :run, :else => :ready},
+            :run     => {:else => :run}})
+  end
+
+  def pre_loading(event=nil)
+    event.to_i
+  end
+
+  def post_loading(event=nil)
+    event
+  end
+
+  def pre_ready(event=nil)
+    event.to_s
+  end
+
+  def post_ready(event=nil)
+    event
+  end
+
+  def post_run(event=nil)
+    true
+  end
+end
+
+class BB2 < BB
+  def post_loading
+    true
+  end
+end
+
+class BB3 < BB
+  def post_loading(event, stuff, mo_stuff)
+    true
+  end
+end
+
+
 describe BabyBots::BabyBot do
   it "should be able to be initiated with no additional initialization" do
     test = BabyBots::BabyBot.new
@@ -29,4 +71,83 @@ describe BabyBots::BabyBot do
     test.add_state($run)
     test.states.should == {:loading => $loading, :ready => $ready, :run => $run}
   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
+  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
+  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
+  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
+  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
+    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
+  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
+  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")
+    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
+  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
+  end
+
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: baby_bots
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-01 00:00:00.000000000Z
+date: 2012-05-02 00:00:00.000000000Z
 dependencies: []
 description: A tiny finite-state automata library.
 email: justinanthonyhamilton@gmail.com
@@ -17,12 +17,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - baby_bots.gemspec
+- example.rb
 - lib/baby_bots.rb
 - lib/baby_bots/baby_bot.rb
 - lib/baby_bots/state.rb

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp