activemodel 3.0.0.beta4 → 3.0.pre

data/lib/active_model/railtie.rb

@@ -1,2 +0,0 @@
-require "active_model"
-require "rails"

data/lib/active_model/translation.rb

@@ -1,60 +0,0 @@
-require 'active_support/core_ext/hash/reverse_merge'
-
-module ActiveModel
-  
-  # ActiveModel::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_attribue')
-  #   #=> "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, goes through the lookup returned by this method.
-    # 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 attributes 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/validates.rb

@@ -1,108 +0,0 @@
-require 'active_support/core_ext/hash/slice'
-
-module ActiveModel
-  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 cusom 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/validator.rb

@@ -1,183 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-require "active_support/core_ext/module/anonymous"
-require 'active_support/core_ext/object/blank'
-
-module ActiveModel #:nodoc:
-  # 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 availible 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 ActiveModel 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