durran-validatable 1.7.5

data/lib/validations/validates_presence_of.rb

@@ -0,0 +1,17 @@
+module Validatable 
+  class ValidatesPresenceOf < ValidationBase #:nodoc:
+    def valid?(instance)
+      value = instance.send(self.attribute)
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+      
+      return false if instance.send(self.attribute).nil?
+      value.respond_to?(:strip) ? instance.send(self.attribute).strip.length != 0 : true
+    end
+    
+    def message(instance)
+      super || "can't be empty"
+    end
+  end
+end
+

data/lib/validations/validates_true_for.rb

@@ -0,0 +1,13 @@
+module Validatable
+  class ValidatesTrueFor < ValidationBase #:nodoc:
+    required_option :logic
+  
+    def valid?(instance)
+      instance.instance_eval(&logic) == true
+    end
+    
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/validations/validation_base.rb

@@ -0,0 +1,91 @@
+module Validatable
+  class ValidationBase #:nodoc:
+    def self.required_option(*args)
+      option(*args)
+      requires(*args)
+    end
+    
+    def self.option(*args)
+      attr_accessor(*args)
+      understands(*args)
+    end
+    
+    def self.default(hash)
+      defaults.merge! hash
+    end
+    
+    def self.defaults
+      @defaults ||= {}
+    end
+    
+    def self.all_defaults
+      return defaults.merge(self.superclass.all_defaults) if self.superclass.respond_to? :all_defaults
+      defaults
+    end
+    
+    def self.after_validate(&block)
+      after_validations << block
+    end
+    
+    def self.after_validations
+      @after_validations ||= []
+    end
+    
+    def self.all_after_validations
+      return after_validations + self.superclass.all_after_validations if self.superclass.respond_to? :all_after_validations
+      after_validations
+    end
+
+    include Understandable
+    include Requireable
+    
+    option :message, :if, :times, :level, :groups, :key, :after_validate, :allow_nil, :allow_blank
+    default :level => 1, :groups => []
+    attr_accessor :attribute
+    
+    def initialize(klass, attribute, options={})
+      must_understand options
+      requires options
+      self.class.all_understandings.each do |understanding|
+        options[understanding] = self.class.all_defaults[understanding] unless options.has_key? understanding
+        self.instance_variable_set("@#{understanding}", options[understanding])
+      end
+      self.attribute = attribute
+      self.groups = [self.groups] unless self.groups.is_a?(Array)
+      self.key = "#{klass.name}/#{self.class.name}/#{self.key || self.attribute}"
+      raise_error_if_key_is_dup(klass)
+    end
+    
+    def raise_error_if_key_is_dup(klass)
+      message = "key #{self.key} must be unique, provide the :key option to specify a unique key"
+      raise ArgumentError.new(message) if klass.validation_keys_include? self.key
+    end
+    
+    def should_validate?(instance)
+      result = validate_this_time?(instance)
+      case self.if
+        when Proc
+          result &&= instance.instance_eval(&self.if)
+        when Symbol, String
+          result &&= instance.instance_eval(self.if.to_s)
+      end
+      result
+    end
+    
+    def message(instance)
+      @message.respond_to?(:call) ? instance.instance_eval(&@message) : @message
+    end
+    
+    def validate_this_time?(instance)
+      return true if @times.nil?
+      self.times > instance.times_validated(self.key)
+    end
+    
+    def run_after_validate(result, instance, attribute)
+      self.class.all_after_validations.each do |block|
+        block.call result, instance, attribute
+      end
+      instance.instance_eval_with_params result, attribute, &self.after_validate unless self.after_validate.nil?
+    end
+  end
+end

data/test/all_tests.rb

@@ -0,0 +1 @@
+Dir['test/**/test_*.rb'].each { |test_case| require test_case }

data/test/functional/test_validatable.rb

@@ -0,0 +1,589 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+functional_tests do
+
+  expect "can't be empty" do
+    child_class = Module.new do
+      include Validatable
+      validates_presence_of :name
+    end
+    klass = Class.new do
+      include Validatable
+      include_validations_from :child 
+      define_method :child do
+        child_class
+      end
+      attr_accessor :name
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:name)
+  end
+  
+  expect "can't be empty" do
+    child_class = Module.new do
+      include Validatable
+      validates_presence_of :name
+    end
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :address
+      include_validations_from :child 
+      define_method :child do
+        child_class
+      end
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:address)
+  end
+  
+  expect :is_set do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :result
+      before_validation do
+        self.result = :is_set
+      end
+    end
+    
+    instance = klass.new
+    instance.valid?
+    instance.result
+  end
+  
+  expect :is_set do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :name, :result
+      validates_presence_of :name, :after_validate => lambda { |result, attribute| self.result = :is_set }
+    end
+
+    instance = klass.new
+    instance.valid?
+    instance.result
+  end
+
+  expect false do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :name
+      validates_presence_of :name
+    end
+    subclass = Class.new klass do
+    end
+    subsubclass = Class.new subclass do
+    end
+    subsubclass.new.valid?
+  end
+  
+  expect false do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :name
+      validates_presence_of :name
+    end
+    subclass = Class.new klass do
+    end
+    subclass.new.valid?
+  end
+  
+  expect true do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :name
+      validates_presence_of :name
+    end
+    subclass = Class.new klass do
+    end
+    instance = subclass.new
+    instance.name = 'a name'
+    instance.valid?
+  end
+
+  expect ArgumentError do
+    Class.new do
+      include Validatable
+      attr_accessor :name
+      validates_presence_of :name, :times => 1
+      validates_presence_of :name, :times => 1
+    end
+  end
+
+  expect ArgumentError do
+    Class.new do
+      include Validatable
+      attr_accessor :name
+      validates_presence_of :name, :times => 1, :key => 'anything'
+      validates_presence_of :name, :times => 1, :key => 'anything'
+    end
+  end
+
+  expect "is invalid" do
+    child_class = Class.new do
+      include Validatable
+      attr_accessor :name, :address
+      validates_presence_of :name
+      validates_format_of :address, :with => /.+/
+    end
+    klass = Class.new do
+      include Validatable
+      include_errors_from :child 
+      define_method :child do
+        child_class.new
+      end
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:address)
+  end
+
+  expect "can't be empty" do
+    child_class = Class.new do
+      include Validatable
+      attr_accessor :name, :address
+      validates_presence_of :name
+      validates_format_of :address, :with => /.+/
+    end
+    klass = Class.new do
+      include Validatable
+      include_errors_from :child 
+      define_method :child do
+        child_class.new
+      end
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:name)
+  end
+
+
+  test "when child validations have errors, level 2 and higher parent validations are not performed" do
+    child_class = Class.new do
+      include Validatable
+      attr_accessor :name
+      validates_presence_of :name
+    end
+
+    klass = Class.new do
+      include Validatable
+      extend Forwardable
+      def_delegator :child, :name
+      validates_true_for :name, :logic => lambda { false }, :level => 2, :message => "invalid message"
+      include_errors_from :child 
+      define_method :child do
+        @child ||= child_class.new
+      end
+    end
+    instance = klass.new
+    instance.valid?
+    assert_equal "can't be empty", instance.errors.on(:name)
+  end
+
+  test "when child validations have errors, level 1 parent validations are still performed" do
+    child_class = Class.new do
+      include Validatable
+      attr_accessor :name
+      validates_presence_of :name
+    end
+
+    klass = Class.new do
+      include Validatable
+      validates_true_for :address, :logic => lambda { false }, :level => 1, :message => "invalid message"
+      include_errors_from :child 
+      define_method :child do
+        @child ||= child_class.new
+      end
+
+    end
+    instance = klass.new
+    instance.valid?
+    assert_equal "can't be empty", instance.errors.on(:name)
+    assert_equal "invalid message", instance.errors.on(:address)
+  end
+
+  expect "can't be empty" do
+    child_class = Class.new do
+      include Validatable
+      attr_accessor :name, :address
+      validates_presence_of :name
+    end
+    klass = Class.new do
+      include Validatable
+      include_errors_from :child, :map => {:name => :namen}
+      define_method :child do
+        child_class.new
+      end
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:namen)
+  end
+
+  expect "can't be empty" do
+    child_class = Class.new do
+      include Validatable
+      attr_accessor :name, :address
+      validates_presence_of :name
+    end
+    klass = Class.new do
+      include Validatable
+      include_errors_from :child, :if => lambda { true }
+      define_method :child do
+        child_class.new
+      end
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:name)
+  end
+
+  expect true do
+    child_class = Class.new do
+      include Validatable
+      attr_accessor :name, :address
+      validates_presence_of :name
+    end
+    klass = Class.new do
+      include Validatable
+      include_errors_from :child, :if => lambda { false }
+      define_method :child do
+        child_class.new
+      end
+    end
+    instance = klass.new
+    instance.valid?
+  end
+  
+  test ':if with symbol should work' do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :name, :name_required
+      validates_presence_of :name, :if => :name_required?
+      
+      def name_required?
+        name_required
+      end
+    end
+    instance = klass.new
+    instance.name_required = false
+    assert instance.valid?
+    instance.name_required = true
+    assert !instance.valid?
+    assert_equal "can't be empty", instance.errors.on(:name)
+  end
+  
+  test ':if with string should work' do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :name, :name_required
+      validates_presence_of :name, :if => 'name_required?'
+      
+      def name_required?
+        name_required
+      end
+    end
+    instance = klass.new
+    instance.name_required = false
+    assert instance.valid?
+    instance.name_required = true
+    assert !instance.valid?
+    assert_equal "can't be empty", instance.errors.on(:name)
+  end
+
+  test "classes only have valid_for_* methods for groups that appear in their validations" do
+    class_with_group_one = Class.new do
+      include Validatable
+      validates_presence_of :name, :groups => :group_one
+      attr_accessor :name
+    end
+    class_with_group_two = Class.new do
+      include Validatable
+      validates_presence_of :name, :groups => :group_two
+      attr_accessor :name
+    end
+    assert_equal false, class_with_group_one.public_instance_methods.include?(:valid_for_group_two?)
+    assert_equal false, class_with_group_two.public_instance_methods.include?(:valid_for_group_one?)
+  end
+
+  test "nonmatching groups are not used as validations" do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :groups => :group_one
+      validates_presence_of :address, :groups => :group_two
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    assert_equal nil, instance.errors.on(:name)
+  end
+
+  expect "can't be empty twice changed message" do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name
+      attr_accessor :name
+    end
+
+    Validatable::ValidationBase.class_eval do
+      after_validate do |result, instance, attribute|
+        instance.errors.add(attribute, " changed message")
+      end
+    end
+    Validatable::ValidatesPresenceOf.class_eval do
+      after_validate do |result, instance, attribute|
+        instance.errors.add(attribute, " twice")
+      end
+    end
+    instance = klass.new
+    instance.valid?
+    Validatable::ValidatesPresenceOf.after_validations.clear
+    Validatable::ValidationBase.after_validations.clear
+    instance.errors.on(:name).join
+  end
+
+  expect false do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :groups => :group_one
+      attr_accessor :name
+    end
+    instance = klass.new
+    instance.valid_for_group_one?
+  end
+
+  expect false do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :groups => [:group_one, :group_two]
+      attr_accessor :name
+    end
+    instance = klass.new
+    instance.valid_for_group_one?
+  end
+
+  expect true do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :groups => :group_one
+      validates_presence_of :address
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.address = 'anything'
+    instance.valid?
+  end
+
+  expect true do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :groups => :group_one
+      attr_accessor :name
+    end
+    instance = klass.new
+    instance.valid?
+  end
+
+  expect true do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :times => 1
+      attr_accessor :name
+    end
+    instance = klass.new
+    instance.valid?
+    instance.valid?
+  end
+
+  expect false do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :times => 1
+      attr_accessor :name
+    end
+    instance1 = klass.new
+    instance1.valid?
+    instance2 = klass.new
+    instance2.valid?
+  end
+
+  expect "name message" do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :level => 1, :message => "name message"
+      validates_presence_of :address, :level => 2
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:name)
+  end
+
+  expect nil do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :level => 1, :message => "name message"
+      validates_presence_of :address, :level => 2
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:address)
+  end
+  
+  expect "Mod::Klass/Validatable::ValidatesPresenceOf/name" do
+    module Mod
+      class Klass
+        include Validatable
+        validates_presence_of :name
+      end
+    end
+    Mod::Klass.validations.first.key
+  end
+
+  expect "/Validatable::ValidatesPresenceOf/custom key" do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :key => "custom key"
+    end
+    klass.validations.first.key
+  end
+  
+  expect "can't be empty" do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :address
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.validate_only("presence_of/name")
+    instance.errors.on(:name)
+  end
+
+  expect nil do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :address
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.validate_only("presence_of/name")
+    instance.errors.on(:address)
+  end
+  
+  test 'validate callback' do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :action
+      validate :action_presence
+      
+      private
+        def action_presence
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+    end
+    instance = klass.new
+    instance.valid?
+    assert_equal 'is invalid', instance.errors.on(:action)
+    
+    instance.action = 'walk'
+    instance.valid?
+    assert_nil instance.errors.on(:action)
+  end
+  
+  test 'validate on create callback for new record' do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :action
+      validate_on_create :action_presence
+      
+      def new?
+        true
+      end
+      
+      private
+        def action_presence
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+    end
+    instance = klass.new
+    instance.valid?
+    assert_equal 'is invalid', instance.errors.on(:action)
+    
+    instance.action = 'walk'
+    instance.valid?
+    assert_nil instance.errors.on(:action)
+  end
+
+  test 'validate on create callback for not new record' do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :action
+      validate_on_create :action_presence
+      
+      def new?
+        false
+      end
+      
+      private
+        def action_presence
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+    end
+    instance = klass.new
+    instance.valid?
+    assert_nil instance.errors.on(:action)
+    
+    instance.action = 'walk'
+    instance.valid?
+    assert_nil instance.errors.on(:action)
+  end
+
+  test 'validate on update callback for new record' do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :action
+      validate_on_update :action_presence
+      
+      def new?
+        true
+      end
+      
+      private
+        def action_presence
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+    end
+    instance = klass.new
+    instance.valid?
+    assert_nil instance.errors.on(:action)
+    
+    instance.action = 'walk'
+    instance.valid?
+    assert_nil instance.errors.on(:action)
+  end
+
+  test 'validate on update callback for not new record' do
+    klass = Class.new do
+      include Validatable
+      attr_accessor :action
+      validate_on_update :action_presence
+      
+      def new?
+        false
+      end
+      
+      private
+        def action_presence
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+    end
+    instance = klass.new
+    instance.valid?
+    assert_equal 'is invalid', instance.errors.on(:action)
+    
+    instance.action = 'walk'
+    instance.valid?
+    assert_nil instance.errors.on(:action)
+  end
+end