activemodel 3.0.pre → 3.0.0.rc

data/lib/active_model/test_case.rb

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

data/lib/active_model/translation.rb

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/hash/reverse_merge'
+
+module ActiveModel
+
+  # == Active Model Translation
+  #   
+  # Provides integration between your object and the Rails internationalization
+  # (i18n) framework.
+  # 
+  # A minimal implementation could be:
+  # 
+  #   class TranslatedPerson
+  #     extend ActiveModel::Translation
+  #   end
+  # 
+  #   TranslatedPerson.human_attribute_name('my_attribute')
+  #   #=> "My attribute"
+  # 
+  # This also provides the required class methods for hooking into the
+  # Rails internationalization API, including being able to define a
+  # class based i18n_scope and lookup_ancestors to find translations in
+  # parent classes.
+  module Translation
+    include ActiveModel::Naming
+
+    # Returns the i18n_scope for the class. Overwrite if you want custom lookup.
+    def i18n_scope
+      :activemodel
+    end
+
+    # When localizing a string, it goes through the lookup returned by this 
+    # method, which is used in ActiveModel::Name#human,
+    # ActiveModel::Errors#full_messages and 
+    # ActiveModel::Translation#human_attribute_name.
+    def lookup_ancestors
+      self.ancestors.select { |x| x.respond_to?(:model_name) }
+    end
+
+    # Transforms attribute names into a more human format, such as "First name"
+    # instead of "first_name".
+    #
+    #   Person.human_attribute_name("first_name") # => "First name"
+    #
+    # Specify +options+ with additional translating options.
+    def human_attribute_name(attribute, options = {})
+      defaults = lookup_ancestors.map do |klass|
+        :"#{self.i18n_scope}.attributes.#{klass.model_name.underscore}.#{attribute}"
+      end
+
+      defaults << :"attributes.#{attribute}"
+      defaults << options.delete(:default) if options[:default]
+      defaults << attribute.to_s.humanize
+
+      options.reverse_merge! :count => 1, :default => defaults
+      I18n.translate(defaults.shift, options)
+    end
+
+    # Model.human_name is deprecated. Use Model.model_name.human instead.
+    def human_name(*args)
+      ActiveSupport::Deprecation.warn("human_name has been deprecated, please use model_name.human instead", caller[0,5])
+      model_name.human(*args)
+    end
+  end
+end

data/lib/active_model/validations.rb

@@ -1,23 +1,105 @@
 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'
+require 'active_model/validations/callbacks'
 
 module ActiveModel
+
+  # == Active Model Validations
+  #   
+  # 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 do this manually.
+  # 
   module Validations
     extend ActiveSupport::Concern
     include ActiveSupport::Callbacks
 
     included do
+      extend ActiveModel::Translation
+
+      extend  HelperMethods
+      include HelperMethods
+
+      attr_accessor :validation_context
       define_callbacks :validate, :scope => :name
+
+      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
+      # overriding the +validate+ instance method becomes too unwieldy and
       # you're looking for more descriptive declaration of your validations.
       #
       # This can be done with a symbol pointing to a method:
       #
-      #   class Comment < ActiveRecord::Base
+      #   class Comment
+      #     include ActiveModel::Validations
+      # 
       #     validate :must_be_friends
       #
       #     def must_be_friends
@@ -25,9 +107,11 @@ module ActiveModel
       #     end
       #   end
       #
-      # Or with a block which is passed the current record to be validated:
+      # Or with a block which is passed with the current record to be validated:
+      #
+      #   class Comment
+      #     include ActiveModel::Validations
       #
-      #   class Comment < ActiveRecord::Base
       #     validate do |comment|
       #       comment.must_be_friends
       #     end
@@ -37,48 +121,37 @@ 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(options[:if])
-          options[:if] << "@_on_validate == :#{options[:on]}"
+          options[:if] = Array.wrap(options[:if])
+          options[:if] << "validation_context == :#{options[:on]}"
         end
         set_callback(:validate, *args, &block)
       end
+
+      # List all validators that are 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
+
+      # Check if method is an attribute method or not.
+      def attribute_method?(attribute)
+        method_defined?(attribute)
+      end
+
+      # Copy validators on inheritance.
+      def inherited(base)
+        dup = _validators.dup
+        base._validators = dup.each { |k, v| dup[k] = v.dup }
+        super
+      end
     end
 
     # Returns the Errors object that holds all information about attribute error messages.
@@ -86,39 +159,48 @@ module ActiveModel
       @errors ||= Errors.new(self)
     end
 
-    # Runs all the specified validations and returns true if no errors were added otherwise false.
-    def valid?
+    # 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
       errors.clear
-      _run_validate_callbacks
-      errors.empty?
+      run_validations!
+    ensure
+      self.validation_context = current_context
     end
 
-    # Performs the opposite of <tt>valid?</tt>. Returns true if errors were added, false otherwise.
-    def invalid?
-      !valid?
+    # Performs the opposite of <tt>valid?</tt>. Returns true if errors were added, 
+    # false otherwise.
+    def invalid?(context = nil)
+      !valid?(context)
     end
 
-    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
+    # Hook method defining how an attribute value should be retrieved. 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:
+    #
+    #   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
+  
+    def run_validations!
+      _run_validate_callbacks
+      errors.empty?
+    end
   end
 end
 

data/lib/active_model/validations/acceptance.rb

@@ -1,47 +1,67 @@
 module ActiveModel
+
+  # == Active Model Acceptance Validator
   module Validations
-    module ClassMethods
-      # Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
+    class AcceptanceValidator < EachValidator
+      def initialize(options)
+        super(options.reverse_merge(:allow_nil => true, :accept => "1"))
+      end
+
+      def validate_each(record, attribute, value)
+        unless value == options[:accept]
+          record.errors.add(attribute, :accepted, options.except(:accept, :allow_nil))
+        end
+      end
+
+      def setup(klass)
+        # Note: instance_methods.map(&:to_s) is important for 1.9 compatibility
+        # as instance_methods returns symbols unlike 1.8 which returns strings.
+        attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+        attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
+        klass.send(:attr_reader, *attr_readers)
+        klass.send(:attr_writer, *attr_writers)
+      end
+    end
+
+    module HelperMethods
+      # Encapsulates the pattern of wanting to validate the acceptance of a 
+      # terms of service check box (or similar agreement). Example:
       #
       #   class Person < ActiveRecord::Base
       #     validates_acceptance_of :terms_of_service
       #     validates_acceptance_of :eula, :message => "must be abided"
       #   end
       #
-      # If the database column does not exist, the +terms_of_service+ attribute is entirely virtual. This check is
-      # performed only if +terms_of_service+ is not +nil+ and by default on save.
+      # If the database column does not exist, the +terms_of_service+ attribute 
+      # is entirely virtual. This check is performed only if +terms_of_service+
+      # is not +nil+ and by default on save.
       #
       # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "must be accepted").
-      # * <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+ (default is true).
-      # * <tt>:accept</tt> - Specifies value that is considered accepted.  The default value is a string "1", which
-      #   makes it easy to relate to an HTML checkbox. This should be set to +true+ if you are validating a database
-      #   column, since the attribute is typecast from "1" to +true+ before validation.
-      # * <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.
+      # * <tt>:message</tt> - A custom error message (default is: "must be 
+      #   accepted").
+      # * <tt>:on</tt> - Specifies when this validation is active (default is
+      #   <tt>:save</tt>, other options are <tt>:create</tt> and 
+      #   <tt>:update</tt>).
+      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default
+      #   is true).
+      # * <tt>:accept</tt> - Specifies value that is considered accepted. 
+      #   The default value is a string "1", which makes it easy to relate to
+      #   an HTML checkbox. This should be set to +true+ if you are validating 
+      #   a database column, since the attribute is typecast from "1" to +true+
+      #   before validation.
+      # * <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 (for example, 
+      #   <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_acceptance_of(*attr_names)
-        configuration = { :allow_nil => true, :accept => "1" }
-        configuration.update(attr_names.extract_options!)
-
-        db_cols = begin
-          column_names
-        rescue Exception # To ignore both statement and connection errors
-          []
-        end
-
-        names = attr_names.reject { |name| db_cols.include?(name.to_s) }
-        attr_accessor(*names)
-
-        validates_each(attr_names,configuration) do |record, attr_name, value|
-          unless value == configuration[:accept]
-            record.errors.add(attr_name, :accepted, :default => configuration[:message])
-          end
-        end
+        validates_with AcceptanceValidator, _merge_attributes(attr_names)
       end
     end
   end

data/lib/active_model/validations/callbacks.rb

@@ -0,0 +1,57 @@
+require 'active_support/callbacks'
+
+module ActiveModel
+  module Validations
+    module Callbacks
+      # == Active Model Validation callbacks
+      #
+      # Provides an interface for any class to have <tt>before_validation</tt> and
+      # <tt>after_validation</tt> callbacks.
+      #
+      # First, extend ActiveModel::Callbacks from the class you are creating:
+      #
+      #   class MyModel
+      #     include ActiveModel::Validations::Callbacks
+      #
+      #     before_validation :do_stuff_before_validation
+      #     after_validation  :do_tuff_after_validation
+      #   end
+      #
+      #   Like other before_* callbacks if <tt>before_validation</tt> returns false
+      #   then <tt>valid?</tt> will not be called.
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveSupport::Callbacks
+        define_callbacks :validation, :terminator => "result == false", :scope => [:kind, :name]
+      end
+
+      module ClassMethods
+        def before_validation(*args, &block)
+          options = args.last
+          if options.is_a?(Hash) && options[:on]
+            options[:if] = Array.wrap(options[:if])
+            options[:if] << "self.validation_context == :#{options[:on]}"
+          end
+          set_callback(:validation, :before, *args, &block)
+        end
+
+        def after_validation(*args, &block)
+          options = args.extract_options!
+          options[:prepend] = true
+          options[:if] = Array.wrap(options[:if])
+          options[:if] << "!halted && value != false"
+          options[:if] << "self.validation_context == :#{options[:on]}" if options[:on]
+          set_callback(:validation, :after, *(args << options), &block)
+        end
+      end
+
+    protected
+
+      # Overwrite run validations to include callbacks.
+      def run_validations!
+        _run_validation_callbacks { super }
+      end
+    end
+  end
+end