simply_fsm 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb54d24c49d69bc4cb382e6c4181a586fe9eef471dd1e44bcef0d95555fb33ae
-  data.tar.gz: 2f336e971e10827c1b731948376b4f2a177e012093c3f66457380df21c0f110c
+  metadata.gz: e96963bd4f2d0cf605ca52b79cc74c3b3ba29d66df452683c6425f6e4243cf62
+  data.tar.gz: ca0ad99246f5f27eb9749ba2dd41c652bd424c55828cdeb4f6365478d8866488
 SHA512:
-  metadata.gz: 9afdd28a4281a6d6c4d40abe7d52e5ab674e9bf1e626a9bc2bf47ee678e047f0fd3c4e5ab3f6857a01fc6fd6647a5eab416a6cc1c03f7ebbbdda1a72b6b1d71b
-  data.tar.gz: 21c938cbced1efb61d61c0cc62c4887d1f8084c4b42c6bc2effd0cda358a9cbade73a958250fdb9d81a17a183ed2b092e7d6896ae043fc1dfcc2afa7c9914134
+  metadata.gz: 37de0fd3446033ef390fb8aa6bf616c936de2125e65b876724904b989163d816f52971198a5fb2055a9412589565633a5fbaaa93eaed35912da549bc366d1446
+  data.tar.gz: 97165581f0a8f1955ffbb568d99958e84a99de955041ead58b52a5ed100eee52fd8cc58175f32702a11c0d4d9c86a62ff858cc306b3b3a0efd52ec5e3cfdcf02

data/.gitignore

@@ -10,3 +10,6 @@
 
 # rspec failure tracking
 .rspec_status
+
+# Mac temps
+.DS_Store

data/.rspec

@@ -1,3 +1,3 @@
---format documentation
+--format progress
 --color
 --require spec_helper

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 - None right now
 
+## [0.3.0]
+
+- Moving main source under the `lib/simply_fsm` folder to remove `require` statement
+- Why? Eventually want to be able to use this with `mruby`
+
+## [0.2.3] - 2022-04-09
+
+- Add `rake yard` to generate local documentation
+- Clean up API documentation
+- Privatise some internal methods
+
+## [0.2.2] - 2022-03-08
+
+- Call `fail` lambda without wrapping it in a lambda
+
+## [0.2.1] - 2022-03-05
+
+- Fixed bug where named fail handlers were not called properly for multi-transition events.
+
 ## [0.2.0] - 2022-03-01
 
 - *Breaks API* (sorry!)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simply_fsm (0.1.1)
+    simply_fsm (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -46,6 +46,9 @@ GEM
     ruby-progressbar (1.11.0)
     stringio (3.0.1)
     unicode-display_width (2.1.0)
+    webrick (1.7.0)
+    yard (0.9.27)
+      webrick (~> 1.7.0)
 
 PLATFORMS
   ruby
@@ -56,6 +59,7 @@ DEPENDENCIES
   rspec (~> 3.0)
   rubocop (~> 1.21)
   simply_fsm!
+  yard
 
 BUNDLED WITH
    2.1.4

data/Rakefile

@@ -17,6 +17,13 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
+require "yard"
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ["lib/**/*.rb"]
+  t.stats_options = ["--list-undoc"]
+end
+
 RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]

data/lib/simply_fsm/simply_fsm.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+#
+# Include *SimplyFSM* in a class to be able to defined state machines.
+#
+module SimplyFSM
+  #
+  # Provides a +state_machine+ for the including class.
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  #
+  # Defines the constructor for defining a state machine
+  module ClassMethods
+    #
+    # Declare a state machine called +name+ which can then be defined
+    # by a DSL defined by the methods of *StateMachine*.
+    #
+    # @param [String] name of the state machine.
+    # @param [Hash] opts to specify options such as:
+    #   - +fail+ lambda that is called with the event name when any event fails to transition
+    #
+    def state_machine(name, opts = {}, &block)
+      fsm = StateMachine.new(name, self, fail: opts[:fail])
+      fsm.instance_eval(&block)
+    end
+  end
+
+  ##
+  # The DSL for defining a state machine. These methods are used within the declaration of a +state_machine+.
+  #
+  # @attr_reader [String] initial_state The initial state of the state machine
+  # @attr_reader [Array] states All the states of the state machine
+  # @attr_reader [Array] events All the events of the state machine
+  # @attr_reader [String] name
+  # @attr_reader [String] full_name The name of the owning class combined with the state machine's name
+  #
+  class StateMachine
+    attr_reader :initial_state, :states, :events, :name, :full_name
+
+    #
+    # @!visibility private
+    def initialize(name, owner_class, fail: nil)
+      @owner_class = owner_class
+      @name = name.to_sym
+      @full_name = "#{owner_class.name}/#{name}"
+      @states = []
+      @events = []
+      @initial_state = nil
+      @fail_handler = fail
+
+      setup_base_methods
+    end
+
+    #
+    # Declare a supported +state_name+, and optionally specify one as the +initial+ state.
+    #
+    # @param [String] state_name
+    # @param [Boolean] initial to indicate if this is the initial state of the state machine
+    #
+    def state(state_name, initial: false)
+      return if state_name.nil? || @states.include?(state_name)
+
+      status = state_name.to_sym
+      state_machine_name = @name
+      @states << status
+      @initial_state = status if initial
+
+      make_owner_method "#{state_name}?", lambda {
+        send(state_machine_name) == status
+      }
+    end
+
+    ##
+    # Define an event by +event_name+
+    #
+    # @param [String] event_name
+    # @param [Hash,Array] transitions either one (Hash) or many (Array of Hashes) transitions +from+ one state +to+ another state.
+    # @param [Lambda] guard if specified must return +true+ before any transitions are attempted
+    # @param [Lambda] fail called with event name if specified when all the attempted transitions fail
+    # @yield when the transition attempt succeeds.
+    def event(event_name, transitions:, guard: nil, fail: nil, &after)
+      return unless event_exists?(event_name) && transitions
+
+      @events << event_name
+      may_event_name = "may_#{event_name}?"
+
+      if transitions.is_a?(Array)
+        setup_multi_transition_may_event_method transitions: transitions, guard: guard,
+                                                may_event_name: may_event_name
+        setup_multi_transition_event_method event_name,
+                                            transitions: transitions, guard: guard,
+                                            var_name: "@#{@name}", fail: fail || @fail_handler
+        return
+      end
+
+      to = transitions[:to]
+      setup_may_event_method may_event_name, transitions[:from] || :any, transitions[:when], guard
+      setup_event_method event_name, var_name: "@#{@name}",
+                                     may_event_name: may_event_name, to: to,
+                                     fail: fail || @fail_handler, &after
+    end
+
+    private
+
+    def setup_multi_transition_may_event_method(transitions:, guard:, may_event_name:)
+      state_machine_name = @name
+
+      make_owner_method may_event_name, lambda {
+        if !guard || instance_exec(&guard)
+          current = send(state_machine_name)
+          # Check each transition, and first one that succeeds ends the scan
+          transitions.each do |t|
+            next if cannot_transition?(t[:from], t[:when], current)
+
+            return true
+          end
+        end
+        false
+      }
+    end
+
+    def setup_fail_lambda_for(fail)
+      return unless fail
+
+      if fail.is_a?(String) || fail.is_a?(Symbol)
+        ->(event_name) { send(fail, event_name) }
+      else
+        fail
+      end
+    end
+
+    def setup_multi_transition_event_method(event_name, transitions:, guard:, var_name:, fail:)
+      state_machine_name = @name
+      fail_lambda = setup_fail_lambda_for(fail)
+      make_owner_method event_name, lambda {
+        if !guard || instance_exec(&guard)
+          current = send(state_machine_name)
+          # Check each transition, and first one that succeeds ends the scan
+          transitions.each do |t|
+            next if cannot_transition?(t[:from], t[:when], current)
+
+            instance_variable_set(var_name, t[:to])
+            return true
+          end
+        end
+        instance_exec(event_name, &fail_lambda) if fail_lambda
+        false
+      }
+    end
+
+    def event_exists?(event_name)
+      event_name && !@events.include?(event_name)
+    end
+
+    def setup_event_method(event_name, var_name:, may_event_name:, to:, fail:, &after)
+      fail_lambda = setup_fail_lambda_for(fail)
+      method_lambda = lambda {
+        if send(may_event_name)
+          instance_variable_set(var_name, to)
+          instance_exec(&after) if after
+          return true
+        end
+        instance_exec(event_name, &fail_lambda) if fail_lambda
+        false
+      }
+      make_owner_method event_name, method_lambda
+    end
+
+    def setup_may_event_method(may_event_name, from, cond, guard)
+      state_machine_name = @name
+      #
+      # Instead of one "may_event?" method that checks all variations every time it's called, here we check
+      # the event definition and define the most optimal lambda to ensure the check is as fast as possible
+      method_lambda = if from == :any
+                        from_any_may_event_lambda(guard, cond, state_machine_name)
+                      else
+                        guarded_or_conditional_may_event_lambda(from, guard, cond, state_machine_name)
+                      end
+      make_owner_method may_event_name, method_lambda
+    end
+
+    def from_any_may_event_lambda(guard, cond, _state_machine_name)
+      if !guard && !cond
+        -> { true } # unguarded transition from any state
+      elsif !cond
+        guard # guarded transition from any state
+      elsif !guard
+        cond # conditional unguarded transition from any state
+      else
+        -> { instance_exec(&guard) && instance_exec(&cond) }
+      end
+    end
+
+    def guarded_or_conditional_may_event_lambda(from, guard, cond, state_machine_name)
+      if !guard && !cond
+        guardless_may_event_lambda(from, state_machine_name)
+      elsif !cond
+        guarded_may_event_lambda(from, guard, state_machine_name)
+      elsif !guard
+        guarded_may_event_lambda(from, cond, state_machine_name)
+      else
+        guarded_and_conditional_may_event_lambda(from, guard, cond, state_machine_name)
+      end
+    end
+
+    def guarded_may_event_lambda(from, guard, state_machine_name)
+      if from.is_a?(Array)
+        lambda { # guarded transition from choice of states
+          current = send(state_machine_name)
+          from.include?(current) && instance_exec(&guard)
+        }
+      else
+        lambda { # guarded transition from one state
+          current = send(state_machine_name)
+          from == current && instance_exec(&guard)
+        }
+      end
+    end
+
+    def guarded_and_conditional_may_event_lambda(from, guard, cond, state_machine_name)
+      if from.is_a?(Array)
+        lambda { # guarded transition from choice of states
+          current = send(state_machine_name)
+          from.include?(current) && instance_exec(&guard) && instance_exec(&cond)
+        }
+      else
+        lambda { # guarded transition from one state
+          current = send(state_machine_name)
+          from == current && instance_exec(&guard) && instance_exec(&cond)
+        }
+      end
+    end
+
+    def guardless_may_event_lambda(from, state_machine_name)
+      if from.is_a?(Array)
+        lambda {    # unguarded transition from choice of states
+          current = send(state_machine_name)
+          from.include?(current)
+        }
+      else
+        lambda {    # unguarded transition from one state
+          current = send(state_machine_name)
+          from == current
+        }
+      end
+    end
+
+    def setup_base_methods
+      var_name = "@#{name}"
+      fsm = self
+      make_owner_method @name, lambda {
+                                 instance_variable_get(var_name) ||
+                                   fsm.initial_state
+                               }
+      make_owner_method "#{@name}_states", -> { fsm.states }
+      make_owner_method "#{@name}_events", -> { fsm.events }
+    end
+
+    def make_owner_method(method_name, method_definition)
+      @owner_class.define_method(method_name, method_definition)
+    end
+  end
+
+  private
+
+  def state_match?(from, current)
+    return true if from == :any
+    return from.include?(current) if from.is_a?(Array)
+
+    from == current
+  end
+
+  def cannot_transition?(from, cond, current)
+    (from && !state_match?(from, current)) || (cond && !instance_exec(&cond))
+  end
+end

data/lib/simply_fsm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimplyFSM
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/simply_fsm.rb

@@ -1,252 +1,4 @@
 # frozen_string_literal: true
 
 require "simply_fsm/version"
-
-##
-# Defines the `SimplyFSM` module
-module SimplyFSM
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  def state_match?(from, current)
-    return true if from == :any
-    return from.include?(current) if from.is_a?(Array)
-
-    from == current
-  end
-
-  def cannot_transition?(from, cond, current)
-    (from && !state_match?(from, current)) || (cond && !instance_exec(&cond))
-  end
-
-  ##
-  # Defines the constructor for defining a state machine
-  module ClassMethods
-    ##
-    # Declare a state machine called +name+ which can then be defined
-    # by a DSL defined by the methods of `StateMachine`, with the following +opts+:
-    # - an optional +fail+ lambda that is called when any event fails to transition)
-    def state_machine(name, opts = {}, &block)
-      fsm = StateMachine.new(name, self, fail: opts[:fail])
-      fsm.instance_eval(&block)
-    end
-  end
-
-  ##
-  # The DSL for defining a state machine
-  class StateMachine
-    attr_reader :initial_state, :states, :events, :name, :full_name
-
-    def initialize(name, owner_class, fail: nil)
-      @owner_class = owner_class
-      @name = name.to_sym
-      @full_name = "#{owner_class.name}/#{name}"
-      @states = []
-      @events = []
-      @initial_state = nil
-      @fail_handler = fail
-
-      setup_base_methods
-    end
-
-    ##
-    # Declare a supported +state_name+, and optionally specify one as the +initial+ state.
-    def state(state_name, initial: false)
-      return if state_name.nil? || @states.include?(state_name)
-
-      status = state_name.to_sym
-      state_machine_name = @name
-      @states << status
-      @initial_state = status if initial
-
-      make_owner_method "#{state_name}?", lambda {
-        send(state_machine_name) == status
-      }
-    end
-
-    ##
-    # Define an event by +event_name+
-    #
-    # - which +transitions+ as a hash with a +from+ state or array of states and the +to+ state,
-    # - an optional +guard+ lambda which must return true for the transition to occur,
-    # - an optional +fail+ lambda that is called when the transition fails (overrides top-level fail handler), and
-    # - an optional do block that is called +after+ the transition succeeds
-    def event(event_name, transitions:, guard: nil, fail: nil, &after)
-      return unless event_exists?(event_name) && transitions
-
-      @events << event_name
-      may_event_name = "may_#{event_name}?"
-
-      if transitions.is_a?(Array)
-        setup_multi_transition_may_event_method transitions: transitions, guard: guard,
-                                                may_event_name: may_event_name
-        setup_multi_transition_event_method event_name,
-                                            transitions: transitions, guard: guard,
-                                            var_name: "@#{@name}", fail: fail || @fail_handler
-        return
-      end
-
-      to = transitions[:to]
-      setup_may_event_method may_event_name, transitions[:from] || :any, transitions[:when], guard
-      setup_event_method event_name, var_name: "@#{@name}",
-                                     may_event_name: may_event_name, to: to,
-                                     fail: fail || @fail_handler, &after
-    end
-
-    private
-
-    def setup_multi_transition_may_event_method(transitions:, guard:, may_event_name:)
-      state_machine_name = @name
-
-      make_owner_method may_event_name, lambda {
-        if !guard || instance_exec(&guard)
-          current = send(state_machine_name)
-          # Check each transition, and first one that succeeds ends the scan
-          transitions.each do |t|
-            next if cannot_transition?(t[:from], t[:when], current)
-
-            return true
-          end
-        end
-        false
-      }
-    end
-
-    def setup_multi_transition_event_method(event_name, transitions:, guard:, var_name:, fail:)
-      state_machine_name = @name
-      make_owner_method event_name, lambda {
-        if !guard || instance_exec(&guard)
-          current = send(state_machine_name)
-          # Check each transition, and first one that succeeds ends the scan
-          transitions.each do |t|
-            next if cannot_transition?(t[:from], t[:when], current)
-
-            instance_variable_set(var_name, t[:to])
-            return true
-          end
-        end
-        instance_exec(&fail) if fail
-        false
-      }
-    end
-
-    def event_exists?(event_name)
-      event_name && !@events.include?(event_name)
-    end
-
-    def setup_event_method(event_name, var_name:, may_event_name:, to:, fail:, &after)
-      method_lambda = lambda {
-        if send(may_event_name)
-          instance_variable_set(var_name, to)
-          instance_exec(&after) if after
-          return true
-        end
-        # unable to satisfy pre-conditions for the event
-        if fail
-          if fail.is_a?(String) || fail.is_a?(Symbol)
-            send(fail, event_name)
-          else
-            instance_exec(event_name, &fail)
-          end
-        end
-        false
-      }
-      make_owner_method event_name, method_lambda
-    end
-
-    def setup_may_event_method(may_event_name, from, cond, guard)
-      state_machine_name = @name
-      #
-      # Instead of one "may_event?" method that checks all variations every time it's called, here we check
-      # the event definition and define the most optimal lambda to ensure the check is as fast as possible
-      method_lambda = if from == :any
-                        from_any_may_event_lambda(guard, cond, state_machine_name)
-                      else
-                        guarded_or_conditional_may_event_lambda(from, guard, cond, state_machine_name)
-                      end
-      make_owner_method may_event_name, method_lambda
-    end
-
-    def from_any_may_event_lambda(guard, cond, _state_machine_name)
-      if !guard && !cond
-        -> { true } # unguarded transition from any state
-      elsif !cond
-        guard # guarded transition from any state
-      elsif !guard
-        cond # conditional unguarded transition from any state
-      else
-        -> { instance_exec(&guard) && instance_exec(&cond) }
-      end
-    end
-
-    def guarded_or_conditional_may_event_lambda(from, guard, cond, state_machine_name)
-      if !guard && !cond
-        guardless_may_event_lambda(from, state_machine_name)
-      elsif !cond
-        guarded_may_event_lambda(from, guard, state_machine_name)
-      elsif !guard
-        guarded_may_event_lambda(from, cond, state_machine_name)
-      else
-        guarded_and_conditional_may_event_lambda(from, guard, cond, state_machine_name)
-      end
-    end
-
-    def guarded_may_event_lambda(from, guard, state_machine_name)
-      if from.is_a?(Array)
-        lambda { # guarded transition from choice of states
-          current = send(state_machine_name)
-          from.include?(current) && instance_exec(&guard)
-        }
-      else
-        lambda { # guarded transition from one state
-          current = send(state_machine_name)
-          from == current && instance_exec(&guard)
-        }
-      end
-    end
-
-    def guarded_and_conditional_may_event_lambda(from, guard, cond, state_machine_name)
-      if from.is_a?(Array)
-        lambda { # guarded transition from choice of states
-          current = send(state_machine_name)
-          from.include?(current) && instance_exec(&guard) && instance_exec(&cond)
-        }
-      else
-        lambda { # guarded transition from one state
-          current = send(state_machine_name)
-          from == current && instance_exec(&guard) && instance_exec(&cond)
-        }
-      end
-    end
-
-    def guardless_may_event_lambda(from, state_machine_name)
-      if from.is_a?(Array)
-        lambda {    # unguarded transition from choice of states
-          current = send(state_machine_name)
-          from.include?(current)
-        }
-      else
-        lambda {    # unguarded transition from one state
-          current = send(state_machine_name)
-          from == current
-        }
-      end
-    end
-
-    def setup_base_methods
-      var_name = "@#{name}"
-      fsm = self
-      make_owner_method @name, lambda {
-                                 instance_variable_get(var_name) ||
-                                   fsm.initial_state
-                               }
-      make_owner_method "#{@name}_states", -> { fsm.states }
-      make_owner_method "#{@name}_events", -> { fsm.events }
-    end
-
-    def make_owner_method(method_name, method_definition)
-      @owner_class.define_method(method_name, method_definition)
-    end
-  end
-end
+require "simply_fsm/simply_fsm"

data/simply_fsm.gemspec

@@ -27,5 +27,6 @@ Gem::Specification.new do |spec|
 
   # development
   spec.add_development_dependency "rdoc"
+  spec.add_development_dependency "yard"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/spec/unit/multi_transition_fail_events_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class MultiTransitionFailHandlingStateMachine
+  class Error < StandardError; end
+  class RunError < StandardError; end
+
+  include SimplyFSM
+
+  state_machine :activity, fail: :on_any_fail do
+    state :sleeping, initial: true
+    state :running
+    state :cleaning
+
+    event :run,
+          fail: ->(_event) { raise RunError, "Cannot run" },
+          transitions: [{ from: :sleeping, to: :running }]
+
+    event :clean, transitions: [
+      { from: :running, to: :cleaning }
+    ]
+
+    event :sleep, transitions: [
+      { from: :running, to: :sleeping },
+      { when: -> { cleaning? }, to: :sleeping }
+    ]
+  end
+
+  def on_any_fail(event_name)
+    raise Error, "Cannot do: #{event_name}"
+  end
+end
+
+RSpec.describe MultiTransitionFailHandlingStateMachine do
+  describe "#sleep" do
+    it "error if already sleeping" do
+      expect { subject.sleep }.to raise_error(MultiTransitionFailHandlingStateMachine::Error)
+    end
+  end
+
+  describe "#run" do
+    it "custom error if already running" do
+      subject.run
+      expect { subject.run }.to raise_error(MultiTransitionFailHandlingStateMachine::RunError)
+    end
+
+    it "custom error if cleaning" do
+      subject.run
+      subject.clean
+      expect { subject.run }.to raise_error(MultiTransitionFailHandlingStateMachine::RunError)
+    end
+  end
+
+  describe "#clean" do
+    it "error if sleeping" do
+      expect { subject.clean }.to raise_error(MultiTransitionFailHandlingStateMachine::Error)
+    end
+
+    it "error if already cleaning" do
+      subject.run
+      subject.clean
+      expect { subject.clean }.to raise_error(MultiTransitionFailHandlingStateMachine::Error)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simply_fsm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - nogginly
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -49,6 +63,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
+- ".yardopts"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -59,12 +74,14 @@ files:
 - bin/console
 - bin/setup
 - lib/simply_fsm.rb
+- lib/simply_fsm/simply_fsm.rb
 - lib/simply_fsm/version.rb
 - simply_fsm.gemspec
 - spec/spec_helper.rb
 - spec/support/state_machine_examples.rb
 - spec/unit/fail_events_spec.rb
 - spec/unit/guard_events_spec.rb
+- spec/unit/multi_transition_fail_events_spec.rb
 - spec/unit/multi_transition_state_machine_spec.rb
 - spec/unit/one_state_machine_spec.rb
 - spec/unit/simply_fsm_spec.rb
@@ -100,6 +117,7 @@ test_files:
 - spec/support/state_machine_examples.rb
 - spec/unit/fail_events_spec.rb
 - spec/unit/guard_events_spec.rb
+- spec/unit/multi_transition_fail_events_spec.rb
 - spec/unit/multi_transition_state_machine_spec.rb
 - spec/unit/one_state_machine_spec.rb
 - spec/unit/simply_fsm_spec.rb