state_machines 0.4.0 → 0.6.0

data/lib/state_machines/state.rb

@@ -2,7 +2,7 @@ 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
   # the most common (and default) type is String.
-  # 
+  #
   # In addition to defining the machine's value, a state can also define a
   # behavioral context for an object when that object is in the state.  See
   # StateMachines::Machine#state for more information about how state-driven
@@ -10,7 +10,7 @@ module StateMachines
   class State
 
     # The state machine for which this state is defined
-    attr_accessor :machine
+    attr_reader :machine
 
     # The unique identifier for the state used in event and callback definitions
     attr_reader :name
@@ -38,7 +38,7 @@ module StateMachines
     attr_accessor :matcher
 
     # Creates a new state within the context of the given machine.
-    # 
+    #
     # Configuration options:
     # * <tt>:initial</tt> - Whether this state is the beginning state for the
     #   machine. Default is false.
@@ -57,7 +57,7 @@ module StateMachines
       @name = name
       @qualified_name = name && machine.namespace ? :"#{machine.namespace}_#{name}" : name
       @human_name = options[:human_name] || (@name ? @name.to_s.tr('_', ' ') : 'nil')
-      @value = options.include?(:value) ? options[:value] : name && name.to_s
+      @value = options.include?(:value) ? options[:value] : name&.to_s
       @cache = options[:cache]
       @matcher = options[:if]
       @initial = options[:initial] == true
@@ -68,8 +68,8 @@ module StateMachines
 
         # 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
+        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
@@ -86,6 +86,11 @@ module StateMachines
       @context = StateContext.new(self)
     end
 
+    def machine=(machine)
+      @machine = machine
+      @context = StateContext.new(self)
+    end
+
     # Determines whether there are any states that can be transitioned to from
     # this state.  If there are none, then this state is considered *final*.
     # Any objects in a final state will remain so forever given the current
@@ -94,7 +99,7 @@ module StateMachines
       !machine.events.any? do |event|
         event.branches.any? do |branch|
           branch.state_requirements.any? do |requirement|
-            requirement[:from].matches?(name) && !requirement[:to].matches?(name, :from => name)
+            requirement[:from].matches?(name) && !requirement[:to].matches?(name, from: name)
           end
         end
       end
@@ -107,15 +112,15 @@ module StateMachines
     end
 
     # Generates a human-readable description of this state's name / value:
-    # 
+    #
     # For example,
-    # 
+    #
     #   State.new(machine, :parked).description                               # => "parked"
     #   State.new(machine, :parked, :value => :parked).description            # => "parked"
     #   State.new(machine, :parked, :value => nil).description                # => "parked (nil)"
     #   State.new(machine, :parked, :value => 1).description                  # => "parked (1)"
     #   State.new(machine, :parked, :value => lambda {Time.now}).description  # => "parked (*)
-    # 
+    #
     # Configuration options:
     # * <tt>:human_name</tt> - Whether to use this state's human name in the
     #   description or just the internal name
@@ -129,9 +134,9 @@ module StateMachines
     # The value that represents this state.  This will optionally evaluate the
     # original block if it's a lambda block.  Otherwise, the static value is
     # returned.
-    # 
+    #
     # For example,
-    # 
+    #
     #   State.new(machine, :parked, :value => 1).value                        # => 1
     #   State.new(machine, :parked, :value => lambda {Time.now}).value        # => Tue Jan 01 00:00:00 UTC 2008
     #   State.new(machine, :parked, :value => lambda {Time.now}).value(false) # => <Proc:0xb6ea7ca0@...>
@@ -152,14 +157,14 @@ module StateMachines
     # Determines whether this state matches the given value.  If no matcher is
     # configured, then this will check whether the values are equivalent.
     # Otherwise, the matcher will determine the result.
-    # 
+    #
     # For example,
-    # 
+    #
     #   # Without a matcher
     #   state = State.new(machine, :parked, :value => 1)
     #   state.matches?(1)           # => true
     #   state.matches?(2)           # => false
-    #   
+    #
     #   # With a matcher
     #   state = State.new(machine, :parked, :value => lambda {Time.now}, :if => lambda {|value| !value.nil?})
     #   state.matches?(nil)         # => false
@@ -170,7 +175,7 @@ module StateMachines
 
     # Defines a context for the state which will be enabled on instances of
     # the owner class when the machine is in this state.
-    # 
+    #
     # This can be called multiple times.  Each time a new context is created,
     # a new module will be included in the owner class.
     def context(&block)
@@ -184,7 +189,7 @@ module StateMachines
       new_methods = context_methods.to_a.select { |(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)|
+      new_methods.each do |(method_name, _method)|
         context_name = context_name_for(method_name)
         context.class_eval <<-end_eval, __FILE__, __LINE__ + 1
           alias_method :"#{context_name}", :#{method_name}
@@ -208,12 +213,12 @@ module StateMachines
 
     # Calls a method defined in this state's context on the given object.  All
     # arguments and any block will be passed into the method defined.
-    # 
+    #
     # If the method has never been defined for this state, then a NoMethodError
     # 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)
@@ -239,9 +244,9 @@ module StateMachines
     end
 
     # Generates a nicely formatted description of this state's contents.
-    # 
+    #
     # For example,
-    # 
+    #
     #   state = StateMachines::State.new(machine, :parked, :value => 1, :initial => true)
     #   state   # => #<StateMachines::State name=:parked value=1 initial=true context=[]>
     def inspect
@@ -249,7 +254,8 @@ 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?
       @cache

data/lib/state_machines/state_collection.rb

@@ -2,25 +2,25 @@ module StateMachines
   # Represents a collection of states in a state machine
   class StateCollection < NodeCollection
     def initialize(machine) #:nodoc:
-      super(machine, :index => [:name, :qualified_name, :value])
+      super(machine, index: [:name, :qualified_name, :value])
     end
 
     # Determines whether the given object is in a specific state.  If the
     # object's current value doesn't match the state, then this will return
     # false, otherwise true.  If the given state is unknown, then an IndexError
     # will be raised.
-    # 
+    #
     # == Examples
-    # 
+    #
     #   class Vehicle
     #     state_machine :initial => :parked do
     #       other_states :idling
     #     end
     #   end
-    #   
+    #
     #   states = Vehicle.state_machine.states
     #   vehicle = Vehicle.new               # => #<Vehicle:0xb7c464b0 @state="parked">
-    #   
+    #
     #   states.matches?(vehicle, :parked)   # => true
     #   states.matches?(vehicle, :idling)   # => false
     #   states.matches?(vehicle, :invalid)  # => IndexError: :invalid is an invalid key for :name index
@@ -31,23 +31,23 @@ module StateMachines
     # Determines the current state of the given object as configured by this
     # state machine.  This will attempt to find a known state that matches
     # the value of the attribute on the object.
-    # 
+    #
     # == Examples
-    # 
+    #
     #   class Vehicle
     #     state_machine :initial => :parked do
     #       other_states :idling
     #     end
     #   end
-    #   
+    #
     #   states = Vehicle.state_machine.states
-    #   
+    #
     #   vehicle = Vehicle.new         # => #<Vehicle:0xb7c464b0 @state="parked">
     #   states.match(vehicle)         # => #<StateMachines::State name=:parked value="parked" initial=true>
-    #   
+    #
     #   vehicle.state = 'idling'
     #   states.match(vehicle)         # => #<StateMachines::State name=:idling value="idling" initial=true>
-    #   
+    #
     #   vehicle.state = 'invalid'
     #   states.match(vehicle)         # => nil
     def match(object)
@@ -58,20 +58,20 @@ module StateMachines
     # Determines the current state of the given object as configured by this
     # state machine.  If no state is found, then an ArgumentError will be
     # raised.
-    # 
+    #
     # == Examples
-    # 
+    #
     #   class Vehicle
     #     state_machine :initial => :parked do
     #       other_states :idling
     #     end
     #   end
-    #   
+    #
     #   states = Vehicle.state_machine.states
-    #   
+    #
     #   vehicle = Vehicle.new         # => #<Vehicle:0xb7c464b0 @state="parked">
     #   states.match!(vehicle)        # => #<StateMachines::State name=:parked value="parked" initial=true>
-    #   
+    #
     #   vehicle.state = 'invalid'
     #   states.match!(vehicle)        # => ArgumentError: "invalid" is not a known state value
     def match!(object)
@@ -80,20 +80,20 @@ module StateMachines
 
     # Gets the order in which states should be displayed based on where they
     # were first referenced.  This will order states in the following priority:
-    # 
+    #
     # 1. Initial state
     # 2. Event transitions (:from, :except_from, :to, :except_to options)
     # 3. States with behaviors
     # 4. States referenced via +state+ or +other_states+
     # 5. States referenced in callbacks
-    # 
+    #
     # This order will determine how the GraphViz visualizations are rendered.
     def by_priority
       order = select { |state| state.initial }.map { |state| state.name }
 
       machine.events.each { |event| order += event.known_states }
       order += select { |state| state.context_methods.any? }.map { |state| state.name }
-      order += keys(:name) - machine.callbacks.values.flatten.map { |callback| callback.known_states }.flatten
+      order += keys(:name) - machine.callbacks.values.flatten.flat_map(&:known_states)
       order += keys(:name)
 
       order.uniq!
@@ -101,7 +101,8 @@ module StateMachines
       order
     end
 
-    private
+  private
+
     # Gets the value for the given attribute on the node
     def value(node, attribute)
       attribute == :value ? node.value(false) : super

data/lib/state_machines/state_context.rb

@@ -1,100 +1,98 @@
 module StateMachines
-
-  
   # Represents a module which will get evaluated within the context of a state.
-  # 
+  #
   # Class-level methods are proxied to the owner class, injecting a custom
   # <tt>:if</tt> condition along with method.  This assumes that the method has
   # support for a set of configuration options, including <tt>:if</tt>.  This
   # condition will check that the object's state matches this context's state.
-  # 
+  #
   # Instance-level methods are used to define state-driven behavior on the
   # state's owner class.
-  # 
+  #
   # == Examples
-  # 
+  #
   #   class Vehicle
   #     class << self
   #       attr_accessor :validations
-  #       
+  #
   #       def validate(options, &block)
   #         validations << options
   #       end
   #     end
-  #     
+  #
   #     self.validations = []
   #     attr_accessor :state, :simulate
-  #     
+  #
   #     def moving?
   #       self.class.validations.all? {|validation| validation[:if].call(self)}
   #     end
   #   end
-  # 
+  #
   # In the above class, a simple set of validation behaviors have been defined.
   # Each validation consists of a configuration like so:
-  # 
+  #
   #   Vehicle.validate :unless => :simulate
   #   Vehicle.validate :if => lambda {|vehicle| ...}
-  # 
+  #
   # In order to scope validations to a particular state context, the class-level
   # +validate+ method can be invoked like so:
-  # 
+  #
   #   machine = StateMachines::Machine.new(Vehicle)
   #   context = StateMachines::StateContext.new(machine.state(:first_gear))
   #   context.validate(:unless => :simulate)
-  #   
+  #
   #   vehicle = Vehicle.new     # => #<Vehicle:0xb7ce491c @simulate=nil, @state=nil>
   #   vehicle.moving?           # => false
-  #   
+  #
   #   vehicle.state = 'first_gear'
   #   vehicle.moving?           # => true
-  #   
+  #
   #   vehicle.simulate = true
   #   vehicle.moving?           # => false
   class StateContext < Module
 
     include EvalHelpers
-    
+
     # The state machine for which this context's state is defined
     attr_reader :machine
-    
+
     # The state that must be present in an object for this context to be active
     attr_reader :state
-    
+
     # Creates a new context for the given state
     def initialize(state)
       @state = state
       @machine = state.machine
-      
+
       state_name = state.name
       machine_name = machine.name
-      @condition = lambda {|object| object.class.state_machine(machine_name).states.matches?(object, state_name)}
+      @condition = lambda { |object| object.class.state_machine(machine_name).states.matches?(object, state_name) }
     end
-    
+
     # Creates a new transition that determines what to change the current state
     # to when an event fires from this state.
-    # 
+    #
     # Since this transition is being defined within a state context, you do
     # *not* need to specify the <tt>:from</tt> option for the transition.  For
     # example:
-    # 
+    #
     #   state_machine do
     #     state :parked do
     #       transition :to => :idling, :on => [:ignite, :shift_up]                          # Transitions to :idling
     #       transition :from => [:idling, :parked], :on => :park, :unless => :seatbelt_on?  # Transitions to :parked if seatbelt is off
     #     end
     #   end
-    # 
+    #
     # See StateMachines::Machine#transition for a description of the possible
     # configurations for defining transitions.
     def transition(options)
       options.assert_valid_keys(:from, :to, :on, :if, :unless)
       raise ArgumentError, 'Must specify :on event' unless options[:on]
       raise ArgumentError, 'Must specify either :to or :from state' unless !options[:to] ^ !options[:from]
-      
-      machine.transition(options.merge(options[:to] ? {:from => state.name} : {:to => state.name}))
+
+      machine.transition(options.merge(options[:to] ? {from: state.name} : {to: state.name}))
     end
-    
+
     # Hooks in condition-merging to methods that don't exist in this module
     def method_missing(*args, &block)
       # Get the configuration
@@ -103,28 +101,28 @@ module StateMachines
       else
         args << options = {}
       end
-      
+
       # Get any existing condition that may need to be merged
       if_condition = options.delete(:if)
       unless_condition = options.delete(:unless)
-      
+
       # Provide scope access to configuration in case the block is evaluated
       # within the object instance
       proxy = self
       proxy_condition = @condition
-      
+
       # Replace the configuration condition with the one configured for this
       # proxy, merging together any existing conditions
       options[:if] = lambda do |*condition_args|
         # Block may be executed within the context of the actual object, so
         # it'll either be the first argument or the executing context
         object = condition_args.first || self
-        
+
         proxy.evaluate_method(object, proxy_condition) &&
-        Array(if_condition).all? {|condition| proxy.evaluate_method(object, condition)} &&
-        !Array(unless_condition).any? {|condition| proxy.evaluate_method(object, condition)}
+        Array(if_condition).all? { |condition| proxy.evaluate_method(object, condition) } &&
+        !Array(unless_condition).any? { |condition| proxy.evaluate_method(object, condition) }
       end
-      
+
       # Evaluate the method on the owner class with the condition proxied
       # through
       machine.owner_class.send(*args, &block)