mongomatic 0.1.31 → 0.2.0

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

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

@@ -1,19 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesExclusionOf < ValidationBase #:nodoc:
-      required_option :within
-
-      def valid?(instance)
-        value = instance.send(attribute)
-        return true if allow_nil && value.nil?
-        return true if allow_blank && value.blank?
-
-        !within.include?(value)
-      end
-
-      def message(instance)
-        super || "is reserved"
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesFormatOf < ValidationBase #:nodoc:
-      required_option :with
-  
-      def valid?(instance)
-        value = instance[self.attribute.to_s]
-        return true if allow_nil && value.nil?
-        return true if allow_blank && value.blank?
-        not (value.to_s =~ self.with).nil?
-      end
-    
-      def message(instance)
-        super || "is invalid"
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesInclusionOf < ValidationBase
-      required_option :within
-    
-      def valid?(instance)
-        value = instance.send(attribute)
-        return true if allow_nil && value.nil?
-        return true if allow_blank && value.blank?
-      
-        within.include?(value)
-      end
-    
-      def message(instance)
-        super || "is not in the list"
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesLengthOf < ValidationBase #:nodoc:
-      option :minimum, :maximum, :is, :within
-    
-      def message(instance)
-        super || "is invalid"
-      end
-    
-      def valid?(instance)
-        valid = true
-        value = instance[self.attribute.to_s]
-      
-        if value.nil?
-          return true if allow_nil
-          value = ''
-        end
-
-        if value.blank?
-          return true if allow_blank
-          value = ''
-        end
-      
-        valid &&= value.length <= maximum unless maximum.nil? 
-        valid &&= value.length >= minimum unless minimum.nil?
-        valid &&= value.length == is unless is.nil?
-        valid &&= within.include?(value.length) unless within.nil?
-        valid
-      end
-    end
-  end
-end