activemodel 3.0.pre → 3.0.0.rc

data/lib/active_model/validations/presence.rb

@@ -1,8 +1,16 @@
 require 'active_support/core_ext/object/blank'
 
 module ActiveModel
+
+  # == Active Model Presence Validator
   module Validations
-    module ClassMethods
+    class PresenceValidator < EachValidator
+      def validate(record)
+        record.errors.add_on_blank(attributes, options)
+      end
+    end
+
+    module HelperMethods
       # Validates that the specified attributes are not blank (as defined by Object#blank?). Happens by default on save. Example:
       #
       #   class Person < ActiveRecord::Base
@@ -28,13 +36,7 @@ module ActiveModel
       #   The method, proc or string should return or evaluate to a true or false value.
       #
       def validates_presence_of(*attr_names)
-        configuration = attr_names.extract_options!
-
-        # can't use validates_each here, because it cannot cope with nonexistent attributes,
-        # while errors.add_on_empty can
-        validate configuration do |record|
-          record.errors.add_on_blank(attr_names, configuration[:message])
-        end
+        validates_with PresenceValidator, _merge_attributes(attr_names)
       end
     end
   end

data/lib/active_model/validations/validates.rb

@@ -0,0 +1,110 @@
+require 'active_support/core_ext/hash/slice'
+
+module ActiveModel
+
+  # == Active Model validates method
+  module Validations
+    module ClassMethods
+      # This method is a shortcut to all default validators and any custom
+      # validator classes ending in 'Validator'. Note that Rails default
+      # validators can be overridden inside specific classes by creating
+      # custom validator classes in their place such as PresenceValidator.
+      # 
+      # Examples of using the default rails validators:
+      #
+      #   validates :terms, :acceptance => true
+      #   validates :password, :confirmation => true
+      #   validates :username, :exclusion => { :in => %w(admin superuser) }
+      #   validates :email, :format => { :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :on => :create }
+      #   validates :age, :inclusion => { :in => 0..9 }
+      #   validates :first_name, :length => { :maximum => 30 }
+      #   validates :age, :numericality => true
+      #   validates :username, :presence => true
+      #   validates :username, :uniqueness => true
+      # 
+      # The power of the +validates+ method comes when using custom validators
+      # and default validators in one call for a given attribute e.g.
+      #
+      #   class EmailValidator < ActiveModel::EachValidator
+      #     def validate_each(record, attribute, value)
+      #       record.errors[attribute] << (options[:message] || "is not an email") unless
+      #         value =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+      #     end
+      #   end
+      # 
+      #   class Person
+      #     include ActiveModel::Validations
+      #     attr_accessor :name, :email
+      # 
+      #     validates :name, :presence => true, :uniqueness => true, :length => { :maximum => 100 }
+      #     validates :email, :presence => true, :email => true
+      #   end
+      # 
+      # Validator classes my also exist within the class being validated
+      # allowing custom modules of validators to be included as needed e.g.
+      #
+      #   class Film
+      #     include ActiveModel::Validations
+      #
+      #     class TitleValidator < ActiveModel::EachValidator
+      #       def validate_each(record, attribute, value)
+      #         record.errors[attribute] << "must start with 'the'" unless =~ /^the/i
+      #       end
+      #     end
+      #
+      #     validates :name, :title => true
+      #   end
+      #
+      # The validators hash can also handle regular expressions, ranges and arrays:
+      #
+      #   validates :email, :format => /@/
+      #   validates :gender, :inclusion => %w(male female)
+      #   validates :password, :length => 6..20
+      #
+      # Finally, the options :if, :unless, :on, :allow_blank and :allow_nil can be given
+      # to one specific validator:
+      #
+      #   validates :password, :presence => { :if => :password_required? }, :confirmation => true
+      #
+      # Or to all at the same time:
+      #
+      #   validates :password, :presence => true, :confirmation => true, :if => :password_required?
+      #
+      def validates(*attributes)
+        defaults = attributes.extract_options!
+        validations = defaults.slice!(:if, :unless, :on, :allow_blank, :allow_nil)
+
+        raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
+        raise ArgumentError, "Attribute names must be symbols" if attributes.any?{ |attribute| !attribute.is_a?(Symbol) }
+        raise ArgumentError, "You need to supply at least one validation" if validations.empty?
+
+        defaults.merge!(:attributes => attributes)
+
+        validations.each do |key, options|
+          begin
+            validator = const_get("#{key.to_s.camelize}Validator")
+          rescue NameError
+            raise ArgumentError, "Unknown validator: '#{key}'"
+          end
+
+          validates_with(validator, defaults.merge(_parse_validates_options(options)))
+        end
+      end
+
+    protected
+
+      def _parse_validates_options(options) #:nodoc:
+        case options
+        when TrueClass
+          {}
+        when Hash
+          options
+        when Regexp
+          { :with => options }
+        when Range, Array
+          { :in => options }
+        end
+      end
+    end
+  end
+end

data/lib/active_model/validations/with.rb

@@ -1,15 +1,24 @@
 module ActiveModel
   module Validations
-    module ClassMethods
+    module HelperMethods
+      private
+        def _merge_attributes(attr_names)
+          options = attr_names.extract_options!
+          options.merge(:attributes => attr_names.flatten)
+        end
+    end
 
-      # Passes the record off to the class or classes specified and allows them to add errors based on more complex conditions.
+    module ClassMethods
+      # Passes the record off to the class or classes specified and allows them
+      # to add errors based on more complex conditions.
       #
-      #   class Person < ActiveRecord::Base
+      #   class Person
+      #     include ActiveModel::Validations
       #     validates_with MyValidator
       #   end
       #
-      #   class MyValidator < ActiveRecord::Validator
-      #     def validate
+      #   class MyValidator < ActiveModel::Validator
+      #     def validate(record)
       #       if some_complex_logic
       #         record.errors[:base] << "This record is invalid"
       #       end
@@ -23,42 +32,100 @@ module ActiveModel
       #
       # You may also pass it multiple classes, like so:
       #
-      #   class Person < ActiveRecord::Base
+      #   class Person
+      #     include ActiveModel::Validations
       #     validates_with MyValidator, MyOtherValidator, :on => :create
       #   end
       #
       # Configuration options:
-      # * <tt>on</tt> - Specifies when this validation is active (<tt>:create</tt> or <tt>:update</tt>
-      # * <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>).
+      # * <tt>on</tt> - Specifies when this validation is active
+      #   (<tt>:create</tt> or <tt>:update</tt>
+      # * <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>).
+      # * <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.
       #
-      # If you pass any additional configuration options, they will be passed to the class and available as <tt>options</tt>:
+      # If you pass any additional configuration options, they will be passed
+      # to the class and available as <tt>options</tt>:
       #
-      #   class Person < ActiveRecord::Base
+      #   class Person
+      #     include ActiveModel::Validations
       #     validates_with MyValidator, :my_custom_key => "my custom value"
       #   end
       #
-      #   class MyValidator < ActiveRecord::Validator
-      #     def validate
+      #   class MyValidator < ActiveModel::Validator
+      #     def validate(record)
       #       options[:my_custom_key] # => "my custom value"
       #     end
       #   end
       #
-      def validates_with(*args)
-        configuration = args.extract_options!
+      def validates_with(*args, &block)
+        options = args.extract_options!
+        args.each do |klass|
+          validator = klass.new(options, &block)
+          validator.setup(self) if validator.respond_to?(:setup)
 
-        validate configuration do |record|
-          args.each do |klass|
-            klass.new(record, configuration.except(:on, :if, :unless)).validate
+          if validator.respond_to?(:attributes) && !validator.attributes.empty?
+            validator.attributes.each do |attribute|
+              _validators[attribute.to_sym] << validator
+            end
+          else
+            _validators[nil] << validator
           end
+
+          validate(validator, options)
         end
       end
     end
-  end
-end
-
 
+    # Passes the record off to the class or classes specified and allows them
+    # to add errors based on more complex conditions.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     validates :instance_validations
+    #
+    #     def instance_validations
+    #       validates_with MyValidator
+    #     end
+    #   end
+    #
+    # Please consult the class method documentation for more information on
+    # creating your own validator.
+    #
+    # You may also pass it multiple classes, like so:
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     validates :instance_validations, :on => :create
+    #
+    #     def instance_validations
+    #       validates_with MyValidator, MyOtherValidator
+    #     end
+    #   end
+    #
+    # Standard configuration options (:on, :if and :unless), which are
+    # available on the class version of validates_with, should instead be
+    # placed on the <tt>validates</tt> method as these are applied and tested
+    # in the callback
+    #
+    # If you pass any additional configuration options, they will be passed
+    # to the class and available as <tt>options</tt>, please refer to the
+    # class version of this method for more information
+    #
+    def validates_with(*args, &block)
+      options = args.extract_options!
+      args.each do |klass|
+        validator = klass.new(options, &block)
+        validator.validate(self)
+      end
+    end
+  end
+end

data/lib/active_model/validator.rb

@@ -0,0 +1,186 @@
+require 'active_support/core_ext/array/wrap'
+require "active_support/core_ext/module/anonymous"
+require 'active_support/core_ext/object/blank'
+
+module ActiveModel #:nodoc:
+
+  # == Active Model Validator
+  # 
+  # A simple base class that can be used along with 
+  # +ActiveModel::Validations::ClassMethods.validates_with+
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     validates_with MyValidator
+  #   end
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def validate(record)
+  #       if some_complex_logic
+  #         record.errors[:base] = "This record is invalid"
+  #       end
+  #     end
+  #
+  #     private
+  #       def some_complex_logic
+  #         # ...
+  #       end
+  #   end
+  #
+  # Any class that inherits from ActiveModel::Validator must implement a method
+  # called <tt>validate</tt> which accepts a <tt>record</tt>.
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     validates_with MyValidator
+  #   end
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def validate(record)
+  #       record # => The person instance being validated
+  #       options # => Any non-standard options passed to validates_with
+  #     end
+  #   end
+  #
+  # To cause a validation error, you must add to the <tt>record<tt>'s errors directly
+  # from within the validators message
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def validate(record)
+  #       record.errors[:base] << "This is some custom error message"
+  #       record.errors[:first_name] << "This is some complex validation"
+  #       # etc...
+  #     end
+  #   end
+  #
+  # To add behavior to the initialize method, use the following signature:
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def initialize(record, options)
+  #       super
+  #       @my_custom_field = options[:field_name] || :first_name
+  #     end
+  #   end
+  # 
+  # The easiest way to add custom validators for validating individual attributes
+  # is with the convenient ActiveModel::EachValidator for example:
+  # 
+  #   class TitleValidator < ActiveModel::EachValidator
+  #     def validate_each(record, attribute, value)
+  #       record.errors[attribute] << 'must be Mr. Mrs. or Dr.' unless ['Mr.', 'Mrs.', 'Dr.'].include?(value)
+  #     end
+  #   end
+  # 
+  # This can now be used in combination with the +validates+ method
+  # (see ActiveModel::Validations::ClassMethods.validates for more on this)
+  # 
+  #   class Person
+  #     include ActiveModel::Validations
+  #     attr_accessor :title
+  # 
+  #     validates :title, :presence => true, :title => true
+  #   end
+  # 
+  # Validator may also define a +setup+ instance method which will get called
+  # with the class that using that validator as it's argument. This can be
+  # useful when there are prerequisites such as an attr_accessor being present
+  # for example:
+  # 
+  #   class MyValidator < ActiveModel::Validator
+  #     def setup(klass)
+  #       klass.send :attr_accessor, :custom_attribute
+  #     end
+  #   end
+  #
+  # This setup method is only called when used with validation macros or the
+  # class level <tt>validates_with</tt> method.
+  # 
+  class Validator
+    attr_reader :options
+
+    # Returns the kind of the validator.
+    #
+    # == Examples
+    #
+    #   PresenceValidator.kind    #=> :presence
+    #   UniquenessValidator.kind  #=> :uniqueness
+    #
+    def self.kind
+      @kind ||= name.split('::').last.underscore.sub(/_validator$/, '').to_sym unless anonymous?
+    end
+
+    # Accepts options that will be made available through the +options+ reader.
+    def initialize(options)
+      @options = options
+    end
+
+    # Return the kind for this validator.
+    def kind
+      self.class.kind
+    end
+
+    # Override this method in subclasses with validation logic, adding errors
+    # to the records +errors+ array where necessary.
+    def validate(record)
+      raise NotImplementedError
+    end
+  end
+
+  # EachValidator is a validator which iterates through the attributes given
+  # in the options hash invoking the validate_each method passing in the
+  # record, attribute and value.
+  #
+  # All Active Model validations are built on top of this Validator.
+  class EachValidator < Validator
+    attr_reader :attributes
+    
+    # Returns a new validator instance. All options will be available via the
+    # +options+ reader, however the <tt>:attributes</tt> option will be removed
+    # and instead be made available through the +attributes+ reader.
+    def initialize(options)
+      @attributes = Array.wrap(options.delete(:attributes))
+      raise ":attributes cannot be blank" if @attributes.empty?
+      super
+      check_validity!
+    end
+
+    # Performs validation on the supplied record. By default this will call
+    # +validates_each+ to determine validity therefore subclasses should
+    # override +validates_each+ with validation logic.
+    def validate(record)
+      attributes.each do |attribute|
+        value = record.read_attribute_for_validation(attribute)
+        next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+        validate_each(record, attribute, value)
+      end
+    end
+
+    # Override this method in subclasses with the validation logic, adding
+    # errors to the records +errors+ array where necessary.
+    def validate_each(record, attribute, value)
+      raise NotImplementedError
+    end
+
+    # Hook method that gets called by the initializer allowing verification
+    # that the arguments supplied are valid. You could for example raise an
+    # ArgumentError when invalid options are supplied.
+    def check_validity!
+    end
+  end
+
+  # BlockValidator is a special EachValidator which receives a block on initialization
+  # and call this block for each attribute being validated. +validates_each+ uses this
+  # Validator.
+  class BlockValidator < EachValidator
+    def initialize(options, &block)
+      @block = block
+      super
+    end
+
+    private
+
+    def validate_each(record, attribute, value)
+      @block.call(record, attribute, value)
+    end
+  end
+end