dm-validations 0.9.2

data/lib/dm-validations/support/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def validatable?
+    false
+  end
+end

data/lib/dm-validations/uniqueness_validator.rb

@@ -0,0 +1,61 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class UniquenessValidator < GenericValidator
+      include Assertions
+
+      def initialize(field_name, options = {})
+        assert_kind_of 'scope', options[:scope], Array, Symbol if options.has_key?(:scope)
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        scope = Array(@options[:scope])
+
+        return true if @options[:allow_nil] && target.send(field_name).nil?
+
+        repository_name = target.repository.name
+
+        opts = { field_name => target.validation_property_value(field_name) }
+
+        scope.each do |item|
+          if !target.model.properties(repository_name)[item].nil?
+            opts[item] = target.validation_property_value(item)
+          elsif target.model.relationships(repository_name).has_key?(item)
+            target.validation_association_keys(item).each do |key|
+              opts[key] = target.validation_property_value(key)
+            end
+          end
+        end
+
+        resource = repository(repository_name) { target.model.first(opts) }
+
+        return true if resource.nil?
+
+        # is target and found resource identic? same instance... but not ==
+        return true if resource.repository.name == repository_name && resource.model == target.model && resource.key == target.key
+
+        error_message = @options[:message] || "%s is already taken".t(Extlib::Inflection.humanize(field_name))
+        add_error(target, error_message , field_name)
+
+        return false
+      end
+    end # class UniquenessValidator
+
+    module ValidatesIsUnique
+
+      # Validate the uniqueness of a field
+      #
+      def validates_is_unique(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::UniquenessValidator)
+      end
+
+    end # module ValidatesIsUnique
+  end # module Validate
+end # module DataMapper

data/lib/dm-validations/validation_errors.rb

@@ -0,0 +1,63 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class ValidationErrors
+
+      include Enumerable
+
+      # Clear existing validation errors.
+      def clear!
+        errors.clear
+      end
+
+      # Add a validation error. Use the field_name :general if the errors does
+      # not apply to a specific field of the Resource.
+      #
+      # @param <Symbol> field_name the name of the field that caused the error
+      # @param <String> message    the message to add
+      def add(field_name, message)
+        (errors[field_name] ||= []) << message
+      end
+
+      # Collect all errors into a single list.
+      def full_messages
+        errors.inject([]) do |list,pair|
+          list += pair.last
+        end
+      end
+
+      # Return validation errors for a particular field_name.
+      #
+      # @param <Symbol> field_name the name of the field you want an error for
+      def on(field_name)
+        errors_for_field = errors[field_name]
+        errors_for_field.blank? ? nil : errors_for_field
+      end
+
+      def each
+        errors.map.each do |k,v|
+          next if v.blank?
+          yield(v)
+        end
+      end
+
+      def empty?
+        entries.empty?
+      end
+
+      def method_missing(meth, *args, &block)
+        errors.send(meth, *args, &block)
+      end
+
+      private
+      def errors
+        @errors ||= {}
+      end
+
+    end # class ValidationErrors
+  end # module Validate
+end # module DataMapper

data/lib/dm-validations/within_validator.rb

@@ -0,0 +1,41 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class WithinValidator < GenericValidator
+
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+        @options[:set] = [] unless @options.has_key?(:set)
+      end
+
+      def call(target)
+        includes = @options[:set].include?(target.send(field_name))
+        return true if includes
+
+        s = ''
+        @options[:set].each {|item| s = s + "#{item}, "}
+        s = '[' + s[0..(s.length-3)] + ']'
+
+        error_message = @options[:message] || "%s must be one of #{s}".t(Extlib::Inflection.humanize(@field_name))
+        add_error(target, error_message , @field_name)
+        return false
+      end
+    end # class WithinValidator
+
+    module ValidatesWithin
+
+      # Validate the absence of a field
+      #
+      def validates_within(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::WithinValidator)
+      end
+
+    end # module ValidatesWithin
+  end # module Validate
+end # module DataMapper

data/spec/integration/absent_field_validator_spec.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe DataMapper::Validate::AbsentFieldValidator do
+  before(:all) do
+    class Kayak
+      include DataMapper::Resource
+      property :id, Integer, :key => true
+      property :salesman, String, :auto_validation => false
+      validates_absent :salesman, :when => :sold
+    end
+
+    class Pirogue
+      include DataMapper::Resource
+      property :id, Integer, :key => true
+      property :salesman, String, :default => 'Layfayette'
+      validates_absent :salesman, :when => :sold
+    end
+  end
+
+  it "should validate the absence of a value on an instance of a resource" do
+    kayak = Kayak.new
+    kayak.valid_for_sold?.should == true
+
+    kayak.salesman = 'Joe'
+    kayak.valid_for_sold?.should_not == true
+  end
+
+  it "should validate the absence of a value and ensure defaults" do
+    pirogue = Pirogue.new
+    pirogue.should_not be_valid_for_sold
+  end
+
+end

data/spec/integration/acceptance_validator_spec.rb

@@ -0,0 +1,87 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe DataMapper::Validate::AcceptanceValidator do
+  describe "with standard options" do
+    before(:all) do
+      class SkimBat
+        include DataMapper::Resource
+        property :id,        Integer, :serial => true
+        property :sailyness, Boolean
+        validates_is_accepted :sailyness
+      end
+      @s = SkimBat.new
+    end
+
+    it "should validate if a resource instance has been accepted" do
+      @s.sailyness = "1"
+      @s.valid?.should == true
+    end
+
+    it "should not validate if a resource instance has not been accepted" do
+      @s.sailyness = "0"
+      @s.valid?.should == false
+    end
+
+    it "should allow nil acceptance" do
+      @s.sailyness = nil
+      @s.valid?.should == true
+    end
+
+    it "should add the default message when invalid" do
+      @s.sailyness = "0"
+      @s.valid?.should == false
+      @s.errors.full_messages.join(" ").should =~ /#{DataMapper::Validate::AcceptanceValidator.default_message_for_field("sailyness")}/
+    end
+  end
+  describe "with :allow_nil => false" do
+    before(:all) do
+      SkimBat.class_eval do
+        validators.clear!
+        validates_is_accepted :sailyness, :allow_nil => false
+      end
+      @s = SkimBat.new
+    end
+
+    it "should not allow nil acceptance" do
+      @s.sailyness = nil
+      @s.valid?.should == false
+    end
+  end
+
+  describe "with custom :accept" do
+    before(:all) do
+      SkimBat.class_eval do
+        validators.clear!
+        validates_is_accepted :sailyness, :accept => "true"
+      end
+      @s = SkimBat.new
+    end
+
+    it "should validate if a resource instance has been accepted" do
+      @s.sailyness = "true"
+      @s.valid?.should == true
+    end
+
+    it "should not validate if a resource instance has not been accepted" do
+      @s.sailyness = "false"
+      @s.valid?.should == false
+    end
+  end
+
+  describe "with custom message" do
+    before(:all) do
+      SkimBat.class_eval do
+        validators.clear!
+        validates_is_accepted :sailyness, :message => "hehu!"
+      end
+      @s = SkimBat.new
+    end
+
+    it "should append the custom message when invalid" do
+      @s.sailyness = "0"
+      @s.valid?.should == false
+      @s.errors.full_messages.join(" ").should =~ /hehu!/
+    end
+  end
+end

data/spec/integration/auto_validate_spec.rb

@@ -0,0 +1,262 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+module TypecastBypassSetter
+  # Bypass typecasting so we can set values for specs
+  def set(attributes)
+    attributes.each do |k,v|
+      instance_variable_set("@#{k}", v)
+    end
+  end
+end
+
+class SailBoat
+  include DataMapper::Resource
+  property :id,            Integer,    :key => true
+  property :name,          String,                                :nullable => false,     :validates       => :presence_test
+  property :description,   String,     :length => 10,                                     :validates       => :length_test_1
+  property :notes,         String,     :length => 2..10,                                  :validates       => :length_test_2
+  property :no_validation, String,                                                        :auto_validation => false
+  property :salesman,      String,                                :nullable => false,     :validates       => [:multi_context_1, :multi_context_2]
+  property :code,          String,     :format => Proc.new { |code| code =~ /A\d{4}\z/ }, :validates       => :format_test
+  property :allow_nil,     String,     :size => 5..10,            :nullable => true,      :validates       => :nil_test
+  property :build_date,    Date,                                                          :validates       => :primitive_test
+  property :float,         Float,      :precision => 2, :scale => 1
+  property :big_decimal,   BigDecimal, :precision => 2, :scale => 1
+
+  include TypecastBypassSetter
+end
+
+class HasNullableBoolean
+  include DataMapper::Resource
+  property :id,   Integer, :key => true
+  property :bool, Boolean # :nullable => true by default
+
+  include TypecastBypassSetter
+end
+
+class HasNotNullableBoolean
+  include DataMapper::Resource
+  property :id,   Integer, :key => true
+  property :bool, Boolean, :nullable => false
+
+  include TypecastBypassSetter
+end
+
+class HasNotNullableParanoidBoolean
+  include DataMapper::Resource
+  property :id,   Integer,         :key => true
+  property :bool, ParanoidBoolean, :nullable => false
+
+  include TypecastBypassSetter
+end
+
+describe "Automatic Validation from Property Definition" do
+  it "should have a hook for adding auto validations called from
+      DataMapper::Property#new" do
+    SailBoat.should respond_to(:auto_generate_validations)
+  end
+
+  it "should auto add a validates_is_present when property has option
+      :nullable => false" do
+    validator = SailBoat.validators.context(:presence_test).first
+    validator.should be_kind_of(DataMapper::Validate::RequiredFieldValidator)
+    validator.field_name.should == :name
+
+    boat = SailBoat.new
+    boat.valid_for_presence_test?.should == false
+    boat.name = 'Float'
+    boat.valid_for_presence_test?.should == true
+  end
+
+  it "should auto add a validates_length for maximum size on String properties" do
+    # max length test max=10
+    boat = SailBoat.new
+    boat.valid_for_length_test_1?.should == true  #no minimum length
+    boat.description = 'ABCDEFGHIJK' #11
+    boat.valid_for_length_test_1?.should == false
+    boat.description = 'ABCDEFGHIJ' #10
+    boat.valid_for_length_test_1?.should == true
+  end
+
+  it "should auto add validates_length within a range when option :length
+      or :size is a range" do
+    # Range test notes = 2..10
+    boat = SailBoat.new
+    boat.should be_valid_for_length_test_2
+    boat.notes = 'AB' #2
+    boat.should be_valid_for_length_test_2
+    boat.notes = 'ABCDEFGHIJK' #11
+    boat.should_not be_valid_for_length_test_2
+    boat.notes = 'ABCDEFGHIJ' #10
+    boat.should be_valid_for_length_test_2
+  end
+
+  it "should auto add a validates_format if the :format option is given" do
+    # format test - format = /A\d{4}\z/   on code
+    boat = SailBoat.new
+    boat.should be_valid_for_format_test
+    boat.code = 'A1234'
+    boat.should be_valid_for_format_test
+    boat.code = 'BAD CODE'
+    boat.should_not be_valid_for_format_test
+  end
+
+  it "should auto validate all strings for max length" do
+    klass = Class.new do
+      include DataMapper::Resource
+      property :id, Integer, :serial => true
+      property :name, String
+    end
+    t = klass.new(:id => 1)
+    t.should be_valid
+    t.name = 'Lip­smackin­thirst­quenchin­acetastin­motivatin­good­buzzin­cool­talkin­high­walkin­fast­livin­ever­givin­cool­fizzin'
+    t.should_not be_valid
+    t.errors.full_messages.should include('Name must be less than 50 characters long')
+  end
+
+  it "should auto validate the primitive type" do
+    validator = SailBoat.validators.context(:primitive_test).first
+    validator.should be_kind_of(DataMapper::Validate::PrimitiveValidator)
+    boat = SailBoat.new
+    boat.should be_valid_for_primitive_test
+    boat.build_date = 'ABC'
+    boat.should_not be_valid_for_primitive_test
+  end
+
+  it "should not auto add any validators if the option :auto_validation => false was given" do
+    klass = Class.new do
+      include DataMapper::Resource
+      property :id,   Integer,     :serial   => true,  :auto_validation => false
+      property :name, String,      :nullable => false, :auto_validation => false
+      property :bool, DM::Boolean, :nullable => false, :auto_validation => false
+    end
+    klass.new.valid?.should == true
+  end
+
+  it "should auto add range checking the length of a string while still allowing null values" do
+    boat = SailBoat.new
+    boat.allow_nil = 'ABC'
+    boat.should_not be_valid_for_nil_test
+    boat.errors.on(:allow_nil).should include('Allow nil must be between 5 and 10 characters long')
+
+    boat.allow_nil = 'ABCDEFG'
+    boat.should be_valid_for_nil_test
+
+    boat.allow_nil = 'ABCDEFGHIJKLMNOP'
+    boat.should_not be_valid_for_nil_test
+    boat.errors.on(:allow_nil).should include('Allow nil must be between 5 and 10 characters long')
+
+    boat.allow_nil = nil
+    boat.should be_valid_for_nil_test
+  end
+
+  describe 'for Integer properties' do
+    before do
+      @boat = SailBoat.new
+    end
+
+    it 'should allow integers' do
+      @boat.set(:id => 1)
+      @boat.should be_valid
+    end
+
+    it 'should not allow floats' do
+      @boat.set(:id => 1.0)
+      @boat.should_not be_valid
+      @boat.errors.on(:id).should == [ 'Id must be an integer' ]
+    end
+
+    it 'should not allow decimals' do
+      @boat.set(:id => BigDecimal('1'))
+      @boat.should_not be_valid
+      @boat.errors.on(:id).should == [ 'Id must be an integer' ]
+    end
+  end
+
+  describe 'for nullable Boolean properties' do
+    before do
+      @boat = HasNullableBoolean.new(:id => 1)
+    end
+
+    it 'should allow true' do
+      @boat.set(:bool => true)
+      @boat.should be_valid
+    end
+
+    it 'should allow false' do
+      @boat.set(:bool => false)
+      @boat.should be_valid
+    end
+
+    it 'should allow nil' do
+      @boat.set(:bool => nil)
+      @boat.should be_valid
+    end
+  end
+
+  describe 'for non-nullable Boolean properties' do
+    before do
+      @boat = HasNotNullableBoolean.new(:id => 1)
+    end
+
+    it 'should allow true' do
+      @boat.set(:bool => true)
+      @boat.should be_valid
+    end
+
+    it 'should allow false' do
+      @boat.set(:bool => false)
+      @boat.should be_valid
+    end
+
+    it 'should not allow nil' do
+      @boat.set(:bool => nil)
+      @boat.should_not be_valid
+    end
+  end
+
+  describe 'for non-nullable ParanoidBoolean properties' do
+    before do
+      @boat = HasNotNullableParanoidBoolean.new(:id => 1)
+    end
+
+    it 'should allow true' do
+      @boat.set(:bool => true)
+      @boat.should be_valid
+    end
+
+    it 'should allow false' do
+      @boat.set(:bool => false)
+      @boat.should be_valid
+    end
+
+    it 'should not allow nil' do
+      @boat.set(:bool => nil)
+      @boat.should_not be_valid
+    end
+  end
+
+  { :float => Float, :big_decimal => BigDecimal }.each do |column,type|
+    describe "for #{type} properties" do
+      before do
+        @boat = SailBoat.new(:id => 1)
+      end
+
+      it 'should allow integers' do
+        @boat.set(column => 1)
+        @boat.should be_valid
+      end
+
+      it 'should allow floats' do
+        @boat.set(column => '1.0')
+        @boat.should be_valid
+      end
+
+      it 'should allow decimals' do
+        @boat.set(column => BigDecimal('1'))
+        @boat.should be_valid
+      end
+    end
+  end
+end