state_machines 0.6.0 → 0.30.0

data/lib/state_machines/machine_collection.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 module StateMachines
   # Represents a collection of state machines for a class
   class MachineCollection < Hash
@@ -20,21 +24,25 @@ module StateMachines
     # * <tt>:to</tt> - A hash to write the initialized state to instead of
     #   writing to the object.  Default is to write directly to the object.
     def initialize_states(object, options = {}, attributes = {})
-      options.assert_valid_keys( :static, :dynamic, :to)
-      options = {static: true, dynamic: true}.merge(options)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :static, :dynamic, :to)
+      options = { static: true, dynamic: true }.merge(options)
 
       result = yield if block_given?
 
-      each_value do |machine|
-        unless machine.dynamic_initial_state?
-          force = options[:static] == :force || !attributes.keys.map(&:to_sym).include?(machine.attribute)
-          machine.initialize_state(object, force: force, to: options[:to])
+      if options[:static]
+        each_value do |machine|
+          unless machine.dynamic_initial_state?
+            force = options[:static] == :force || !attributes.keys.map(&:to_sym).include?(machine.attribute)
+            machine.initialize_state(object, force: force, to: options[:to])
+          end
         end
-      end if options[:static]
+      end
 
-      each_value do |machine|
-        machine.initialize_state(object, force: options[:dynamic] == :force, to: options[:to]) if machine.dynamic_initial_state?
-      end if options[:dynamic]
+      if options[:dynamic]
+        each_value do |machine|
+          machine.initialize_state(object, force: options[:dynamic] == :force, to: options[:to]) if machine.dynamic_initial_state?
+        end
+      end
 
       result
     end
@@ -48,7 +56,7 @@ module StateMachines
       transitions = events.collect do |event_name|
         # Find the actual event being run
         event = nil
-        detect { |name, machine| event = machine.events[event_name, :qualified_name] }
+        detect { |_name, machine| event = machine.events[event_name, :qualified_name] }
 
         raise(InvalidEvent.new(object, event_name)) unless event
 
@@ -62,7 +70,7 @@ module StateMachines
       # Run the events in parallel only if valid transitions were found for
       # all of them
       if events.length == transitions.length
-        TransitionCollection.new(transitions, {use_transactions: resolve_use_transactions, actions: run_action}).perform
+        TransitionCollection.new(transitions, { use_transactions: resolve_use_transactions, actions: run_action }).perform
       else
         false
       end
@@ -74,14 +82,14 @@ module StateMachines
     #
     # These should only be fired as a result of the action being run.
     def transitions(object, action, options = {})
-      transitions = map do |name, machine|
+      transitions = map do |_name, machine|
         machine.events.attribute_transition_for(object, true) if machine.action == action
       end
 
-      AttributeTransitionCollection.new(transitions.compact, {use_transactions: resolve_use_transactions}.merge(options))
+      AttributeTransitionCollection.new(transitions.compact, { use_transactions: resolve_use_transactions }.merge(options))
     end
 
-  protected
+    protected
 
     def resolve_use_transactions
       use_transactions = nil

data/lib/state_machines/macro_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A state machine is a model of behavior composed of states, events, and
 # transitions.  This helper adds support for defining this type of
 # functionality on any Ruby class.
@@ -513,8 +515,8 @@ module StateMachines
     # See StateMachines::Machine for more information about using integrations
     # and the individual integration docs for information about the actual
     # scopes that are generated.
-    def state_machine(*args, &block)
-      StateMachines::Machine.find_or_create(self, *args, &block)
+    def state_machine(*, &)
+      StateMachines::Machine.find_or_create(self, *, &)
     end
   end
 end

data/lib/state_machines/matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Provides a general strategy pattern for determining whether a match is found
   # for a value.  The algorithm that actually determines the match depends on
@@ -30,12 +32,13 @@ module StateMachines
     #   matcher = StateMachines::AllMatcher.instance - [:parked, :idling]
     #   matcher.matches?(:parked)       # => false
     #   matcher.matches?(:first_gear)   # => true
-    def -(blacklist)
-      BlacklistMatcher.new(blacklist)
+    def -(other)
+      BlacklistMatcher.new(other)
     end
+    alias except -
 
     # Always returns true
-    def matches?(value, context = {})
+    def matches?(_value, _context = {})
       true
     end
 
@@ -60,7 +63,7 @@ module StateMachines
     #   matcher = StateMachines::WhitelistMatcher.new([:parked, :idling])
     #   matcher.matches?(:parked)       # => true
     #   matcher.matches?(:first_gear)   # => false
-    def matches?(value, context = {})
+    def matches?(value, _context = {})
       values.include?(value)
     end
 
@@ -80,7 +83,7 @@ module StateMachines
     #   matcher = StateMachines::BlacklistMatcher.new([:parked, :idling])
     #   matcher.matches?(:parked)       # => false
     #   matcher.matches?(:first_gear)   # => true
-    def matches?(value, context = {})
+    def matches?(value, _context = {})
       !values.include?(value)
     end
 

data/lib/state_machines/matcher_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Provides a set of helper methods for generating matchers
   module MatcherHelpers
@@ -28,7 +30,7 @@ module StateMachines
     def all
       AllMatcher.instance
     end
-    alias_method :any, :all
+    alias any all
 
     # Represents a state that matches the original +from+ state.  This is useful
     # for defining transitions which are loopbacks.

data/lib/state_machines/node_collection.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 module StateMachines
   # Represents a collection of nodes in a state machine, be it events or states.
   # Nodes will not differentiate between the String and Symbol versions of the
@@ -16,17 +20,16 @@ module StateMachines
     #   hashed indices for in order to perform quick lookups.  Default is to
     #   index by the :name attribute
     def initialize(machine, options = {})
-      options.assert_valid_keys(:index)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :index)
       options = { index: :name }.merge(options)
 
       @machine = machine
       @nodes = []
       @index_names = Array(options[:index])
-      @indices = @index_names.reduce({}) do |indices, name|
+      @indices = @index_names.each_with_object({}) do |name, indices|
         indices[name] = {}
         indices[:"#{name}_to_s"] = {}
         indices[:"#{name}_to_sym"] = {}
-        indices
       end
       @default_index = Array(options[:index]).first
       @contexts = []
@@ -34,14 +37,16 @@ module StateMachines
 
     # Creates a copy of this collection such that modifications don't affect
     # the original collection
-    def initialize_copy(orig) #:nodoc:
+    def initialize_copy(orig) # :nodoc:
       super
 
       nodes = @nodes
       contexts = @contexts
       @nodes = []
       @contexts = []
-      @indices = @indices.reduce({}) { |indices, (name, *)| indices[name] = {}; indices }
+      @indices = @indices.each_with_object({}) do |(name, *), indices|
+        indices[name] = {}
+      end
 
       # Add nodes *prior* to copying over the contexts so that they don't get
       # evaluated multiple times
@@ -112,8 +117,8 @@ module StateMachines
     # ...produces:
     #
     #   parked -- idling --
-    def each
-      @nodes.each { |node| yield node }
+    def each(&)
+      @nodes.each(&)
       self
     end
 
@@ -141,9 +146,9 @@ module StateMachines
     # If the key cannot be found, then nil will be returned.
     def [](key, index_name = @default_index)
       index(index_name)[key] ||
-      index(:"#{index_name}_to_s")[key.to_s] ||
-      to_sym?(key) && index(:"#{index_name}_to_sym")[:"#{key}"] ||
-      nil
+        index(:"#{index_name}_to_s")[key.to_s] ||
+        (to_sym?(key) && index(:"#{index_name}_to_sym")[:"#{key}"]) ||
+        nil
     end
 
     # Gets the node indexed by the given key.  By default, this will look up the
@@ -159,17 +164,17 @@ module StateMachines
     #
     #   collection['invalid', :value]   # => IndexError: "invalid" is an invalid value
     def fetch(key, index_name = @default_index)
-      self[key, index_name] || fail(IndexError, "#{key.inspect} is an invalid #{index_name}")
+      self[key, index_name] || raise(IndexError, "#{key.inspect} is an invalid #{index_name}")
     end
 
-  protected
+    protected
 
     # Gets the given index.  If the index does not exist, then an ArgumentError
     # is raised.
     def index(name)
-      fail ArgumentError, 'No indices configured' unless @indices.any?
+      raise ArgumentError, 'No indices configured' unless @indices.any?
 
-      @indices[name] || fail(ArgumentError, "Invalid index: #{name.inspect}")
+      @indices[name] || raise(ArgumentError, "Invalid index: #{name.inspect}")
     end
 
     # Gets the value for the given attribute on the node
@@ -201,10 +206,10 @@ module StateMachines
       new_key = value(node, name)
 
       # Only replace the key if it's changed
-      if old_key != new_key
-        remove_from_index(name, old_key)
-        add_to_index(name, new_key, node)
-      end
+      return unless old_key != new_key
+
+      remove_from_index(name, old_key)
+      add_to_index(name, new_key, node)
     end
 
     # Determines whether the given value can be converted to a symbol

data/lib/state_machines/options_validator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module StateMachines
+  # Define the module if it doesn't exist yet
+  # Module for validating options without monkey-patching Hash
+  # Provides the same functionality as the Hash monkey patch but in a cleaner way
+  module OptionsValidator
+    class << self
+      # Validates that all keys in the options hash are in the list of valid keys
+      #
+      # @param options [Hash] The options hash to validate
+      # @param valid_keys [Array<Symbol>] List of valid key names
+      # @param caller_info [String] Information about the calling method for better error messages
+      # @raise [ArgumentError] If any invalid keys are found
+      def assert_valid_keys!(options, *valid_keys, caller_info: nil)
+        return if options.empty?
+
+        valid_keys.flatten!
+        invalid_keys = options.keys - valid_keys
+
+        return if invalid_keys.empty?
+
+        caller_context = caller_info ? " in #{caller_info}" : ''
+        raise ArgumentError, "Unknown key#{'s' if invalid_keys.length > 1}: #{invalid_keys.map(&:inspect).join(', ')}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}#{caller_context}"
+      end
+
+      # Validates that at most one of the exclusive keys is present in the options hash
+      #
+      # @param options [Hash] The options hash to validate
+      # @param exclusive_keys [Array<Symbol>] List of mutually exclusive keys
+      # @param caller_info [String] Information about the calling method for better error messages
+      # @raise [ArgumentError] If more than one exclusive key is found
+      def assert_exclusive_keys!(options, *exclusive_keys, caller_info: nil)
+        return if options.empty?
+
+        conflicting_keys = exclusive_keys & options.keys
+        return if conflicting_keys.length <= 1
+
+        caller_context = caller_info ? " in #{caller_info}" : ''
+        raise ArgumentError, "Conflicting keys: #{conflicting_keys.join(', ')}#{caller_context}"
+      end
+
+      # Validates options using a more convenient interface that works with both
+      # hash-style and kwargs-style method definitions
+      #
+      # @param valid_keys [Array<Symbol>] List of valid key names
+      # @param exclusive_key_groups [Array<Array<Symbol>>] Groups of mutually exclusive keys
+      # @param caller_info [String] Information about the calling method
+      # @return [Proc] A validation proc that can be called with options
+      def validator(valid_keys: [], exclusive_key_groups: [], caller_info: nil)
+        proc do |options|
+          assert_valid_keys!(options, *valid_keys, caller_info: caller_info) unless valid_keys.empty?
+
+          exclusive_key_groups.each do |group|
+            assert_exclusive_keys!(options, *group, caller_info: caller_info)
+          end
+        end
+      end
+
+      # Helper method for backwards compatibility - allows gradual migration
+      # from Hash monkey patch to this module
+      #
+      # @param options [Hash] The options to validate
+      # @param valid_keys [Array<Symbol>] Valid keys
+      # @return [Hash] The same options hash (for chaining)
+      def validate_and_return(options, *valid_keys)
+        assert_valid_keys!(options, *valid_keys)
+        options
+      end
+    end
+  end
+end

data/lib/state_machines/path.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 module StateMachines
   # A path represents a sequence of transitions that can be run for a particular
   # object.  Paths can walk to new transitions, revealing all of the possible
   # branches that can be encountered in the object's state machine.
   class Path < Array
-
-
     # The object whose state machine is being walked
     attr_reader :object
 
@@ -20,7 +22,7 @@ module StateMachines
     # * <tt>:guard</tt> - Whether to guard transitions with the if/unless
     #   conditionals defined for each one
     def initialize(object, machine, options = {})
-      options.assert_valid_keys(:target, :guard)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :target, :guard)
 
       @object = object
       @machine = machine
@@ -28,7 +30,7 @@ module StateMachines
       @guard = options[:guard]
     end
 
-    def initialize_copy(orig) #:nodoc:
+    def initialize_copy(orig) # :nodoc:
       super
       @transitions = nil
     end
@@ -86,7 +88,7 @@ module StateMachines
       !empty? && (@target ? to_name == @target : transitions.empty?)
     end
 
-  private
+    private
 
     # Calculates the number of times the given state has been walked to
     def times_walked_to(state)

data/lib/state_machines/path_collection.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 module StateMachines
   # Represents a collection of paths that are generated based on a set of
   # requirements regarding what states to start and end on
   class PathCollection < Array
-
     # The object whose state machine is being walked
     attr_reader :object
 
@@ -24,8 +27,8 @@ module StateMachines
     # * <tt>:guard</tt> - Whether to guard transitions with the if/unless
     #   conditionals defined for each one
     def initialize(object, machine, options = {})
-      options = {deep: false, from: machine.states.match!(object).name}.merge(options)
-      options.assert_valid_keys( :from, :to, :deep, :guard)
+      options = { deep: false, from: machine.states.match!(object).name }.merge(options)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :from, :to, :deep, :guard)
 
       @object = object
       @machine = machine
@@ -67,7 +70,7 @@ module StateMachines
       flat_map(&:events).uniq
     end
 
-  private
+    private
 
     # Gets the initial set of paths to walk
     def initial_paths

data/lib/state_machines/state.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 module StateMachines
   # A state defines a value that an attribute can be in after being transitioned
   # 0 or more times.  States can represent a value of any type in Ruby, though
@@ -8,7 +12,6 @@ module StateMachines
   # StateMachines::Machine#state for more information about how state-driven
   # behavior can be utilized.
   class State
-
     # The state machine for which this state is defined
     attr_reader :machine
 
@@ -31,7 +34,7 @@ module StateMachines
 
     # Whether or not this state is the initial state to use for new objects
     attr_accessor :initial
-    alias_method :initial?, :initial
+    alias initial? initial
 
     # A custom lambda block for determining whether a given value matches this
     # state
@@ -50,38 +53,58 @@ module StateMachines
     #   (e.g. :value => lambda {Time.now}, :if => lambda {|state| !state.nil?}).
     #   By default, the configured value is matched.
     # * <tt>:human_name</tt> - The human-readable version of this state's name
-    def initialize(machine, name, options = {}) #:nodoc:
-      options.assert_valid_keys(:initial, :value, :cache, :if, :human_name)
+    def initialize(machine, name, options = nil, initial: false, value: :__not_provided__, cache: nil, if: nil, human_name: nil, **extra_options) # :nodoc:
+      # Handle both old hash style and new kwargs style for backward compatibility
+      if options.is_a?(Hash)
+        # Old style: initialize(machine, name, {initial: true, value: 'foo'})
+        StateMachines::OptionsValidator.assert_valid_keys!(options, :initial, :value, :cache, :if, :human_name)
+        initial = options.fetch(:initial, false)
+        value = options.include?(:value) ? options[:value] : :__not_provided__
+        cache = options[:cache]
+        if_condition = options[:if]
+        human_name = options[:human_name]
+      else
+        # New style: initialize(machine, name, initial: true, value: 'foo')
+        # options parameter should be nil in this case
+        raise ArgumentError, "Unexpected positional argument: #{options.inspect}" unless options.nil?
+
+        StateMachines::OptionsValidator.assert_valid_keys!(extra_options, :initial, :value, :cache, :if, :human_name) unless extra_options.empty?
+        if_condition = binding.local_variable_get(:if) # 'if' is a keyword, need special handling
+      end
 
       @machine = machine
       @name = name
       @qualified_name = name && machine.namespace ? :"#{machine.namespace}_#{name}" : name
-      @human_name = options[:human_name] || (@name ? @name.to_s.tr('_', ' ') : 'nil')
-      @value = options.include?(:value) ? options[:value] : name&.to_s
-      @cache = options[:cache]
-      @matcher = options[:if]
-      @initial = options[:initial] == true
+      @human_name = human_name || (@name ? @name.to_s.tr('_', ' ') : 'nil')
+      @value = value == :__not_provided__ ? name&.to_s : value
+      @cache = cache
+      @matcher = if_condition
+      @initial = initial == true
       @context = StateContext.new(self)
 
-      if name
-        conflicting_machines = machine.owner_class.state_machines.select { |other_name, other_machine| other_machine != machine && other_machine.states[qualified_name, :qualified_name] }
-
-        # Output a warning if another machine has a conflicting qualified name
-        # for a different attribute
-        if (conflict = conflicting_machines.detect { |_other_name, other_machine| other_machine.attribute != machine.attribute })
-          _name, other_machine = conflict
-          warn "State #{qualified_name.inspect} for #{machine.name.inspect} is already defined in #{other_machine.name.inspect}"
-        elsif conflicting_machines.empty?
-          # Only bother adding predicates when another machine for the same
-          # attribute hasn't already done so
-          add_predicate
-        end
+      return unless name
+
+      conflicting_machines = machine.owner_class.state_machines.select do |_other_name, other_machine|
+        other_machine != machine && other_machine.states[qualified_name, :qualified_name]
+      end
+
+      # Output a warning if another machine has a conflicting qualified name
+      # for a different attribute
+      if (conflict = conflicting_machines.detect do |_other_name, other_machine|
+        other_machine.attribute != machine.attribute
+      end)
+        _name, other_machine = conflict
+        warn "State #{qualified_name.inspect} for #{machine.name.inspect} is already defined in #{other_machine.name.inspect}"
+      elsif conflicting_machines.empty?
+        # Only bother adding predicates when another machine for the same
+        # attribute hasn't already done so
+        add_predicate
       end
     end
 
     # Creates a copy of this state, excluding the context to prevent conflicts
     # across different machines.
-    def initialize_copy(orig) #:nodoc:
+    def initialize_copy(orig) # :nodoc:
       super
       @context = StateContext.new(self)
     end
@@ -96,7 +119,7 @@ module StateMachines
     # Any objects in a final state will remain so forever given the current
     # machine's definition.
     def final?
-      !machine.events.any? do |event|
+      machine.events.none? do |event|
         event.branches.any? do |branch|
           branch.state_requirements.any? do |requirement|
             requirement[:from].matches?(name) && !requirement[:to].matches?(name, from: name)
@@ -126,7 +149,7 @@ module StateMachines
     #   description or just the internal name
     def description(options = {})
       label = options[:human_name] ? human_name : name
-      description = label ? label.to_s : label.inspect
+      description = +(label ? label.to_s : label.inspect)
       description << " (#{@value.is_a?(Proc) ? '*' : @value.inspect})" unless name.to_s == @value.to_s
       description
     end
@@ -178,27 +201,27 @@ module StateMachines
     #
     # This can be called multiple times.  Each time a new context is created,
     # a new module will be included in the owner class.
-    def context(&block)
+    def context(&)
       # Include the context
       context = @context
       machine.owner_class.class_eval { include context }
 
       # Evaluate the method definitions and track which ones were added
       old_methods = context_methods
-      context.class_eval(&block)
-      new_methods = context_methods.to_a.select { |(name, method)| old_methods[name] != method }
+      context.class_eval(&)
+      new_methods = context_methods.to_a.reject { |(name, method)| old_methods[name] == method }
 
       # Alias new methods so that the only execute when the object is in this state
       new_methods.each do |(method_name, _method)|
         context_name = context_name_for(method_name)
-        context.class_eval <<-end_eval, __FILE__, __LINE__ + 1
+        context.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           alias_method :"#{context_name}", :#{method_name}
           def #{method_name}(*args, &block)
             state = self.class.state_machine(#{machine.name.inspect}).states.fetch(#{name.inspect})
             options = {:method_missing => lambda {super(*args, &block)}, :method_name => #{method_name.inspect}}
             state.call(self, :"#{context_name}", *(args + [options]), &block)
           end
-        end_eval
+        END_EVAL
       end
 
       true
@@ -216,31 +239,30 @@ module StateMachines
     #
     # If the method has never been defined for this state, then a NoMethodError
     # will be raised.
-    def call(object, method, *args, &block)
+    def call(object, method, *args, &)
       options = args.last.is_a?(Hash) ? args.pop : {}
-      options = {method_name: method}.merge(options)
+      options = { method_name: method }.merge(options)
       state = machine.states.match!(object)
 
       if state == self && object.respond_to?(method)
-        object.send(method, *args, &block)
-      elsif method_missing = options[:method_missing]
+        object.send(method, *args, &)
+      elsif (method_missing = options[:method_missing])
         # Dispatch to the superclass since the object either isn't in this state
         # or this state doesn't handle the method
         begin
           method_missing.call
-        rescue NoMethodError => ex
-          if ex.name.to_s == options[:method_name].to_s && ex.args == args
-            # No valid context for this method
-            raise InvalidContext.new(object, "State #{state.name.inspect} for #{machine.name.inspect} is not a valid context for calling ##{options[:method_name]}")
-          else
-            raise
-          end
+        rescue NoMethodError => e
+          raise unless e.name.to_s == options[:method_name].to_s && e.args == args
+
+          # No valid context for this method
+          raise InvalidContext.new(object,
+                                   "State #{state.name.inspect} for #{machine.name.inspect} is not a valid context for calling ##{options[:method_name]}")
         end
       end
     end
 
-    def draw(graph, options = {})
-      fail NotImplementedError
+    def draw(graph, options = {}, io = $stdout)
+      machine.renderer.draw_state(self, graph, options, io)
     end
 
     # Generates a nicely formatted description of this state's contents.
@@ -254,7 +276,7 @@ module StateMachines
       "#<#{self.class} #{attributes.map { |attr, value| "#{attr}=#{value.inspect}" } * ' '}>"
     end
 
-  private
+    private
 
     # Should the value be cached after it's evaluated for the first time?
     def cache_value?
@@ -264,9 +286,16 @@ module StateMachines
     # Adds a predicate method to the owner class so long as a name has
     # actually been configured for the state
     def add_predicate
-      # Checks whether the current value matches this state
-      machine.define_helper(:instance, "#{qualified_name}?") do |machine, object|
-        machine.states.matches?(object, name)
+      predicate_method = "#{qualified_name}?"
+
+      if machine.send(:owner_class_ancestor_has_method?, :instance, predicate_method)
+        warn "Instance method #{predicate_method.inspect} is already defined in #{machine.owner_class.ancestors.first.inspect}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true."
+      elsif machine.send(:owner_class_has_method?, :instance, predicate_method)
+        warn "Instance method #{predicate_method.inspect} is already defined in #{machine.owner_class.inspect}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true."
+      else
+        machine.define_helper(:instance, predicate_method) do |machine, object|
+          machine.states.matches?(object, name)
+        end
       end
     end
 

data/lib/state_machines/state_collection.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a collection of states in a state machine
   class StateCollection < NodeCollection
-    def initialize(machine) #:nodoc:
-      super(machine, index: [:name, :qualified_name, :value])
+    def initialize(machine) # :nodoc:
+      super(machine, index: %i[name qualified_name value])
     end
 
     # Determines whether the given object is in a specific state.  If the
@@ -101,7 +103,7 @@ module StateMachines
       order
     end
 
-  private
+    private
 
     # Gets the value for the given attribute on the node
     def value(node, attribute)