activemodel 3.0.0.beta4 → 3.0.pre

data/lib/active_model/state_machine.rb

@@ -0,0 +1,70 @@
+module ActiveModel
+  module StateMachine
+    autoload :Event, 'active_model/state_machine/event'
+    autoload :Machine, 'active_model/state_machine/machine'
+    autoload :State, 'active_model/state_machine/state'
+    autoload :StateTransition, 'active_model/state_machine/state_transition'
+
+    extend ActiveSupport::Concern
+
+    class InvalidTransition < Exception
+    end
+
+    module ClassMethods
+      def inherited(klass)
+        super
+        klass.state_machines = state_machines
+      end
+
+      def state_machines
+        @state_machines ||= {}
+      end
+
+      def state_machines=(value)
+        @state_machines = value ? value.dup : nil
+      end
+
+      def state_machine(name = nil, options = {}, &block)
+        if name.is_a?(Hash)
+          options = name
+          name    = nil
+        end
+        name ||= :default
+        state_machines[name] ||= Machine.new(self, name)
+        block ? state_machines[name].update(options, &block) : state_machines[name]
+      end
+
+      def define_state_query_method(state_name)
+        name = "#{state_name}?"
+        undef_method(name) if method_defined?(name)
+        class_eval "def #{name}; current_state.to_s == %(#{state_name}) end"
+      end
+    end
+
+    def current_state(name = nil, new_state = nil, persist = false)
+      sm   = self.class.state_machine(name)
+      ivar = sm.current_state_variable
+      if name && new_state
+        if persist && respond_to?(:write_state)
+          write_state(sm, new_state)
+        end
+
+        if respond_to?(:write_state_without_persistence)
+          write_state_without_persistence(sm, new_state)
+        end
+
+        instance_variable_set(ivar, new_state)
+      else
+        instance_variable_set(ivar, nil) unless instance_variable_defined?(ivar)
+        value = instance_variable_get(ivar)
+        return value if value
+
+        if respond_to?(:read_state)
+          value = instance_variable_set(ivar, read_state(sm))
+        end
+
+        value || sm.initial_state
+      end
+    end
+  end
+end

data/lib/active_model/state_machine/event.rb

@@ -0,0 +1,62 @@
+module ActiveModel
+  module StateMachine
+    class Event
+      attr_reader :name, :success
+
+      def initialize(machine, name, options = {}, &block)
+        @machine, @name, @transitions = machine, name, []
+        if machine
+          machine.klass.send(:define_method, "#{name}!") do |*args|
+            machine.fire_event(name, self, true, *args)
+          end
+
+          machine.klass.send(:define_method, name.to_s) do |*args|
+            machine.fire_event(name, self, false, *args)
+          end
+        end
+        update(options, &block)
+      end
+
+      def fire(obj, to_state = nil, *args)
+        transitions = @transitions.select { |t| t.from == obj.current_state(@machine ? @machine.name : nil) }
+        raise InvalidTransition if transitions.size == 0
+
+        next_state = nil
+        transitions.each do |transition|
+          next if to_state && !Array(transition.to).include?(to_state)
+          if transition.perform(obj)
+            next_state = to_state || Array(transition.to).first
+            transition.execute(obj, *args)
+            break
+          end
+        end
+        next_state
+      end
+
+      def transitions_from_state?(state)
+        @transitions.any? { |t| t.from? state }
+      end
+
+      def ==(event)
+        if event.is_a? Symbol
+          name == event
+        else
+          name == event.name
+        end
+      end
+
+      def update(options = {}, &block)
+        if options.key?(:success) then @success = options[:success] end
+        if block                  then instance_eval(&block)        end
+        self
+      end
+
+      private
+        def transitions(trans_opts)
+          Array(trans_opts[:from]).each do |s|
+            @transitions << StateTransition.new(trans_opts.merge({:from => s.to_sym}))
+          end
+        end
+    end
+  end
+end

data/lib/active_model/state_machine/machine.rb

@@ -0,0 +1,75 @@
+module ActiveModel
+  module StateMachine
+    class Machine
+      attr_writer :initial_state
+      attr_accessor :states, :events, :state_index
+      attr_reader :klass, :name
+
+      def initialize(klass, name, options = {}, &block)
+        @klass, @name, @states, @state_index, @events = klass, name, [], {}, {}
+        update(options, &block)
+      end
+
+      def initial_state
+        @initial_state ||= (states.first ? states.first.name : nil)
+      end
+
+      def update(options = {}, &block)
+        if options.key?(:initial) then @initial_state = options[:initial] end
+        if block                  then instance_eval(&block)              end
+        self
+      end
+
+      def fire_event(event, record, persist, *args)
+        state_index[record.current_state(@name)].call_action(:exit, record)
+        if new_state = @events[event].fire(record, *args)
+          state_index[new_state].call_action(:enter, record)
+
+          if record.respond_to?(event_fired_callback)
+            record.send(event_fired_callback, record.current_state, new_state)
+          end
+
+          record.current_state(@name, new_state, persist)
+          record.send(@events[event].success) if @events[event].success
+          true
+        else
+          if record.respond_to?(event_failed_callback)
+            record.send(event_failed_callback, event)
+          end
+
+          false
+        end
+      end
+
+      def states_for_select
+        states.map { |st| [st.display_name, st.name.to_s] }
+      end
+
+      def events_for(state)
+        events = @events.values.select { |event| event.transitions_from_state?(state) }
+        events.map! { |event| event.name }
+      end
+
+      def current_state_variable
+        "@#{@name}_current_state"
+      end
+
+      private
+        def state(name, options = {})
+          @states << (state_index[name] ||= State.new(name, :machine => self)).update(options)
+        end
+
+        def event(name, options = {}, &block)
+          (@events[name] ||= Event.new(self, name)).update(options, &block)
+        end
+
+        def event_fired_callback
+          @event_fired_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_fired'
+        end
+
+        def event_failed_callback
+          @event_failed_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_failed'
+        end
+    end
+  end
+end

data/lib/active_model/state_machine/state.rb

@@ -0,0 +1,47 @@
+module ActiveModel
+  module StateMachine
+    class State
+      attr_reader :name, :options
+
+      def initialize(name, options = {})
+        @name = name
+        if machine = options.delete(:machine)
+          machine.klass.define_state_query_method(name)
+        end
+        update(options)
+      end
+
+      def ==(state)
+        if state.is_a? Symbol
+          name == state
+        else
+          name == state.name
+        end
+      end
+
+      def call_action(action, record)
+        action = @options[action]
+        case action
+        when Symbol, String
+          record.send(action)
+        when Proc
+          action.call(record)
+        end
+      end
+
+      def display_name
+        @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
+      end
+
+      def for_select
+        [display_name, name.to_s]
+      end
+
+      def update(options = {})
+        if options.key?(:display) then @display_name = options.delete(:display) end
+        @options = options
+        self
+      end
+    end
+  end
+end

data/lib/active_model/state_machine/state_transition.rb

@@ -0,0 +1,40 @@
+module ActiveModel
+  module StateMachine
+    class StateTransition
+      attr_reader :from, :to, :options
+
+      def initialize(opts)
+        @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
+        @options = opts
+      end
+
+      def perform(obj)
+        case @guard
+        when Symbol, String
+          obj.send(@guard)
+        when Proc
+          @guard.call(obj)
+        else
+          true
+        end
+      end
+
+      def execute(obj, *args)
+        case @on_transition
+        when Symbol, String
+          obj.send(@on_transition, *args)
+        when Proc
+          @on_transition.call(obj, *args)
+        end
+      end
+
+      def ==(obj)
+        @from == obj.from && @to == obj.to
+      end
+
+      def from?(value)
+        @from == value
+      end
+    end
+  end
+end

data/lib/active_model/test_case.rb

@@ -1,3 +1,5 @@
+require "active_support/test_case"
+
 module ActiveModel #:nodoc:
   class TestCase < ActiveSupport::TestCase #:nodoc:
     def with_kcode(kcode)

data/lib/active_model/validations.rb

@@ -1,103 +1,23 @@
 require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/hash/keys'
-require 'active_model/errors'
 
 module ActiveModel
-  
-  # Provides a full validation framework to your objects.
-  # 
-  # A minimal implementation could be:
-  # 
-  #   class Person
-  #     include ActiveModel::Validations
-  # 
-  #     attr_accessor :first_name, :last_name
-  #
-  #     validates_each :first_name, :last_name do |record, attr, value|
-  #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
-  #     end
-  #   end
-  # 
-  # Which provides you with the full standard validation stack that you
-  # know from ActiveRecord.
-  # 
-  #   person = Person.new
-  #   person.valid?
-  #   #=> true
-  #   person.invalid?
-  #   #=> false
-  #   person.first_name = 'zoolander'
-  #   person.valid?
-  #   #=> false
-  #   person.invalid?
-  #   #=> true
-  #   person.errors
-  #   #=> #<OrderedHash {:first_name=>["starts with z."]}>
-  # 
-  # Note that ActiveModel::Validations automatically adds an +errors+ method
-  # to your instances initialized with a new ActiveModel::Errors object, so
-  # there is no need for you to add this manually.
-  # 
   module Validations
     extend ActiveSupport::Concern
     include ActiveSupport::Callbacks
 
     included do
-      extend ActiveModel::Translation
-
-      extend  HelperMethods
-      include HelperMethods
-
       define_callbacks :validate, :scope => :name
-
-      attr_accessor :validation_context
-
-      class_attribute :_validators
-      self._validators = Hash.new { |h,k| h[k] = [] }
     end
 
     module ClassMethods
-      # Validates each attribute against a block.
-      #
-      #   class Person
-      #     include ActiveModel::Validations
-      # 
-      #     attr_accessor :first_name, :last_name
-      #
-      #     validates_each :first_name, :last_name do |record, attr, value|
-      #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
-      #     end
-      #   end
-      #
-      # Options:
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>,
-      #   other options <tt>:create</tt>, <tt>:update</tt>).
-      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
-      # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or
-      #   <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
-      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_each(*attr_names, &block)
-        options = attr_names.extract_options!.symbolize_keys
-        validates_with BlockValidator, options.merge(:attributes => attr_names.flatten), &block
-      end
-
       # Adds a validation method or block to the class. This is useful when
       # overriding the +validate+ instance method becomes too unwieldly and
       # you're looking for more descriptive declaration of your validations.
       #
       # This can be done with a symbol pointing to a method:
       #
-      #   class Comment
-      #     include ActiveModel::Validations
-      # 
+      #   class Comment < ActiveRecord::Base
       #     validate :must_be_friends
       #
       #     def must_be_friends
@@ -107,9 +27,7 @@ module ActiveModel
       #
       # Or with a block which is passed the current record to be validated:
       #
-      #   class Comment
-      #     include ActiveModel::Validations
-      #
+      #   class Comment < ActiveRecord::Base
       #     validate do |comment|
       #       comment.must_be_friends
       #     end
@@ -119,29 +37,48 @@ module ActiveModel
       #     end
       #   end
       #
+      # This usage applies to +validate_on_create+ and +validate_on_update as well+.
+
+      # Validates each attribute against a block.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_each :first_name, :last_name do |record, attr, value|
+      #       record.errors.add attr, 'starts with z.' if value[0] == ?z
+      #     end
+      #   end
+      #
+      # Options:
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
+      # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
+      #   method, proc or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
+      #   method, proc or string should return or evaluate to a true or false value.
+      def validates_each(*attrs)
+        options = attrs.extract_options!.symbolize_keys
+        attrs   = attrs.flatten
+
+        # Declare the validation.
+        validate options do |record|
+          attrs.each do |attr|
+            value = record.send(:read_attribute_for_validation, attr)
+            next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+            yield record, attr, value
+          end
+        end
+      end
+
       def validate(*args, &block)
         options = args.last
         if options.is_a?(Hash) && options.key?(:on)
-          options[:if] = Array.wrap(options[:if])
-          options[:if] << "validation_context == :#{options[:on]}"
+          options[:if] = Array(options[:if])
+          options[:if] << "@_on_validate == :#{options[:on]}"
         end
         set_callback(:validate, *args, &block)
       end
-
-      # List all validators that being used to validate the model using +validates_with+
-      # method.
-      def validators
-        _validators.values.flatten.uniq
-      end
-
-      # List all validators that being used to validate a specific attribute.
-      def validators_on(attribute)
-        _validators[attribute.to_sym]
-      end
-
-      def attribute_method?(attribute)
-        method_defined?(attribute)
-      end
     end
 
     # Returns the Errors object that holds all information about attribute error messages.
@@ -150,38 +87,38 @@ module ActiveModel
     end
 
     # Runs all the specified validations and returns true if no errors were added otherwise false.
-    # Context can optionally be supplied to define which callbacks to test against (the context is
-    # defined on the validations using :on).
-    def valid?(context = nil)
-      current_context, self.validation_context = validation_context, context
+    def valid?
       errors.clear
       _run_validate_callbacks
       errors.empty?
-    ensure
-      self.validation_context = current_context
     end
 
     # Performs the opposite of <tt>valid?</tt>. Returns true if errors were added, false otherwise.
-    def invalid?(context = nil)
-      !valid?(context)
+    def invalid?
+      !valid?
     end
 
-    # Hook method defining how an attribute value should be retieved. By default this is assumed
-    # to be an instance named after the attribute. Override this method in subclasses should you
-    # need to retrieve the value for a given attribute differently e.g.
-    #   class MyClass
-    #     include ActiveModel::Validations
-    #
-    #     def initialize(data = {})
-    #       @data = data
-    #     end
-    #
-    #     def read_attribute_for_validation(key)
-    #       @data[key]
-    #     end
-    #   end
-    #
-    alias :read_attribute_for_validation :send
+    protected
+      # Hook method defining how an attribute value should be retieved. By default this is assumed
+      # to be an instance named after the attribute. Override this method in subclasses should you
+      # need to retrieve the value for a given attribute differently e.g.
+      #   class MyClass
+      #     include ActiveModel::Validations
+      #
+      #     def initialize(data = {})
+      #       @data = data
+      #     end
+      #
+      #     private
+      #
+      #     def read_attribute_for_validation(key)
+      #       @data[key]
+      #     end
+      #   end
+      #
+      def read_attribute_for_validation(key)
+        send(key)
+      end
   end
 end