hashrocket-validatable 1.7.2

data/lib/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/requireable.rb

@@ -0,0 +1,26 @@
+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/understandable.rb

@@ -0,0 +1,31 @@
+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.rb

@@ -0,0 +1,25 @@
+require 'forwardable'
+require 'rubygems'
+require 'activesupport'
+
+dir = File.expand_path(File.dirname(__FILE__))
+
+require File.join(dir, 'object_extension')
+require File.join(dir, 'errors')
+require File.join(dir, 'validatable_class_methods')
+require File.join(dir, 'macros')
+require File.join(dir, 'validatable_instance_methods')
+require File.join(dir, 'included_validation')
+require File.join(dir, 'child_validation')
+require File.join(dir, 'understandable')
+require File.join(dir, 'requireable')
+require File.join(dir, 'validations/validation_base')
+require File.join(dir, 'validations/validates_format_of')
+require File.join(dir, 'validations/validates_presence_of')
+require File.join(dir, 'validations/validates_acceptance_of')
+require File.join(dir, 'validations/validates_confirmation_of')
+require File.join(dir, 'validations/validates_length_of')
+require File.join(dir, 'validations/validates_true_for')
+require File.join(dir, 'validations/validates_numericality_of')
+require File.join(dir, 'validations/validates_each')
+require File.join(dir, 'validations/validates_associated')

data/lib/validatable_class_methods.rb

@@ -0,0 +1,85 @@
+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 = instance.send child_validation.attribute
+        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
+    
+    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_instance_methods.rb

@@ -0,0 +1,116 @@
+module Validatable
+  def self.included(klass) #:nodoc:
+    klass.extend Validatable::ClassMethods
+    klass.extend Validatable::Macros
+    klass.class_eval do
+      include ActiveSupport::Callbacks
+      define_callbacks :validate, :validate_on_create, :validate_on_update
+    end
+  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:
+    run_before_validations
+    errors.clear
+    run_callbacks(:validate)
+    
+    if respond_to?(:new?)
+      new? ? run_callbacks(:validate_on_create) : run_callbacks(:validate_on_update)
+    end
+    
+    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/validations/validates_acceptance_of.rb

@@ -0,0 +1,14 @@
+module Validatable
+  class ValidatesAcceptanceOf < ValidationBase #:nodoc:    
+    def valid?(instance)
+      value = instance.send(self.attribute)
+      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

data/lib/validations/validates_confirmation_of.rb

@@ -0,0 +1,23 @@
+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.send(self.attribute) == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive
+      instance.send(self.attribute).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

data/lib/validations/validates_each.rb

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

data/lib/validations/validates_format_of.rb

@@ -0,0 +1,16 @@
+module Validatable
+  class ValidatesFormatOf < ValidationBase #:nodoc:
+    required_option :with
+  
+    def valid?(instance)
+      value = instance.send(self.attribute)
+      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

data/lib/validations/validates_length_of.rb

@@ -0,0 +1,30 @@
+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.send(self.attribute)
+      
+      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

data/lib/validations/validates_numericality_of.rb

@@ -0,0 +1,27 @@
+module Validatable 
+  class ValidatesNumericalityOf < ValidationBase #:nodoc:
+    option :only_integer
+    
+    def valid?(instance)
+      value = value_for(instance)
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+      
+      value = value.to_s
+      regex = self.only_integer ? /\A[+-]?\d+\Z/ : /^\d*\.{0,1}\d+$/
+      not (value =~ regex).nil?
+    end
+    
+    def message(instance)
+      super || "must be a number"
+    end
+    
+    private
+      def value_for(instance)
+        before_typecast_method = "#{self.attribute}_before_typecast"
+        value_method = instance.respond_to?(before_typecast_method.intern) ? before_typecast_method : self.attribute
+        instance.send(value_method)
+      end
+  end
+end
+