hifsm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e43ef721bec5c9d473610831836bf1531ae5c782
+  data.tar.gz: c6396a4f8ecd0f81c2963a84685bdae93a1dae3c
+SHA512:
+  metadata.gz: 6c586dba477b583fd85e1bb4eedac0df1610af363d178569645f51a0aa4820c385edd21709149d3dce2a997f95d847ece2a6cbf3a96b864582b01d7f689b8be5
+  data.tar.gz: 90ffecc59fc1bf1a8af8cf54c2a70cf7c48a52a6a37ae84bf3ce92da72a89102449d94688c63ece647c42987d10fafb60ee063feecd6612decdd9d00a01db52c

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,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Vladimir Meremyanin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,187 @@
+# Hierarchical Finite State Machine in Ruby
+
+This library was created from the desire to have nested states inspired by [rFSM](https://github.com/kmarkus/rFSM).
+
+It can be used in plain old ruby objects, but works well with `ActiveRecord`s too.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hifsm'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hifsm
+
+I prefer 1.8-style hashes, and since no advanced Ruby magic used it should work in 1.8, but only tested in 2+.
+
+__This is in early development, so be careful.__
+
+## Features
+
+* Easy to use
+* Any number of state machines per object
+* Nested states
+* Parameterised events
+* Support of both Mealy and Moore machines
+* Lightweight and non-obtrusive
+
+## Usage
+
+Here is how to use it to model a monster in a Quake-like game. It covers most Hifsm features:
+
+```ruby
+require 'hifsm'
+
+class Monster
+  @@fsm = Hifsm::FSM.define do
+    state :idle, :initial => true
+    state :attacking do
+      state :acquiring_target, :initial => true do
+        action do
+          # self is the monster instance here
+          plan_attack
+        end
+      end
+      state :pursuing do
+        before_enter do
+          self.roar!
+        end
+        action do
+          step_towards target
+        end
+      end
+      state :fighting do
+        action do
+          hit target
+        end
+      end
+
+      event :acquire, :from => :acquiring_target, :to => :pursuing
+      event :reached, :from => :pursuing, :to => :fighting
+
+      action do |tick|
+        debug && puts("#{tick}: Attack!")
+      end
+    end
+    state :coming_back do
+      action do
+        step_towards @home
+      end
+    end
+    state :runaway
+
+    event :sight, :from => [:idle, :coming_back], :to => :runaway, :guard => :low_hp?
+    event :sight, :from => [:idle, :coming_back], :to => :attacking do
+      before do |t|
+        debug && puts("Setting target to #{t}")
+        self.target = t
+      end
+    end
+    event :enemy_dead, :from => :attacking, :to => :coming_back do
+      after do
+        debug && puts("Woohoo!")
+        self.target = nil
+      end
+    end
+  end
+
+  attr_accessor :target, :low_hp, :debug
+  attr_reader :state
+
+  def initialize
+    @debug = false
+    @home = 'home'
+    @state = @@fsm.new(self) # or @@fsm.new(self, 'attacking.pursuing')
+    @tick = 1
+    @low_hp = false
+  end
+
+  def act!
+    debug && puts("Acting @#{@state}")
+    @state.act!(@tick)
+    @tick = @tick + 1
+  end
+
+  def hit(target)
+    debug && puts("~~> #{target}")
+  end
+
+  def low_hp?
+    @low_hp
+  end
+
+  def plan_attack
+    debug && puts("planning...")
+    acquire
+  end
+
+  def roar!
+    debug && puts("AARGHH!")
+  end
+
+  def step_towards(target)
+    debug && puts("step step #{target}")
+  end
+
+end
+
+ogre = Monster.new
+ogre.debug = true       # Console output:
+ogre.act!               # -> Acting @idle
+ogre.sight 'player'     # -> Setting target to player
+ogre.act!               # -> Acting @attacking.acquiring_target
+                        # -> planning...
+                        # -> AARGHH!
+# ogre.acquire        -> Hifsm::MissingTransition, already acquired in act!
+ogre.act!               # -> Acting @attacking.pursuing
+                        # -> step step player
+ogre.enemy_dead         # -> Woohoo!
+ogre.act!               # -> Acting @coming_back
+
+ogre.sight 'player2'    # -> Setting target to player2
+ogre.acquire            # -> AARGHH!
+ogre.act!               # -> Acting @attacking.pursuing
+                        # -> step step player2
+ogre.reached
+puts ogre.state         # -> attacking.fighting
+ogre.act!               # -> ~~> player2
+5.times { ogre.act! }   # -> ...
+ogre.enemy_dead         # -> Woohoo!
+ogre.act!               # -> Acting @coming_back
+                        # -> step step home
+
+```
+
+## Guards
+
+Events are tried in order they were defined, if guard callback returns `false` then event is skipped.
+
+## Callbacks
+
+On event:
+
+* event.before
+* to_state.before_enter
+* from_state.before_exit
+* *state changes*
+* from_state.after_exit
+* to_state.after_enter
+* event.after
+
+If `before...` callback returns Hifsm.cancel then no further processing is done
+
+On `act!` just calls action block if it was given.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push 'test'
+  t.pattern = "test/test_*.rb"
+end

data/hifsm.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hifsm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hifsm"
+  spec.version       = Hifsm::VERSION
+  spec.authors       = ["Vladimir Meremyanin"]
+  spec.email         = ["vladimir@meremyanin.com"]
+  spec.description   = %q{FSM with support for nested states and parameterised events}
+  spec.summary       = %q{Hierarchical state machines in Ruby}
+  spec.homepage      = "http://github.com/stiff/hifsm"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/lib/hifsm/callbacks.rb

@@ -0,0 +1,27 @@
+class Callbacks
+
+  class <<self
+    def invoke(target, cb, *args)
+      if cb.nil?
+      elsif cb.is_a? Symbol
+        target.send(cb, *args)
+      else
+        target.instance_exec *args, &cb
+      end
+    end
+  end
+
+  def initialize
+    @listeners = []
+  end
+
+  def add(&callback)
+    @listeners.push callback
+  end
+
+  def trigger(target, *args)
+    @listeners.each do |callback|
+      Callbacks.invoke target, callback, *args
+    end
+  end
+end

data/lib/hifsm/event.rb

@@ -0,0 +1,27 @@
+module Hifsm
+  class Event
+    CALLBACKS = [:before, :after].freeze
+
+    attr_reader :name, :to
+
+    def initialize(name, to, guard)
+      @name = name
+      @guard = guard
+      @to = to
+
+      @callbacks = Hash.new {|h, key| h[key] = Callbacks.new }
+    end
+
+    CALLBACKS.each do |cb|
+      define_method(cb) { |&block| @callbacks[cb].add(&block) }
+    end
+
+    def trigger(target, cb, *args)
+      @callbacks[cb].trigger(target, *args)
+    end
+
+    def guard?(target)
+      !@guard || Callbacks.invoke(target, @guard)
+    end
+  end
+end

data/lib/hifsm/fsm.rb

@@ -0,0 +1,58 @@
+module Hifsm
+  class FSM
+    attr_reader :states, :transitions
+
+    class <<self
+      def define(&block)
+        Hifsm::FSM.new(&block)
+      end
+    end
+
+    def initialize(parent = nil, &block)
+      @parent = parent
+      @states = {}
+      @initial_state
+
+      instance_eval &block if block
+    end
+
+    def new(target = nil, initial_state = nil)
+      Hifsm::Machine.new(target, self, initial_state)
+    end
+
+    def all_events
+      @states.collect {|name, st| st.events }.flatten.uniq
+    end
+
+    def initial_state!
+      @initial_state || raise(Hifsm::MissingState.new("<initial>"))
+    end
+
+    def get_state!(name)
+      @states[name.to_s] || raise(Hifsm::MissingState.new(name.to_s))
+    end
+
+    def event(name, options, &block)
+      ev = Hifsm::Event.new(name, get_state!(options[:to]), options[:guard])
+      from_states = array_wrap(options[:from])
+      from_states = @states.keys if from_states.empty?
+      from_states.each do |from|
+        st = get_state!(from)
+        st.add_transition(ev)
+      end
+      ev.instance_eval &block if block
+    end
+
+    def state(name, options = {}, &block)
+      st = @states[name.to_s] = Hifsm::State.new(name, @parent)
+      @initial_state = st if options[:initial]
+      st.instance_eval &block if block
+    end
+
+    private
+      # like in ActiveSupport
+      def array_wrap(anything)
+        anything.is_a?(Array) ? anything : [anything].compact
+      end
+  end
+end

data/lib/hifsm/machine.rb

@@ -0,0 +1,35 @@
+module Hifsm
+  class Machine
+    def initialize(target, fsm, initial_state = nil)
+      @target = target || self
+      @fsm = fsm
+
+      @state = fsm.states[initial_state] || fsm.initial_state!
+
+      mach = self
+      fsm.all_events.each do |event_name, event|
+        @target.singleton_class.instance_exec do
+          define_method(event_name) {|*args| mach.fire(event_name, *args) }
+        end
+      end
+    end
+
+    def act!(*args)
+      @state.act!(@target, *args)
+    end
+
+    def state
+      @state.to_s
+    end
+
+    def fire(event, *args)
+      @state.fire(@target, event, *args) do |new_state|
+        @state = new_state
+      end
+    end
+
+    def to_s
+      @state.to_s
+    end
+  end
+end

data/lib/hifsm/state.rb

@@ -0,0 +1,93 @@
+module Hifsm
+  class State
+    CALLBACKS = [:before_enter, :before_exit, :after_enter, :after_exit].freeze
+
+    def initialize(name, parent = nil)
+      @name = name
+      @parent = parent
+      @action
+
+      @callbacks = Hash.new {|h, key| h[key] = Callbacks.new }
+      @transitions = Hash.new {|h, key| h[key] = Array.new }
+    end
+
+    def add_transition(ev)
+      name = ev.name.to_s
+      @transitions[name].push ev
+    end
+
+    def action(&block)
+      @action = block
+    end
+
+    def state(*args, &block)
+      sub_fsm!.state *args, &block
+    end
+
+    def event(*args, &block)
+      sub_fsm!.event *args, &block
+    end
+
+    def events
+      @transitions.keys + (@sub_fsm && @sub_fsm.all_events || [])
+    end
+
+    def fire(target, event_name, *args, &new_state_callback)
+      event_name = event_name.to_s
+      @transitions[event_name].each do |ev|
+        if ev.guard?(target)
+          from_state = self
+          to_state = ev.to
+          if ev.trigger(target, :before, *args) &&
+              to_state.trigger(target, :before_enter, *args) &&
+              from_state.trigger(target, :before_exit, *args)
+            new_state_callback.call(to_state.enter!)
+            from_state.trigger(target, :after_exit, *args)
+            to_state.trigger(target, :after_enter, *args)
+            ev.trigger(target, :after, *args)
+          end
+          return
+        end
+      end
+      if @parent
+        return @parent.fire(target, event_name, *args, &new_state_callback)
+      end
+      raise Hifsm::MissingTransition.new(to_s, event_name)
+    end
+
+    CALLBACKS.each do |cb|
+      define_method(cb) { |&block| @callbacks[cb].add(&block) }
+    end
+
+    def trigger(target, cb, *args)
+      @callbacks[cb].trigger(target, *args)
+    end
+
+    def act!(target, *args)
+      @action && Callbacks.invoke(target, @action, *args)
+      if @sub_fsm
+      end
+    end
+
+    def enter!
+      if @sub_fsm
+        @sub_fsm.initial_state!
+      else
+        self
+      end
+    end
+
+    def to_s
+      if @parent
+        "#{@parent.to_s}.#{@name.to_s}"
+      else
+        @name.to_s
+      end
+    end
+
+    private
+      def sub_fsm!
+        @sub_fsm ||= Hifsm::FSM.new(self)
+      end
+  end
+end

data/lib/hifsm/version.rb

@@ -0,0 +1,3 @@
+module Hifsm
+  VERSION = "0.1.0"
+end

data/lib/hifsm.rb

@@ -0,0 +1,21 @@
+require "hifsm/callbacks"
+require "hifsm/fsm"
+require "hifsm/event"
+require "hifsm/machine"
+require "hifsm/state"
+require "hifsm/version"
+
+module Hifsm
+  class MissingTransition < StandardError
+    def initialize(state, name)
+      super "No transition :#{name} from :#{state}"
+    end
+  end
+
+  class MissingState < StandardError
+    def initialize(name)
+      super "No state :#{name} defined"
+    end
+  end
+
+end

data/test/minitest_helper.rb

@@ -0,0 +1,4 @@
+require 'hifsm'
+
+gem 'minitest'
+require 'minitest/autorun'

data/test/monster.rb

@@ -0,0 +1,121 @@
+require 'hifsm'
+
+class Monster
+  @@fsm = Hifsm::FSM.define do
+    state :idle, :initial => true
+    state :attacking do
+      state :acquiring_target, :initial => true do
+        action do
+          # self is the monster instance here
+          plan_attack
+        end
+      end
+      state :pursuing do
+        before_enter do
+          self.roar!
+        end
+        action do
+          step_towards target
+        end
+      end
+      state :fighting do
+        action do
+          hit target
+        end
+      end
+
+      event :acquire, :from => :acquiring_target, :to => :pursuing
+      event :reached, :from => :pursuing, :to => :fighting
+
+      action do |tick|
+        debug && puts("#{tick}: Attack!")
+      end
+    end
+    state :coming_back do
+      action do
+        step_towards @home
+      end
+    end
+    state :runaway
+
+    event :sight, :from => [:idle, :coming_back], :to => :runaway, :guard => :low_hp?
+    event :sight, :from => [:idle, :coming_back], :to => :attacking do
+      before do |t|
+        debug && puts("Setting target to #{t}")
+        self.target = t
+      end
+    end
+    event :enemy_dead, :from => :attacking, :to => :coming_back do
+      after do
+        debug && puts("Woohoo!")
+        self.target = nil
+      end
+    end
+  end
+
+  attr_accessor :target, :low_hp, :debug
+  attr_reader :state
+
+  def initialize
+    @debug = false
+    @home = 'home'
+    @state = @@fsm.new(self) # or @@fsm.new(self, 'attacking.pursuing')
+    @tick = 1
+    @low_hp = false
+  end
+
+  def act!
+    debug && puts("Acting @#{@state}")
+    @state.act!(@tick)
+    @tick = @tick + 1
+  end
+
+  def hit(target)
+    debug && puts("~~> #{target}")
+  end
+
+  def low_hp?
+    @low_hp
+  end
+
+  def plan_attack
+    debug && puts("planning...")
+    acquire
+  end
+
+  def roar!
+    debug && puts("AARGHH!")
+  end
+
+  def step_towards(target)
+    debug && puts("step step #{target}")
+  end
+
+end
+
+if $0 == __FILE__
+  ogre = Monster.new
+  ogre.debug = true       # Console output:
+  ogre.act!               # -> Acting @idle
+  ogre.sight 'player'     # -> Setting target to player
+  ogre.act!               # -> Acting @attacking.acquiring_target
+                          # -> planning...
+                          # -> AARGHH!
+  # ogre.acquire        -> Hifsm::MissingTransition, already acquired in act!
+  ogre.act!               # -> Acting @attacking.pursuing
+                          # -> step step player
+  ogre.enemy_dead         # -> Woohoo!
+  ogre.act!               # -> Acting @coming_back
+
+  ogre.sight 'player2'    # -> Setting target to player2
+  ogre.acquire            # -> AARGHH!
+  ogre.act!               # -> Acting @attacking.pursuing
+                          # -> step step player2
+  ogre.reached
+  puts ogre.state         # -> attacking.fighting
+  ogre.act!               # -> ~~> player2
+  5.times { ogre.act! }   # -> ...
+  ogre.enemy_dead         # -> Woohoo!
+  ogre.act!               # -> Acting @coming_back
+                          # -> step step home
+end

data/test/setup_tests.rb

@@ -0,0 +1,2 @@
+require "minitest/autorun"
+require "hifsm"

data/test/test_any_state_event.rb

@@ -0,0 +1,28 @@
+require 'setup_tests'
+
+class TestAnyStateEvent < Minitest::Test
+  def setup
+    @fsm = Hifsm::FSM.define do
+      state :off, :initial => true
+      state :on
+      state :halt
+
+      event :toggle, :from => :off, :to => :on
+      event :toggle, :from => :on, :to => :off
+      event :halt, :to => :halt
+    end
+    @machine = @fsm.new
+  end
+
+  def test_halt_from_off
+    @machine.halt
+    assert_equal 'halt', @machine.state
+  end
+
+  def test_halt_from_on
+    @machine.toggle
+    @machine.halt
+    assert_equal 'halt', @machine.state
+  end
+
+end

data/test/test_basic_fsm.rb

@@ -0,0 +1,29 @@
+require 'setup_tests'
+
+class TestBasicFSM < Minitest::Test
+  def setup
+    @fsm = Hifsm::FSM.define do
+      state :off, :initial => true
+      state :on
+
+      event :toggle, :from => :off, :to => :on
+      event :toggle, :from => :on, :to => :off
+    end
+    @machine = @fsm.new
+  end
+
+  def test_initial_state_is_off
+    assert_equal 'off', @machine.state
+  end
+
+  def test_toggle_switches_state_to_on
+    @machine.toggle
+    assert_equal 'on', @machine.state
+  end
+
+  def test_toggle_twice_switches_state_back_to_off
+    @machine.toggle
+    @machine.toggle
+    assert_equal 'off', @machine.state
+  end
+end

data/test/test_event_guard.rb

@@ -0,0 +1,28 @@
+require 'setup_tests'
+
+class TestEventGuard < Minitest::Test
+  def setup
+    @wall = Struct.new(:stones).new(10)
+
+    @fsm = Hifsm::FSM.define do
+      state :constructed, :initial => true
+      state :broken
+
+      event :break, :from => :constructed, :to => :broken, :guard => proc { stones < 5 }
+    end
+    @machine = @fsm.new(@wall)
+  end
+
+  def test_cant_break_wall_10_stones_thick
+    assert_raises(Hifsm::MissingTransition) do
+      @wall.break
+    end
+  end
+
+  def test_cant_break_thin_wall
+    @wall.stones = 3
+    @wall.break
+    assert_equal 'broken', @machine.state
+  end
+
+end

data/test/test_monster.rb

@@ -0,0 +1,44 @@
+require 'setup_tests'
+require 'monster'
+
+class TestMonster < Minitest::Test
+  def setup
+    @monster = Monster.new
+  end
+
+  def test_initial_state_is_idle
+    assert_equal 'idle', @monster.state.to_s
+  end
+
+  def test_acting_from_idle_state
+    @monster.act!
+    pass
+  end
+
+  def test_will_attack_player_on_sight_if_alot_hp
+    @monster.sight 'player'
+    assert_equal 'attacking.acquiring_target', @monster.state.to_s
+    assert_equal 'player', @monster.target
+  end
+
+  def test_will_runaway_on_sight_if_low_hp
+    @monster.low_hp = true
+    @monster.sight 'player'
+    assert_equal 'runaway', @monster.state.to_s
+    assert_nil @monster.target
+  end
+
+  def test_will_pursue_player_on_acquire
+    @monster.sight 'player'
+    @monster.acquire
+    assert_equal 'attacking.pursuing', @monster.state.to_s
+  end
+
+  def test_kill_in_middle_of_attack
+    @monster.sight 'player'
+    @monster.acquire
+    @monster.enemy_dead
+    assert_equal 'coming_back', @monster.state.to_s
+  end
+
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: hifsm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vladimir Meremyanin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: FSM with support for nested states and parameterised events
+email:
+- vladimir@meremyanin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hifsm.gemspec
+- lib/hifsm.rb
+- lib/hifsm/callbacks.rb
+- lib/hifsm/event.rb
+- lib/hifsm/fsm.rb
+- lib/hifsm/machine.rb
+- lib/hifsm/state.rb
+- lib/hifsm/version.rb
+- test/minitest_helper.rb
+- test/monster.rb
+- test/setup_tests.rb
+- test/test_any_state_event.rb
+- test/test_basic_fsm.rb
+- test/test_event_guard.rb
+- test/test_monster.rb
+homepage: http://github.com/stiff/hifsm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Hierarchical state machines in Ruby
+test_files:
+- test/minitest_helper.rb
+- test/monster.rb
+- test/setup_tests.rb
+- test/test_any_state_event.rb
+- test/test_basic_fsm.rb
+- test/test_event_guard.rb
+- test/test_monster.rb