mongomatic 0.1.3 → 0.1.4

data/lib/mongomatic/validatable/macros.rb

@@ -1,316 +0,0 @@
-module Mongomatic
-  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
-end

data/lib/mongomatic/validatable/object_extension.rb

@@ -1,21 +0,0 @@
-class Object #:nodoc:
-  module InstanceExecHelper #:nodoc:
-  end
-  include InstanceExecHelper
-  def instance_eval_with_params(*args, &block)
-    begin
-      old_critical, Thread.critical = Thread.critical, true
-      n = 0
-      n += 1 while respond_to?(mname="__instance_exec#{n}")
-      InstanceExecHelper.module_eval{ define_method(mname, &block) }
-    ensure
-      Thread.critical = old_critical
-    end
-    begin
-      ret = send(mname, *args)
-    ensure
-      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
-    end
-    ret
-  end
-end

data/lib/mongomatic/validatable/requireable.rb

@@ -1,28 +0,0 @@
-module Mongomatic
-  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
-end

data/lib/mongomatic/validatable/understandable.rb

@@ -1,33 +0,0 @@
-module Mongomatic
-  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
-end

data/lib/mongomatic/validatable/validatable_class_methods.rb

@@ -1,89 +0,0 @@
-module Mongomatic
-  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
-end

data/lib/mongomatic/validatable/validatable_instance_methods.rb

@@ -1,111 +0,0 @@
-module Mongomatic
-  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?
-      self.send(:before_validate) if self.respond_to?(:before_validate)
-      r = valid_for_group?(nil)
-      self.send(:after_validate) if self.respond_to?(:after_validate)
-      r
-    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
-end

data/lib/mongomatic/validatable/validations/validates_acceptance_of.rb

@@ -1,16 +0,0 @@
-module Mongomatic
-  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
-end

data/lib/mongomatic/validatable/validations/validates_associated.rb

@@ -1,15 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesAssociated < ValidationBase #:nodoc:
-      def valid?(instance)
-        Array(instance.send(attribute)).compact.map do |child|
-          child.valid?
-        end.all?
-      end
-
-      def message(instance)
-        super || "is invalid"
-      end
-    end
-  end
-end

data/lib/mongomatic/validatable/validations/validates_confirmation_of.rb

@@ -1,25 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesConfirmationOf < ValidationBase #:nodoc:
-      option :case_sensitive
-      default :case_sensitive => true
-    
-      def initialize(klass, attribute, options={})
-        klass.class_eval { attr_accessor "#{attribute}_confirmation" }
-        super
-      end
-    
-      def valid?(instance)
-        confirmation_value = instance.send("#{self.attribute}_confirmation")
-        return true if allow_nil && confirmation_value.nil?
-        return true if allow_blank && confirmation_value.blank?
-        return instance[self.attribute.to_s] == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive
-        instance[self.attribute.to_s].to_s.casecmp(instance.send("#{self.attribute}_confirmation".to_sym).to_s) == 0
-      end
-    
-      def message(instance)
-        super || "doesn't match confirmation"
-      end
-    end
-  end
-end

data/lib/mongomatic/validatable/validations/validates_each.rb

@@ -1,16 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesEach < ValidationBase #:nodoc:
-      required_option :logic
-  
-      def valid?(instance)
-        instance.instance_eval(&logic)
-        true # return true so no error is added. should look in the future at doing this different.
-      end
-    
-      def message(instance)
-        super || "is invalid"
-      end
-    end
-  end
-end