activemodel 3.0.0.beta3 → 3.0.0.beta4

data/CHANGELOG

@@ -1,3 +1,8 @@
+*Rails 3.0.0 [beta 4] (June 8th, 2010)*
+
+* JSON supports a custom root option: to_json(:root => 'custom')  #4515 [Jatinder Singh]
+
+
 *Rails 3.0.0 [beta 3] (April 13th, 2010)*
 
 * No changes

data/lib/active_model/attribute_methods.rb

@@ -80,7 +80,7 @@ module ActiveModel
       # 
       #   end
       # 
-      # Provivdes you with:
+      # Provides you with:
       # 
       #   AttributePerson.primary_key
       #   # => "sysid"

data/lib/active_model/dirty.rb

@@ -124,11 +124,12 @@ module ActiveModel
       @previously_changed
     end
 
+    # Map of change <tt>attr => original value</tt>.
+    def changed_attributes
+      @changed_attributes ||= {}
+    end
+
     private
-      # Map of change <tt>attr => original value</tt>.
-      def changed_attributes
-        @changed_attributes ||= {}
-      end
 
       # Handle <tt>*_changed?</tt> for +method_missing+.
       def attribute_changed?(attr)

data/lib/active_model/errors.rb

@@ -170,13 +170,13 @@ module ActiveModel
       end
     end
 
-    # Adds an error message (+messsage+) to the +attribute+, which will be returned on a call to <tt>on(attribute)</tt>
-    # for the same attribute and ensure that this error object returns false when asked if <tt>empty?</tt>. More than one
-    # error can be added to the same +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
-    # If no +messsage+ is supplied, :invalid is assumed.
+    # Adds +message+ to the error messages on +attribute+, which will be returned on a call to
+    # <tt>on(attribute)</tt> for the same attribute. More than one error can be added to the same
+    # +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
+    # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
     # 
-    # If +message+ is a Symbol, it will be translated, using the appropriate scope (see translate_error).
-    # If +message+ is a Proc, it will be called, allowing for things like Time.now to be used within an error
+    # If +message+ is a symbol, it will be translated using the appropriate scope (see +translate_error+).
+    # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an error.
     def add(attribute, message = nil, options = {})
       message ||= :invalid
       message = generate_message(attribute, message, options) if message.is_a?(Symbol)
@@ -223,7 +223,7 @@ module ActiveModel
         else
           attr_name = attribute.to_s.gsub('.', '_').humanize
           attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
-          options = { :default => "{{attribute}} {{message}}", :attribute => attr_name }
+          options = { :default => "%{attribute} %{message}", :attribute => attr_name }
 
           messages.each do |m|
             full_messages << I18n.t(:"errors.format", options.merge(:message => m))

data/lib/active_model/locale/en.yml

@@ -1,7 +1,7 @@
 en:
   errors:
     # The default format use in full error messages.
-    format: "{{attribute}} {{message}}"
+    format: "%{attribute} %{message}"
 
     # The values :model, :attribute and :value are always available for interpolation
     # The value :count is available when applicable. Can be used for pluralization.
@@ -13,14 +13,15 @@ en:
       accepted: "must be accepted"
       empty: "can't be empty"
       blank: "can't be blank"
-      too_long: "is too long (maximum is {{count}} characters)"
-      too_short: "is too short (minimum is {{count}} characters)"
-      wrong_length: "is the wrong length (should be {{count}} characters)"
+      too_long: "is too long (maximum is %{count} characters)"
+      too_short: "is too short (minimum is %{count} characters)"
+      wrong_length: "is the wrong length (should be %{count} characters)"
       not_a_number: "is not a number"
-      greater_than: "must be greater than {{count}}"
-      greater_than_or_equal_to: "must be greater than or equal to {{count}}"
-      equal_to: "must be equal to {{count}}"
-      less_than: "must be less than {{count}}"
-      less_than_or_equal_to: "must be less than or equal to {{count}}"
+      not_an_integer: "must be an integer"
+      greater_than: "must be greater than %{count}"
+      greater_than_or_equal_to: "must be greater than or equal to %{count}"
+      equal_to: "must be equal to %{count}"
+      less_than: "must be less than %{count}"
+      less_than_or_equal_to: "must be less than or equal to %{count}"
       odd: "must be odd"
       even: "must be even"

data/lib/active_model/observing.rb

@@ -1,17 +1,13 @@
-require 'observer'
 require 'singleton'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/conversions'
 
 module ActiveModel
   module Observing
     extend ActiveSupport::Concern
 
-    included do
-      extend Observable
-    end
-
     module ClassMethods
       # Activates the observers assigned. Examples:
       #
@@ -41,6 +37,26 @@ module ActiveModel
         observers.each { |o| instantiate_observer(o) }
       end
 
+      def add_observer(observer)
+        unless observer.respond_to? :update
+          raise ArgumentError, "observer needs to respond to `update'"
+        end
+        @observer_instances ||= []
+        @observer_instances << observer
+      end
+
+      def notify_observers(*arg)
+        if defined? @observer_instances
+          for observer in @observer_instances
+            observer.update(*arg)
+          end
+        end
+      end
+
+      def count_observers
+        @observer_instances.size
+      end
+
       protected
         def instantiate_observer(observer) #:nodoc:
           # string/symbol
@@ -56,7 +72,6 @@ module ActiveModel
         # Notify observers when the observed class is subclassed.
         def inherited(subclass)
           super
-          changed
           notify_observers :observed_class_inherited, subclass
         end
     end
@@ -70,7 +85,6 @@ module ActiveModel
       #   notify_observers(:after_save)
       # end
       def notify_observers(method)
-        self.class.changed
         self.class.notify_observers(method, self)
       end
   end

data/lib/active_model/serializers/json.rb

@@ -1,5 +1,5 @@
 require 'active_support/json'
-require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/attribute'
 
 module ActiveModel
   module Serializers
@@ -10,7 +10,8 @@ module ActiveModel
       included do
         extend ActiveModel::Naming
 
-        cattr_accessor :include_root_in_json, :instance_writer => true
+        class_attribute :include_root_in_json
+        self.include_root_in_json = true
       end
 
       # Returns a JSON string representing the model. Some configuration is
@@ -79,7 +80,11 @@ module ActiveModel
       #                    "title": "So I was thinking"}]}
       def encode_json(encoder)
         hash = serializable_hash(encoder.options)
-        hash = { self.class.model_name.element => hash } if include_root_in_json
+        if include_root_in_json
+          custom_root = encoder.options && encoder.options[:root]
+          hash = { custom_root || self.class.model_name.element => hash }
+        end
+
         ActiveSupport::JSON.encode(hash)
       end
 
@@ -88,7 +93,9 @@ module ActiveModel
       end
 
       def from_json(json)
-        self.attributes = ActiveSupport::JSON.decode(json)
+        hash = ActiveSupport::JSON.decode(json)
+        hash = hash.values.first if include_root_in_json
+        self.attributes = hash
         self
       end
     end

data/lib/active_model/serializers/xml.rb

@@ -1,6 +1,8 @@
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/hash/slice'
 
 module ActiveModel
   module Serializers
@@ -12,68 +14,31 @@ module ActiveModel
         class Attribute #:nodoc:
           attr_reader :name, :value, :type
 
-          def initialize(name, serializable)
+          def initialize(name, serializable, raw_value=nil)
             @name, @serializable = name, serializable
+            @value = value || @serializable.send(name)
             @type  = compute_type
-            @value = compute_value
           end
 
-          # There is a significant speed improvement if the value
-          # does not need to be escaped, as <tt>tag!</tt> escapes all values
-          # to ensure that valid XML is generated. For known binary
-          # values, it is at least an order of magnitude faster to
-          # Base64 encode binary values and directly put them in the
-          # output XML than to pass the original value or the Base64
-          # encoded value to the <tt>tag!</tt> method. It definitely makes
-          # no sense to Base64 encode the value and then give it to
-          # <tt>tag!</tt>, since that just adds additional overhead.
-          def needs_encoding?
-            ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
-          end
-
-          def decorations(include_types = true)
+          def decorations
             decorations = {}
-
-            if type == :binary
-              decorations[:encoding] = 'base64'
-            end
-
-            if include_types && type != :string
-              decorations[:type] = type
-            end
-
-            if value.nil?
-              decorations[:nil] = true
-            end
-
+            decorations[:encoding] = 'base64' if type == :binary
+            decorations[:type] = type unless type == :string
+            decorations[:nil] = true if value.nil?
             decorations
           end
 
-          protected
-            def compute_type
-              value = @serializable.send(name)
-              type = Hash::XML_TYPE_NAMES[value.class.name]
-              type ||= :string if value.respond_to?(:to_str)
-              type ||= :yaml
-              type
-            end
-
-            def compute_value
-              value = @serializable.send(name)
+        protected
 
-              if formatter = Hash::XML_FORMATTING[type.to_s]
-                value ? formatter.call(value) : nil
-              else
-                value
-              end
-            end
+          def compute_type
+            type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name]
+            type ||= :string if value.respond_to?(:to_str)
+            type ||= :yaml
+            type
+          end
         end
 
         class MethodAttribute < Attribute #:nodoc:
-          protected
-            def compute_type
-              Hash::XML_TYPE_NAMES[@serializable.send(name).class.name] || :string
-            end
         end
 
         attr_reader :options
@@ -92,104 +57,78 @@ module ActiveModel
         # then because <tt>:except</tt> is set to a default value, the second
         # level model can have both <tt>:except</tt> and <tt>:only</tt> set.  So if
         # <tt>:only</tt> is set, always delete <tt>:except</tt>.
-        def serializable_attribute_names
-          attribute_names = @serializable.attributes.keys.sort
-
+        def attributes_hash
+          attributes = @serializable.attributes
           if options[:only].any?
-            attribute_names &= options[:only]
+            attributes.slice(*options[:only])
           elsif options[:except].any?
-            attribute_names -= options[:except]
+            attributes.except(*options[:except])
+          else
+            attributes
           end
-
-          attribute_names
         end
 
         def serializable_attributes
-          serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
+          attributes_hash.map do |name, value|
+            self.class::Attribute.new(name, @serializable, value)
+          end
         end
 
-        def serializable_method_attributes
+        def serializable_methods
           Array.wrap(options[:methods]).inject([]) do |methods, name|
-            methods << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
+            methods << self.class::MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
             methods
           end
         end
 
         def serialize
-          args = [root]
-
-          if options[:namespace]
-            args << {:xmlns => options[:namespace]}
-          end
+          require 'builder' unless defined? ::Builder
 
-          if options[:type]
-            args << {:type => options[:type]}
-          end
+          options[:indent]  ||= 2
+          options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
 
-          builder.tag!(*args) do
-            add_attributes
-            procs = options.delete(:procs)
-            options[:procs] = procs
-            add_procs
-            yield builder if block_given?
-          end
-        end
+          @builder = options[:builder]
+          @builder.instruct! unless options[:skip_instruct]
 
-        private
-          def builder
-            @builder ||= begin
-              require 'builder' unless defined? ::Builder
-              options[:indent] ||= 2
-              builder = options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
+          root = (options[:root] || @serializable.class.model_name.element).to_s
+          root = ActiveSupport::XmlMini.rename_key(root, options)
 
-              unless options[:skip_instruct]
-                builder.instruct!
-                options[:skip_instruct] = true
-              end
-
-              builder
-            end
-          end
-
-          def root
-            root = (options[:root] || @serializable.class.model_name.singular).to_s
-            reformat_name(root)
-          end
+          args = [root]
+          args << {:xmlns => options[:namespace]} if options[:namespace]
+          args << {:type => options[:type]} if options[:type] && !options[:skip_types]
 
-          def dasherize?
-            !options.has_key?(:dasherize) || options[:dasherize]
+          @builder.tag!(*args) do
+            add_attributes_and_methods
+            add_extra_behavior
+            add_procs
+            yield @builder if block_given?
           end
+        end
 
-          def camelize?
-            options.has_key?(:camelize) && options[:camelize]
-          end
+      private
 
-          def reformat_name(name)
-            name = name.camelize if camelize?
-            dasherize? ? name.dasherize : name
-          end
+        def add_extra_behavior
+        end
 
-          def add_attributes
-            (serializable_attributes + serializable_method_attributes).each do |attribute|
-              builder.tag!(
-                reformat_name(attribute.name),
-                attribute.value.to_s,
-                attribute.decorations(!options[:skip_types])
-              )
-            end
+        def add_attributes_and_methods
+          (serializable_attributes + serializable_methods).each do |attribute|
+            key = ActiveSupport::XmlMini.rename_key(attribute.name, options)
+            ActiveSupport::XmlMini.to_tag(key, attribute.value,
+              options.merge(attribute.decorations))
           end
+        end
 
-          def add_procs
-            if procs = options.delete(:procs)
-              [ *procs ].each do |proc|
-                if proc.arity > 1
-                  proc.call(options, @serializable)
-                else
-                  proc.call(options)
-                end
+        def add_procs
+          if procs = options.delete(:procs)
+            Array.wrap(procs).each do |proc|
+              if proc.arity == 1
+                proc.call(options)
+              else
+                proc.call(options, @serializable)
               end
             end
           end
+        end
       end
 
       def to_xml(options = {}, &block)

data/lib/active_model/validations.rb

@@ -29,7 +29,7 @@ module ActiveModel
   #   person.invalid?
   #   #=> false
   #   person.first_name = 'zoolander'
-  #   person.valid?         
+  #   person.valid?
   #   #=> false
   #   person.invalid?
   #   #=> true
@@ -46,8 +46,14 @@ module ActiveModel
 
     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
@@ -117,7 +123,7 @@ module ActiveModel
         options = args.last
         if options.is_a?(Hash) && options.key?(:on)
           options[:if] = Array.wrap(options[:if])
-          options[:if] << "@_on_validate == :#{options[:on]}"
+          options[:if] << "validation_context == :#{options[:on]}"
         end
         set_callback(:validate, *args, &block)
       end
@@ -133,11 +139,8 @@ module ActiveModel
         _validators[attribute.to_sym]
       end
 
-    private
-
-      def _merge_attributes(attr_names)
-        options = attr_names.extract_options!
-        options.merge(:attributes => attr_names.flatten)
+      def attribute_method?(attribute)
+        method_defined?(attribute)
       end
     end
 
@@ -147,15 +150,20 @@ module ActiveModel
     end
 
     # Runs all the specified validations and returns true if no errors were added otherwise false.
-    def valid?
+    # 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?
+    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?
+    def invalid?(context = nil)
+      !valid?(context)
     end
 
     # Hook method defining how an attribute value should be retieved. By default this is assumed

data/lib/active_model/validations/acceptance.rb

@@ -14,12 +14,14 @@ module ActiveModel
       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.
-        new_attributes = attributes.reject { |name| klass.instance_methods.map(&:to_s).include?("#{name}=") }
-        klass.send(:attr_accessor, *new_attributes)        
+        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 ClassMethods
+    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

data/lib/active_model/validations/confirmation.rb

@@ -12,7 +12,7 @@ module ActiveModel
       end
     end
 
-    module ClassMethods
+    module HelperMethods
       # Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
       #
       #   Model:

data/lib/active_model/validations/exclusion.rb

@@ -12,13 +12,13 @@ module ActiveModel
       end
     end
 
-    module ClassMethods
+    module HelperMethods
       # Validates that the value of the specified attribute is not in a particular enumerable object.
       #
       #   class Person < ActiveRecord::Base
       #     validates_exclusion_of :username, :in => %w( admin superuser ), :message => "You don't belong here"
       #     validates_exclusion_of :age, :in => 30..60, :message => "This site is only for under 30 and over 60"
-      #     validates_exclusion_of :format, :in => %w( mov avi ), :message => "extension {{value}} is not allowed"
+      #     validates_exclusion_of :format, :in => %w( mov avi ), :message => "extension %{value} is not allowed"
       #   end
       #
       # Configuration options:

data/lib/active_model/validations/format.rb

@@ -24,7 +24,7 @@ module ActiveModel
       end
     end
 
-    module ClassMethods
+    module HelperMethods
       # Validates whether the value of the specified attribute is of the correct form, going by the regular expression provided.
       # You can require that the attribute matches the regular expression:
       #

data/lib/active_model/validations/inclusion.rb

@@ -12,13 +12,13 @@ module ActiveModel
       end
     end
 
-    module ClassMethods
+    module HelperMethods
       # Validates whether the value of the specified attribute is available in a particular enumerable object.
       #
       #   class Person < ActiveRecord::Base
       #     validates_inclusion_of :gender, :in => %w( m f )
       #     validates_inclusion_of :age, :in => 0..99
-      #     validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension {{value}} is not included in the list"
+      #     validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension %{value} is not included in the list"
       #   end
       #
       # Configuration options:

data/lib/active_model/validations/length.rb

@@ -51,7 +51,7 @@ module ActiveModel
       end
     end
 
-    module ClassMethods
+    module HelperMethods
 
       # Validates that the specified attribute matches the length restrictions supplied. Only one option can be used at a time:
       #
@@ -74,9 +74,9 @@ module ActiveModel
       # * <tt>:in</tt> - A synonym(or alias) for <tt>:within</tt>.
       # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
       # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
-      # * <tt>:too_long</tt> - The error message if the attribute goes over the maximum (default is: "is too long (maximum is {{count}} characters)").
-      # * <tt>:too_short</tt> - The error message if the attribute goes under the minimum (default is: "is too short (min is {{count}} characters)").
-      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt> method and the attribute is the wrong size (default is: "is the wrong length (should be {{count}} characters)").
+      # * <tt>:too_long</tt> - The error message if the attribute goes over the maximum (default is: "is too long (maximum is %{count} characters)").
+      # * <tt>:too_short</tt> - The error message if the attribute goes under the minimum (default is: "is too short (min is %{count} characters)").
+      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt> method and the attribute is the wrong size (default is: "is the wrong length (should be %{count} characters)").
       # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>, <tt>:maximum</tt>, or <tt>:is</tt> violation.  An alias of the appropriate <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
       # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should

data/lib/active_model/validations/numericality.rb

@@ -25,11 +25,18 @@ module ActiveModel
 
         return if options[:allow_nil] && raw_value.nil?
 
-        unless value = parse_raw_value(raw_value, options)
+        unless value = parse_raw_value_as_a_number(raw_value)
           record.errors.add(attr_name, :not_a_number, :value => raw_value, :default => options[:message])
           return
         end
 
+        if options[:only_integer]
+          unless value = parse_raw_value_as_an_integer(raw_value)
+            record.errors.add(attr_name, :not_an_integer, :value => raw_value, :default => options[:message])
+            return
+          end
+        end
+
         options.slice(*CHECKS.keys).each do |option, option_value|
           case option
           when :odd, :even
@@ -44,14 +51,15 @@ module ActiveModel
               record.errors.add(attr_name, option, :default => options[:message], :value => value, :count => option_value)
             end
           end
-        end      
+        end
       end
 
     protected
 
-      def parse_raw_value(raw_value, options)
-        if options[:only_integer]
-          raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
+      def parse_raw_value_as_a_number(raw_value)
+        case raw_value
+        when /\A0[xX]/
+          nil
         else
           begin
             Kernel.Float(raw_value)
@@ -61,9 +69,13 @@ module ActiveModel
         end
       end
 
+      def parse_raw_value_as_an_integer(raw_value)
+        raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
+      end
+
     end
 
-    module ClassMethods
+    module HelperMethods
       # Validates whether the value of the specified attribute is numeric by trying to convert it to
       # a float with Kernel.Float (if <tt>only_integer</tt> is false) or applying it to the regular expression
       # <tt>/\A[\+\-]?\d+\Z/</tt> (if <tt>only_integer</tt> is set to true).

data/lib/active_model/validations/presence.rb

@@ -8,7 +8,7 @@ module ActiveModel
       end
     end
 
-    module ClassMethods
+    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

data/lib/active_model/validations/with.rb

@@ -1,5 +1,13 @@
 module ActiveModel
   module Validations
+    module HelperMethods
+      private
+        def _merge_attributes(attr_names)
+          options = attr_names.extract_options!
+          options.merge(:attributes => attr_names.flatten)
+        end
+    end
+
     module ClassMethods
 
       # Passes the record off to the class or classes specified and allows them
@@ -75,5 +83,50 @@ module ActiveModel
         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

@@ -88,6 +88,9 @@ module ActiveModel #:nodoc:
   #       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

data/lib/active_model/version.rb

@@ -3,7 +3,7 @@ module ActiveModel
     MAJOR = 3
     MINOR = 0
     TINY  = 0
-    BUILD = "beta3"
+    BUILD = "beta4"
 
     STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
   end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 3
   - 0
   - 0
-  - beta3
-  version: 3.0.0.beta3
+  - beta4
+  version: 3.0.0.beta4
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-13 00:00:00 -07:00
+date: 2010-06-08 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,10 +29,38 @@ dependencies:
         - 3
         - 0
         - 0
-        - beta3
-        version: 3.0.0.beta3
+        - beta4
+        version: 3.0.0.beta4
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 1
+        version: 0.4.1
+  type: :runtime
+  version_requirements: *id003
 description: A toolkit for building modeling frameworks like Active Record and Active Resource. Rich support for attributes, callbacks, validations, observers, serialization, internationalization, and testing.
 email: david@loudthinking.com
 executables: []