state_machines 0.6.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d22dcf0b70eca7cbf9a6894d592609874cfdef01474b70a2226018c0e8966b7
-  data.tar.gz: 9a9bed680181f45bc613649bf4f3b90a4ea1e198e8fb19f734d264c7652e5051
+  metadata.gz: 39c8073bdf33aff2e34bfc3403db686c7d6e4344f158e144cb881230b10d9597
+  data.tar.gz: 150e14164e42addded79421e90456de2f60b4c451c743ee31a8eb2227d91896b
 SHA512:
-  metadata.gz: d1446488cbb427e407611d2cba2e571401931a4a20f9f8655e14ebf896990468d24a94a02ba708627db8beb3a3821ac481b220551f0d0c02e366ba3d78112da4
-  data.tar.gz: 4949561813ac58b6442611d37083091b6c4532f41227f3f9f0999bbecc18c18aacc458f9aa6d6570b5855b6a30a24394d421e6b6012dfa4ebed638a642da82f3
+  metadata.gz: 34af008f9378c058a199dd05d3204df5d995466f7db126589a8614d540bb636ce08c42f38796504753be8414431623e02b30c10d772fc2d524d4a2f9f4ba58e2
+  data.tar.gz: a64f178f0f5ce8e13139b871c3cd351570df7c665f43338201225ff27d2482fe3cb3e1619f79e01544d4f9b3341bb9e589db7a659717e4975312684b6fd0ee82

data/README.md

@@ -428,7 +428,7 @@ easily migrate from a different library, you can do so as shown below:
 ```ruby
 class Vehicle
   state_machine initial: :parked do
-    ...
+    # ...
 
     state :parked do
       transition to: :idling, :on => [:ignite, :shift_up], if: :seatbelt_on?
@@ -464,7 +464,7 @@ example below:
 ```ruby
 class Vehicle
   state_machine initial: :parked do
-    ...
+    # ...
 
     transition parked: :idling, :on => [:ignite, :shift_up]
     transition first_gear: :second_gear, second_gear: :third_gear, on: :shift_up
@@ -496,12 +496,31 @@ class Vehicle
       transition [:idling, :first_gear] => :parked
     end
 
-    ...
+    # ...
   end
 end
 ```
 
-However, there may be cases where the definition of a state machine is **dynamic**.
+#### Draw state machines
+
+State machines includes a default STDIORenderer for debugging state machines without external dependencies.
+This renderer can be used to visualize the state machine in the console.
+
+To use the renderer, simply call the `draw` method on the state machine:
+
+```ruby
+Vehicle.state_machine.draw # Outputs the state machine diagram to the console
+```
+
+You can customize the output by passing in options to the `draw` method, such as the output stream:
+
+```ruby
+Vehicle.state_machine.draw(io: $stderr) # Outputs the state machine diagram to stderr
+```
+
+#### Dynamic definitions
+
+There may be cases where the definition of a state machine is **dynamic**.
 This means that you don't know the possible states or events for a machine until
 runtime.  For example, you may allow users in your application to manage the
 state machine of a project or task in your system.  This means that the list of
@@ -580,22 +599,19 @@ transitions.
 
 Ruby versions officially supported and tested:
 
-* Ruby (MRI) 2.6.0+
-* JRuby
-* Rubinius
+* Ruby (MRI) 3.0.0+
 
 For graphing state machine:
 
-* [state_machines-graphviz](http://github.com/state-machines/state_machines-graphviz)
+* [state_machines-graphviz](https://github.com/state-machines/state_machines-graphviz)
 
 For documenting state machines:
 
-* [state_machines-yard](http://github.com/state-machines/state_machines-yard)
-
+* [state_machines-yard](https://github.com/state-machines/state_machines-yard)
 
-## TODO
+For RSpec testing, use the custom RSpec matchers:
 
-* Add matchers/assertions for rspec and minitest
+* [state_machines-rspec](https://github.com/state-machines/state_machines-rspec)
 
 ## Contributing
 

data/lib/state_machines/assertions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # Provides a set of helper methods for making assertions about the content
   # of various objects

data/lib/state_machines/branch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a set of requirements that must be met in order for a transition
   # or callback to occur.  Branches verify that the event, from state, and to
@@ -119,8 +121,8 @@ module StateMachines
       end
     end
 
-    def draw(graph, event, valid_states)
-     fail NotImplementedError
+    def draw(graph, event, valid_states, io = $stdout)
+      machine.renderer.draw_branch(self, graph, event, valid_states, io)
     end
 
   protected

data/lib/state_machines/callback.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'state_machines/branch'
 require 'state_machines/eval_helpers'
 

data/lib/state_machines/core.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Load all of the core implementation required to use state_machine.  This
 # includes:
 # * StateMachines::MacroMethods which adds the state_machine DSL to your class

data/lib/state_machines/core_ext/class/state_machine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Class.class_eval do
   include StateMachines::MacroMethods
 end

data/lib/state_machines/core_ext.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 # Loads all of the extensions to be made to Ruby core classes
 require 'state_machines/core_ext/class/state_machine'

data/lib/state_machines/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # An error occurred during a state machine invocation
   class Error < StandardError

data/lib/state_machines/eval_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Provides a set of helper methods for evaluating methods within the context
   # of an object.
@@ -50,19 +52,17 @@ module StateMachines
     #   evaluate_method(person, lambda {|person| person.name}, 21)                              # => "John Smith"
     #   evaluate_method(person, lambda {|person, age| "#{person.name} is #{age}"}, 21)          # => "John Smith is 21"
     #   evaluate_method(person, lambda {|person, age| "#{person.name} is #{age}"}, 21, 'male')  # => ArgumentError: wrong number of arguments (3 for 2)
-    def evaluate_method(object, method, *args, &block)
+    def evaluate_method(object, method, *args, **kwargs, &block)
       case method
         when Symbol
           klass = (class << object; self; end)
           args = [] if (klass.method_defined?(method) || klass.private_method_defined?(method)) && object.method(method).arity == 0
-          object.send(method, *args, &block)
-        when Proc, Method
+          object.send(method, *args, **kwargs, &block)
+        when Proc
           args.unshift(object)
           arity = method.arity
-
-          # Procs don't support blocks in < Ruby 1.9, so it's tacked on as an
-          # argument for consistency across versions of Ruby
-          if block_given? && Proc === method && arity != 0
+          # Handle blocks for Procs
+          if block_given? && arity != 0
             if [1, 2].include?(arity)
               # Force the block to be either the only argument or the 2nd one
               # after the object (may mean additional arguments get discarded)
@@ -76,9 +76,38 @@ module StateMachines
             args = args[0, arity] if [0, 1].include?(arity)
           end
 
-          method.is_a?(Proc) ? method.call(*args) : method.call(*args, &block)
+        # Call the Proc with the arguments
+        method.call(*args, **kwargs)
+
+        when Method
+          args.unshift(object)
+          arity = method.arity
+
+          # Methods handle blocks via &block, not as arguments
+          # Only limit arguments if necessary based on arity
+          args = args[0, arity] if [0, 1].include?(arity)
+
+          # Call the Method with the arguments and pass the block
+          method.call(*args, **kwargs, &block)
         when String
-          eval(method, object.instance_eval { binding }, &block)
+          if block_given?
+            if StateMachines::Transition.pause_supported?
+              eval(method, object.instance_eval { binding }, &block)
+            else
+              # Support for JRuby and Truffle Ruby, which don't support binding blocks
+              eigen = class << object; self; end
+              eigen.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                  def __temp_eval_method__(*args, &b)
+                    #{method}
+                  end
+                RUBY
+              result = object.__temp_eval_method__(*args, &block)
+              eigen.send(:remove_method, :__temp_eval_method__)
+              result
+            end
+          else
+            eval(method, object.instance_eval { binding })
+          end
         else
           raise ArgumentError, 'Methods must be a symbol denoting the method to call, a block to be invoked, or a string to be evaluated'
       end

data/lib/state_machines/event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # An event defines an action that transitions an attribute from one state to
   # another.  The state that an attribute is transitioned to depends on the
@@ -180,8 +182,8 @@ module StateMachines
     end
 
 
-    def draw(graph, options = {})
-      fail NotImplementedError
+    def draw(graph, options = {}, io = $stdout)
+      machine.renderer.draw_event(self, graph, options, io)
     end
 
     # Generates a nicely formatted description of this event's contents.

data/lib/state_machines/event_collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a collection of events in a state machine
   class EventCollection < NodeCollection

data/lib/state_machines/extensions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   module ClassMethods
     def self.extended(base) #:nodoc:

data/lib/state_machines/helper_module.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a type of module that defines instance / class methods for a
   # state machine

data/lib/state_machines/integrations/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   module Integrations
     # Provides a set of base helpers for managing individual integrations

data/lib/state_machines/integrations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Integrations allow state machines to take advantage of features within the
   # context of a particular library.  This is currently most useful with

data/lib/state_machines/machine/class_methods.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module StateMachines
+  class Machine
+    module ClassMethods
+      # Attempts to find or create a state machine for the given class.  For
+      # example,
+      #
+      #   StateMachines::Machine.find_or_create(Vehicle)
+      #   StateMachines::Machine.find_or_create(Vehicle, :initial => :parked)
+      #   StateMachines::Machine.find_or_create(Vehicle, :status)
+      #   StateMachines::Machine.find_or_create(Vehicle, :status, :initial => :parked)
+      #
+      # If a machine of the given name already exists in one of the class's
+      # superclasses, then a copy of that machine will be created and stored
+      # in the new owner class (the original will remain unchanged).
+      def find_or_create(owner_class, *args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        name = args.first || :state
+
+        # Find an existing machine
+        machine = owner_class.respond_to?(:state_machines) &&
+                  (args.first && owner_class.state_machines[name] || !args.first &&
+                  owner_class.state_machines.values.first) || nil
+
+        if machine
+          # Only create a new copy if changes are being made to the machine in
+          # a subclass
+          if machine.owner_class != owner_class && (options.any? || block_given?)
+            machine = machine.clone
+            machine.initial_state = options[:initial] if options.include?(:initial)
+            machine.owner_class = owner_class
+          end
+
+          # Evaluate DSL
+          machine.instance_eval(&block) if block_given?
+        else
+          # No existing machine: create a new one
+          machine = new(owner_class, name, options, &block)
+        end
+
+        machine
+      end
+
+      def draw(*)
+        raise NotImplementedError
+      end
+
+      # Default messages to use for validation errors in ORM integrations
+      attr_accessor :ignore_method_conflicts
+
+      def default_messages
+        @default_messages ||= {
+          invalid: 'is invalid',
+          invalid_event: 'cannot transition when %s',
+          invalid_transition: 'cannot transition via "%1$s"'
+        }
+      end
+
+      def default_messages=(messages)
+        @default_messages = messages
+      end
+
+      def replace_messages(message_hash)
+        message_hash.each do |key, value|
+          default_messages[key] = value
+        end
+      end
+
+      attr_writer :renderer
+
+      def renderer
+        return @renderer if @renderer
+
+        STDIORenderer
+      end
+    end
+  end
+end

data/lib/state_machines/machine.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'machine/class_methods' 
+
 module StateMachines
   # Represents a state machine for a particular attribute.  State machines
   # consist of states, events and a set of transitions that define how the
@@ -398,65 +402,10 @@ module StateMachines
   # machine's behavior, refer to all constants defined under the
   # StateMachines::Integrations namespace.
   class Machine
-
+    extend ClassMethods
     include EvalHelpers
     include MatcherHelpers
 
-    class << self
-      # Attempts to find or create a state machine for the given class.  For
-      # example,
-      #
-      #   StateMachines::Machine.find_or_create(Vehicle)
-      #   StateMachines::Machine.find_or_create(Vehicle, :initial => :parked)
-      #   StateMachines::Machine.find_or_create(Vehicle, :status)
-      #   StateMachines::Machine.find_or_create(Vehicle, :status, :initial => :parked)
-      #
-      # If a machine of the given name already exists in one of the class's
-      # superclasses, then a copy of that machine will be created and stored
-      # in the new owner class (the original will remain unchanged).
-      def find_or_create(owner_class, *args, &block)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        name = args.first || :state
-
-        # Find an existing machine
-        machine = owner_class.respond_to?(:state_machines) &&
-          (args.first && owner_class.state_machines[name] || !args.first &&
-          owner_class.state_machines.values.first) || nil
-
-        if machine
-          # Only create a new copy if changes are being made to the machine in
-          # a subclass
-          if machine.owner_class != owner_class && (options.any? || block_given?)
-            machine = machine.clone
-            machine.initial_state = options[:initial] if options.include?(:initial)
-            machine.owner_class = owner_class
-          end
-
-          # Evaluate DSL
-          machine.instance_eval(&block) if block_given?
-        else
-          # No existing machine: create a new one
-          machine = new(owner_class, name, options, &block)
-        end
-
-        machine
-      end
-
-
-      def draw(*)
-        fail NotImplementedError
-      end
-
-      # Default messages to use for validation errors in ORM integrations
-      attr_accessor :default_messages
-      attr_accessor :ignore_method_conflicts
-    end
-    @default_messages = {
-        invalid: 'is invalid',
-        invalid_event: 'cannot transition when %s',
-        invalid_transition: 'cannot transition via "%1$s"'
-    }
-
     # Whether to ignore any conflicts that are detected for helper methods that
     # get generated for a machine's owner class.  Default is false.
     @ignore_method_conflicts = false
@@ -644,12 +593,12 @@ module StateMachines
     #   vehicle.force_idle = false
     #   Vehicle.state_machine.initial_state(vehicle)  # => #<StateMachines::State name=:parked value="parked" initial=false>
     def initial_state(object)
-      states.fetch(dynamic_initial_state? ? evaluate_method(object, @initial_state) : @initial_state) if instance_variable_defined?('@initial_state')
+      states.fetch(dynamic_initial_state? ? evaluate_method(object, @initial_state) : @initial_state) if instance_variable_defined?(:@initial_state)
     end
 
     # Whether a dynamic initial state is being used in the machine
     def dynamic_initial_state?
-      instance_variable_defined?('@initial_state') && @initial_state.is_a?(Proc)
+      instance_variable_defined?(:@initial_state) && @initial_state.is_a?(Proc)
     end
 
     # Initializes the state on the given object.  Initial values are only set if
@@ -1053,7 +1002,7 @@ module StateMachines
     def read(object, attribute, ivar = false)
       attribute = self.attribute(attribute)
       if ivar
-        object.instance_variable_defined?("@#{attribute}") ? object.instance_variable_get("@#{attribute}") : nil
+        object.instance_variable_defined?(:"@#{attribute}") ? object.instance_variable_get("@#{attribute}") : nil
       else
         object.send(attribute)
       end
@@ -1076,7 +1025,7 @@ module StateMachines
     #   vehicle.event                                           # => "park"
     def write(object, attribute, value, ivar = false)
       attribute = self.attribute(attribute)
-      ivar ? object.instance_variable_set("@#{attribute}", value) : object.send("#{attribute}=", value)
+      ivar ? object.instance_variable_set(:"@#{attribute}", value) : object.send("#{attribute}=", value)
     end
 
     # Defines one or more events for the machine and the transitions that can
@@ -1874,8 +1823,12 @@ module StateMachines
     end
 
 
-    def draw(*)
-      fail NotImplementedError
+    def renderer
+      self.class.renderer
+    end
+
+    def draw(**options)
+      renderer.draw_machine(self, **options)
     end
 
     # Determines whether an action hook was defined for firing attribute-based
@@ -1884,7 +1837,7 @@ module StateMachines
       @action_hook_defined || !self_only && owner_class.state_machines.any? { |name, machine| machine.action == action && machine != self && machine.action_hook?(true) }
     end
 
-  protected
+    protected
 
     # Runs additional initialization hooks.  By default, this is a no-op.
     def after_initialize

data/lib/state_machines/machine_collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a collection of state machines for a class
   class MachineCollection < Hash

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.

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
@@ -33,6 +35,7 @@ module StateMachines
     def -(blacklist)
       BlacklistMatcher.new(blacklist)
     end
+    alias_method :except, :-
 
     # Always returns true
     def matches?(value, context = {})

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

data/lib/state_machines/node_collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 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

data/lib/state_machines/path.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 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

data/lib/state_machines/path_collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a collection of paths that are generated based on a set of
   # requirements regarding what states to start and end on

data/lib/state_machines/state.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 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 +10,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 +32,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,7 +51,7 @@ 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:
+    def initialize(machine, name, options = {}) # :nodoc:
       options.assert_valid_keys(:initial, :value, :cache, :if, :human_name)
 
       @machine = machine
@@ -63,25 +64,29 @@ module StateMachines
       @initial = options[: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 +101,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 +131,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
@@ -186,19 +191,19 @@ module StateMachines
       # 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 }
+      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
@@ -218,29 +223,28 @@ module StateMachines
     # will be raised.
     def call(object, method, *args, &block)
       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]
+      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 +258,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 +268,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,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a collection of states in a state machine
   class StateCollection < NodeCollection

data/lib/state_machines/state_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a module which will get evaluated within the context of a state.
   #

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/transition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # A transition represents a state change for a specific attribute.
   #

data/lib/state_machines/transition_collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
   # Represents a collection of transitions in a state machine
   class TransitionCollection < Array

data/lib/state_machines/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StateMachines
-  VERSION = '0.6.0'
+  VERSION = '0.10.0'
 end

data/lib/state_machines.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 require 'state_machines/version'
 require 'state_machines/core'
-require 'state_machines/core_ext'
+require 'state_machines/core_ext'
+require 'state_machines/stdio_renderer'

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: state_machines
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Abdelkader Boudih
 - Aaron Pfeifer
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,7 +55,6 @@ dependencies:
 description: Adds support for creating state machines for attributes on any Ruby class
 email:
 - terminale@gmail.com
-- aaron@pluginaweek.org
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -79,6 +77,7 @@ files:
 - lib/state_machines/integrations.rb
 - lib/state_machines/integrations/base.rb
 - lib/state_machines/machine.rb
+- lib/state_machines/machine/class_methods.rb
 - lib/state_machines/machine_collection.rb
 - lib/state_machines/macro_methods.rb
 - lib/state_machines/matcher.rb
@@ -89,14 +88,17 @@ files:
 - lib/state_machines/state.rb
 - lib/state_machines/state_collection.rb
 - lib/state_machines/state_context.rb
+- lib/state_machines/stdio_renderer.rb
 - lib/state_machines/transition.rb
 - lib/state_machines/transition_collection.rb
 - lib/state_machines/version.rb
 homepage: https://github.com/state-machines/state_machines
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  changelog_uri: https://github.com/state-machines/state_machines/blob/master/CHANGELOG.md
+  homepage_uri: https://github.com/state-machines/state_machines
+  source_code_uri: https://github.com/state-machines/state_machines
 rdoc_options: []
 require_paths:
 - lib
@@ -111,8 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: State machines for attributes
 test_files: []