state_machines 0.0.1 → 0.0.2

data/lib/state_machines/integrations.rb

@@ -1,11 +1,4 @@
 module StateMachines
-  # An invalid integration was specified
-  class IntegrationNotFound < Error
-    def initialize(name)
-      super(nil, "#{name.inspect} is an invalid integration")
-    end
-  end
-  
   # Integrations allow state machines to take advantage of features within the
   # context of a particular library.  This is currently most useful with
   # database libraries.  For example, the various database integrations allow
@@ -25,89 +18,104 @@ module StateMachines
   # built-in integrations for more information about how to define additional
   # integrations.
   module Integrations
-    # Attempts to find an integration that matches the given class.  This will
-    # look through all of the built-in integrations under the StateMachines::Integrations
-    # namespace and find one that successfully matches the class.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle
-    #   end
-    #   
-    #   class ActiveModelVehicle
-    #     include ActiveModel::Observing
-    #     include ActiveModel::Validations
-    #   end
-    #   
-    #   class ActiveRecordVehicle < ActiveRecord::Base
-    #   end
-    #   
-    #   class DataMapperVehicle
-    #     include DataMapper::Resource
-    #   end
-    #   
-    #   class MongoidVehicle
-    #     include Mongoid::Document
-    #   end
-    #   
-    #   class MongoMapperVehicle
-    #     include MongoMapper::Document
-    #   end
-    #   
-    #   class SequelVehicle < Sequel::Model
-    #   end
-    #   
-    #   StateMachines::Integrations.match(Vehicle)             # => nil
-    #   StateMachines::Integrations.match(ActiveModelVehicle)  # => StateMachines::Integrations::ActiveModel
-    #   StateMachines::Integrations.match(ActiveRecordVehicle) # => StateMachines::Integrations::ActiveRecord
-    #   StateMachines::Integrations.match(DataMapperVehicle)   # => StateMachines::Integrations::DataMapper
-    #   StateMachines::Integrations.match(MongoidVehicle)      # => StateMachines::Integrations::Mongoid
-    #   StateMachines::Integrations.match(MongoMapperVehicle)  # => StateMachines::Integrations::MongoMapper
-    #   StateMachines::Integrations.match(SequelVehicle)       # => StateMachines::Integrations::Sequel
-    def self.match(klass)
-      all.detect {|integration| integration.matches?(klass)}
-    end
-    
-    # Attempts to find an integration that matches the given list of ancestors.
-    # This will look through all of the built-in integrations under the StateMachines::Integrations
-    # namespace and find one that successfully matches one of the ancestors.
-    # 
-    # == Examples
-    # 
-    #   StateMachines::Integrations.match([])                    # => nil
-    #   StateMachines::Integrations.match(['ActiveRecord::Base') # => StateMachines::Integrations::ActiveModel
-    def self.match_ancestors(ancestors)
-      all.detect {|integration| integration.matches_ancestors?(ancestors)}
-    end
-    
-    # Finds an integration with the given name.  If the integration cannot be
-    # found, then a NameError exception will be raised.
-    # 
-    # == Examples
-    # 
-    #   StateMachines::Integrations.find_by_name(:active_record) # => StateMachines::Integrations::ActiveRecord
-    #   StateMachines::Integrations.find_by_name(:active_model)  # => StateMachines::Integrations::ActiveModel
-    #   StateMachines::Integrations.find_by_name(:data_mapper)   # => StateMachines::Integrations::DataMapper
-    #   StateMachines::Integrations.find_by_name(:mongoid)       # => StateMachines::Integrations::Mongoid
-    #   StateMachines::Integrations.find_by_name(:mongo_mapper)  # => StateMachines::Integrations::MongoMapper
-    #   StateMachines::Integrations.find_by_name(:sequel)        # => StateMachines::Integrations::Sequel
-    #   StateMachines::Integrations.find_by_name(:invalid)       # => StateMachines::IntegrationNotFound: :invalid is an invalid integration
-    def self.find_by_name(name)
-      all.detect {|integration| integration.integration_name == name} || raise(IntegrationNotFound.new(name))
-    end
-    
-    # Gets a list of all of the available integrations for use.  This will
-    # always list the ActiveModel integration last.
-    # 
-    # == Example
-    # 
-    #   StateMachines::Integrations.all
-    #   # => [StateMachines::Integrations::ActiveRecord, StateMachines::Integrations::DataMapper
-    #   #     StateMachines::Integrations::Mongoid, StateMachines::Integrations::MongoMapper,
-    #   #     StateMachines::Integrations::Sequel, StateMachines::Integrations::ActiveModel]
-    def self.all
-      constants = self.constants.map {|c| c.to_s}.select {|c| c }.sort
-      constants.map {|c| const_get(c)}
+    @integrations = Set.new
+
+    class << self
+      #  Register integration
+      def register(arg)
+        #TODO check name conflict
+        case arg.class.to_s
+          when 'Module'
+            add(arg)
+          else
+            fail IntegrationError
+        end
+        true
+      end
+
+
+      # Gets a list of all of the available integrations for use.
+      #
+      # == Example
+      #
+      #   StateMachines::Integrations.integrations
+      #   # => []
+      #   StateMachines::Integrations.register(StateMachines::Integrations::ActiveModel)
+      #   StateMachines::Integrations.integrations
+      #   # => [StateMachines::Integrations::ActiveModel]
+      def integrations
+        # Register all namespaced integrations
+        name_spaced_integrations
+        @integrations
+      end
+
+
+      # Attempts to find an integration that matches the given class.  This will
+      # look through all of the built-in integrations under the StateMachines::Integrations
+      # namespace and find one that successfully matches the class.
+      # 
+      # == Examples
+      # 
+      #   class Vehicle
+      #   end
+      #   
+      #   class ActiveModelVehicle
+      #     include ActiveModel::Observing
+      #     include ActiveModel::Validations
+      #   end
+      #   
+      #   class ActiveRecordVehicle < ActiveRecord::Base
+      #   end
+      #   
+      #   StateMachines::Integrations.match(Vehicle)             # => nil
+      #   StateMachines::Integrations.match(ActiveModelVehicle)  # => StateMachines::Integrations::ActiveModel
+      #   StateMachines::Integrations.match(ActiveRecordVehicle) # => StateMachines::Integrations::ActiveRecord
+      def match(klass)
+        integrations.detect { |integration| integration.matches?(klass) }
+      end
+
+      # Attempts to find an integration that matches the given list of ancestors.
+      # This will look through all of the built-in integrations under the StateMachines::Integrations
+      # namespace and find one that successfully matches one of the ancestors.
+      #
+      # == Examples
+      #
+      #   StateMachines::Integrations.match_ancestors([])                    # => nil
+      #   StateMachines::Integrations.match_ancestors(['ActiveRecord::Base']) # => StateMachines::Integrations::ActiveModel
+      def match_ancestors(ancestors)
+        integrations.detect { |integration| integration.matches_ancestors?(ancestors) }
+      end
+
+      # Finds an integration with the given name.  If the integration cannot be
+      # found, then a NameError exception will be raised.
+      #
+      # == Examples
+      #
+      #   StateMachines::Integrations.find_by_name(:active_model)  # => StateMachines::Integrations::ActiveModel
+      #   StateMachines::Integrations.find_by_name(:active_record) # => StateMachines::Integrations::ActiveRecord
+      #   StateMachines::Integrations.find_by_name(:invalid)       # => StateMachines::IntegrationNotFound: :invalid is an invalid integration
+      def find_by_name(name)
+        integrations.detect { |integration| integration.integration_name == name } || raise(IntegrationNotFound.new(name))
+      end
+
+
+      private
+
+      def name_spaced_integrations
+        self.constants.each do |const|
+          integration = self.const_get(const)
+          add(integration) if integration.respond_to?(:integration_name)
+        end
+      end
+
+      def add(integration)
+        @integrations << integration
+      end
+
+      def reset
+        @integrations = Set.new
+        name_spaced_integrations
+      end
     end
   end
 end

data/lib/state_machines/integrations/base.rb

@@ -5,93 +5,44 @@ module StateMachines
       module ClassMethods
         # The default options to use for state machines using this integration
         attr_reader :defaults
-        
+
         # The name of the integration
         def integration_name
           @integration_name ||= begin
             name = self.name.split('::').last
-            name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-            name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+            name.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            name.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
             name.downcase!
             name.to_sym
           end
         end
-        
+
         # Whether this integration is available for the current library.  This
         # is only true if the ORM that the integration is for is currently
         # defined.
         def available?
           matching_ancestors.any? && Object.const_defined?(matching_ancestors[0].split('::')[0])
         end
-        
+
         # The list of ancestor names that cause this integration to matched.
         def matching_ancestors
           []
         end
-        
+
         # Whether the integration should be used for the given class.
         def matches?(klass)
-          matches_ancestors?(klass.ancestors.map {|ancestor| ancestor.name})
+          matches_ancestors?(klass.ancestors.map { |ancestor| ancestor.name })
         end
-        
+
         # Whether the integration should be used for the given list of ancestors.
         def matches_ancestors?(ancestors)
           (ancestors & matching_ancestors).any?
         end
-        
-        # Tracks the various version overrides for an integration
-        def versions
-          @versions ||= []
-        end
-        
-        # Creates a new version override for an integration.  When this
-        # integration is activated, each version that is marked as active will
-        # also extend the integration.
-        # 
-        # == Example
-        # 
-        #   module StateMachines
-        #     module Integrations
-        #       module ORMLibrary
-        #         version '0.2.x - 0.3.x' do
-        #           def self.active?
-        #             ::ORMLibrary::VERSION >= '0.2.0' && ::ORMLibrary::VERSION < '0.4.0'
-        #           end
-        #           
-        #           def invalidate(object, attribute, message, values = [])
-        #             # Override here...
-        #           end
-        #         end
-        #       end
-        #     end
-        #   end
-        # 
-        # In the above example, a version override is defined for the ORMLibrary
-        # integration when the version is between 0.2.x and 0.3.x.
-        def version(name, &block)
-          versions << mod = Module.new(&block)
-          mod
-        end
-        
-        # The path to the locale file containing translations for this
-        # integration.  This file will only exist for integrations that actually
-        # support i18n.
-        def locale_path
-          path = "#{File.dirname(__FILE__)}/#{integration_name}/locale.rb"
-          path if File.exist?(path)
-        end
-        
-        # Extends the given object with any version overrides that are currently
-        # active
-        def extended(base)
-          versions.each do |version|
-             base.extend(version) if version.active?
-          end
-        end
+
       end
-      
+
       extend ClassMethods
-      
+
       def self.included(base) #:nodoc:
         base.class_eval { extend ClassMethods }
       end

data/lib/state_machines/matcher.rb

@@ -1,5 +1,3 @@
-require 'singleton'
-
 module StateMachines
   # Provides a general strategy pattern for determining whether a match is found
   # for a value.  The algorithm that actually determines the match depends on

data/lib/state_machines/node_collection.rb

@@ -1,5 +1,3 @@
-require 'state_machines/assertions'
-
 module StateMachines
   # Represents a collection of nodes in a state machine, be it events or states.
   # Nodes will not differentiate between the String and Symbol versions of the

data/lib/state_machines/path_collection.rb

@@ -1,5 +1,3 @@
-require 'state_machines/path'
-
 module StateMachines
   # Represents a collection of paths that are generated based on a set of
   # requirements regarding what states to start and end on

data/lib/state_machines/state.rb

@@ -1,6 +1,3 @@
-require 'state_machines/assertions'
-require 'state_machines/state_context'
-
 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

data/lib/state_machines/state_collection.rb

@@ -1,12 +1,10 @@
-require 'state_machines/node_collection'
-
 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])
     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
@@ -29,7 +27,7 @@ module StateMachines
     def matches?(object, name)
       fetch(name).matches?(machine.read(object, :state))
     end
-    
+
     # 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.
@@ -54,9 +52,9 @@ module StateMachines
     #   states.match(vehicle)         # => nil
     def match(object)
       value = machine.read(object, :state)
-      self[value, :value] || detect {|state| state.matches?(value)}
+      self[value, :value] || detect { |state| state.matches?(value) }
     end
-    
+
     # 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.
@@ -79,7 +77,7 @@ module StateMachines
     def match!(object)
       match(object) || raise(ArgumentError, "#{machine.read(object, :state).inspect} is not a known #{machine.name} value")
     end
-    
+
     # Gets the order in which states should be displayed based on where they
     # were first referenced.  This will order states in the following priority:
     # 
@@ -91,22 +89,22 @@ module StateMachines
     # 
     # 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 = 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)
-      
+
       order.uniq!
-      order.map! {|name| self[name]}
+      order.map! { |name| self[name] }
       order
     end
-    
+
     private
-      # Gets the value for the given attribute on the node
-      def value(node, attribute)
-        attribute == :value ? node.value(false) : super
-      end
+    # Gets the value for the given attribute on the node
+    def value(node, attribute)
+      attribute == :value ? node.value(false) : super
+    end
   end
 end

data/lib/state_machines/state_context.rb

@@ -1,10 +1,5 @@
-require 'state_machines/assertions'
-require 'state_machines/eval_helpers'
-
 module StateMachines
-  # A method was called in an invalid state context
-  class InvalidContext < Error
-  end
+
   
   # Represents a module which will get evaluated within the context of a state.
   # 

data/lib/state_machines/transition.rb

@@ -1,60 +1,4 @@
-require 'state_machines/transition_collection'
-require 'state_machines/error'
-
 module StateMachines
-  # An invalid transition was attempted
-  class InvalidTransition < Error
-    # The machine attempting to be transitioned
-    attr_reader :machine
-    
-    # The current state value for the machine
-    attr_reader :from
-    
-    def initialize(object, machine, event) #:nodoc:
-      @machine = machine
-      @from_state = machine.states.match!(object)
-      @from = machine.read(object, :state)
-      @event = machine.events.fetch(event)
-      errors = machine.errors_for(object)
-      
-      message = "Cannot transition #{machine.name} via :#{self.event} from #{from_name.inspect}"
-      message << " (Reason(s): #{errors})" unless errors.empty?
-      super(object, message)
-    end
-    
-    # The event that triggered the failed transition
-    def event
-      @event.name
-    end
-    
-    # The fully-qualified name of the event that triggered the failed transition
-    def qualified_event
-      @event.qualified_name
-    end
-    
-    # The name for the current state
-    def from_name
-      @from_state.name
-    end
-    
-    # The fully-qualified name for the current state
-    def qualified_from_name
-      @from_state.qualified_name
-    end
-  end
-  
-  # A set of transition failed to run in parallel
-  class InvalidParallelTransition < Error
-    # The set of events that failed the transition(s)
-    attr_reader :events
-    
-    def initialize(object, events) #:nodoc:
-      @events = events
-      
-      super(object, "Cannot run events in parallel: #{events * ', '}")
-    end
-  end
-  
   # A transition represents a state change for a specific attribute.
   # 
   # Transitions consist of: