finite_machine 0.10.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec0da72426b4f28c1b3e06cb7bce0de974ac4445
-  data.tar.gz: 36d0560b1fc8148cf9c3d194aff3843148e56854
+  metadata.gz: edb4b2a96673bef5c94c26d477821d2e59a5f756
+  data.tar.gz: 518346cb8ac30326a5a9550f6b0b18bea9de5918
 SHA512:
-  metadata.gz: 57dbe7dada41dcfe1fafda95f2a5e7664cdaa62c506e9afdf5f943aa561bae2ea2d9a9a399bc910a08c82e3c76e5350345f89471c90e4deb9e8133a4a37c3a73
-  data.tar.gz: a14127d9c43b5bcb68b0223c4b5dc3f807c48513ba6fe89fda7e0f4e191e849ac013d2144bf489c54fbe71b9b7c61d0999bef986e436159a3de287acdae807e8
+  metadata.gz: d179ed858abc96e2776de1f45278b261ce50f8adccf1841420c334a4f2427d0999ee3cc46e40c263bff62cadbf68284a619d491f8ea8016cfa0d3c576d1dd40c
+  data.tar.gz: 2036811dac682bb9decb39a5c39e5cc7c026109db57e97946dd3ca26b8106d109eaecffd200c6c8481cf5c5fb3a5fff6eaae5ed188b9e4bd1ab2d3ea1276aa6a

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+0.10.2 (July 5, 2015)
+
+* Fix to run 'on_after' callbacks even when event cancalled by @craiglittle
+* Fix to cancel transition when no matching choice is found by @craiglittle
+* Change StateParser #parse method
+* Change EventBuilder to EventDefinition and invert dependencies
+* Change Event#call to #trigger
+* Change Transition#call to #execute
+
 0.10.1 (May 24, 2015)
 
 * Add ability to inherit state machine definitions

data/lib/finite_machine.rb

@@ -17,7 +17,7 @@ require "finite_machine/async_call"
 require "finite_machine/hook_event"
 require "finite_machine/env"
 require "finite_machine/event"
-require "finite_machine/event_builder"
+require "finite_machine/event_definition"
 require "finite_machine/event_queue"
 require "finite_machine/events_chain"
 require "finite_machine/hooks"

data/lib/finite_machine/catchable.rb

@@ -41,6 +41,9 @@ module FiniteMachine
     #
     # @param [Exception] exception
     #
+    # @return [Boolean]
+    #   true if handler is found, nil otherwise
+    #
     # @api public
     def catch_error(exception)
       if handler = handler_for_error(exception)

data/lib/finite_machine/event.rb

@@ -2,20 +2,32 @@
 
 module FiniteMachine
   # A class representing event with transitions
+  #
+  # Used by {EventDefinition} to create events.
+  #
+  # @api private
   class Event
     include Comparable
     include Threadable
 
     # The name of this event
+    #
+    # @return [Symbol]
     attr_threadsafe :name
 
     # The state transitions for this event
+    #
+    # @return [Array[Transition]]
     attr_threadsafe :state_transitions
 
     # The reference to the state machine for this event
+    #
+    # @return [StateMachine]
     attr_threadsafe :machine
 
     # The silent option for this transition
+    #
+    # @return [Boolean]
     attr_threadsafe :silent
 
     # Initialize an Event
@@ -39,19 +51,21 @@ module FiniteMachine
     # @example
     #   event << FiniteMachine::Transition.new machine, :a => :b
     #
-    # @return [nil]
+    # @return [Event]
     #
     # @api public
     def <<(transition)
       sync_exclusive do
         Array(transition).flatten.each { |trans| state_transitions << trans }
       end
+      self
     end
     alias_method :add, :<<
 
     # Find next transition
     #
-    # @return [FiniteMachine::Transition]
+    # @return [Transition]
+    #   the next available transition
     #
     # @api private
     def next_transition
@@ -65,7 +79,7 @@ module FiniteMachine
     #
     # @param [Array[Object]] args
     #
-    # return FiniteMachine::TransitionChoice
+    # return [Transition]
     #
     # @api private
     def find_transition(*args)
@@ -81,17 +95,18 @@ module FiniteMachine
     # If silent option is passed the event will not fire any callbacks
     #
     # @example
-    #   transition = Transition.create(machine, {})
-    #   transition.call
+    #   transition = Event.new(machine, {})
+    #   transition.trigger
     #
-    # @return [nil]
+    # @return [Boolean]
+    #   true is transition succeeded, false otherwise
     #
     # @api public
-    def call(*args, &block)
+    def trigger(*args, &block)
       sync_exclusive do
         event_transition = next_transition
         if silent
-          event_transition.call(*args, &block)
+          event_transition.execute(*args, &block)
         else
           machine.send(:transition, event_transition, *args, &block)
         end

data/lib/finite_machine/{event_builder.rb → event_definition.rb}

@@ -1,8 +1,13 @@
 # encoding: utf-8
 
 module FiniteMachine
-  # A class responsible for building event methods
-  class EventBuilder
+  # A class responsible for defining event methods on state machine
+  #
+  # Used to add event definitions from {TransitionBuilder} to
+  # the {StateMachine} to obtain convenience helpers.
+  #
+  # @api private
+  class EventDefinition
     include Threadable
     include Safety
 
@@ -18,15 +23,15 @@ module FiniteMachine
       @machine = machine
     end
 
-    # Build state machine events
+    # Define transition event names as state machine events
     #
-    # @param [FiniteMachine::Transition] transition
-    #   the transition for which event is build
+    # @param [Transition] transition
+    #   the transition for which event definition is created
     #
-    # @return [FiniteMachine::Transition]
+    # @return [Transition]
     #
     # @api private
-    def call(transition)
+    def apply(transition)
       name = transition.name
       detect_event_conflict!(name)
       if machine.singleton_class.send(:method_defined?, name)
@@ -53,12 +58,12 @@ module FiniteMachine
     # @api private
     def define_event_transition(name, transition)
       silent = transition.silent
-      _event = FiniteMachine::Event.new(machine, name: name, silent: silent)
+      _event = Event.new(machine, name: name, silent: silent)
       _event << transition
       machine.events_chain.add(name, _event)
 
       machine.send(:define_singleton_method, name) do |*args, &block|
-        _event.call(*args, &block)
+        _event.trigger(*args, &block)
       end
     end
 

data/lib/finite_machine/events_chain.rb

@@ -99,7 +99,7 @@ module FiniteMachine
     # @api public
     def check_choice_conditions(name, *args, &block)
       chain[name].state_transitions.any? do |trans|
-        trans.check_conditions(*args, &block)
+        trans.current? && trans.check_conditions(*args, &block)
       end
     end
 

data/lib/finite_machine/hooks.rb

@@ -66,10 +66,8 @@ module FiniteMachine
     # @return [Hash]
     #
     # @api public
-    def call(event_type, event_state)
-      collection[event_type][event_state].each do |hook|
-        yield hook
-      end
+    def call(event_type, event_state, &block)
+      collection[event_type][event_state].each(&block)
     end
 
     # Check if collection has any elements

data/lib/finite_machine/state_machine.rb

@@ -257,8 +257,9 @@ module FiniteMachine
         exception = InvalidStateError
         catch_error(exception) ||
           fail(exception, "inappropriate current state '#{state}'")
-        true
+        return false
       end
+      return true
     end
 
     # Performs transition
@@ -274,24 +275,28 @@ module FiniteMachine
       sync_exclusive do
         notify HookEvent::Before, event_transition, *args
 
-        return CANCELLED if valid_state?(event_transition)
-        return CANCELLED unless event_transition.valid?(*args, &block)
+        if valid_state?(event_transition) && event_transition.valid?(*args, &block)
+          notify HookEvent::Exit, event_transition, *args
 
-        notify HookEvent::Exit, event_transition, *args
+          begin
+            event_transition.execute(*args)
+            Logger.report_transition(event_transition, *args) if log_transitions
 
-        begin
-          event_transition.call(*args)
-          Logger.report_transition(event_transition, *args) if log_transitions
+            notify HookEvent::Transition, event_transition, *args
+          rescue Exception => e
+            catch_error(e) || raise_transition_error(e)
+          end
 
-          notify HookEvent::Transition, event_transition, *args
-        rescue Exception => e
-          catch_error(e) || raise_transition_error(e)
-        end
+          notify HookEvent::Enter, event_transition, *args
+
+          notify HookEvent::After, event_transition, *args
 
-        notify HookEvent::Enter, event_transition, *args
-        notify HookEvent::After, event_transition, *args
+          event_transition.same?(state) ? NOTRANSITION : SUCCEEDED
+        else
+          notify HookEvent::After, event_transition, *args
 
-        event_transition.same?(state) ? NOTRANSITION : SUCCEEDED
+          CANCELLED
+        end
       end
     end
 

data/lib/finite_machine/state_parser.rb

@@ -2,6 +2,10 @@
 
 module FiniteMachine
   # A class responsible for converting transition arguments to states
+  #
+  # Used by {TransitionBuilder} to parse user input state transitions.
+  #
+  # @api private
   class StateParser
     include Threadable
 
@@ -19,6 +23,7 @@ module FiniteMachine
     # @api public
     def initialize(attrs)
       @attrs = ensure_only_states!(attrs)
+      freeze
     end
 
     # Extract states from attributes
@@ -28,16 +33,14 @@ module FiniteMachine
     # @example
     #   StateParpser.new(attr).parase_states
     #
-    # @return [Hash[Symbol]] states
+    # @yield [Hash[Symbol]] the resolved states
+    #
+    # @return [Hash[Symbol]] the resolved states
     #
     # @api public
-    def parse_states(&block)
-      transitions = if contains_from_to_keys?
-        convert_from_to_attributes_to_states_hash
-      else
-        convert_attributes_to_states_hash
-      end
-      block ? transitions.each(&block) : transitions
+    def parse(&block)
+      states = extract_states
+      block ? states.each(&block) : states
     end
 
     # Check if attributes contain :from or :to key
@@ -84,10 +87,10 @@ module FiniteMachine
     #
     # @api private
     def ensure_only_states!(attrs)
-      _attrs = attrs.dup
-      BLACKLIST.each { |key| _attrs.delete(key) }
-      raise_not_enough_transitions unless _attrs.any?
-      _attrs
+      attributes = attrs.dup
+      BLACKLIST.each { |key| attributes.delete(key) }
+      raise_not_enough_transitions unless attributes.any?
+      attributes
     end
 
     # Convert attrbiutes with :from, :to keys to states hash
@@ -104,6 +107,10 @@ module FiniteMachine
 
     # Convert collapsed attributes to states hash
     #
+    # @example
+    #   parser = StateParser.new([:green, :red] => :yellow)
+    #   parser.parse # => {green: :yellow, red: :yellow}
+    #
     # @return [Hash[Symbol]]
     #
     # @api private
@@ -118,6 +125,19 @@ module FiniteMachine
       end
     end
 
+    # Perform extraction of states from user supplied definitions
+    #
+    # @return [Hash[Symbol]] the resolved states
+    #
+    # @api private
+    def extract_states
+      if contains_from_to_keys?
+        convert_from_to_attributes_to_states_hash
+      else
+        convert_attributes_to_states_hash
+      end
+    end
+
     # Raise error when not enough transitions are provided
     #
     # @raise [NotEnoughTransitionsError]

data/lib/finite_machine/transition.rb

@@ -26,7 +26,7 @@ module FiniteMachine
     attr_threadsafe :cancelled
 
     # All states for this transition event
-    attr_threadsafe :map
+    attr_threadsafe :states
 
     # Silence callbacks
     attr_threadsafe :silent
@@ -40,10 +40,10 @@ module FiniteMachine
     def initialize(machine, attrs = {})
       @machine     = machine
       @name        = attrs.fetch(:name, DEFAULT_STATE)
-      @map         = attrs.fetch(:parsed_states, {})
+      @states      = attrs.fetch(:parsed_states, {})
       @silent      = attrs.fetch(:silent, false)
-      @from_states = @map.keys
-      @to_states   = @map.values
+      @from_states = @states.keys
+      @to_states   = @states.values
       @from_state  = @from_states.first
       @if          = Array(attrs.fetch(:if, []))
       @unless      = Array(attrs.fetch(:unless, []))
@@ -54,21 +54,21 @@ module FiniteMachine
     # Create transition with associated helper methods
     #
     # @param [FiniteMachine::StateMachine] machine
+    #
     # @param [Hash] attrs
     #
     # @example
-    #   Transition.create(machine, {})
+    #   attributes = {parsed_states: {green: :yellow}, silent: true}
+    #   Transition.create(machine, attrbiutes)
     #
-    # @return [FiniteMachine::Transition]
+    # @return [Transition]
     #
     # @api public
     def self.create(machine, attrs = {})
       transition = new(machine, attrs)
       transition.update_transitions
-      transition.define_state_methods
-
-      builder = EventBuilder.new(machine)
-      builder.call(transition)
+      transition.define_state_query_methods
+      transition
     end
 
     # Decide :to state from available transitions for this event
@@ -79,7 +79,12 @@ module FiniteMachine
     def to_state(*args)
       if transition_choice?
         found_trans = machine.select_choice_transition(name, from_state, *args)
-        found_trans.map[from_state] || found_trans.map[ANY_STATE]
+
+        if found_trans.nil? # no choice found
+          from_state
+        else
+          found_trans.states[from_state] || found_trans.states[ANY_STATE]
+        end
       else
         available_trans = machine.transitions[name]
         available_trans[from_state] || available_trans[ANY_STATE]
@@ -114,7 +119,7 @@ module FiniteMachine
     #
     # @api public
     def same?(state)
-      map[state] == state || (map[ANY_STATE] == state && from_state == state)
+      states[state] == state || (states[ANY_STATE] == state && from_state == state)
     end
 
     # Check if from matches current state
@@ -161,24 +166,30 @@ module FiniteMachine
 
     # Add transition to the machine
     #
-    # @return [FiniteMachine::Transition]
+    # @return [Transition]
     #
     # @api private
     def update_transitions
       from_states.each do |from|
         if (value = machine.transitions[name][from])
-          machine.transitions[name][from] = [value, map[from]].flatten
+          machine.transitions[name][from] = [value, states[from]].flatten
         else
-          machine.transitions[name][from] = map[from] || ANY_STATE
+          machine.transitions[name][from] = states[from] || ANY_STATE
         end
       end
+      self
     end
 
     # Define helper state mehods for the transition states
     #
+    # @return [Transition]
+    #
     # @api private
-    def define_state_methods
-      from_states.concat(to_states).each { |state| define_state_method(state) }
+    def define_state_query_methods
+      from_states.concat(to_states).each do |state|
+        define_state_query_method(state)
+      end
+      self
     end
 
     # Define state helper method
@@ -186,7 +197,7 @@ module FiniteMachine
     # @param [Symbol] state
     #
     # @api private
-    def define_state_method(state)
+    def define_state_query_method(state)
       return if machine.respond_to?("#{state}?")
       machine.send(:define_singleton_method, "#{state}?") do
         machine.is?(state.to_sym)
@@ -225,7 +236,7 @@ module FiniteMachine
     # @return [nil]
     #
     # @api private
-    def call(*args)
+    def execute(*args)
       sync_exclusive do
         return if cancelled
         self.from_state = machine.state
@@ -250,7 +261,7 @@ module FiniteMachine
     #
     # @api public
     def inspect
-      transitions = @map.map { |from, to| "#{from} -> #{to}" }.join(', ')
+      transitions = @states.map { |from, to| "#{from} -> #{to}" }.join(', ')
       "<##{self.class} @name=#{@name}, @transitions=#{transitions}, @when=#{@conditions}>"
     end
   end # Transition

data/lib/finite_machine/transition_builder.rb

@@ -2,6 +2,8 @@
 
 module FiniteMachine
   # A class reponsible for building transition out of parsed states
+  #
+  # @api private
   class TransitionBuilder
     include Threadable
 
@@ -10,6 +12,8 @@ module FiniteMachine
 
     attr_threadsafe :attributes
 
+    attr_threadsafe :event_definition
+
     # Initialize a TransitionBuilder
     #
     # @example
@@ -19,6 +23,7 @@ module FiniteMachine
     def initialize(machine, attributes = {})
       @machine = machine
       @attributes = attributes
+      @event_definition = EventDefinition.new(machine)
     end
 
     # Creates transitions for the states
@@ -33,9 +38,10 @@ module FiniteMachine
     #
     # @api public
     def call(states)
-      FiniteMachine::StateParser.new(states).parse_states do |from, to|
+      FiniteMachine::StateParser.new(states).parse do |from, to|
         attributes.merge!(parsed_states: { from => to })
-        Transition.create(machine, attributes)
+        transition = Transition.create(machine, attributes)
+        event_definition.apply(transition)
       end
     end
   end # TransitionBuilder

data/lib/finite_machine/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module FiniteMachine
-  VERSION = "0.10.1"
+  VERSION = "0.10.2"
 end

data/spec/unit/callbacks_spec.rb

@@ -902,4 +902,32 @@ RSpec.describe FiniteMachine, 'callbacks' do
     fsm.stop
     expect(called).to eq(['on_enter_red'])
   end
+
+  it "executes event-based callbacks even when state does not change" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :active
+
+      events {
+        event :advance, :active   => :inactive, if: -> { false }
+        event :advance, :inactive => :active,   if: -> { false }
+      }
+
+      callbacks {
+        on_before do |event|
+          called << "before_#{event.name}_#{event.from}_#{event.to}"
+        end
+        on_after do |event|
+          called << "after_#{event.name}_#{event.from}_#{event.to}"
+        end
+      }
+    end
+    expect(fsm.current).to eq(:active)
+    fsm.advance
+    expect(fsm.current).to eq(:active)
+    expect(called).to eq([
+      'before_advance_active_inactive',
+      'after_advance_active_inactive'
+    ])
+  end
 end

data/spec/unit/choice_spec.rb

@@ -85,7 +85,7 @@ RSpec.describe FiniteMachine, '#choice' do
     expect(fsm.current).to eq(:agreement_form)
   end
 
-  it "choses state when skipped if/unless" do
+  it "chooses state when skipped if/unless" do
     fsm = FiniteMachine.define do
       initial :company_form
 
@@ -102,7 +102,7 @@ RSpec.describe FiniteMachine, '#choice' do
     expect(fsm.current).to eq(:promo_form)
   end
 
-  it "choice default state when branching conditions don't match" do
+  it "chooses default state when branching conditions don't match" do
     fsm = FiniteMachine.define do
       initial :company_form
 
@@ -213,6 +213,46 @@ RSpec.describe FiniteMachine, '#choice' do
     expect(fsm.current).to eq(:fulfilled)
   end
 
+  it "does not transition when no matching choice for multiple event definitions" do
+    ticket = double(:ticket, :pending? => true, :finished? => false)
+    called = []
+    fsm = FiniteMachine.define do
+      initial :inactive
+
+      target ticket
+
+      events {
+        event :advance, from: [:inactive, :paused, :fulfilled] do
+          choice :active, if: proc { |_ticket| !_ticket.pending? }
+        end
+
+        event :advance, from: [:inactive, :active, :fulfilled] do
+          choice :paused, if: proc { |_ticket| _ticket.pending? }
+        end
+
+        event :advance, from: [:inactive, :active, :paused] do
+          choice :fulfilled, if: proc { |_ticket| _ticket.finished? }
+        end
+      }
+
+      callbacks {
+        on_before(:advance) { called << 'on_before_advance' }
+        on_after(:advance)  { called << 'on_after_advance' }
+      }
+    end
+    expect(fsm.current).to eq(:inactive)
+    fsm.advance
+    expect(fsm.current).to eq(:paused)
+    fsm.advance
+    expect(fsm.current).to eq(:paused)
+    expect(called).to eq([
+      'on_before_advance',
+      'on_after_advance',
+      'on_before_advance',
+      'on_after_advance'
+    ])
+  end
+
   it "sets callback properties correctly" do
     expected = {name: :init, from: :none, to: :red, a: nil, b: nil, c: nil }
 

data/spec/unit/event/add_spec.rb

@@ -7,12 +7,10 @@ RSpec.describe FiniteMachine::Event, '#<<' do
 
   let(:object) { described_class }
 
-  subject(:event) { object.new(machine, name: :test) }
-
   it "adds multiple transitions" do
     transition = double(:transition)
-    event << transition
-    event << transition
+    event = object.new(machine)
+    event << transition << transition
     expect(event.state_transitions).to match_array([transition, transition])
   end
 end

data/spec/unit/events_spec.rb

@@ -181,7 +181,10 @@ RSpec.describe FiniteMachine, 'events' do
 
     expect(fsm.current).to eql(:green)
 
-    expect { fsm.stop }.to raise_error(FiniteMachine::InvalidStateError, /state 'green'/)
+    expect {
+      fsm.stop
+    }.to raise_error(FiniteMachine::InvalidStateError,
+                     /inappropriate current state 'green'/)
   end
 
   it "allows to transition to any state" do

data/spec/unit/state_parser/{parse_states_spec.rb → parse_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-RSpec.describe FiniteMachine::StateParser, '#inspect' do
+RSpec.describe FiniteMachine::StateParser, '#parse' do
   let(:object) { described_class }
 
   subject(:parser) { object.new(attrs) }
@@ -12,7 +12,7 @@ RSpec.describe FiniteMachine::StateParser, '#inspect' do
 
     it "raises error for no transitions" do
       expect {
-        parser.parse_states
+        parser.parse
       }.to raise_error(FiniteMachine::NotEnoughTransitionsError)
     end
   end
@@ -21,7 +21,7 @@ RSpec.describe FiniteMachine::StateParser, '#inspect' do
     let(:attrs) { { from: :green, to: :yellow }}
 
     it "removes :from and :to keys" do
-      expect(parser.parse_states).to eq({green: :yellow})
+      expect(parser.parse).to eq({green: :yellow})
     end
   end
 
@@ -29,7 +29,7 @@ RSpec.describe FiniteMachine::StateParser, '#inspect' do
     let(:attrs) { { from: :green }}
 
     it "adds to state as copy of from" do
-      expect(parser.parse_states).to eq({green: :green})
+      expect(parser.parse).to eq({green: :green})
     end
   end
 
@@ -37,7 +37,7 @@ RSpec.describe FiniteMachine::StateParser, '#inspect' do
     let(:attrs) { { to: :green }}
 
     it "inserts :any from state" do
-      expect(parser.parse_states).to eq({any: :green})
+      expect(parser.parse).to eq({any: :green})
     end
   end
 
@@ -45,15 +45,15 @@ RSpec.describe FiniteMachine::StateParser, '#inspect' do
     let(:attrs) { { green: :yellow } }
 
     it "copies attributes over" do
-      expect(parser.parse_states).to eq({green: :yellow})
+      expect(parser.parse).to eq({green: :yellow})
     end
   end
 
   context 'when array of from states' do
-    let(:attrs) { { [:green] => :yellow } }
+    let(:attrs) { { [:green, :red] => :yellow } }
 
     it "extracts states" do
-      expect(parser.parse_states).to eq({green: :yellow})
+      expect(parser.parse).to include({red: :yellow, green: :yellow})
     end
   end
 end

data/spec/unit/transition/parse_states_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe FiniteMachine::Transition, 'parsed_states' do
     it "groups states" do
       expect(transition.from_states).to eq([:any])
       expect(transition.to_states).to eq([:red])
-      expect(transition.map).to eql({any: :red})
+      expect(transition.states).to eql({any: :red})
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.2
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-24 00:00:00.000000000 Z
+date: 2015-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,7 +56,7 @@ files:
 - lib/finite_machine/dsl.rb
 - lib/finite_machine/env.rb
 - lib/finite_machine/event.rb
-- lib/finite_machine/event_builder.rb
+- lib/finite_machine/event_definition.rb
 - lib/finite_machine/event_queue.rb
 - lib/finite_machine/events_chain.rb
 - lib/finite_machine/hook_event.rb
@@ -110,7 +110,7 @@ files:
 - spec/unit/logger_spec.rb
 - spec/unit/respond_to_spec.rb
 - spec/unit/state_parser/inspect_spec.rb
-- spec/unit/state_parser/parse_states_spec.rb
+- spec/unit/state_parser/parse_spec.rb
 - spec/unit/states_spec.rb
 - spec/unit/subscribers_spec.rb
 - spec/unit/target_spec.rb
@@ -180,7 +180,7 @@ test_files:
 - spec/unit/logger_spec.rb
 - spec/unit/respond_to_spec.rb
 - spec/unit/state_parser/inspect_spec.rb
-- spec/unit/state_parser/parse_states_spec.rb
+- spec/unit/state_parser/parse_spec.rb
 - spec/unit/states_spec.rb
 - spec/unit/subscribers_spec.rb
 - spec/unit/target_spec.rb