mongomatic 0.1.4 → 0.1.31

data/lib/mongomatic/validatable/object_extension.rb

@@ -0,0 +1,21 @@
+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

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

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

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

@@ -0,0 +1,111 @@
+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

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,25 @@
+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

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,32 @@
+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