state_machines 0.6.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d22dcf0b70eca7cbf9a6894d592609874cfdef01474b70a2226018c0e8966b7
-  data.tar.gz: 9a9bed680181f45bc613649bf4f3b90a4ea1e198e8fb19f734d264c7652e5051
+  metadata.gz: 5aa5d105c78cb53f15f42e8662dd7f8e0d0d5f8807b88dcbd8b4201f13718384
+  data.tar.gz: d761cedbe052c5c8829626e0875f54dce064f7156162119b4a040594b439068c
 SHA512:
-  metadata.gz: d1446488cbb427e407611d2cba2e571401931a4a20f9f8655e14ebf896990468d24a94a02ba708627db8beb3a3821ac481b220551f0d0c02e366ba3d78112da4
-  data.tar.gz: 4949561813ac58b6442611d37083091b6c4532f41227f3f9f0999bbecc18c18aacc458f9aa6d6570b5855b6a30a24394d421e6b6012dfa4ebed638a642da82f3
+  metadata.gz: 37398c9ca5f2de7413dfb7a8a467984d0fc4d47f8367ea0747fec6d9c1eaca5a7c3439f37988c02dd8ce27622a9a9e54cf5cc0b2d84404f00f92a862c168bb23
+  data.tar.gz: 159022534eb3c308bc2f2c8e960f111053631d3e10adafc9ae8156c95a26165f48690c682229a577bdfecf918b335ebe5b6d57e82e095c924585ad8d11b9d1ee

data/README.md

@@ -1,5 +1,4 @@
 ![Build Status](https://github.com/state-machines/state_machines/actions/workflows/ruby.yml/badge.svg)
-[![Code Climate](https://codeclimate.com/github/state-machines/state_machines.svg)](https://codeclimate.com/github/state-machines/state_machines)
 # State Machines
 
 State Machines adds support for creating state machines for attributes on any Ruby class.
@@ -255,6 +254,71 @@ vehicle.state_name              # => :parked
 # vehicle.state = :parked
 ```
 
+## Testing
+
+State Machines provides a `TestHelper` module with assertion methods to make testing state machines easier and more expressive.
+
+### Setup
+
+Include the test helper in your test class:
+
+```ruby
+# For Minitest
+class VehicleTest < Minitest::Test
+  include StateMachines::TestHelper
+  
+  def test_initial_state
+    vehicle = Vehicle.new
+    assert_state vehicle, :state, :parked
+  end
+end
+
+# For RSpec  
+RSpec.describe Vehicle do
+  include StateMachines::TestHelper
+  
+  it "starts in parked state" do
+    vehicle = Vehicle.new
+    assert_state vehicle, :state, :parked
+  end
+end
+```
+
+### Available Assertions
+
+The TestHelper provides both basic assertions and comprehensive state machine-specific assertions with `sm_` prefixes:
+
+#### Basic Assertions
+
+```ruby
+vehicle = Vehicle.new
+assert_state vehicle, :state, :parked
+assert_can_transition vehicle, :ignite
+assert_cannot_transition vehicle, :shift_up
+assert_transition vehicle, :ignite, :state, :idling
+```
+
+#### Extended State Machine Assertions
+
+```ruby
+machine = Vehicle.state_machine(:state)
+vehicle = Vehicle.new
+
+# State configuration
+assert_sm_states_list machine, [:parked, :idling, :stalled]
+assert_sm_initial_state machine, :parked
+
+# Event behavior  
+assert_sm_event_triggers vehicle, :ignite
+refute_sm_event_triggers vehicle, :shift_up
+assert_sm_event_raises_error vehicle, :invalid_event, StateMachines::InvalidTransition
+
+# Persistence (with ActiveRecord integration)
+assert_sm_state_persisted record, expected: :active
+```
+
+The test helper works with both Minitest and RSpec, automatically detecting your testing framework.
+
 ## Additional Topics
 
 ### Explicit vs. Implicit Event Transitions
@@ -428,7 +492,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 +528,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 +560,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 +663,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/branch.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 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
@@ -112,15 +116,15 @@ module StateMachines
     #   branch.match(object, :on => :ignite)  # => {:to => ..., :from => ..., :on => ...}
     #   branch.match(object, :on => :park)    # => nil
     def match(object, query = {})
-      query.assert_valid_keys(:from, :to, :on, :guard)
+      StateMachines::OptionsValidator.assert_valid_keys!(query, :from, :to, :on, :guard)
 
       if (match = match_query(query)) && matches_conditions?(object, query)
         match
       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
@@ -129,7 +133,7 @@ module StateMachines
     # whitelist nor a blacklist option is specified, then an AllMatcher is
     # built.
     def build_matcher(options, whitelist_option, blacklist_option)
-      options.assert_exclusive_keys(whitelist_option, blacklist_option)
+      StateMachines::OptionsValidator.assert_exclusive_keys!(options, whitelist_option, blacklist_option)
 
       if options.include?(whitelist_option)
         value = options[whitelist_option]

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,9 +1,10 @@
+# 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
 # * A set of initializers for setting state_machine defaults based on the current
 #   running environment (such as within Rails)
-require 'state_machines/assertions'
 require 'state_machines/error'
 
 require 'state_machines/extensions'
@@ -40,4 +41,4 @@ require 'state_machines/path_collection'
 require 'state_machines/machine'
 require 'state_machines/machine_collection'
 
-require 'state_machines/macro_methods'
+require 'state_machines/macro_methods'

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,7 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+
 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
@@ -30,13 +34,22 @@ module StateMachines
     #
     # Configuration options:
     # * <tt>:human_name</tt> - The human-readable version of this event's name
-    def initialize(machine, name, options = {}) #:nodoc:
-      options.assert_valid_keys(:human_name)
+    def initialize(machine, name, options = 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, {human_name: 'Custom Name'})
+        StateMachines::OptionsValidator.assert_valid_keys!(options, :human_name)
+        human_name = options[:human_name]
+      else
+        # New style: initialize(machine, name, human_name: 'Custom Name')
+        raise ArgumentError, "Unexpected positional argument: #{options.inspect}" unless options.nil?
+        StateMachines::OptionsValidator.assert_valid_keys!(extra_options, :human_name) unless extra_options.empty?
+      end
 
       @machine = machine
       @name = name
       @qualified_name = machine.namespace ? :"#{name}_#{machine.namespace}" : name
-      @human_name = options[:human_name] || @name.to_s.tr('_', ' ')
+      @human_name = human_name || @name.to_s.tr('_', ' ')
       reset
 
       # Output a warning if another event has a conflicting qualified name
@@ -89,7 +102,9 @@ module StateMachines
 
       # Only a certain subset of explicit options are allowed for transition
       # requirements
-      options.assert_valid_keys(:from, :to, :except_from, :except_to, :if, :unless) if (options.keys - [:from, :to, :on, :except_from, :except_to, :except_on, :if, :unless]).empty?
+      if (options.keys - [:from, :to, :on, :except_from, :except_to, :except_on, :if, :unless]).empty?
+        StateMachines::OptionsValidator.assert_valid_keys!(options, :from, :to, :except_from, :except_to, :if, :unless)
+      end
 
       branches << branch = Branch.new(options.merge(on: name))
       @known_states |= branch.known_states
@@ -119,7 +134,7 @@ module StateMachines
     # * <tt>:guard</tt> - Whether to guard transitions with the if/unless
     #   conditionals defined for each one.  Default is true.
     def transition_for(object, requirements = {})
-      requirements.assert_valid_keys(:from, :to, :guard)
+      StateMachines::OptionsValidator.assert_valid_keys!(requirements, :from, :to, :guard)
       requirements[:from] = machine.states.match!(object).name unless (custom_from_state = requirements.include?(:from))
 
       branches.each do |branch|
@@ -180,8 +195,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,8 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+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 +403,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
@@ -502,7 +452,7 @@ module StateMachines
     # Creates a new state machine for the given attribute
     def initialize(owner_class, *args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
-      options.assert_valid_keys(:attribute, :initial, :initialize, :action, :plural, :namespace, :integration, :messages, :use_transactions)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :attribute, :initial, :initialize, :action, :plural, :namespace, :integration, :messages, :use_transactions)
 
       # Find an integration that matches this machine's owner class
       if options.include?(:integration)
@@ -644,12 +594,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
@@ -1004,7 +954,7 @@ module StateMachines
     # options hash which contains at least <tt>:if</tt> condition support.
     def state(*names, &block)
       options = names.last.is_a?(Hash) ? names.pop : {}
-      options.assert_valid_keys(:value, :cache, :if, :human_name)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :value, :cache, :if, :human_name)
 
       # Store the context so that it can be used for / matched against any state
       # that gets added
@@ -1053,7 +1003,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 +1026,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
@@ -1307,7 +1257,7 @@ module StateMachines
     #   end
     def event(*names, &block)
       options = names.last.is_a?(Hash) ? names.pop : {}
-      options.assert_valid_keys(:human_name)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :human_name)
 
       # Store the context so that it can be used for / matched against any event
       # that gets added
@@ -1749,7 +1699,7 @@ module StateMachines
     def after_failure(*args, &block)
       options = (args.last.is_a?(Hash) ? args.pop : {})
       options[:do] = args if args.any?
-      options.assert_valid_keys(:on, :do, :if, :unless)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :on, :do, :if, :unless)
 
       add_callback(:failure, options, &block)
     end
@@ -1874,8 +1824,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 +1838,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