branston 0.6.1 → 0.6.2

data/lib/branston/vendor/plugins/state_machine/lib/state_machine/event_collection.rb

@@ -1,122 +0,0 @@
-module StateMachine
-  # Represents a collection of events in a state machine
-  class EventCollection < NodeCollection
-    def initialize(machine) #:nodoc:
-      super(machine, :index => [:name, :qualified_name])
-    end
-    
-    # Gets the list of events that can be fired on the given object.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle
-    #     state_machine :initial => :parked do
-    #       event :park do
-    #         transition :idling => :parked
-    #       end
-    #       
-    #       event :ignite do
-    #         transition :parked => :idling
-    #       end
-    #     end
-    #   end
-    #   
-    #   events = Vehicle.state_machine(:state).events
-    #   
-    #   vehicle = Vehicle.new               # => #<Vehicle:0xb7c464b0 @state="parked">
-    #   events.valid_for(vehicle)           # => [#<StateMachine::Event name=:ignite transitions=[:parked => :idling]>]
-    #   
-    #   vehicle.state = 'idling'
-    #   events.valid_for(vehicle)           # => [#<StateMachine::Event name=:park transitions=[:idling => :parked]>]
-    def valid_for(object)
-      select {|event| event.can_fire?(object)}
-    end
-    
-    # Gets the list of transitions that can be run on the given object.
-    # 
-    # Valid requirement options:
-    # * <tt>:from</tt> - One or more states being transitioned from.  If none
-    #   are specified, then this will be the object's current state.
-    # * <tt>:to</tt> - One or more states being transitioned to.  If none are
-    #   specified, then this will match any to state.
-    # * <tt>:on</tt> - One or more events that fire the transition.  If none
-    #   are specified, then this will match any event.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle
-    #     state_machine :initial => :parked do
-    #       event :park do
-    #         transition :idling => :parked
-    #       end
-    #       
-    #       event :ignite do
-    #         transition :parked => :idling
-    #       end
-    #     end
-    #   end
-    #   
-    #   events = Vehicle.state_machine.events
-    #   
-    #   vehicle = Vehicle.new                             # => #<Vehicle:0xb7c464b0 @state="parked">
-    #   events.transitions_for(vehicle)                   # => [#<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>]
-    #   
-    #   vehicle.state = 'idling'
-    #   events.transitions_for(vehicle)                   # => [#<StateMachine::Transition attribute=:state event=:park from="idling" from_name=:idling to="parked" to_name=:parked>]
-    #   
-    #   # Search for explicit transitions regardless of the current state
-    #   events.transitions_for(vehicle, :from => :parked) # => [#<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>]
-    def transitions_for(object, requirements = {})
-      map {|event| event.transition_for(object, requirements)}.compact
-    end
-    
-    # Gets the transition that should be performed for the event stored in the
-    # given object's event attribute.  This also takes an additional parameter
-    # for automatically invalidating the object if the event or transition are
-    # invalid.  By default, this is turned off.
-    # 
-    # *Note* that if a transition has already been generated for the event, then
-    # that transition will be used.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle < ActiveRecord::Base
-    #     state_machine :initial => :parked do
-    #       event :ignite do
-    #         transition :parked => :idling
-    #       end
-    #     end
-    #   end
-    #   
-    #   vehicle = Vehicle.new                       # => #<Vehicle id: nil, state: "parked">
-    #   events = Vehicle.state_machine.events
-    #   
-    #   vehicle.state_event = nil
-    #   events.attribute_transition_for(vehicle)    # => nil # Event isn't defined
-    #   
-    #   vehicle.state_event = 'invalid'
-    #   events.attribute_transition_for(vehicle)    # => false # Event is invalid
-    #   
-    #   vehicle.state_event = 'ignite'
-    #   events.attribute_transition_for(vehicle)    # => #<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>
-    def attribute_transition_for(object, invalidate = false)
-      return unless machine.action
-      
-      result = machine.read(object, :event_transition) || if event_name = machine.read(object, :event)
-        if event = self[event_name.to_sym, :name]
-          event.transition_for(object) || begin
-            # No valid transition: invalidate
-            machine.invalidate(object, :event, :invalid_event, [[:state, machine.states.match!(object).name || 'nil']]) if invalidate
-            false
-          end
-        else
-          # Event is unknown: invalidate
-          machine.invalidate(object, :event, :invalid) if invalidate
-          false
-        end
-      end
-      
-      result
-    end
-  end
-end

data/lib/branston/vendor/plugins/state_machine/lib/state_machine/extensions.rb

@@ -1,149 +0,0 @@
-require 'state_machine/machine_collection'
-
-module StateMachine
-  module ClassMethods
-    def self.extended(base) #:nodoc:
-      base.class_eval do
-        @state_machines = MachineCollection.new
-      end
-    end
-    
-    # Gets the current list of state machines defined for this class.  This
-    # class-level attribute acts like an inheritable attribute.  The attribute
-    # is available to each subclass, each having a copy of its superclass's
-    # attribute.
-    # 
-    # The hash of state machines maps <tt>:attribute</tt> => +machine+, e.g.
-    # 
-    #   Vehicle.state_machines # => {:state => #<StateMachine::Machine:0xb6f6e4a4 ...>}
-    def state_machines
-      @state_machines ||= superclass.state_machines.dup
-    end
-  end
-  
-  module InstanceMethods
-    # Runs one or more events in parallel.  All events will run through the
-    # following steps:
-    # * Before callbacks
-    # * Persist state
-    # * Invoke action
-    # * After callbacks
-    # 
-    # For example, if two events (for state machines A and B) are run in
-    # parallel, the order in which steps are run is:
-    # * A - Before transition callbacks
-    # * B - Before transition callbacks
-    # * A - Persist new state
-    # * B - Persist new state
-    # * A - Invoke action
-    # * B - Invoke action (only if different than A's action)
-    # * A - After transition callbacks
-    # * B - After transition callbacks
-    # 
-    # *Note* that multiple events on the same state machine / attribute cannot
-    # be run in parallel.  If this is attempted, an ArgumentError will be
-    # raised.
-    # 
-    # == Halting callbacks
-    # 
-    # When running multiple events in parallel, special consideration should
-    # be taken with regard to how halting within callbacks affects the flow.
-    # 
-    # For *before* callbacks, any <tt>:halt</tt> error that's thrown will
-    # immediately cancel the perform for all transitions.  As a result, it's
-    # possible for one event's transition to affect the continuation of
-    # another.
-    # 
-    # On the other hand, any <tt>:halt</tt> error that's thrown within an
-    # *after* callback with only affect that event's transition.  Other
-    # transitions will continue to run their own callbacks.
-    # 
-    # == Example
-    # 
-    #   class Vehicle
-    #     state_machine :initial => :parked do
-    #       event :ignite do
-    #         transition :parked => :idling
-    #       end
-    #       
-    #       event :park do
-    #         transition :idling => :parked
-    #       end
-    #     end
-    #     
-    #     state_machine :alarm_state, :namespace => 'alarm', :initial => :on do
-    #       event :enable do
-    #         transition all => :active
-    #       end
-    #       
-    #       event :disable do
-    #         transition all => :off
-    #       end
-    #     end
-    #   end
-    #   
-    #   vehicle = Vehicle.new                         # => #<Vehicle:0xb7c02850 @state="parked", @alarm_state="active">
-    #   vehicle.state                                 # => "parked"
-    #   vehicle.alarm_state                           # => "active"
-    #   
-    #   vehicle.fire_events(:ignite, :disable_alarm)  # => true
-    #   vehicle.state                                 # => "idling"
-    #   vehicle.alarm_state                           # => "off"
-    #   
-    #   # If any event fails, the entire event chain fails
-    #   vehicle.fire_events(:ignite, :enable_alarm)   # => false
-    #   vehicle.state                                 # => "idling"
-    #   vehicle.alarm_state                           # => "off"
-    #   
-    #   # Exception raised on invalid event
-    #   vehicle.fire_events(:park, :invalid)          # => StateMachine::InvalidEvent: :invalid is an unknown event
-    #   vehicle.state                                 # => "idling"
-    #   vehicle.alarm_state                           # => "off"
-    def fire_events(*events)
-      self.class.state_machines.fire_events(self, *events)
-    end
-    
-    # Run one or more events in parallel.  If any event fails to run, then
-    # a StateMachine::InvalidTransition exception will be raised.
-    # 
-    # See StateMachine::InstanceMethods#fire_events for more information.
-    # 
-    # == Example
-    # 
-    #   class Vehicle
-    #     state_machine :initial => :parked do
-    #       event :ignite do
-    #         transition :parked => :idling
-    #       end
-    #       
-    #       event :park do
-    #         transition :idling => :parked
-    #       end
-    #     end
-    #     
-    #     state_machine :alarm_state, :namespace => 'alarm', :initial => :active do
-    #       event :enable do
-    #         transition all => :active
-    #       end
-    #       
-    #       event :disable do
-    #         transition all => :off
-    #       end
-    #     end
-    #   end
-    #   
-    #   vehicle = Vehicle.new                         # => #<Vehicle:0xb7c02850 @state="parked", @alarm_state="active">
-    #   vehicle.fire_events(:ignite, :disable_alarm)  # => true
-    #   
-    #   vehicle.fire_events!(:ignite, :disable_alarm) # => StateMachine::InvalidTranstion: Cannot run events in parallel: ignite, disable_alarm
-    def fire_events!(*events)
-      run_action = [true, false].include?(events.last) ? events.pop : true
-      fire_events(*(events + [run_action])) || raise(StateMachine::InvalidTransition, "Cannot run events in parallel: #{events * ', '}")
-    end
-    
-    protected
-      def initialize_state_machines(options = {}) #:nodoc:
-        self.class.state_machines.initialize_states(self, options)
-      end
-  end
-end

data/lib/branston/vendor/plugins/state_machine/lib/state_machine/guard.rb

@@ -1,230 +0,0 @@
-require 'state_machine/matcher'
-require 'state_machine/eval_helpers'
-require 'state_machine/assertions'
-
-module StateMachine
-  # Represents a set of requirements that must be met in order for a transition
-  # or callback to occur.  Guards verify that the event, from state, and to
-  # state of the transition match, in addition to if/unless conditionals for
-  # an object's state.
-  class Guard
-    include Assertions
-    include EvalHelpers
-    
-    # The condition that must be met on an object
-    attr_reader :if_condition
-    
-    # The condition that must *not* be met on an object
-    attr_reader :unless_condition
-    
-    # The requirement for verifying the event being guarded
-    attr_reader :event_requirement
-    
-    # One or more requirements for verifying the states being guarded.  All
-    # requirements contain a mapping of {:from => matcher, :to => matcher}.
-    attr_reader :state_requirements
-    
-    # The requirement for verifying the success of the event
-    attr_reader :success_requirement
-    
-    # A list of all of the states known to this guard.  This will pull states
-    # from the following options (in the same order):
-    # * +from+ / +except_from+
-    # * +to+ / +except_to+
-    attr_reader :known_states
-    
-    # Creates a new guard
-    def initialize(options = {}) #:nodoc:
-      # Build conditionals
-      @if_condition = options.delete(:if)
-      @unless_condition = options.delete(:unless)
-      
-      # Build event requirement
-      @event_requirement = build_matcher(options, :on, :except_on)
-      
-      # Build success requirement
-      @success_requirement = options.delete(:include_failures) ? AllMatcher.instance : WhitelistMatcher.new([true])
-      
-      if (options.keys - [:from, :to, :on, :except_from, :except_to, :except_on]).empty?
-        # Explicit from/to requirements specified
-        @state_requirements = [{:from => build_matcher(options, :from, :except_from), :to => build_matcher(options, :to, :except_to)}]
-      else
-        # Separate out the event requirement
-        options.delete(:on)
-        options.delete(:except_on)
-        
-        # Implicit from/to requirements specified
-        @state_requirements = options.collect do |from, to|
-          from = WhitelistMatcher.new(from) unless from.is_a?(Matcher)
-          to = WhitelistMatcher.new(to) unless to.is_a?(Matcher)
-          {:from => from, :to => to}
-        end
-      end
-      
-      # Track known states.  The order that requirements are iterated is based
-      # on the priority in which tracked states should be added.
-      @known_states = []
-      @state_requirements.each do |state_requirement|
-        [:from, :to].each {|option| @known_states |= state_requirement[option].values}
-      end
-    end
-    
-    # Determines whether the given object / query matches the requirements
-    # configured for this guard.  In addition to matching the event, from state,
-    # and to state, this will also check whether the configured :if/:unless
-    # conditions pass on the given object.
-    # 
-    # == Examples
-    # 
-    #   guard = StateMachine::Guard.new(:parked => :idling, :on => :ignite)
-    #   
-    #   # Successful
-    #   guard.matches?(object, :on => :ignite)                                    # => true
-    #   guard.matches?(object, :from => nil)                                      # => true
-    #   guard.matches?(object, :from => :parked)                                  # => true
-    #   guard.matches?(object, :to => :idling)                                    # => true
-    #   guard.matches?(object, :from => :parked, :to => :idling)                  # => true
-    #   guard.matches?(object, :on => :ignite, :from => :parked, :to => :idling)  # => true
-    #   
-    #   # Unsuccessful
-    #   guard.matches?(object, :on => :park)                                      # => false
-    #   guard.matches?(object, :from => :idling)                                  # => false
-    #   guard.matches?(object, :to => :first_gear)                                # => false
-    #   guard.matches?(object, :from => :parked, :to => :first_gear)              # => false
-    #   guard.matches?(object, :on => :park, :from => :parked, :to => :idling)    # => false
-    def matches?(object, query = {})
-      !match(object, query).nil?
-    end
-    
-    # Attempts to match the given object / query against the set of requirements
-    # configured for this guard.  In addition to matching the event, from state,
-    # and to state, this will also check whether the configured :if/:unless
-    # conditions pass on the given object.
-    # 
-    # If a match is found, then the event/state requirements that the query
-    # passed successfully will be returned.  Otherwise, nil is returned if there
-    # was no match.
-    # 
-    # Query options:
-    # * <tt>:from</tt> - One or more states being transitioned from.  If none
-    #   are specified, then this will always match.
-    # * <tt>:to</tt> - One or more states being transitioned to.  If none are
-    #   specified, then this will always match.
-    # * <tt>:on</tt> - One or more events that fired the transition.  If none
-    #   are specified, then this will always match.
-    # 
-    # == Examples
-    # 
-    #   guard = StateMachine::Guard.new(:parked => :idling, :on => :ignite)
-    #   
-    #   guard.match(object, :on => :ignite) # => {:to => ..., :from => ..., :on => ...}
-    #   guard.match(object, :on => :park)   # => nil
-    def match(object, query = {})
-      if (match = match_query(query)) && matches_conditions?(object)
-        match
-      end
-    end
-    
-    # Draws a representation of this guard on the given graph.  This will draw
-    # an edge between every state this guard matches *from* to either the
-    # configured to state or, if none specified, then a loopback to the from
-    # state.
-    # 
-    # For example, if the following from states are configured:
-    # * +idling+
-    # * +first_gear+
-    # * +backing_up+
-    # 
-    # ...and the to state is +parked+, then the following edges will be created:
-    # * +idling+      -> +parked+
-    # * +first_gear+  -> +parked+
-    # * +backing_up+  -> +parked+
-    # 
-    # Each edge will be labeled with the name of the event that would cause the
-    # transition.
-    # 
-    # The collection of edges generated on the graph will be returned.
-    def draw(graph, event, valid_states)
-      state_requirements.inject([]) do |edges, state_requirement|
-        # From states determined based on the known valid states
-        from_states = state_requirement[:from].filter(valid_states)
-        
-        # If a to state is not specified, then it's a loopback and each from
-        # state maps back to itself
-        if state_requirement[:to].values.empty?
-          loopback = true
-        else
-          to_state = state_requirement[:to].values.first
-          to_state = to_state ? to_state.to_s : 'nil'
-          loopback = false
-        end
-        
-        # Generate an edge between each from and to state
-        from_states.each do |from_state|
-          from_state = from_state ? from_state.to_s : 'nil'
-          edges << graph.add_edge(from_state, loopback ? from_state : to_state, :label => event.to_s)
-        end
-        
-        edges
-      end
-    end
-    
-    protected
-      # Builds a matcher strategy to use for the given options.  If neither a
-      # whitelist nor a blacklist option is specified, then an AllMatcher is
-      # built.
-      def build_matcher(options, whitelist_option, blacklist_option)
-        assert_exclusive_keys(options, whitelist_option, blacklist_option)
-        
-        if options.include?(whitelist_option)
-          WhitelistMatcher.new(options[whitelist_option])
-        elsif options.include?(blacklist_option)
-          BlacklistMatcher.new(options[blacklist_option])
-        else
-          AllMatcher.instance
-        end
-      end
-      
-      # Verifies that all configured requirements (event and state) match the
-      # given query.  If a match is found, then a hash containing the
-      # event/state requirements that passed will be returned; otherwise, nil.
-      def match_query(query)
-        query ||= {}
-        
-        if match_success(query) && match_event(query) && (state_requirement = match_states(query))
-          state_requirement.merge(:on => event_requirement)
-        end
-      end
-      
-      # Verifies that the success requirement matches the given query
-      def match_success(query)
-        matches_requirement?(query, :success, success_requirement)
-      end
-      
-      # Verifies that the event requirement matches the given query
-      def match_event(query)
-        matches_requirement?(query, :on, event_requirement)
-      end
-      
-      # Verifies that the state requirements match the given query.  If a
-      # matching requirement is found, then it is returned.
-      def match_states(query)
-        state_requirements.detect do |state_requirement|
-          [:from, :to].all? {|option| matches_requirement?(query, option, state_requirement[option])}
-        end
-      end
-      
-      # Verifies that an option in the given query matches the values required
-      # for that option
-      def matches_requirement?(query, option, requirement)
-        !query.include?(option) || requirement.matches?(query[option], query)
-      end
-      
-      # Verifies that the conditionals for this guard evaluate to true for the
-      # given object
-      def matches_conditions?(object)
-        Array(if_condition).all? {|condition| evaluate_method(object, condition)} &&
-        !Array(unless_condition).any? {|condition| evaluate_method(object, condition)}
-      end
-  end
-end