baby_bots 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in baby_bots.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012, Justin Hamilton
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,11 @@
+Baby Bots
+=========
+
+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).
+
+Let me know of any improviments, thank you!

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/baby_bots.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/baby_bots/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Justin Hamilton"]
+  gem.email         = ["justinanthonyhamilton@gmail.com"]
+  gem.description   = %q{A tiny finite-state automata library.}
+  gem.summary       = %q{While there are many fsa libraries out there, I wanted to implement my own so I could learn how to create a module/gem, as I am not really a Ruby guy and have no idea how.}
+  gem.homepage      = "https://github.com/jamiltron/BabyBots"
+  gem.email         = "justinanthonyhamilton@gmail.com"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "baby_bots"
+  gem.require_paths = ["lib"]
+  gem.version       = BabyBots::VERSION
+end

data/lib/baby_bots/baby_bot.rb

@@ -0,0 +1,98 @@
+module BabyBots
+
+  class NoSuchStateException < Exception
+  end
+
+  class NoSuchTransitionException < Exception
+  end
+
+  class BabyBot
+    attr_accessor :curr, :states, :start
+
+    def initialize(states={})
+      @states = states
+      @start = nil
+      @curr = nil
+    end
+
+    # add a new state to the state machine
+    def add_state(state, start=nil)
+      # key on state names to the actual state hash
+      @states[state.state] = state
+      if start
+        @start = state
+        @curr = @start
+      end
+    end
+
+
+    # accepts a hash of hashes consiting of {state => {event => transition, ...} ...}
+    # structure, and adds these states to the state machine, assumes first state
+    # is the starting state
+    def build(table)
+      first_state = true
+      
+      # iterate through the provided {state => {event => transition, ...}, ...}
+      table.each do |state, state_table|
+        temp_state = State.new(state)
+        
+        # iterate through each event and transition, building up the transitions
+        state_table.each do |event, transition|
+          temp_state.add_transition(event, transition)
+        end
+
+        # finally, add the state to the machine, and since we've already
+        # added a start state, clear the first_state flag
+        add_state(temp_state, first_state)
+        first_state = false
+      end
+    end
+
+    # this is the driving function behind the fsa, process
+    # will check the current state, doing any processing necessary
+    # on the input based on whether or not this 
+    
+    def process(event=nil)
+      # get the current state
+      curr_state = @curr
+
+      # check if we need to preprocess the event
+      if respond_to?("pre_#{@curr.state}")
+        event = send("pre_#{@curr.state}", event)
+      end
+
+      next_state = @states[curr.table[event]]
+      if next_state.nil?
+        next_state = @states[curr.table[:else]]
+      end
+      
+      # 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}"
+      end
+
+      # 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)
+      end
+      
+
+      # actually transition, and make sure such a transition exists
+      @curr = next_state
+      if @curr.nil?
+        raise NoSuchStateException,
+        "No valid state #{@curr} for transition #{event} from #{curr_state}"
+      end
+
+      return ret_val
+    end
+
+    def restart
+      @curr = @start
+    end
+  end
+
+end

data/lib/baby_bots/state.rb

@@ -0,0 +1,22 @@
+module BabyBots
+
+  class State 
+    attr_reader :state, :table
+    
+    def initialize(state, table={})
+      @state = state
+      @table = table
+    end
+
+    def add_transition(event, transition, &callback)
+      @table[event] = transition
+    end
+
+    # the idea behind build is that you can call multiple
+    # :event :transition and the build method
+    # will parse them out and add them to state
+    def build(*args)
+      args.map {|k,v| add_transition(k, v) }
+    end
+  end
+end

data/lib/baby_bots/version.rb

@@ -0,0 +1,3 @@
+module BabyBots
+  VERSION = "0.0.1"
+end

data/lib/baby_bots.rb

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

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: baby_bots
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Justin Hamilton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-30 00:00:00.000000000Z
+dependencies: []
+description: A tiny finite-state automata library.
+email: justinanthonyhamilton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- baby_bots.gemspec
+- lib/baby_bots.rb
+- lib/baby_bots/baby_bot.rb
+- lib/baby_bots/state.rb
+- lib/baby_bots/version.rb
+homepage: https://github.com/jamiltron/BabyBots
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: While there are many fsa libraries out there, I wanted to implement my own
+  so I could learn how to create a module/gem, as I am not really a Ruby guy and have
+  no idea how.
+test_files: []