state_machines 0.6.0 → 0.30.0

data/lib/state_machines/machine.rb

@@ -1,3 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'options_validator'
+require_relative 'machine/class_methods'
+require_relative 'machine/utilities'
+require_relative 'machine/parsing'
+require_relative 'machine/validation'
+require_relative 'machine/helper_generators'
+require_relative 'machine/action_hooks'
+require_relative 'machine/scoping'
+require_relative 'machine/configuration'
+require_relative 'machine/state_methods'
+require_relative 'machine/event_methods'
+require_relative 'machine/callbacks'
+require_relative 'machine/rendering'
+require_relative 'machine/integration'
+require_relative 'syntax_validator'
+
 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,67 +416,25 @@ 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"'
-    }
+    include Utilities
+    include Parsing
+    include Validation
+    include HelperGenerators
+    include ActionHooks
+    include Scoping
+    include Configuration
+    include StateMethods
+    include EventMethods
+    include Callbacks
+    include Rendering
+    include Integration
 
     # Whether to ignore any conflicts that are detected for helper methods that
     # get generated for a machine's owner class.  Default is false.
+    # Thread-safe via atomic reference updates
     @ignore_method_conflicts = false
 
     # The class that the machine is defined in
@@ -500,114 +476,6 @@ module StateMachines
     attr_reader :use_transactions
 
     # 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)
-
-      # Find an integration that matches this machine's owner class
-      if options.include?(:integration)
-        @integration = options[:integration] && StateMachines::Integrations.find_by_name(options[:integration])
-      else
-        @integration = StateMachines::Integrations.match(owner_class)
-      end
-
-      if @integration
-        extend @integration
-        options = (@integration.defaults || {}).merge(options)
-      end
-
-      # Add machine-wide defaults
-      options = {use_transactions: true, initialize: true}.merge(options)
-
-      # Set machine configuration
-      @name = args.first || :state
-      @attribute = options[:attribute] || @name
-      @events = EventCollection.new(self)
-      @states = StateCollection.new(self)
-      @callbacks = {before: [], after: [], failure: []}
-      @namespace = options[:namespace]
-      @messages = options[:messages] || {}
-      @action = options[:action]
-      @use_transactions = options[:use_transactions]
-      @initialize_state = options[:initialize]
-      @action_hook_defined = false
-      self.owner_class = owner_class
-
-      # Merge with sibling machine configurations
-      add_sibling_machine_configs
-
-      # Define class integration
-      define_helpers
-      define_scopes(options[:plural])
-      after_initialize
-
-      # Evaluate DSL
-      instance_eval(&block) if block_given?
-      self.initial_state = options[:initial] unless sibling_machines.any?
-    end
-
-    # Creates a copy of this machine in addition to copies of each associated
-    # event/states/callback, so that the modifications to those collections do
-    # not affect the original machine.
-    def initialize_copy(orig) #:nodoc:
-      super
-
-      @events = @events.dup
-      @events.machine = self
-      @states = @states.dup
-      @states.machine = self
-      @callbacks = {before: @callbacks[:before].dup, after: @callbacks[:after].dup, failure: @callbacks[:failure].dup}
-    end
-
-    # Sets the class which is the owner of this state machine.  Any methods
-    # generated by states, events, or other parts of the machine will be defined
-    # on the given owner class.
-    def owner_class=(klass)
-      @owner_class = klass
-
-      # Create modules for extending the class with state/event-specific methods
-      @helper_modules = helper_modules = {instance: HelperModule.new(self, :instance), class: HelperModule.new(self, :class)}
-      owner_class.class_eval do
-        extend helper_modules[:class]
-        include helper_modules[:instance]
-      end
-
-      # Add class-/instance-level methods to the owner class for state initialization
-      unless owner_class < StateMachines::InstanceMethods
-        owner_class.class_eval do
-          extend StateMachines::ClassMethods
-          include StateMachines::InstanceMethods
-        end
-
-        define_state_initializer if @initialize_state
-      end
-
-      # Record this machine as matched to the name in the current owner class.
-      # This will override any machines mapped to the same name in any superclasses.
-      owner_class.state_machines[name] = self
-    end
-
-    # Sets the initial state of the machine.  This can be either the static name
-    # of a state or a lambda block which determines the initial state at
-    # creation time.
-    def initial_state=(new_initial_state)
-      @initial_state = new_initial_state
-      add_states([@initial_state]) unless dynamic_initial_state?
-
-      # Update all states to reflect the new initial state
-      states.each { |state| state.initial = (state.name == @initial_state) }
-
-      # Output a warning if there are conflicting initial states for the machine's
-      # attribute
-      initial_state = states.detect { |state| state.initial }
-      if !owner_class_attribute_default.nil? && (dynamic_initial_state? || !owner_class_attribute_default_matches?(initial_state))
-        warn(
-            "Both #{owner_class.name} and its #{name.inspect} machine have defined "\
-          "a different default for \"#{attribute}\". Use only one or the other for "\
-          "defining defaults to avoid unexpected behaviors."
-        )
-      end
-    end
 
     # Gets the initial state of the machine for the given object. If a dynamic
     # initial state was configured for this machine, then the object will be
@@ -643,41 +511,6 @@ 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')
-    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)
-    end
-
-    # Initializes the state on the given object.  Initial values are only set if
-    # the machine's attribute hasn't been previously initialized.
-    #
-    # Configuration options:
-    # * <tt>:force</tt> - Whether to initialize the state regardless of its
-    #   current value
-    # * <tt>:to</tt> - A hash to set the initial value in instead of writing
-    #   directly to the object
-    def initialize_state(object, options = {})
-      state = initial_state(object)
-      if state && (options[:force] || initialize_state?(object))
-        value = state.value
-
-        if (hash = options[:to])
-          hash[attribute.to_s] = value
-        else
-          write(object, :state, value)
-        end
-      end
-    end
-
-    # Gets the actual name of the attribute on the machine's owner class that
-    # stores data with the given name.
-    def attribute(name = :state)
-      name == :state ? @attribute : :"#{self.name}_#{name}"
-    end
 
     # Defines a new helper method in an instance or class scope with the given
     # name.  If the method is already defined in the scope, then this will not
@@ -715,7 +548,7 @@ module StateMachines
     #       "State"
     #     end
     #   end_eval
-    def define_helper(scope, method, *args, **kwargs, &block)
+    def define_helper(scope, method, *, **, &block)
       helper_module = @helper_modules.fetch(scope)
 
       if block_given?
@@ -731,7 +564,9 @@ module StateMachines
           end
         end
       else
-        helper_module.class_eval(method, *args, **kwargs)
+        # Validate string input before eval if method is a string
+        validate_eval_string(method) if method.is_a?(String)
+        helper_module.class_eval(method, __FILE__, __LINE__)
       end
     end
 
@@ -1002,82 +837,6 @@ module StateMachines
     #
     # The minimum requirement is that the last argument in the method be an
     # 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)
-
-      # Store the context so that it can be used for / matched against any state
-      # that gets added
-      @states.context(names, &block) if block_given?
-
-      if names.first.is_a?(Matcher)
-        # Add any states referenced in the matcher.  When matchers are used,
-        # states are not allowed to be configured.
-        raise ArgumentError, "Cannot configure states when using matchers (using #{options.inspect})" if options.any?
-
-        states = add_states(names.first.values)
-      else
-        states = add_states(names)
-
-        # Update the configuration for the state(s)
-        states.each do |state|
-          if options.include?(:value)
-            state.value = options[:value]
-            self.states.update(state)
-          end
-
-          state.human_name = options[:human_name] if options.include?(:human_name)
-          state.cache = options[:cache] if options.include?(:cache)
-          state.matcher = options[:if] if options.include?(:if)
-        end
-      end
-
-      states.length == 1 ? states.first : states
-    end
-
-    alias_method :other_states, :state
-
-    # Gets the current value stored in the given object's attribute.
-    #
-    # For example,
-    #
-    #   class Vehicle
-    #     state_machine :initial => :parked do
-    #       ...
-    #     end
-    #   end
-    #
-    #   vehicle = Vehicle.new                           # => #<Vehicle:0xb7d94ab0 @state="parked">
-    #   Vehicle.state_machine.read(vehicle, :state)     # => "parked" # Equivalent to vehicle.state
-    #   Vehicle.state_machine.read(vehicle, :event)     # => nil      # Equivalent to vehicle.state_event
-    def read(object, attribute, ivar = false)
-      attribute = self.attribute(attribute)
-      if ivar
-        object.instance_variable_defined?("@#{attribute}") ? object.instance_variable_get("@#{attribute}") : nil
-      else
-        object.send(attribute)
-      end
-    end
-
-    # Sets a new value in the given object's attribute.
-    #
-    # For example,
-    #
-    #   class Vehicle
-    #     state_machine :initial => :parked do
-    #       ...
-    #     end
-    #   end
-    #
-    #   vehicle = Vehicle.new                                   # => #<Vehicle:0xb7d94ab0 @state="parked">
-    #   Vehicle.state_machine.write(vehicle, :state, 'idling')  # => Equivalent to vehicle.state = 'idling'
-    #   Vehicle.state_machine.write(vehicle, :event, 'park')    # => Equivalent to vehicle.state_event = 'park'
-    #   vehicle.state                                           # => "idling"
-    #   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)
-    end
 
     # Defines one or more events for the machine and the transitions that can
     # be performed when those events are run.
@@ -1305,36 +1064,6 @@ module StateMachines
     #       end
     #     end
     #   end
-    def event(*names, &block)
-      options = names.last.is_a?(Hash) ? names.pop : {}
-      options.assert_valid_keys(:human_name)
-
-      # Store the context so that it can be used for / matched against any event
-      # that gets added
-      @events.context(names, &block) if block_given?
-
-      if names.first.is_a?(Matcher)
-        # Add any events referenced in the matcher.  When matchers are used,
-        # events are not allowed to be configured.
-        raise ArgumentError, "Cannot configure events when using matchers (using #{options.inspect})" if options.any?
-
-        events = add_events(names.first.values)
-      else
-        events = add_events(names)
-
-        # Update the configuration for the event(s)
-        events.each do |event|
-          event.human_name = options[:human_name] if options.include?(:human_name)
-
-          # Add any states that may have been referenced within the event
-          add_states(event.known_states)
-        end
-      end
-
-      events.length == 1 ? events.first : events
-    end
-
-    alias_method :on, :event
 
     # Creates a new transition that determines what to change the current state
     # to when an event fires.
@@ -1425,15 +1154,6 @@ module StateMachines
     # Transitions are evaluated in the order in which they're defined.  As a
     # result, if more than one transition applies to a given object, then the
     # first transition that matches will be performed.
-    def transition(options)
-      raise ArgumentError, 'Must specify :on event' unless options[:on]
-
-      branches = []
-      options = options.dup
-      event(*Array(options.delete(:on))) { branches << transition(options) }
-
-      branches.length == 1 ? branches.first : branches
-    end
 
     # Creates a callback that will be invoked *before* a transition is
     # performed so long as the given requirements match the transition.
@@ -1640,10 +1360,15 @@ module StateMachines
     #
     # As can be seen, any number of transitions can be created using various
     # combinations of configuration options.
-    def before_transition(*args, &block)
-      options = (args.last.is_a?(Hash) ? args.pop : {})
-      options[:do] = args if args.any?
-      add_callback(:before, options, &block)
+    def before_transition(*args, **options, &)
+      # Extract legacy positional arguments and merge with keyword options
+      parsed_options = parse_callback_arguments(args, options)
+
+      # Only validate callback-specific options, not state transition requirements
+      callback_options = parsed_options.slice(:do, :if, :unless, :bind_to_object, :terminator)
+      StateMachines::OptionsValidator.assert_valid_keys!(callback_options, :do, :if, :unless, :bind_to_object, :terminator)
+
+      add_callback(:before, parsed_options, &)
     end
 
     # Creates a callback that will be invoked *after* a transition is
@@ -1651,10 +1376,15 @@ module StateMachines
     #
     # See +before_transition+ for a description of the possible configurations
     # for defining callbacks.
-    def after_transition(*args, &block)
-      options = (args.last.is_a?(Hash) ? args.pop : {})
-      options[:do] = args if args.any?
-      add_callback(:after, options, &block)
+    def after_transition(*args, **options, &)
+      # Extract legacy positional arguments and merge with keyword options
+      parsed_options = parse_callback_arguments(args, options)
+
+      # Only validate callback-specific options, not state transition requirements
+      callback_options = parsed_options.slice(:do, :if, :unless, :bind_to_object, :terminator)
+      StateMachines::OptionsValidator.assert_valid_keys!(callback_options, :do, :if, :unless, :bind_to_object, :terminator)
+
+      add_callback(:after, parsed_options, &)
     end
 
     # Creates a callback that will be invoked *around* a transition so long as
@@ -1712,10 +1442,15 @@ module StateMachines
     #
     # See +before_transition+ for a description of the possible configurations
     # for defining callbacks.
-    def around_transition(*args, &block)
-      options = (args.last.is_a?(Hash) ? args.pop : {})
-      options[:do] = args if args.any?
-      add_callback(:around, options, &block)
+    def around_transition(*args, **options, &)
+      # Extract legacy positional arguments and merge with keyword options
+      parsed_options = parse_callback_arguments(args, options)
+
+      # Only validate callback-specific options, not state transition requirements
+      callback_options = parsed_options.slice(:do, :if, :unless, :bind_to_object, :terminator)
+      StateMachines::OptionsValidator.assert_valid_keys!(callback_options, :do, :if, :unless, :bind_to_object, :terminator)
+
+      add_callback(:around, parsed_options, &)
     end
 
     # Creates a callback that will be invoked *after* a transition failures to
@@ -1746,12 +1481,12 @@ module StateMachines
     #       ...
     #     end
     #   end
-    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)
+    def after_failure(*args, **options, &)
+      # Extract legacy positional arguments and merge with keyword options
+      parsed_options = parse_callback_arguments(args, options)
+      StateMachines::OptionsValidator.assert_valid_keys!(parsed_options, :on, :do, :if, :unless)
 
-      add_callback(:failure, options, &block)
+      add_callback(:failure, parsed_options, &)
     end
 
     # Generates a list of the possible transition sequences that can be run on
@@ -1823,15 +1558,11 @@ module StateMachines
     #
     #   # Get the list of events that can be accessed from the current state
     #   vehicle.state_paths.events    # => [:ignite, :shift_up, :shift_down]
-    def paths_for(object, requirements = {})
-      PathCollection.new(object, self, requirements)
-    end
 
     # Marks the given object as invalid with the given message.
     #
     # By default, this is a no-op.
-    def invalidate(_object, _attribute, _message, _values = [])
-    end
+    def invalidate(_object, _attribute, _message, _values = []); end
 
     # Gets a description of the errors for the given object.  This is used to
     # provide more detailed information when an InvalidTransition exception is
@@ -1843,18 +1574,17 @@ module StateMachines
     # Resets any errors previously added when invalidating the given object.
     #
     # By default, this is a no-op.
-    def reset(_object)
-    end
+    def reset(_object); end
 
     # Generates the message to use when invalidating the given object after
     # failing to transition on a specific event
     def generate_message(name, values = [])
-      message = (@messages[name] || self.class.default_messages[name])
+      message = @messages[name] || self.class.default_messages[name]
 
       # Check whether there are actually any values to interpolate to avoid
       # any warnings
       if message.scan(/%./).any? { |match| match != '%%' }
-        message % values.map { |value| value.last }
+        message % values.map(&:last)
       else
         message
       end
@@ -1865,305 +1595,40 @@ module StateMachines
     # This is only applicable to integrations that involve databases.  By
     # default, this will not run any transactions since the changes aren't
     # taking place within the context of a database.
-    def within_transaction(object)
+    def within_transaction(object, &)
       if use_transactions
-        transaction(object) { yield }
+        transaction(object, &)
       else
         yield
       end
     end
 
+    def renderer
+      self.class.renderer
+    end
 
-    def draw(*)
-      fail NotImplementedError
+    def draw(**)
+      renderer.draw_machine(self, **)
     end
 
     # Determines whether an action hook was defined for firing attribute-based
     # event transitions when the configured action gets called.
     def action_hook?(self_only = false)
-      @action_hook_defined || !self_only && owner_class.state_machines.any? { |name, machine| machine.action == action && machine != self && machine.action_hook?(true) }
+      @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
-    end
-
-    # Looks up other machines that have been defined in the owner class and
-    # are targeting the same attribute as this machine.  When accessing
-    # sibling machines, they will be automatically copied for the current
-    # class if they haven't been already.  This ensures that any configuration
-    # changes made to the sibling machines only affect this class and not any
-    # base class that may have originally defined the machine.
-    def sibling_machines
-      owner_class.state_machines.inject([]) do |machines, (name, machine)|
-        if machine.attribute == attribute && machine != self
-          machines << (owner_class.state_machine(name) {})
-        end
-        machines
-      end
-    end
-
-    # Determines if the machine's attribute needs to be initialized.  This
-    # will only be true if the machine's attribute is blank.
-    def initialize_state?(object)
-      value = read(object, :state)
-      (value.nil? || value.respond_to?(:empty?) && value.empty?) && !states[value, :value]
-    end
-
-    # Adds helper methods for interacting with the state machine, including
-    # for states, events, and transitions
-    def define_helpers
-      define_state_accessor
-      define_state_predicate
-      define_event_helpers
-      define_path_helpers
-      define_action_helpers if define_action_helpers?
-      define_name_helpers
-    end
-
-    # Defines the initial values for state machine attributes.  Static values
-    # are set prior to the original initialize method and dynamic values are
-    # set *after* the initialize method in case it is dependent on it.
-    def define_state_initializer
-      define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-          def initialize(*)
-            self.class.state_machines.initialize_states(self) { super }
-          end
-      end_eval
-    end
-
-    # Adds reader/writer methods for accessing the state attribute
-    def define_state_accessor
-      attribute = self.attribute
-
-      @helper_modules[:instance].class_eval { attr_reader attribute } unless owner_class_ancestor_has_method?(:instance, attribute)
-      @helper_modules[:instance].class_eval { attr_writer attribute } unless owner_class_ancestor_has_method?(:instance, "#{attribute}=")
-    end
-
-    # Adds predicate method to the owner class for determining the name of the
-    # current state
-    def define_state_predicate
-      call_super = !!owner_class_ancestor_has_method?(:instance, "#{name}?")
-      define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-          def #{name}?(*args)
-            args.empty? && (#{call_super} || defined?(super)) ? super : self.class.state_machine(#{name.inspect}).states.matches?(self, *args)
-          end
-      end_eval
-    end
-
-    # Adds helper methods for getting information about this state machine's
-    # events
-    def define_event_helpers
-      # Gets the events that are allowed to fire on the current object
-      define_helper(:instance, attribute(:events)) do |machine, object, *args|
-        machine.events.valid_for(object, *args).map { |event| event.name }
-      end
-
-      # Gets the next possible transitions that can be run on the current
-      # object
-      define_helper(:instance, attribute(:transitions)) do |machine, object, *args|
-        machine.events.transitions_for(object, *args)
-      end
-
-      # Fire an arbitrary event for this machine
-      define_helper(:instance, "fire_#{attribute(:event)}") do |machine, object, event, *args|
-        machine.events.fetch(event).fire(object, *args)
-      end
-
-      # Add helpers for tracking the event / transition to invoke when the
-      # action is called
-      if action
-        event_attribute = attribute(:event)
-        define_helper(:instance, event_attribute) do |machine, object|
-          # Interpret non-blank events as present
-          event = machine.read(object, :event, true)
-          event && !(event.respond_to?(:empty?) && event.empty?) ? event.to_sym : nil
-        end
-
-        # A roundabout way of writing the attribute is used here so that
-        # integrations can hook into this modification
-        define_helper(:instance, "#{event_attribute}=") do |machine, object, value|
-          machine.write(object, :event, value, true)
-        end
-
-        event_transition_attribute = attribute(:event_transition)
-        define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-            protected; attr_accessor #{event_transition_attribute.inspect}
-        end_eval
-      end
-    end
-
-    # Adds helper methods for getting information about this state machine's
-    # available transition paths
-    def define_path_helpers
-      # Gets the paths of transitions available to the current object
-      define_helper(:instance, attribute(:paths)) do |machine, object, *args|
-        machine.paths_for(object, *args)
-      end
-    end
-
-    # Determines whether action helpers should be defined for this machine.
-    # This is only true if there is an action configured and no other machines
-    # have process this same configuration already.
-    def define_action_helpers?
-      action && !owner_class.state_machines.any? { |name, machine| machine.action == action && machine != self }
-    end
-
-    # Adds helper methods for automatically firing events when an action
-    # is invoked
-    def define_action_helpers
-      if action_hook
-        @action_hook_defined = true
-        define_action_hook
-      end
-    end
-
-    # Hooks directly into actions by defining the same method in an included
-    # module.  As a result, when the action gets invoked, any state events
-    # defined for the object will get run.  Method visibility is preserved.
-    def define_action_hook
-      action_hook = self.action_hook
-      action = self.action
-      private_action_hook = owner_class.private_method_defined?(action_hook)
-
-      # Only define helper if it hasn't
-      define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-          def #{action_hook}(*)
-            self.class.state_machines.transitions(self, #{action.inspect}).perform { super }
-          end
-
-          private #{action_hook.inspect} if #{private_action_hook}
-      end_eval
-    end
-
-    # The method to hook into for triggering transitions when invoked.  By
-    # default, this is the action configured for the machine.
-    #
-    # Since the default hook technique relies on module inheritance, the
-    # action must be defined in an ancestor of the owner classs in order for
-    # it to be the action hook.
-    def action_hook
-      action && owner_class_ancestor_has_method?(:instance, action) ? action : nil
-    end
+    def after_initialize; end
 
     # Determines whether there's already a helper method defined within the
     # given scope.  This is true only if one of the owner's ancestors defines
     # the method and is further along in the ancestor chain than this
     # machine's helper module.
-    def owner_class_ancestor_has_method?(scope, method)
-      return false unless owner_class_has_method?(scope, method)
-
-      superclasses = owner_class.ancestors.select { |ancestor| ancestor.is_a?(Class) }[1..-1]
-
-      if scope == :class
-        current = owner_class.singleton_class
-        superclass = superclasses.first
-      else
-        current = owner_class
-        superclass = owner_class.superclass
-      end
-
-      # Generate the list of modules that *only* occur in the owner class, but
-      # were included *prior* to the helper modules, in addition to the
-      # superclasses
-      ancestors = current.ancestors - superclass.ancestors + superclasses
-      ancestors = ancestors[ancestors.index(@helper_modules[scope])..-1].reverse
-
-      # Search for for the first ancestor that defined this method
-      ancestors.detect do |ancestor|
-        ancestor = ancestor.singleton_class if scope == :class && ancestor.is_a?(Class)
-        ancestor.method_defined?(method) || ancestor.private_method_defined?(method)
-      end
-    end
-
-    def owner_class_has_method?(scope, method)
-      target = scope == :class ? owner_class.singleton_class : owner_class
-      target.method_defined?(method) || target.private_method_defined?(method)
-    end
-
-    # Adds helper methods for accessing naming information about states and
-    # events on the owner class
-    def define_name_helpers
-      # Gets the humanized version of a state
-      define_helper(:class, "human_#{attribute(:name)}") do |machine, klass, state|
-        machine.states.fetch(state).human_name(klass)
-      end
-
-      # Gets the humanized version of an event
-      define_helper(:class, "human_#{attribute(:event_name)}") do |machine, klass, event|
-        machine.events.fetch(event).human_name(klass)
-      end
-
-      # Gets the state name for the current value
-      define_helper(:instance, attribute(:name)) do |machine, object|
-        machine.states.match!(object).name
-      end
-
-      # Gets the human state name for the current value
-      define_helper(:instance, "human_#{attribute(:name)}") do |machine, object|
-        machine.states.match!(object).human_name(object.class)
-      end
-    end
-
-    # Defines the with/without scope helpers for this attribute.  Both the
-    # singular and plural versions of the attribute are defined for each
-    # scope helper.  A custom plural can be specified if it cannot be
-    # automatically determined by either calling +pluralize+ on the attribute
-    # name or adding an "s" to the end of the name.
-    def define_scopes(custom_plural = nil)
-      plural = custom_plural || pluralize(name)
-
-      [:with, :without].each do |kind|
-        [name, plural].map { |s| s.to_s }.uniq.each do |suffix|
-          method = "#{kind}_#{suffix}"
-
-          if (scope = send("create_#{kind}_scope", method))
-            # Converts state names to their corresponding values so that they
-            # can be looked up properly
-            define_helper(:class, method) do |machine, klass, *states|
-              run_scope(scope, machine, klass, states)
-            end
-          end
-        end
-      end
-    end
-
-    # Generates the results for the given scope based on one or more states to
-    # filter by
-    def run_scope(scope, machine, klass, states)
-      values = states.flatten.compact.map { |state| machine.states.fetch(state).value }
-      scope.call(klass, values)
-    end
-
-    # Pluralizes the given word using #pluralize (if available) or simply
-    # adding an "s" to the end of the word
-    def pluralize(word)
-      word = word.to_s
-      if word.respond_to?(:pluralize)
-        word.pluralize
-      else
-        "#{name}s"
-      end
-    end
-
-    # Creates a scope for finding objects *with* a particular value or values
-    # for the attribute.
-    #
-    # By default, this is a no-op.
-    def create_with_scope(name)
-    end
-
-    # Creates a scope for finding objects *without* a particular value or
-    # values for the attribute.
-    #
-    # By default, this is a no-op.
-    def create_without_scope(name)
-    end
 
     # Always yields
-    def transaction(object)
+    def transaction(_object)
       yield
     end
 
@@ -2178,60 +1643,5 @@ module StateMachines
     def owner_class_attribute_default_matches?(state)
       state.matches?(owner_class_attribute_default)
     end
-
-    # Updates this machine based on the configuration of other machines in the
-    # owner class that share the same target attribute.
-    def add_sibling_machine_configs
-      # Add existing states
-      sibling_machines.each do |machine|
-        machine.states.each { |state| states << state unless states[state.name] }
-      end
-    end
-
-    # Adds a new transition callback of the given type.
-    def add_callback(type, options, &block)
-      callbacks[type == :around ? :before : type] << callback = Callback.new(type, options, &block)
-      add_states(callback.known_states)
-      callback
-    end
-
-    # Tracks the given set of states in the list of all known states for
-    # this machine
-    def add_states(new_states)
-      new_states.map do |new_state|
-        # Check for other states that use a different class type for their name.
-        # This typically prevents string / symbol misuse.
-        if new_state && (conflict = states.detect { |state| state.name && state.name.class != new_state.class })
-          raise ArgumentError, "#{new_state.inspect} state defined as #{new_state.class}, #{conflict.name.inspect} defined as #{conflict.name.class}; all states must be consistent"
-        end
-
-        unless (state = states[new_state])
-          states << state = State.new(self, new_state)
-
-          # Copy states over to sibling machines
-          sibling_machines.each { |machine| machine.states << state }
-        end
-
-        state
-      end
-    end
-
-    # Tracks the given set of events in the list of all known events for
-    # this machine
-    def add_events(new_events)
-      new_events.map do |new_event|
-        # Check for other states that use a different class type for their name.
-        # This typically prevents string / symbol misuse.
-        if (conflict = events.detect { |event| event.name.class != new_event.class })
-          raise ArgumentError, "#{new_event.inspect} event defined as #{new_event.class}, #{conflict.name.inspect} defined as #{conflict.name.class}; all events must be consistent"
-        end
-
-        unless (event = events[new_event])
-          events << event = Event.new(self, new_event)
-        end
-
-        event
-      end
-    end
   end
 end