branston 0.6.1 → 0.6.2

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

@@ -1,155 +0,0 @@
-module StateMachine
-  # Represents a collection of state machines for a class
-  class MachineCollection < Hash
-    # Initializes the state of each machine in the given object.  Initial
-    # values are only set if the machine's attribute doesn't already exist
-    # (which must mean the defaults are being skipped)
-    def initialize_states(object, options = {})
-      if ignore = options[:ignore]
-        ignore.map! {|attribute| attribute.to_sym}
-      end
-      
-      each_value do |machine|
-        if (!ignore || !ignore.include?(machine.attribute)) && (!options.include?(:dynamic) || machine.dynamic_initial_state? == options[:dynamic])
-          value = machine.read(object, :state)
-          machine.write(object, :state, machine.initial_state(object).value) if ignore || value.nil? || value.respond_to?(:empty?) && value.empty?
-        end
-      end
-    end
-    
-    # Runs one or more events in parallel on the given object.  See
-    # StateMachine::InstanceMethods#fire_events for more information.
-    def fire_events(object, *events)
-      run_action = [true, false].include?(events.last) ? events.pop : true
-      
-      # Generate the transitions to run for each event
-      transitions = events.collect do |event_name|
-        # Find the actual event being run
-        event = nil
-        detect do |name, machine|
-          event = machine.events[event_name, :qualified_name]
-        end
-        
-        raise InvalidEvent, "#{event_name.inspect} is an unknown state machine event" unless event
-        
-        # Get the transition that will be performed for the event
-        unless transition = event.transition_for(object)
-          machine = event.machine
-          machine.invalidate(object, :state, :invalid_transition, [[:event, event_name]])
-        end
-        
-        transition
-      end.compact
-      
-      # Run the events in parallel only if valid transitions were found for
-      # all of them
-      if events.length == transitions.length
-        Transition.perform_within_transaction(transitions, :action => run_action)
-      else
-        false
-      end
-    end
-    
-    # Runs one or more event attributes in parallel during the invocation of
-    # an action on the given object.  after_transition callbacks can be
-    # optionally disabled if the events are being only partially fired (for
-    # example, when validating records in ORM integrations).
-    # 
-    # The event attributes that will be fired are based on which machines
-    # match the action that is being invoked.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle
-    #     include DataMapper::Resource
-    #     property :id, Serial
-    #     
-    #     state_machine :initial => :parked do
-    #       event :ignite do
-    #         transition :parked => :idling
-    #       end
-    #     end
-    #     
-    #     state_machine :alarm_state, :namespace => 'alarm', :initial => :active do
-    #       event :disable do
-    #         transition all => :off
-    #       end
-    #     end
-    #   end
-    # 
-    # With valid events:
-    # 
-    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
-    #   vehicle.state_event = 'ignite'
-    #   vehicle.alarm_state_event = 'disable'
-    #   
-    #   Vehicle.state_machines.fire_event_attributes(vehicle, :save) { true }
-    #   vehicle.state                                 # => "idling"
-    #   vehicle.state_event                           # => nil
-    #   vehicle.alarm_state                           # => "off"
-    #   vehicle.alarm_state_event                     # => nil
-    # 
-    # With invalid events:
-    #   
-    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
-    #   vehicle.state_event = 'park'
-    #   vehicle.alarm_state_event = 'disable'
-    #   
-    #   Vehicle.state_machines.fire_event_attributes(vehicle, :save) { true }
-    #   vehicle.state                                 # => "parked"
-    #   vehicle.state_event                           # => nil
-    #   vehicle.alarm_state                           # => "active"
-    #   vehicle.alarm_state_event                     # => nil
-    #   vehicle.errors                                # => #<DataMapper::Validate::ValidationErrors:0xb7af9abc @errors={"state_event"=>["is invalid"]}>
-    # 
-    # With partial firing:
-    # 
-    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
-    #   vehicle.state_event = 'ignite'
-    #   
-    #   Vehicle.state_machines.fire_event_attributes(vehicle, :save, false) { true }
-    #   vehicle.state                                 # => "idling"
-    #   vehicle.state_event                           # => "ignite"
-    #   vehicle.state_event_transition                # => #<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>
-    def fire_event_attributes(object, action, complete = true)
-      # Get the transitions to fire for each applicable machine
-      transitions = map {|name, machine| machine.action == action ? machine.events.attribute_transition_for(object, true) : nil}.compact
-      return yield if transitions.empty?
-      
-      # The value generated by the yielded block (the actual action)
-      action_value = nil
-      
-      # Make sure all events were valid
-      if result = transitions.all? {|transition| transition != false}
-        # Clear any traces of the event since transitions are available and to
-        # prevent from being evaluated multiple times if actions are nested
-        transitions.each do |transition|
-          transition.machine.write(object, :event, nil)
-          transition.machine.write(object, :event_transition, nil)
-        end
-        
-        # Perform the transitions
-        begin
-          result = Transition.perform(transitions, :after => complete) { action_value = yield }
-        rescue Exception
-          # Reset the event attribute so it can be re-evaluated if attempted again
-          transitions.each do |transition|
-            transition.machine.write(object, :event, transition.event)
-          end
-          
-          raise
-        end
-        
-        transitions.each do |transition|
-          # Revert event if failed (to allow for more attempts)
-          transition.machine.write(object, :event, transition.event) unless result
-          
-          # Track transition if partial transition was successful
-          transition.machine.write(object, :event_transition, transition) if !complete && result
-        end
-      end
-      
-      action_value.nil? ? result : action_value
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-require 'singleton'
-
-module StateMachine
-  # Provides a general strategy pattern for determining whether a match is found
-  # for a value.  The algorithm that actually determines the match depends on
-  # the matcher in use.
-  class Matcher
-    # The list of values against which queries are matched
-    attr_reader :values
-    
-    # Creates a new matcher for querying against the given set of values
-    def initialize(values = [])
-      @values = values.is_a?(Array) ? values : [values] 
-    end
-    
-    # Generates a subset of values that exists in both the set of values being
-    # filtered and the values configured for the matcher
-    def filter(values)
-      self.values & values
-    end
-  end
-  
-  # Matches any given value.  Since there is no configuration for this type of
-  # matcher, it must be used as a singleton.
-  class AllMatcher < Matcher
-    include Singleton
-    
-    # Generates a blacklist matcher based on the given set of values
-    # 
-    # == Examples
-    # 
-    #   matcher = StateMachine::AllMatcher.instance - [:parked, :idling]
-    #   matcher.matches?(:parked)       # => false
-    #   matcher.matches?(:first_gear)   # => true
-    def -(blacklist)
-      BlacklistMatcher.new(blacklist)
-    end
-    
-    # Always returns true
-    def matches?(value, context = {})
-      true
-    end
-    
-    # Always returns the given set of values
-    def filter(values)
-      values
-    end
-    
-    # A human-readable description of this matcher.  Always "all".
-    def description
-      'all'
-    end
-  end
-  
-  # Matches a specific set of values
-  class WhitelistMatcher < Matcher
-    # Checks whether the given value exists within the whitelist configured
-    # for this matcher.
-    # 
-    # == Examples
-    # 
-    #   matcher = StateMachine::WhitelistMatcher.new([:parked, :idling])
-    #   matcher.matches?(:parked)       # => true
-    #   matcher.matches?(:first_gear)   # => false
-    def matches?(value, context = {})
-      values.include?(value)
-    end
-    
-    # A human-readable description of this matcher
-    def description
-      values.length == 1 ? values.first.inspect : values.inspect
-    end
-  end
-  
-  # Matches everything but a specific set of values
-  class BlacklistMatcher < Matcher
-    # Checks whether the given value exists outside the blacklist configured
-    # for this matcher.
-    # 
-    # == Examples
-    # 
-    #   matcher = StateMachine::BlacklistMatcher.new([:parked, :idling])
-    #   matcher.matches?(:parked)       # => false
-    #   matcher.matches?(:first_gear)   # => true
-    def matches?(value, context = {})
-      !values.include?(value)
-    end
-    
-    # Finds all values that are *not* within the blacklist configured for this
-    # matcher
-    def filter(values)
-      values - self.values
-    end
-    
-    # A human-readable description of this matcher
-    def description
-      "all - #{values.length == 1 ? values.first.inspect : values.inspect}"
-    end
-  end
-  
-  # Matches a loopback of two values within a context.  Since there is no
-  # configuration for this type of matcher, it must be used as a singleton.
-  class LoopbackMatcher < Matcher
-    include Singleton
-    
-    # Checks whether the given value matches what the value originally was.
-    # This value should be defined in the context.
-    # 
-    # == Examples
-    # 
-    #   matcher = StateMachine::LoopbackMatcher.instance
-    #   matcher.matches?(:parked, :from => :parked)   # => true
-    #   matcher.matches?(:parked, :from => :idling)   # => false
-    def matches?(value, context)
-      context[:from] == value
-    end
-    
-    # A human-readable description of this matcher.  Always "same".
-    def description
-      'same'
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-module StateMachine
-  # Provides a set of helper methods for generating matchers
-  module MatcherHelpers
-    # Represents a state that matches all known states in a machine.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle
-    #     state_machine do
-    #       before_transition any => :parked, :do => lambda {...}
-    #       before_transition all - :parked => all - :idling, :do => lambda {}
-    #       
-    #       event :park
-    #         transition all => :parked
-    #       end
-    #       
-    #       event :crash
-    #         transition all - :parked => :stalled
-    #       end
-    #     end
-    #   end
-    # 
-    # In the above example, +all+ will match the following states since they
-    # are known:
-    # * +parked+
-    # * +stalled+
-    # * +idling+
-    def all
-      AllMatcher.instance
-    end
-    alias_method :any, :all
-    
-    # Represents a state that matches the original +from+ state.  This is useful
-    # for defining transitions which are loopbacks.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle
-    #     state_machine do
-    #       event :ignite
-    #         transition [:idling, :first_gear] => same
-    #       end
-    #     end
-    #   end
-    # 
-    # In the above example, +same+ will match whichever the from state is.  In
-    # the case of the +ignite+ event, it is essential the same as the following:
-    # 
-    #   transition :parked => :parked, :first_gear => :first_gear
-    def same
-      LoopbackMatcher.instance
-    end
-  end
-end

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

@@ -1,152 +0,0 @@
-require 'state_machine/assertions'
-
-module StateMachine
-  # Represents a collection of nodes in a state machine, be it events or states.
-  class NodeCollection
-    include Enumerable
-    include Assertions
-    
-    # The machine associated with the nodes
-    attr_reader :machine
-    
-    # Creates a new collection of nodes for the given state machine.  By default,
-    # the collection is empty.
-    # 
-    # Configuration options:
-    # * <tt>:index</tt> - One or more attributes to automatically generate
-    #   hashed indices for in order to perform quick lookups.  Default is to
-    #   index by the :name attribute
-    def initialize(machine, options = {})
-      assert_valid_keys(options, :index)
-      options = {:index => :name}.merge(options)
-      
-      @machine = machine
-      @nodes = []
-      @indices = Array(options[:index]).inject({}) {|indices, attribute| indices[attribute] = {}; indices}
-      @default_index = Array(options[:index]).first
-    end
-    
-    # Creates a copy of this collection such that modifications don't affect
-    # the original collection
-    def initialize_copy(orig) #:nodoc:
-      super
-      
-      nodes = @nodes
-      @nodes = []
-      @indices = @indices.inject({}) {|indices, (name, index)| indices[name] = {}; indices}
-      nodes.each {|node| self << node.dup}
-    end
-    
-    # Changes the current machine associated with the collection.  In turn, this
-    # will change the state machine associated with each node in the collection.
-    def machine=(new_machine)
-      @machine = new_machine
-      each {|node| node.machine = new_machine}
-    end
-    
-    # Gets the number of nodes in this collection
-    def length
-      @nodes.length
-    end
-    
-    # Gets the set of unique keys for the given index
-    def keys(index_name = @default_index)
-      index(index_name).keys
-    end
-    
-    # Adds a new node to the collection.  By doing so, this will also add it to
-    # the configured indices.
-    def <<(node)
-      @nodes << node
-      @indices.each {|attribute, index| index[value(node, attribute)] = node}
-      self
-    end
-    
-    # Updates the indexed keys for the given node.  If the node's attribute
-    # has changed since it was added to the collection, the old indexed keys
-    # will be replaced with the updated ones.
-    def update(node)
-      @indices.each do |attribute, index|
-        old_key = RUBY_VERSION < '1.9' ? index.index(node) : index.key(node)
-        new_key = value(node, attribute)
-        
-        # Only replace the key if it's changed
-        if old_key != new_key
-          index.delete(old_key)
-          index[new_key] = node
-        end
-      end
-    end
-    
-    # Calls the block once for each element in self, passing that element as a
-    # parameter.
-    # 
-    #   states = StateMachine::NodeCollection.new
-    #   states << StateMachine::State.new(machine, :parked)
-    #   states << StateMachine::State.new(machine, :idling)
-    #   states.each {|state| puts state.name, ' -- '}
-    # 
-    # ...produces:
-    # 
-    #   parked -- idling --
-    def each
-      @nodes.each {|node| yield node}
-      self
-    end
-    
-    # Gets the node at the given index.
-    # 
-    #   states = StateMachine::NodeCollection.new
-    #   states << StateMachine::State.new(machine, :parked)
-    #   states << StateMachine::State.new(machine, :idling)
-    #   
-    #   states.at(0).name    # => :parked
-    #   states.at(1).name    # => :idling
-    def at(index)
-      @nodes[index]
-    end
-    
-    # Gets the node indexed by the given key.  By default, this will look up the
-    # key in the first index configured for the collection.  A custom index can
-    # be specified like so:
-    # 
-    #   collection['parked', :value]
-    # 
-    # The above will look up the "parked" key in a hash indexed by each node's
-    # +value+ attribute.
-    # 
-    # If the key cannot be found, then nil will be returned.
-    def [](key, index_name = @default_index)
-      index(index_name)[key]
-    end
-    
-    # Gets the node indexed by the given key.  By default, this will look up the
-    # key in the first index configured for the collection.  A custom index can
-    # be specified like so:
-    # 
-    #   collection['parked', :value]
-    # 
-    # The above will look up the "parked" key in a hash indexed by each node's
-    # +value+ attribute.
-    # 
-    # If the key cannot be found, then an IndexError exception will be raised:
-    # 
-    #   collection['invalid', :value]   # => IndexError: "invalid" is an invalid value
-    def fetch(key, index_name = @default_index)
-      self[key, index_name] || raise(IndexError, "#{key.inspect} is an invalid #{index_name}")
-    end
-    
-    private
-      # Gets the given index.  If the index does not exist, then an ArgumentError
-      # is raised.
-      def index(name)
-        raise ArgumentError, 'No indices configured' unless @indices.any?
-        @indices[name] || raise(ArgumentError, "Invalid index: #{name.inspect}")
-      end
-      
-      # Gets the value for the given attribute on the node
-      def value(node, attribute)
-        node.send(attribute)
-      end
-  end
-end