state_machine_updated_for_ruby_3_2 2.0.0

data/lib/state_machine/integrations/base.rb

@@ -0,0 +1,100 @@
+module StateMachine
+  module Integrations
+    # Provides a set of base helpers for managing individual integrations
+    module Base
+      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.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})
+        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 StateMachine
+        #     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
+    end
+  end
+end

data/lib/state_machine/integrations/data_mapper/observer.rb

@@ -0,0 +1,210 @@
+module StateMachine
+  module Integrations #:nodoc:
+    module DataMapper
+      # Adds support for creating before/after/around/failure transition
+      # callbacks within a DataMapper observer.  These callbacks behave very
+      # similar to hooks during save/update/destroy/etc., but with the following
+      # modifications:
+      # * Each callback can define a set of transition requirements that must be
+      #   met in order for the callback to get invoked.
+      # * An additional transition parameter is available that provides
+      #   contextual information about the event (see StateMachine::Transition
+      #   for more information)
+      # 
+      # To define a single observer for multiple state machines:
+      # 
+      #   class StateMachineObserver
+      #     include DataMapper::Observer
+      #     
+      #     observe Vehicle, Switch, Project
+      #     
+      #     after_transition do |transition|
+      #       Audit.log(self, transition)
+      #     end
+      #   end
+      # 
+      # == Requirements
+      # 
+      # To use this feature of the DataMapper integration, the dm-observer library
+      # must be available.  This can be installed either directly or indirectly
+      # through dm-more.  When loading DataMapper, be sure to load the dm-observer
+      # library as well like so:
+      # 
+      #   require 'rubygems'
+      #   require 'dm-core'
+      #   require 'dm-observer'
+      # 
+      # If dm-observer is not available, then this feature will be skipped.
+      module Observer
+        include MatcherHelpers
+        
+        # Creates a callback that will be invoked *before* a transition is
+        # performed, so long as the given configuration options match the
+        # transition.  Each part of the transition (event, to state, from state)
+        # must match in order for the callback to get invoked.
+        # 
+        # See StateMachine::Machine#before_transition for more
+        # information about the various configuration options available.
+        # 
+        # == Examples
+        # 
+        #   class Vehicle
+        #     include DataMapper::Resource
+        #     
+        #     property :id, Serial
+        #     property :state, :String
+        #     
+        #     state_machine :initial => :parked do
+        #       event :ignite do
+        #         transition :parked => :idling
+        #       end
+        #     end
+        #   end
+        #   
+        #   class VehicleObserver
+        #     include DataMapper::Observer
+        #     
+        #     observe Vehicle
+        #     
+        #     before :save do
+        #       # log message
+        #     end
+        #     
+        #     # Target all state machines
+        #     before_transition :parked => :idling, :on => :ignite do
+        #       # put on seatbelt
+        #     end
+        #     
+        #     # Target a specific state machine
+        #     before_transition :state, any => :idling do
+        #       # put on seatbelt
+        #     end
+        #     
+        #     # Target all state machines without requirements
+        #     before_transition do |transition|
+        #       # log message
+        #     end
+        #   end
+        # 
+        # *Note* that in each of the above +before_transition+ callbacks, the
+        # callback is executed within the context of the object (i.e. the
+        # Vehicle instance being transition).  This means that +self+ refers
+        # to the vehicle record within each callback block.
+        def before_transition(*args, &block)
+          add_transition_callback(:before_transition, *args, &block)
+        end
+        
+        # Creates a callback that will be invoked *after* a transition is
+        # performed so long as the given configuration options match the
+        # transition.
+        # 
+        # See +before_transition+ for a description of the possible configurations
+        # for defining callbacks.
+        def after_transition(*args, &block)
+          add_transition_callback(:after_transition, *args, &block)
+        end
+        
+        # Creates a callback that will be invoked *around* a transition so long
+        # as the given requirements match the transition.
+        # 
+        # == Examples
+        # 
+        #   class Vehicle
+        #     include DataMapper::Resource
+        #     
+        #     property :id, Serial
+        #     property :state, :String
+        #     
+        #     state_machine :initial => :parked do
+        #       event :ignite do
+        #         transition :parked => :idling
+        #       end
+        #     end
+        #   end
+        #   
+        #   class VehicleObserver
+        #     include DataMapper::Observer
+        #     
+        #     observe Vehicle
+        #     
+        #     around_transition do |transition, block|
+        #       # track start time
+        #       block.call
+        #       # track end time
+        #     end
+        #   end
+        # 
+        # See +before_transition+ for a description of the possible configurations
+        # for defining callbacks.
+        def around_transition(*args, &block)
+          add_transition_callback(:around_transition, *args, &block)
+        end
+        
+        # Creates a callback that will be invoked *after* a transition failures to
+        # be performed so long as the given requirements match the transition.
+        # 
+        # == Example
+        # 
+        #   class Vehicle
+        #     include DataMapper::Resource
+        #     
+        #     property :id, Serial
+        #     property :state, :String
+        #     
+        #     state_machine :initial => :parked do
+        #       event :ignite do
+        #         transition :parked => :idling
+        #       end
+        #     end
+        #   end
+        #   
+        #   class VehicleObserver
+        #     after_transition_failure do |transition|
+        #       # log failure
+        #     end
+        #     
+        #     after_transition_failure :on => :ignite do
+        #       # log failure
+        #     end
+        #   end
+        # 
+        # See +before_transition+ for a description of the possible configurations
+        # for defining callbacks.  *Note* however that you cannot define the state
+        # requirements in these callbacks.  You may only define event requirements.
+        def after_transition_failure(*args, &block)
+          add_transition_callback(:after_failure, *args, &block)
+        end
+        
+        private
+          # Adds the transition callback to a specific machine or all of the
+          # state machines for each observed class.
+          def add_transition_callback(type, *args, &block)
+            if args.any? && !args.first.is_a?(Hash)
+              # Specific machine(s) being targeted
+              names = args
+              args = args.last.is_a?(Hash) ? [args.pop] : []
+            else
+              # Target all state machines
+              names = nil
+            end
+            
+            # Add the transition callback to each class being observed
+            observing.each do |klass|
+              state_machines =
+                if names
+                  names.map {|name| klass.state_machines.fetch(name)}
+                else
+                  klass.state_machines.values
+                end
+              
+              state_machines.each {|machine| machine.send(type, *args, &block)}
+            end if observing
+          end
+      end
+    end
+  end
+end
+
+DataMapper::Observer::ClassMethods.class_eval do
+  include StateMachine::Integrations::DataMapper::Observer
+end

data/lib/state_machine/integrations/data_mapper/versions.rb

@@ -0,0 +1,85 @@
+module StateMachine
+  module Integrations #:nodoc:
+    module DataMapper
+      version '0.9.x - 0.10.x' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.\d\./ || ::DataMapper::VERSION =~ /^0\.10\./
+        end
+        
+        def pluralize(word)
+          ::Extlib::Inflection.pluralize(word.to_s)
+        end
+      end
+      
+      version '0.9.x' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.9\./
+        end
+        
+        def define_action_helpers
+          if action_hook == :save
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def save(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+            end_eval
+            
+            define_validation_hook
+          else
+            super
+          end
+        end
+      end
+      
+      version '0.9.4 - 0.9.6' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.9\.[4-6]/
+        end
+        
+        # 0.9.4 - 0.9.6 fails to run after callbacks when validations are
+        # enabled because of the way dm-validations integrates
+        def define_action_helpers?
+          super if action != :save || !supports_validations?
+        end
+      end
+      
+      version '0.10.x' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.10\./
+        end
+        
+        def define_action_helpers
+          if action_hook == :save
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def save(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+              
+              def save!(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+              
+              def save_self(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+            end_eval
+            
+            define_validation_hook
+          else
+            super
+          end
+        end
+      end
+      
+      version '1.0.0' do
+        def self.active?
+          ::DataMapper::VERSION == '1.0.0'
+        end
+        
+        def pluralize(word)
+          (defined?(::ActiveSupport::Inflector) ? ::ActiveSupport::Inflector : ::Extlib::Inflection).pluralize(word.to_s)
+        end
+      end
+    end
+  end
+end