hifsm 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25b5e3332cdc03d7cdc7efee6fa52b83a2a85881
-  data.tar.gz: 52f1ffd9779265883292b018ed76ee480032cbf5
+  metadata.gz: 2dd540fa33580b8e82c96d82a1746aa5016ab3c6
+  data.tar.gz: ab0492f94873e14a2f75d1e3fd32ae764ed652c1
 SHA512:
-  metadata.gz: ecec06c7780e4ab19a6c98fa6191d5a3aeea238ba5c790d0b9a3a02a87b68838ec36c166bbdec15f8d75f9d125d0197f6b79d1833f2e1bcb73f96b110df702e2
-  data.tar.gz: 4e113ea01e29154d6cf2b62a08243a0b7a4054a9c254f59dffc468874f94b843e94c7586de327d0743dfda2c2f98c0e6f775c6168a968011ec3ef62f9d3d20c7
+  metadata.gz: 258cd2e2f5a18942a0ee40a96779246ba0b99adc4659834460ac482f96882cef9c2d5ca4f7e49301df4cb759ea12f4969a8f2aeb00554af5f092664c419b089e
+  data.tar.gz: 56cf2f726e53af3fdfa98067030448cbcd86a9306937e30d3ab75ab0c35bfc24246371df1fb1b7e202c7ccf54a443762bb1e126582d2462f36c5139438a244f7

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.0
+gemfile:
+  - Gemfile
+script: "bundle exec rake test"

data/README.md

@@ -1,5 +1,8 @@
 # Hierarchical Finite State Machine in Ruby
 
+[![Build Status](https://travis-ci.org/stiff/hifsm.svg?branch=master)](https://travis-ci.org/stiff/hifsm)
+[![Coverage Status](https://coveralls.io/repos/stiff/hifsm/badge.png?branch=master)](https://coveralls.io/r/stiff/hifsm?branch=master)
+
 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.
@@ -39,7 +42,7 @@ Here is how to use it to model a monster in a Quake-like game. It covers most Hi
 require 'hifsm'
 
 class Monster
-  @@fsm = Hifsm::FSM.new do
+  include Hifsm.fsm_module {
     state :idle, :initial => true
     state :attacking do
       state :acquiring_target, :initial => true do
@@ -89,22 +92,20 @@ class Monster
         self.target = nil
       end
     end
-  end
+  }
 
   attr_accessor :target, :low_hp, :debug
-  attr_reader :state
 
   def initialize
     @debug = false
     @home = 'home'
-    @state = @@fsm.instantiate(self) # or @@fsm.instantiate(self, 'attacking.pursuing')
     @tick = 1
     @low_hp = false
   end
 
   def act!
-    debug && puts("Acting @#{@state}")
-    @state.act!(@tick)
+    debug && puts("Acting @#{state}")
+    state_machine.act! @tick
     @tick = @tick + 1
   end
 
@@ -132,35 +133,43 @@ class Monster
 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.debug = true       ### Console output:
+ogre.act!               # Acting @idle
+ogre.sight 'player'     # Setting target to player
+ogre.act!               # Acting @attacking.acquiring_target
+                        # 2: Attack!     <- parent state act! first
+                        # 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.act!               # Acting @attacking.pursuing
+                        # 3: Attack!
+                        # step step player
+ogre.enemy_dead         # Woohoo!
+ogre.act!               # Acting @coming_back
+                        # step step home
+
+ogre.sight 'player2'    # Setting target to player2
+ogre.acquire            # AARGHH!
+ogre.act!               # Acting @attacking.pursuing
+                        # 5: Attack!
+                        # 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
+puts ogre.state         # attacking.fighting
+ogre.act!               # Acting @attacking.fighting
+                        # 6: Attack!
+                        # ~~> player2
+5.times { ogre.act! }   # ...
+ogre.enemy_dead         # Woohoo!
+ogre.act!               # Acting @coming_back
+                        # step step home
 ogre.low_hp = true
 ogre.sight 'player3'
-ogre.act!               # -> Acting @runaway
+ogre.act!               # Acting @runaway
 
 ```
 
+Note the use of `{..}` construct instead of `do..end` in `include`. `do..end` is treated as block for include itself, instead of `fsm_module`.
+
 ## Guards
 
 Events are tried in order they were defined, if guard callback returns `false` then event is skipped.
@@ -181,6 +190,29 @@ If any of `before...` callbacks returns `false` then no further processing is do
 
 On `act!` just calls action block if it was given.
 
+## ActiveRecord integration
+
+Add column to your database which would hold the state, and then:
+
+```ruby
+class Order < ActiveRecord::Base
+  hifsm do
+    state :draft, :initial => true
+    state :processing do
+      state :packaging, :initial => true
+      state :delivering
+    end
+    state :done
+    state :cancelled
+
+    event :start_processing, :from => :draft, :to => :processing
+    event :cancel, :to => :cancelled
+  end
+end
+Order.new # draft
+
+```
+
 ## Testing
 
 Only 'public' API is unit-tested, internal implementation may be freely changed, so don't rely on it.

data/hifsm.gemspec

@@ -21,4 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
 end

data/lib/hifsm/adapters/active_record_adapter.rb

@@ -0,0 +1,34 @@
+module Hifsm
+  module Adapters
+    module ActiveRecordAdapter
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def hifsm(column, &block)
+          include Hifsm.fsm_module(column, &block)
+          before_save "hifsm_write_#{column}_attribute"
+
+          define_method "#{column}=" do |value|
+            raise 'not (sure will be) implemented'
+          end
+
+          define_method "initial_#{column}" do
+            read_attribute(column)
+          end
+
+          define_method "hifsm_write_#{column}_attribute" do
+            write_attribute(column, send(column))
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include Hifsm::Adapters::ActiveRecordAdapter
+end

data/lib/hifsm/fsm.rb

@@ -1,17 +1,26 @@
 module Hifsm
+
+  # This class holds immutable state machine definition
   class FSM
-    attr_reader :states, :transitions
+    attr_reader :name, :states, :transitions
 
-    def initialize(parent = nil, &block)
+    def initialize(name = :state, parent = nil, &block)
+      @name = name
       @parent = parent
       @states = {}
       @initial_state = nil
 
       instance_eval(&block) if block
+
+      @fsm_module = fsm_module = initialize_module
+      @machine_class = Class.new(Hifsm::Machine) do
+        include fsm_module
+        define_method("#{name}_machine") { self }
+      end
     end
 
     def instantiate(target = nil, initial_state = nil)
-      Hifsm::Machine.new(self, target, initial_state)
+      @machine_class.new(self, target, initial_state)
     end
 
     def all_events
@@ -44,15 +53,48 @@ module Hifsm
     end
 
     def state(name, options = {}, &block)
-      st = @states[name.to_s] = Hifsm::State.new(name, @parent)
+      st = @states[name.to_s] = Hifsm::State.new(self, name, @parent)
       @initial_state = st if options[:initial]
       st.instance_eval(&block) if block
     end
 
+    def to_module
+      @fsm_module
+    end
+
     private
       # like in ActiveSupport
       def array_wrap(anything)
         anything.is_a?(Array) ? anything : [anything].compact
       end
+
+      def initialize_module
+        fsm = self  # capture self
+        machine_var = "@#{name}_machine"
+        machine_name = "#{name}_machine"
+
+        Module.new.module_exec do
+
+          # <state>_machine returns machine instance
+          define_method(machine_name) do
+            if instance_variable_defined?(machine_var)
+              instance_variable_get(machine_var)
+            else
+              machine = fsm.instantiate(self)
+              instance_variable_set(machine_var, machine)
+            end
+          end
+
+          # <state> returns string representation of the current state
+          define_method(fsm.name) { send(machine_name).to_s }
+
+          # <event> fires event
+          fsm.all_events.each do |event_name, event|
+            define_method(event_name) {|*args| send(machine_name).fire(event_name, *args) }
+          end
+
+          self  # return module
+        end
+      end
   end
 end

data/lib/hifsm/machine.rb

@@ -1,17 +1,16 @@
 module Hifsm
+  # This is just a storage of current state
   class Machine
     def initialize(fsm, target, initial_state = nil)
       @target = target || self
       @fsm = fsm
 
-      @state = (initial_state && fsm.get_state!(initial_state) || fsm.initial_state!).enter!
+      initial_state_method_name = "initial_#{fsm.name}"
+      initial_state ||= target.send(initial_state_method_name) if target.respond_to?(initial_state_method_name)
+      initial_state &&= fsm.get_state!(initial_state)
+      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
+      @state = initial_state.enter!
     end
 
     def act!(*args)

data/lib/hifsm/state.rb

@@ -2,7 +2,8 @@ module Hifsm
   class State
     CALLBACKS = [:before_enter, :before_exit, :after_enter, :after_exit].freeze
 
-    def initialize(name, parent = nil)
+    def initialize(fsm, name, parent = nil)
+      @fsm = fsm
       @name = name
       @parent = parent
       @action = nil
@@ -92,7 +93,8 @@ module Hifsm
 
     private
       def sub_fsm!
-        @sub_fsm ||= Hifsm::FSM.new(self)
+        # FIXME too much coupling
+        @sub_fsm ||= Hifsm::FSM.new(@fsm.name, self)
       end
   end
 end

data/lib/hifsm/version.rb

@@ -1,3 +1,3 @@
 module Hifsm
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/hifsm.rb

@@ -18,4 +18,15 @@ module Hifsm
     end
   end
 
+  class <<self
+    def fsm_module(name = :state, &block)
+      FSM::new(name, &block).to_module
+    end
+  end
+end
+
+begin
+  require 'active_record'
+  require 'hifsm/adapters/active_record_adapter'
+rescue LoadError
 end

data/test/monster.rb

@@ -1,7 +1,7 @@
 require 'hifsm'
 
 class Monster
-  @@fsm = Hifsm::FSM.new do
+  include Hifsm.fsm_module {
     state :idle, :initial => true
     state :attacking do
       state :acquiring_target, :initial => true do
@@ -51,22 +51,20 @@ class Monster
         self.target = nil
       end
     end
-  end
+  }
 
   attr_accessor :target, :low_hp, :debug
-  attr_reader :state
 
   def initialize
     @debug = false
     @home = 'home'
-    @state = @@fsm.instantiate(self) # or @@fsm.instantiate(self, 'attacking.pursuing')
     @tick = 1
     @low_hp = false
   end
 
   def act!
-    debug && puts("Acting @#{@state}")
-    @state.act!(@tick)
+    debug && puts("Acting @#{state}")
+    state_machine.act! @tick
     @tick = @tick + 1
   end
 
@@ -95,30 +93,36 @@ 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.debug = true       ### Console output:
+  ogre.act!               # Acting @idle
+  ogre.sight 'player'     # Setting target to player
+  ogre.act!               # Acting @attacking.acquiring_target
+                          # 2: Attack!     <- parent state act! first
+                          # 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.act!               # Acting @attacking.pursuing
+                          # 3: Attack!
+                          # step step player
+  ogre.enemy_dead         # Woohoo!
+  ogre.act!               # Acting @coming_back
+                          # step step home
 
-  ogre.sight 'player2'    # -> Setting target to player2
-  ogre.acquire            # -> AARGHH!
-  ogre.act!               # -> Acting @attacking.pursuing
-                          # -> step step player2
+  ogre.sight 'player2'    # Setting target to player2
+  ogre.acquire            # AARGHH!
+  ogre.act!               # Acting @attacking.pursuing
+                          # 5: Attack!
+                          # 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
+  puts ogre.state         # attacking.fighting
+  ogre.act!               # Acting @attacking.fighting
+                          # 6: Attack!
+                          # ~~> player2
+  5.times { ogre.act! }   # ...
+  ogre.enemy_dead         # Woohoo!
+  ogre.act!               # Acting @coming_back
+                          # step step home
   ogre.low_hp = true
   ogre.sight 'player3'
-  ogre.act!               # -> Acting @runaway
+  ogre.act!               # Acting @runaway
 end

data/test/setup_tests.rb

@@ -1,2 +1,6 @@
+require 'coveralls'
+Coveralls.wear! do
+  add_filter 'test'
+end
 require "minitest/autorun"
 require "hifsm"

data/test/test_activerecord_adapter.rb

@@ -0,0 +1,80 @@
+require 'setup_tests'
+require 'active_record'
+
+class TestActiverecrodAdapter < Minitest::Test
+  class SodaMachine < ActiveRecord::Base
+    hifsm :state do
+      state :off, :initial => true
+      state :on do
+        state :idle, :initial => true
+        state :accepting_cash
+        state :cooking
+        state :ready
+
+        event :done, :from => :accepting_cash, :to => :cooking
+        event :done, :from => :cooking, :to => :ready
+        event :done, :from => :ready, :to => :idle do
+          after { self.counter += 1 }
+        end
+      end
+      state :broken
+
+      event :toggle_power, :from => :off, :to => :on
+      event :toggle_power, :from => :on, :to => :off
+      event :break, :to => :broken
+    end
+  end
+
+  def setup
+    ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+    ActiveRecord::Base.connection.create_table :soda_machines do |t|
+      t.column :address, :string
+      t.column :state, :string
+      t.column :counter, :integer, :null => false, :default => 0
+    end
+
+    insert_record 'South Park', 'on.idle'
+    insert_record 'Springfield', 'broken'
+  end
+
+  def teardown
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  def test_hifsm_installed
+    @machine = SodaMachine.create
+    assert @machine.state_machine.is_a?(Hifsm::Machine), ".state should be Hifsm::Mahine"
+  end
+
+  def test_new_machines_saved_in_initial_state
+    @machine = SodaMachine.create
+    assert_equal 'off', @machine.state_machine.state
+    assert_equal 'off', @machine.state
+  end
+
+  def test_state_fetched_from_db
+    @machine = SodaMachine.where(:address => 'South Park').first
+    assert_equal 'on.idle', @machine.state.to_s
+  end
+
+  def test_events_defined_on_record
+    @machine = SodaMachine.first
+    @machine.toggle_power.save
+    pass # assert_nothing_raised
+  end
+
+  def test_state_saved_in_db
+    @machine = SodaMachine.where(:address => 'South Park').first
+    @machine.toggle_power.save
+    assert_equal 'off', SodaMachine.where(:id => @machine.id).pluck(:state).first
+  end
+
+  private
+    def insert_record(address, state)
+      insert_manager = Arel::InsertManager.new(SodaMachine)
+      insert_manager.insert([[SodaMachine.arel_table[:address], address], [SodaMachine.arel_table[:state], state]])
+      ActiveRecord::Base.connection.insert insert_manager
+    end
+
+end
+

data/test/test_basic_fsm.rb

@@ -26,4 +26,11 @@ class TestBasicFSM < Minitest::Test
     @machine.toggle
     assert_equal 'off', @machine.state
   end
+
+  def test_instantiating_maching_in_unknown_state_raises_error
+    assert_raises(Hifsm::MissingState) do
+      @fsm.instantiate(nil, 'on.no')
+    end
+  end
+
 end

data/test/test_dynamic_initial_state.rb

@@ -0,0 +1,51 @@
+require 'setup_tests'
+
+class TestDynamicInitialState < Minitest::Test
+  class Value < Struct.new(:value)
+    include Hifsm.fsm_module(:group) {
+      state :few do
+        state :very
+        state :almost
+      end
+      state :lots do
+        state :very
+        state :almost, :initial => true
+      end
+      state :throng
+      state :swarm
+    }
+
+    def initial_group
+      case value
+      when 1..5 then 'few.very'
+      when 5..10 then 'few.almost'
+      when 10..50 then :lots
+      when 50..150 then :throng
+      when 150..1000 then :swarm
+      else :unknown
+      end
+    end
+  end
+
+  def test_initial_group_3
+    assert_equal 'few.very', Value.new(3).group
+  end
+
+  def test_initial_group_7
+    assert_equal 'few.almost', Value.new(7).group
+  end
+
+  def test_initial_group_30
+    assert_equal 'lots.almost', Value.new(30).group
+  end
+
+  def test_initial_group_120
+    assert_equal 'throng', Value.new(120).group
+  end
+
+  def test_unknown_intiial_group
+    assert_raises(Hifsm::MissingState) do
+      Value.new(-3).group
+    end
+  end
+end

data/test/test_event_guard.rb

@@ -1,31 +1,39 @@
 require 'setup_tests'
 
 class TestEventGuard < Minitest::Test
-  Wall = Struct.new(:stones)
-
-  def build_wall(thickness)
-    fsm = Hifsm::FSM.new do
+  class Wall < Struct.new(:stones)
+    include Hifsm.fsm_module {
       state :constructed, :initial => true
       state :broken
 
+      # guards can be inline proc, or symbols
       event :break, :from => :constructed, :to => :broken, :guard => proc { stones < 5 }
+
+      # event parameters are passed to guards only if arity > 0
+      event :shoot, :from => :constructed, :to => :broken, :guard => :breakable?
+    }
+    def breakable?(hits)
+      hits * 5 > stones
     end
-    wall = Wall.new(thickness)
-    @machine = fsm.instantiate(wall)
-    wall
+  end
+
+  def test_can_break_thin_wall
+    wall = Wall.new(3)
+    wall.break
+    assert_equal 'broken', wall.state
   end
 
   def test_cant_break_wall_10_stones_thick
-    wall = build_wall 10
+    wall = Wall.new(10)
     assert_raises(Hifsm::MissingTransition) do
       wall.break
     end
   end
 
-  def test_cant_break_thin_wall
-    wall = build_wall 3
-    wall.break
-    assert_equal 'broken', @machine.state
+  def test_can_break_thick_wall_if_hit_3_times
+    wall = Wall.new(10)
+    wall.shoot 3
+    assert_equal 'broken', wall.state
   end
 
 end

data/test/test_ifless_factorial.rb

@@ -1,30 +1,27 @@
 require 'setup_tests'
 
 class TestIflessFactorial < Minitest::Test
-  Value = Struct.new(:value)
-
-  def setup
-    @fsm = Hifsm::FSM.new do
+  class Value < Struct.new(:value)
+    include Hifsm.fsm_module {
       state :idle, :initial => true
-      state :counting
+      state :computing
 
-      event :count, :to => :idle do
+      event :compute, :to => :idle do
         guard { |x| x == 0 }
         after { |x| self.value = 1 }
       end
-      event :count, :to => :counting do
+      event :compute, :to => :computing do
         after do |x|
-          count(x - 1)
+          compute(x - 1)
           self.value *= x
         end
       end
-    end
+    }
   end
 
   def factorial(n)
     val = Value.new
-    @fsm.instantiate(val)
-    val.count(n).value
+    val.compute(n).value
   end
 
   def test_factorial_0

data/test/test_two_machines.rb

@@ -0,0 +1,41 @@
+require 'setup_tests'
+
+class TestTwoMachines < Minitest::Test
+  class ColorPrinter
+    include Hifsm.fsm_module(:working_state) {
+      state :off, :initial => true
+      state :on do
+        action do
+          color_machine.to_s
+        end
+      end
+
+      event :toggle, :from => :off, :to => :on
+      event :toggle, :from => :on, :to => :off
+    }
+    include Hifsm.fsm_module(:color) {
+      state :red, :initial => true
+      state :green
+      state :blue
+
+      event :cycle_color!, :from => :red, :to => :green
+      event :cycle_color!, :from => :green, :to => :blue
+      event :cycle_color!, :from => :blue, :to => :red
+    }
+  end
+
+  def setup
+    @color_printer = ColorPrinter.new
+  end
+
+  def test_two_machines_defined
+    assert_equal 'off', @color_printer.working_state_machine.state
+    assert_equal 'red', @color_printer.color_machine.color
+  end
+
+  def test_initial_state_is_off_and_red
+    assert_equal 'off', @color_printer.working_state
+    assert_equal 'red', @color_printer.color
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hifsm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Vladimir Meremyanin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-03 00:00:00.000000000 Z
+date: 2014-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: activerecord
+  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: sqlite3
+  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
@@ -60,12 +102,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - hifsm.gemspec
 - lib/hifsm.rb
+- lib/hifsm/adapters/active_record_adapter.rb
 - lib/hifsm/callbacks.rb
 - lib/hifsm/event.rb
 - lib/hifsm/fsm.rb
@@ -75,13 +119,16 @@ files:
 - test/minitest_helper.rb
 - test/monster.rb
 - test/setup_tests.rb
+- test/test_activerecord_adapter.rb
 - test/test_any_state_event.rb
 - test/test_basic_fsm.rb
+- test/test_dynamic_initial_state.rb
 - test/test_event_guard.rb
 - test/test_hierarchical.rb
 - test/test_ifless_factorial.rb
 - test/test_many_states.rb
 - test/test_monster.rb
+- test/test_two_machines.rb
 homepage: http://github.com/stiff/hifsm
 licenses:
 - MIT
@@ -110,10 +157,13 @@ test_files:
 - test/minitest_helper.rb
 - test/monster.rb
 - test/setup_tests.rb
+- test/test_activerecord_adapter.rb
 - test/test_any_state_event.rb
 - test/test_basic_fsm.rb
+- test/test_dynamic_initial_state.rb
 - test/test_event_guard.rb
 - test/test_hierarchical.rb
 - test/test_ifless_factorial.rb
 - test/test_many_states.rb
 - test/test_monster.rb
+- test/test_two_machines.rb