mongomatic 0.0.2 → 0.0.3

data/lib/validatable/errors.rb

@@ -1,106 +0,0 @@
-module Validatable
-  class Errors
-    extend Forwardable
-    include Enumerable
-
-    def_delegators :errors, :clear, :each, :each_pair, :empty?, :length, :size
-
-    # Returns true if the specified +attribute+ has errors associated with it.
-    #
-    #   class Company < ActiveRecord::Base
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.invalid?(:name)      # => true
-    #   company.errors.invalid?(:address)   # => false
-    def invalid?(attribute)
-      !@errors[attribute.to_sym].nil?
-    end
-
-    # Adds an error to the base object instead of any particular attribute. This is used
-    # to report errors that don't tie to any specific attribute, but rather to the object
-    # as a whole. These error messages don't get prepended with any field name when iterating
-    # with +each_full+, so they should be complete sentences.
-    def add_to_base(msg)
-      add(:base, msg)
-    end
-
-    # Returns errors assigned to the base object through +add_to_base+ according to the normal rules of <tt>on(attribute)</tt>.
-    def on_base
-      on(:base)
-    end    
-
-    # call-seq: on(attribute)
-    #
-    # * Returns nil, if no errors are associated with the specified +attribute+.
-    # * Returns the error message, if one error is associated with the specified +attribute+.
-    # * Returns an array of error messages, if more than one error is associated with the specified +attribute+.
-    def on(attribute)
-      return nil if errors[attribute.to_sym].nil?
-      errors[attribute.to_sym].size == 1 ? errors[attribute.to_sym].first : errors[attribute.to_sym]
-    end
-
-    # Rails 3 API for errors, always return array.
-    def [](attribute)
-      errors[attribute.to_sym] || []
-    end
-
-    def add(attribute, message) #:nodoc:
-      errors[attribute.to_sym] = [] if errors[attribute.to_sym].nil?
-      errors[attribute.to_sym] << message
-    end
-
-    def merge!(errors) #:nodoc:
-      errors.each_pair{|k, v| add(k,v)}
-      self
-    end
-
-    # call-seq: replace(attribute)
-    #
-    # * Replaces the errors value for the given +attribute+
-    def replace(attribute, value)
-      errors[attribute.to_sym] = value
-    end
-
-    # call-seq: raw(attribute)
-    #
-    # * Returns an array of error messages associated with the specified +attribute+.
-    def raw(attribute)
-      errors[attribute.to_sym]
-    end
-
-    def errors #:nodoc:
-      @errors ||= {}
-    end
-
-    def count #:nodoc:
-      errors.values.flatten.size
-    end
-
-    # call-seq: full_messages -> an_array_of_messages
-    #
-    # Returns an array containing the full list of error messages.
-    def full_messages
-      full_messages = []
-
-      errors.each_key do |attribute|
-        errors[attribute].each do |msg|
-          next if msg.nil?
-
-          if attribute.to_s == "base"
-            full_messages << msg
-          else
-            full_messages << humanize(attribute.to_s) + " " + msg
-          end
-        end
-      end
-      full_messages
-    end
-
-    def humanize(lower_case_and_underscored_word) #:nodoc:
-      lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
-    end
-  end
-end

data/lib/validatable/included_validation.rb

@@ -1,9 +0,0 @@
-module Validatable
-  class IncludedValidation #:nodoc:
-    attr_accessor :attribute
-    
-    def initialize(attribute)
-      @attribute = attribute
-    end
-  end
-end

data/lib/validatable/macros.rb

@@ -1,314 +0,0 @@
-module Validatable
-  module Macros
-    # call-seq: validates_each(*args)
-    # 
-    # Validates that the logic evaluates to true
-    # 
-    #   class Address
-    #     include Validatable
-    #     validates_each :zip_code, :logic => lambda { errors.add(:zip_code, "is not valid") if ZipCodeService.allows(zip_code) }
-    #   end
-    #
-    # The logic option is required.
-    #
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * level - The level at which the validation should occur
-    #     * logic - A block that executes to perform the validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    def validates_each(*args)
-      add_validations(args, ValidatesEach)
-    end
-    
-    # call-seq: validates_format_of(*args)
-    # 
-    # Validates whether the value of the specified attribute is of the 
-    # correct form by matching it against the regular expression provided.
-    # 
-    #   class Person
-    #     include Validatable    
-    #     validates_format_of :first_name, :with => /[ A-Za-z]/
-    #   end
-    # 
-    # A regular expression must be provided or else an exception will be raised.
-    # 
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * with - The regular expression used to validate the format
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_format_of(*args)
-      add_validations(args, ValidatesFormatOf)
-    end
-    
-    # call-seq: validates_length_of(*args)
-    # 
-    # Validates that the specified attribute matches the length restrictions supplied.
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_length_of :first_name, :maximum=>30
-    #     validates_length_of :last_name, :minimum=>30
-    #   end
-    # 
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * minimum - The minimum size of the attribute
-    #     * maximum - The maximum size of the attribute
-    #     * is - The size the attribute must be
-    #     * within - A range that the size of the attribute must fall within
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_length_of(*args)
-      add_validations(args, ValidatesLengthOf)
-    end
-
-    # call-seq: validates_numericality_of(*args)
-    # 
-    # Validates that the specified attribute is numeric.
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_numericality_of :age
-    #   end
-    # 
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    #     * only_integer - Whether the attribute must be an integer (default is false)
-    def validates_numericality_of(*args)
-      add_validations(args, ValidatesNumericalityOf)
-    end
-
-    # call-seq: validates_acceptance_of(*args)
-    #
-    # Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_acceptance_of :terms_of_service
-    #     validates_acceptance_of :eula, :message => "must be abided"
-    #   end
-    #
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_acceptance_of(*args)
-      add_validations(args, ValidatesAcceptanceOf)
-    end
-
-    # call-seq: validates_confirmation_of(*args)
-    #
-    # Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
-    # 
-    #   Class:
-    #     class PersonPresenter
-    #       include Validatable
-    #       validates_confirmation_of :user_name, :password
-    #       validates_confirmation_of :email_address, :message => "should match confirmation"
-    #     end
-    # 
-    #   View:
-    #     <%= password_field "person", "password" %>
-    #     <%= password_field "person", "password_confirmation" %>
-    #
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * case_sensitive - Whether or not to apply case-sensitivity on the comparison.  Defaults to true.
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_confirmation_of(*args)
-      add_validations(args, ValidatesConfirmationOf)
-    end
-  
-    # call-seq: validates_presence_of(*args)
-    # 
-    # Validates that the specified attributes are not nil or an empty string
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_presence_of :first_name
-    #   end
-    #
-    # The first_name attribute must be in the object and it cannot be nil or empty.
-    #
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_presence_of(*args)
-      add_validations(args, ValidatesPresenceOf)
-    end
-    
-    # call-seq: validates_true_for(*args)
-    # 
-    # Validates that the logic evaluates to true
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_true_for :first_name, :logic => lambda { first_name == 'Jamie' }
-    #   end
-    #
-    # The logic option is required.
-    #
-    # Configuration options:
-    # 
-    #     * after_validate - A block that executes following the run of a validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    #     * logic - A block that executes to perform the validation
-    def validates_true_for(*args)
-      add_validations(args, ValidatesTrueFor)
-    end
-    
-    def validates_exclusion_of(*args)
-      add_validations(args, ValidatesExclusionOf)
-    end
-
-    def validates_inclusion_of(*args)
-      add_validations(args, ValidatesInclusionOf)
-    end
-
-    # call-seq: validates_associated(*args)
-    #
-    # Checks the validity of an associated object or objects and adds a single
-    # error if validation fails.
-    #
-    #   class Person
-    #     include Validatable
-    #     attr_accessor :addresses
-    #     validates_associated :addresses
-    #   end
-    #
-    # Configuration options:
-    #
-    #     * after_validate - A block that executes following the run of a validation
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_associated(*args)
-      add_validations(args, ValidatesAssociated)
-    end
-
-    # call-seq: include_validations_from(attribute)
-    # 
-    # Includes all the validations that are defined on the attribute.
-    #   class Person
-    #     include Validatable
-    #     validates_presence_of :name
-    #   end
-    # 
-    #   class PersonPresenter
-    #     include Validatable
-    #     include_validataions_from :person
-    #     attr_accessor :person
-    #     def name
-    #       person.name
-    #     end
-    #
-    #     def initialize(person)
-    #       @person = person
-    #     end
-    #   end
-    #   
-    #   presenter = PersonPresenter.new(Person.new)
-    #   presenter.valid? #=> false
-    #   presenter.errors.on(:name) #=> "can't be blank"
-    #
-    # The name attribute whose validations should be added.
-    def include_validations_from(attribute_to_validate, options = {})
-      validations_to_include << IncludedValidation.new(attribute_to_validate)
-    end
-
-    # call-seq: include_errors_from(attribute_to_validate, options = {})
-    # 
-    # Validates the specified attributes.
-    #   class Person
-    #     include Validatable
-    #     validates_presence_of :name
-    #     attr_accessor :name
-    #   end
-    # 
-    #   class PersonPresenter
-    #     include Validatable
-    #     include_errors_from :person, :map => { :name => :namen }, :if => lambda { not person.nil? }
-    #     attr_accessor :person
-    #     
-    #     def initialize(person)
-    #       @person = person
-    #     end
-    #   end
-    #   
-    #   presenter = PersonPresenter.new(Person.new)
-    #   presenter.valid? #=> false
-    #   presenter.errors.on(:namen) #=> "can't be blank"
-    #
-    # The person attribute will be validated.  
-    # If person is invalid the errors will be added to the PersonPresenter errors collection.
-    #
-    # Configuration options:
-    # 
-    #     * map - A hash that maps attributes of the child to attributes of the parent.
-    #     * if - A block that when executed must return true of the validation will not occur.
-    def include_errors_from(attribute_to_validate, options = {})
-      children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
-    end
-    
-    def include_validations_for(attribute_to_validate, options = {}) #:nodoc:
-      puts "include_validations_for is deprecated; use include_errors_from instead"
-      children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
-    end
-    
-    # call-seq: before_validation(&block)
-    # 
-    # Is called before valid? or valid_for_*?
-    # 
-    #   class Person
-    #     include Validatable
-    #     before_validation do
-    #       self.name = "default name"
-    #     end
-    # 
-    #     attr_accessor :name
-    #   end
-    # 
-    def before_validation(&block)
-      before_validations << block
-    end
-  end
-end

data/lib/validatable/requireable.rb

@@ -1,26 +0,0 @@
-module Validatable
-  module Requireable #:nodoc:
-    module ClassMethods #:nodoc:
-      def requires(*args)
-        required_options.concat args        
-      end
-      
-      def required_options
-        @required_options ||= []
-      end
-    end
-    
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
-    
-    def requires(options)
-      required_options = self.class.required_options.inject([]) do |errors, attribute|
-        errors << attribute.to_s unless options.has_key?(attribute)
-        errors
-      end
-      raise ArgumentError.new("#{self.class} requires options: #{required_options.join(', ')}") if required_options.any?
-      true
-    end
-  end
-end

data/lib/validatable/understandable.rb

@@ -1,31 +0,0 @@
-module Validatable
-  module Understandable #:nodoc:
-    module ClassMethods #:nodoc:
-      def understands(*args)
-        understandings.concat args
-      end
-
-      def understandings
-        @understandings ||= []
-      end
-
-      def all_understandings
-        return understandings + self.superclass.all_understandings if self.superclass.respond_to? :all_understandings
-        understandings
-      end
-    end
-
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
-
-    def must_understand(hash)
-      invalid_options = hash.inject([]) do |errors, (key, value)|
-        errors << key.to_s unless self.class.all_understandings.include?(key)
-        errors
-      end
-      raise ArgumentError.new("invalid options: #{invalid_options.join(', ')}") if invalid_options.any?
-      true
-    end
-  end
-end

data/lib/validatable/validatable_class_methods.rb

@@ -1,87 +0,0 @@
-module Validatable
-  module ClassMethods #:nodoc:
-    
-    def validate_children(instance, group)
-      self.children_to_validate.each do |child_validation|
-        next unless child_validation.should_validate?(instance)
-        child_or_children = instance.send child_validation.attribute
-        [child_or_children].flatten.each do |child|
-          if (child.respond_to?(:valid_for_group?))
-            child.valid_for_group?(group)
-          else
-            child.valid?
-          end
-          child.errors.each do |attribute, messages|
-            if messages.is_a?(String)
-              add_error(instance, child_validation.map[attribute.to_sym] || attribute, messages)
-            else
-              messages.each do |message|
-                add_error(instance, child_validation.map[attribute.to_sym] || attribute, message)
-              end
-            end
-          end
-        end
-      end
-    end
-    
-    def all_before_validations
-      if self.superclass.respond_to? :all_before_validations
-        return before_validations + self.superclass.all_before_validations 
-      end
-      before_validations
-    end
-    
-    def before_validations
-      @before_validations ||= []
-    end
-
-    def all_validations
-      if self.respond_to?(:superclass) && self.superclass.respond_to?(:all_validations)
-        return validations + self.superclass.all_validations 
-      end
-      validations
-    end
-
-    def validations
-      @validations ||= []
-    end
-    
-    def add_error(instance, attribute, msg)
-      instance.errors.add(attribute, msg)
-    end
-    
-    def validation_keys_include?(key)
-      validations.map { |validation| validation.key }.include?(key)
-    end
-    
-    def validations_to_include
-      @validations_to_include ||= []
-    end
-    
-    protected
-    
-    def add_validations(args, klass)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      args.each do |attribute|
-        new_validation = klass.new self, attribute, options
-        self.validations << new_validation
-        self.create_valid_method_for_groups new_validation.groups
-      end
-    end
-    
-    def create_valid_method_for_groups(groups)
-      groups.each do |group|
-        self.class_eval do
-          define_method "valid_for_#{group}?".to_sym do
-            valid_for_group?(group)
-          end
-        end
-      end
-    end
-    
-    def children_to_validate
-      @children_to_validate ||= []
-    end
-    
-  end
-end

data/lib/validatable/validatable_instance_methods.rb

@@ -1,106 +0,0 @@
-module Validatable
-  def self.included(klass) #:nodoc:
-    klass.extend Validatable::ClassMethods
-    klass.extend Validatable::Macros
-  end
-  
-  # call-seq: valid?
-  #
-  # Returns true if no errors were added otherwise false. Only executes validations that have no :groups option specified
-  def valid?
-    valid_for_group?(nil)
-  end
-  
-  # call-seq: errors
-  #
-  # Returns the Errors object that holds all information about attribute error messages.
-  def errors
-    @errors ||= Validatable::Errors.new
-  end
-  
-  def valid_for_group?(group) #:nodoc:
-    errors.clear
-    run_before_validations
-    self.class.validate_children(self, group)
-    self.validate_group(group)
-    errors.empty?
-  end
-  
-  def times_validated(key) #:nodoc:
-    times_validated_hash[key] || 0
-  end
-  
-  def increment_times_validated_for(validation) #:nodoc:
-    if validation.key != nil
-      if times_validated_hash[validation.key].nil?
-        times_validated_hash[validation.key] = 1
-      else
-        times_validated_hash[validation.key] += 1
-      end
-    end
-  end
-
-  # call-seq: validate_only(key)
-  #
-  # Only executes a specified validation. The argument should follow a pattern based on the key of the validation.
-  #   Examples:
-  #     * validates_presence_of :name can be run with obj.validate_only("presence_of/name")
-  #     * validates_presence_of :birthday, :key => "a key" can be run with obj.validate_only("presence_of/a key")
-  def validate_only(key)
-    validation_name, attribute_name = key.split("/")
-    validation_name = validation_name.split("_").collect{|word| word.capitalize}.join
-    validation_key = "#{self.class.name}/Validatable::Validates#{validation_name}/#{attribute_name}"
-    validation = self.class.all_validations.find { |validation| validation.key == validation_key }
-    raise ArgumentError.new("validation with key #{validation_key} could not be found") if validation.nil?
-    errors.clear
-    run_validation(validation)
-  end
-
-  protected
-  def times_validated_hash #:nodoc:
-    @times_validated_hash ||= {}
-  end
-
-  def validate_group(group) #:nodoc:
-    validation_levels.each do |level|
-      validations_for_level_and_group(level, group).each do |validation|
-        run_validation(validation) if validation.should_validate?(self)
-      end
-      return unless self.errors.empty?
-    end
-  end
-
-  def run_validation(validation) #:nodoc:
-    validation_result = validation.valid?(self)
-    add_error(validation.attribute, validation.message(self)) unless validation_result
-    increment_times_validated_for(validation)
-    validation.run_after_validate(validation_result, self, validation.attribute)
-  end
-  
-  def run_before_validations #:nodoc:
-    self.class.all_before_validations.each do |block|
-      instance_eval &block
-    end
-  end
-  
-  def add_error(attribute, message) #:nodoc:
-    self.class.add_error(self, attribute, message)
-  end
-  
-  def validations_for_level_and_group(level, group) #:nodoc:
-    validations_for_level = self.all_validations.select { |validation| validation.level == level }
-    return validations_for_level.select { |validation| validation.groups.empty? } if group.nil?
-    validations_for_level.select { |validation| validation.groups.include?(group) }
-  end
-  
-  def all_validations #:nodoc:
-    res = self.class.validations_to_include.inject(self.class.all_validations) do |result, included_validation_class|
-      result += self.send(included_validation_class.attribute).all_validations
-      result
-    end
-  end
-  
-  def validation_levels #:nodoc:
-    self.class.all_validations.inject([1]) { |result, validation| result << validation.level }.uniq.sort
-  end
-end

data/lib/validatable/validations/validates_acceptance_of.rb

@@ -1,14 +0,0 @@
-module Validatable
-  class ValidatesAcceptanceOf < ValidationBase #:nodoc:    
-    def valid?(instance)
-      value = instance[self.attribute.to_s]
-      return true if allow_nil && value.nil?
-      return true if allow_blank && value.blank?
-      %w(1 true t).include?(value)
-    end
-    
-    def message(instance)
-      super || "must be accepted"
-    end
-  end
-end