state_machines 0.6.0 → 0.30.0

data/lib/state_machines/state_context.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 module StateMachines
   # Represents a module which will get evaluated within the context of a state.
   #
@@ -50,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
@@ -66,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
@@ -86,15 +89,15 @@ module StateMachines
     # See StateMachines::Machine#transition for a description of the possible
     # configurations for defining transitions.
     def transition(options)
-      options.assert_valid_keys(:from, :to, :on, :if, :unless)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :from, :to, :on, :if, :unless)
       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
@@ -119,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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module StateMachines
+  module STDIORenderer
+    module_function def draw_machine(machine, io: $stdout)
+      draw_class(machine: machine, io: io)
+      draw_states(machine: machine, io: io)
+      draw_events(machine: machine, io: io)
+    end
+
+    module_function def draw_class(machine:, io: $stdout)
+      io.puts "Class: #{machine.owner_class.name}"
+    end
+
+    module_function def draw_states(machine:, io: $stdout)
+      io.puts '  States:'
+      if machine.states.to_a.empty?
+        io.puts '    - None'
+      else
+        machine.states.each do |state|
+          io.puts "    - #{state.name}"
+        end
+      end
+    end
+
+    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)
+      io = io || options[:io] || $stdout
+      io.puts "  Branch: #{branch.inspect}"
+    end
+
+    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:'
+      if machine.events.to_a.empty?
+        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 << "#{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
+              io.puts out
+            end
+          end
+        end
+      end
+    end
+
+    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(', ')
+      end
+    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