state_machines 0.20.0 → 0.30.0

data/lib/state_machines/machine_collection.rb

@@ -25,20 +25,24 @@ module StateMachines
     #   writing to the object.  Default is to write directly to the object.
     def initialize_states(object, options = {}, attributes = {})
       StateMachines::OptionsValidator.assert_valid_keys!(options, :static, :dynamic, :to)
-      options = {static: true, dynamic: true}.merge(options)
+      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
@@ -52,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
 
@@ -66,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
@@ -78,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

@@ -515,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

@@ -32,13 +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_method :except, :-
+    alias except -
 
     # Always returns true
-    def matches?(value, context = {})
+    def matches?(_value, _context = {})
       true
     end
 
@@ -63,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
 
@@ -83,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

@@ -30,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

@@ -26,11 +26,10 @@ module StateMachines
       @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 = []
@@ -38,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
@@ -116,8 +117,8 @@ module StateMachines
     # ...produces:
     #
     #   parked -- idling --
-    def each
-      @nodes.each { |node| yield node }
+    def each(&)
+      @nodes.each(&)
       self
     end
 
@@ -145,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
@@ -163,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
@@ -205,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/path.rb

@@ -7,8 +7,6 @@ module StateMachines
   # 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
 
@@ -32,7 +30,7 @@ module StateMachines
       @guard = options[:guard]
     end
 
-    def initialize_copy(orig) #:nodoc:
+    def initialize_copy(orig) # :nodoc:
       super
       @transitions = nil
     end
@@ -90,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

@@ -6,7 +6,6 @@ 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
 
@@ -28,7 +27,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 = {deep: false, from: machine.states.match!(object).name}.merge(options)
+      options = { deep: false, from: machine.states.match!(object).name }.merge(options)
       StateMachines::OptionsValidator.assert_valid_keys!(options, :from, :to, :deep, :guard)
 
       @object = object
@@ -71,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

@@ -67,8 +67,9 @@ module StateMachines
         # 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
+        if_condition = binding.local_variable_get(:if) # 'if' is a keyword, need special handling
       end
 
       @machine = machine
@@ -200,14 +201,14 @@ 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)
+      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
@@ -238,13 +239,13 @@ 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)
       state = machine.states.match!(object)
 
       if state == self && object.respond_to?(method)
-        object.send(method, *args, &block)
+        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

data/lib/state_machines/state_collection.rb

@@ -3,8 +3,8 @@
 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
@@ -103,7 +103,7 @@ module StateMachines
       order
     end
 
-  private
+    private
 
     # Gets the value for the given attribute on the node
     def value(node, attribute)

data/lib/state_machines/state_context.rb

@@ -54,7 +54,6 @@ module StateMachines
   #   vehicle.simulate = true
   #   vehicle.moving?           # => false
   class StateContext < Module
-
     include EvalHelpers
 
     # The state machine for which this context's state is defined
@@ -70,7 +69,7 @@ module StateMachines
 
       state_name = state.name
       machine_name = machine.name
-      @condition = lambda { |object| object.class.state_machine(machine_name).states.matches?(object, state_name) }
+      @condition = ->(object) { object.class.state_machine(machine_name).states.matches?(object, state_name) }
     end
 
     # Creates a new transition that determines what to change the current state
@@ -94,11 +93,11 @@ module StateMachines
       raise ArgumentError, 'Must specify :on event' unless options[:on]
       raise ArgumentError, 'Must specify either :to or :from state' unless !options[:to] ^ !options[:from]
 
-      machine.transition(options.merge(options[:to] ? {from: state.name} : {to: state.name}))
+      machine.transition(options.merge(options[:to] ? { from: state.name } : { to: state.name }))
     end
 
     # Hooks in condition-merging to methods that don't exist in this module
-    def method_missing(*args, &block)
+    def method_missing(*args, &)
       # Get the configuration
       if args.last.is_a?(Hash)
         options = args.last
@@ -123,13 +122,13 @@ module StateMachines
         object = condition_args.first || self
 
         proxy.evaluate_method(object, proxy_condition) &&
-        Array(if_condition).all? { |condition| proxy.evaluate_method(object, condition) } &&
-        !Array(unless_condition).any? { |condition| proxy.evaluate_method(object, condition) }
+          Array(if_condition).all? { |condition| proxy.evaluate_method(object, condition) } &&
+          !Array(unless_condition).any? { |condition| proxy.evaluate_method(object, condition) }
       end
 
       # Evaluate the method on the owner class with the condition proxied
       # through
-      machine.owner_class.send(*args, &block)
+      machine.owner_class.send(*args, &)
     end
   end
 end

data/lib/state_machines/stdio_renderer.rb

@@ -13,9 +13,9 @@ module StateMachines
     end
 
     module_function def draw_states(machine:, io: $stdout)
-      io.puts "  States:"
+      io.puts '  States:'
       if machine.states.to_a.empty?
-        io.puts "    - None"
+        io.puts '    - None'
       else
         machine.states.each do |state|
           io.puts "    - #{state.name}"
@@ -23,31 +23,31 @@ module StateMachines
       end
     end
 
-    module_function def draw_event(event, graph, options: {}, io: $stdout)
+    module_function def draw_event(event, _graph, options: {}, io: $stdout)
       io = io || options[:io] || $stdout
       io.puts "  Event: #{event.name}"
     end
 
-    module_function def draw_branch(branch, graph, event, options: {}, io: $stdout)
+    module_function def draw_branch(branch, _graph, _event, options: {}, io: $stdout)
       io = io || options[:io] || $stdout
       io.puts "  Branch: #{branch.inspect}"
     end
 
-    module_function def draw_state(state, graph, options: {}, io: $stdout)
+    module_function def draw_state(state, _graph, options: {}, io: $stdout)
       io = io || options[:io] || $stdout
       io.puts "  State: #{state.name}"
     end
 
     module_function def draw_events(machine:, io: $stdout)
-      io.puts "  Events:"
+      io.puts '  Events:'
       if machine.events.to_a.empty?
-        io.puts "    - None"
+        io.puts '    - None'
       else
         machine.events.each do |event|
           io.puts "    - #{event.name}"
           event.branches.each do |branch|
             branch.state_requirements.each do |requirement|
-              out = +"      - "
+              out = +'      - '
               out << "#{draw_requirement(requirement[:from])} => #{draw_requirement(requirement[:to])}"
               out << " IF #{branch.if_condition}" if branch.if_condition
               out << " UNLESS #{branch.unless_condition}" if branch.unless_condition
@@ -60,14 +60,14 @@ module StateMachines
 
     module_function def draw_requirement(requirement)
       case requirement
-        when StateMachines::BlacklistMatcher
-          "ALL EXCEPT #{requirement.values.join(', ')}"
-        when StateMachines::AllMatcher
-          "ALL"
-        when StateMachines::LoopbackMatcher
-          "SAME"
-        else
-          requirement.values.join(', ')
+      when StateMachines::BlacklistMatcher
+        "ALL EXCEPT #{requirement.values.join(', ')}"
+      when StateMachines::AllMatcher
+        'ALL'
+      when StateMachines::LoopbackMatcher
+        'SAME'
+      else
+        requirement.values.join(', ')
       end
     end
   end

data/lib/state_machines/syntax_validator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'ripper'
+
+module StateMachines
+  # Cross-platform syntax validation for eval strings
+  # Supports CRuby, JRuby, TruffleRuby via pluggable backends
+  module SyntaxValidator
+    # Public API: raises SyntaxError if code is invalid
+    def validate!(code, filename = '(eval)')
+      backend.validate!(code, filename)
+    end
+    module_function :validate!
+
+    private
+
+    # Lazily pick the best backend for this platform
+    # Prefer RubyVM for performance on CRuby, fallback to Ripper for compatibility
+    def backend
+      @backend ||= if RubyVmBackend.available?
+                     RubyVmBackend
+                   else
+                     RipperBackend
+                   end
+    end
+    module_function :backend
+
+    # MRI backend using RubyVM::InstructionSequence
+    module RubyVmBackend
+      def available?
+        RUBY_ENGINE == 'ruby'
+      end
+      module_function :available?
+
+      def validate!(code, filename)
+        # compile will raise a SyntaxError on bad syntax
+        RubyVM::InstructionSequence.compile(code, filename)
+        true
+      end
+      module_function :validate!
+    end
+
+    # Universal Ruby backend via Ripper
+    module RipperBackend
+      def validate!(code, filename)
+        sexp = Ripper.sexp(code)
+        if sexp.nil?
+          # Ripper.sexp returns nil on a parse error, but no exception
+          raise SyntaxError, "syntax error in #{filename}"
+        end
+
+        true
+      end
+      module_function :validate!
+    end
+  end
+end