dm-validations 0.9.11 → 0.10.0

data/lib/dm-validations/length_validator.rb

@@ -1,113 +0,0 @@
-module DataMapper
-  module Validate
-
-    ##
-    #
-    # @author Guy van den Berg
-    # @since  0.9
-    class LengthValidator < GenericValidator
-
-      def initialize(field_name, options)
-        super
-        @field_name = field_name
-        @options = options
-
-        @min = options[:minimum] || options[:min]
-        @max = options[:maximum] || options[:max]
-        @equal = options[:is] || options[:equals]
-        @range = options[:within] || options[:in]
-
-        @validation_method ||= :range if @range
-        @validation_method ||= :min if @min && @max.nil?
-        @validation_method ||= :max if @max && @min.nil?
-        @validation_method ||= :equals unless @equal.nil?
-      end
-
-      def call(target)
-        field_value = target.validation_property_value(field_name)
-        return true if @options[:allow_nil] && field_value.nil?
-
-        field_value = '' if field_value.nil?
-
-        # XXX: HACK seems hacky to do this on every validation, probably should
-        #      do this elsewhere?
-        field = Extlib::Inflection.humanize(field_name)
-        min = @range ? @range.min : @min
-        max = @range ? @range.max : @max
-        equal = @equal
-
-        case @validation_method
-        when :range then
-          unless valid = @range.include?(field_value.size)
-            error_message = ValidationErrors.default_error_message(:length_between, field, min, max)
-          end
-        when :min then
-          unless valid = field_value.size >= min
-            error_message = ValidationErrors.default_error_message(:too_short, field, min)
-          end
-        when :max then
-          unless valid = field_value.size <= max
-            error_message = ValidationErrors.default_error_message(:too_long, field, max)
-          end
-        when :equals then
-          unless valid = field_value.size == equal
-            error_message = ValidationErrors.default_error_message(:wrong_length, field, equal)
-          end
-        end
-
-        error_message = @options[:message] || error_message
-
-        add_error(target, error_message, field_name) unless valid
-
-        return valid
-      end
-
-    end # class LengthValidator
-
-    module ValidatesLength
-
-      # Validates that the length of the attribute is equal to, less than,
-      # greater than or within a certain range (depending upon the options
-      # you specify).
-      #
-      # @option :allow_nil<Boolean> true/false (default is true)
-      # @option :minimum    ensures that the attribute's length is greater than
-      #   or equal to the supplied value
-      # @option :min        alias for :minimum
-      # @option :maximum    ensures the attribute's length is less than or equal
-      #   to the supplied value
-      # @option :max        alias for :maximum
-      # @option :equals     ensures the attribute's length is equal to the
-      #   supplied value
-      # @option :is         alias for :equals
-      # @option :in<Range>  given a Range, ensures that the attributes length is
-      #   include?'ed in the Range
-      # @option :within<Range>  alias for :in
-      #
-      # @example [Usage]
-      #   require 'dm-validations'
-      #
-      #   class Page
-      #     include DataMapper::Resource
-      #
-      #     property high, Integer
-      #     property low, Integer
-      #     property just_right, Integer
-      #
-      #     validates_length :high, :min => 100000000000
-      #     validates_length :low, :equals => 0
-      #     validates_length :just_right, :within => 1..10
-      #
-      #     # a call to valid? will return false unless:
-      #     # high is greater than or equal to 100000000000
-      #     # low is equal to 0
-      #     # just_right is between 1 and 10 (inclusive of both 1 and 10)
-      #
-      def validates_length(*fields)
-        opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, DataMapper::Validate::LengthValidator)
-      end
-
-    end # module ValidatesLength
-  end # module Validate
-end # module DataMapper

data/lib/dm-validations/method_validator.rb

@@ -1,68 +0,0 @@
-module DataMapper
-  module Validate
-
-    ##
-    #
-    # @author Guy van den Berg
-    # @since  0.9
-    class MethodValidator < GenericValidator
-
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options.clone
-        @options[:method] = @field_name unless @options.has_key?(:method)
-      end
-
-      def call(target)
-        result, message = target.send(@options[:method])
-        add_error(target, message, field_name) unless result
-        result
-      end
-
-      def ==(other)
-        @options[:method] == other.instance_variable_get(:@options)[:method] && super
-      end
-    end # class MethodValidator
-
-    module ValidatesWithMethod
-
-      ##
-      # Validate using the given method. The method given needs to return:
-      # [result::<Boolean>, Error Message::<String>]
-      #
-      # @example [Usage]
-      #   require 'dm-validations'
-      #
-      #   class Page
-      #     include DataMapper::Resource
-      #
-      #     property :zip_code, String
-      #
-      #     validates_with_method :in_the_right_location?
-      #
-      #     def in_the_right_location?
-      #       if @zip_code == "94301"
-      #         return true
-      #       else
-      #         return [false, "You're in the wrong zip code"]
-      #       end
-      #     end
-      #
-      #     # A call to valid? will return false and
-      #     # populate the object's errors with "You're in the
-      #     # wrong zip code" unless zip_code == "94301"
-      #
-      #     # You can also specify field:
-      #
-      #     validates_with_method :zip_code, :in_the_right_location?
-      #
-      #     # it will add returned error message to :zip_code field
-      #
-      def validates_with_method(*fields)
-        opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, DataMapper::Validate::MethodValidator)
-      end
-
-    end # module ValidatesWithMethod
-  end # module Validate
-end # module DataMapper

data/lib/dm-validations/numeric_validator.rb

@@ -1,83 +0,0 @@
-module DataMapper
-  module Validate
-
-    ##
-    #
-    # @author Guy van den Berg
-    # @since  0.9
-    class NumericValidator < GenericValidator
-
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-        @options[:integer_only] = false unless @options.has_key?(:integer_only)
-      end
-
-      def call(target)
-        value = target.send(field_name)
-        return true if @options[:allow_nil] && value.nil?
-
-        value = value.kind_of?(BigDecimal) ? value.to_s('F') : value.to_s
-
-        error_message = @options[:message]
-        precision     = @options[:precision]
-        scale         = @options[:scale]
-
-        if @options[:integer_only]
-          return true if value =~ /\A[+-]?\d+\z/
-          error_message ||= ValidationErrors.default_error_message(:not_an_integer, field_name)
-        else
-          # FIXME: if precision and scale are not specified, can we assume that it is an integer?
-          #        probably not, as floating point numbers don't have hard
-          #        defined scale. the scale floats with the length of the
-          #        integral and precision. Ie. if precision = 10 and integral
-          #        portion of the number is 9834 (4 digits), the max scale will
-          #        be 6 (10 - 4). But if the integral length is 1, max scale
-          #        will be (10 - 1) = 9, so 1.234567890.
-          #        In MySQL somehow you can hard-define scale on floats. Not
-          #        quite sure how that works...
-          if precision && scale
-            #handles both Float when it has scale specified and BigDecimal
-            if precision > scale && scale > 0
-              return true if value =~ /\A[+-]?(?:\d{1,#{precision - scale}}|\d{0,#{precision - scale}}\.\d{1,#{scale}})\z/
-            elsif precision > scale && scale == 0
-              return true if value =~ /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/
-            elsif precision == scale
-              return true if value =~ /\A[+-]?(?:0(?:\.\d{1,#{scale}})?)\z/
-            else
-              raise ArgumentError, "Invalid precision #{precision.inspect} and scale #{scale.inspect} for #{field_name} (value: #{value.inspect} #{value.class})"
-            end
-          elsif precision && scale.nil?
-            # for floats, if scale is not set
-
-            #total number of digits is less or equal precision
-            return true if value.gsub(/[^\d]/, '').length <= precision
-
-            #number of digits before decimal == precision, and the number is x.0. same as scale = 0
-            return true if value =~ /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/
-          else
-            return true if value =~ /\A[+-]?(?:\d+|\d*\.\d+)\z/
-          end
-          error_message ||= ValidationErrors.default_error_message(:not_a_number, field_name)
-        end
-
-        add_error(target, error_message, field_name)
-
-        # TODO: check the gt, gte, lt, lte, and eq options
-
-        return false
-      end
-    end # class NumericValidator
-
-    module ValidatesIsNumber
-
-      # Validate whether a field is numeric
-      #
-      def validates_is_number(*fields)
-        opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, DataMapper::Validate::NumericValidator)
-      end
-
-    end # module ValidatesIsNumber
-  end # module Validate
-end # module DataMapper

data/spec/integration/absent_field_validator_spec.rb

@@ -1,36 +0,0 @@
-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
-    kayak.errors.on(:salesman).should include('Salesman must be absent')
-  end
-
-  it "should validate the absence of a value and ensure defaults" do
-    pirogue = Pirogue.new
-    pirogue.should_not be_valid_for_sold
-    pirogue.errors.on(:salesman).should include('Salesman must be absent')
-  end
-
-end

data/spec/integration/acceptance_validator_spec.rb

@@ -1,87 +0,0 @@
-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.on(:sailyness).should include('Sailyness is not accepted')
-    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.on(:sailyness).should include('hehu!')
-    end
-  end
-end

data/spec/integration/auto_validate_spec.rb

@@ -1,342 +0,0 @@
-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.errors.on(:name).should include('Name must not be blank')
-    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.errors.on(:description).should include('Description must be less than 10 characters long')
-    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.errors.on(:notes).should include('Notes must be between 2 and 10 characters long')
-    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
-    boat.errors.on(:code).should include('Code has an invalid format')
-  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 = 'a' * 51
-    t.should_not be_valid
-    t.errors.on(:name).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
-    boat.errors.on(:build_date).should include('Build date must be of type Date')
-  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, DataMapper::Types::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 include('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 include('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
-      @boat.errors.on(:bool).should include('Bool must not be nil')
-    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
-      @boat.errors.on(:bool).should include('Bool must not be nil')
-    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
-
-  describe 'for within validator' do
-    before :all do
-      class ::LimitedBoat
-        include DataMapper::Resource
-        property :id,       Integer,  :serial => true
-        property :limited,  String,   :set => ['foo', 'bar', 'bang'], :default => 'foo'
-      end
-    end
-
-    before do
-      @boat = LimitedBoat.new
-    end
-
-    it 'should set default value' do
-      @boat.should be_valid
-    end
-
-    it 'should not accept value not in range' do
-      @boat.limited = "blah"
-      @boat.should_not be_valid
-      @boat.errors.on(:limited).should include('Limited must be one of [foo, bar, bang]')
-    end
-
-  end
-
-  describe 'for custom messages' do
-    it "should have correct error message" do
-      custom_boat = Class.new do
-        include DataMapper::Resource
-        property :id,   Integer, :serial => true
-        property :name, String,  :nullable => false, :message => "This boat must have name"
-      end
-      boat = custom_boat.new
-      boat.should_not be_valid
-      boat.errors.on(:name).should include('This boat must have name')
-    end
-
-    it "should have correct error messages" do
-      custom_boat = Class.new do
-        include DataMapper::Resource
-        property :id,   Integer, :serial => true
-        property :name, String,  :nullable => false, :length => 5..20, :format => /^[a-z]+$/,
-                 :messages => {
-                   :presence => "This boat must have name",
-                   :length => "Name must have at least 4 and at most 20 chars",
-                   :format => "Please use only small letters"
-                 }
-      end
-
-      boat = custom_boat.new
-      boat.should_not be_valid
-      boat.errors.on(:name).should include("This boat must have name")
-      boat.errors.on(:name).should include("Name must have at least 4 and at most 20 chars")
-      boat.errors.on(:name).should include("Please use only small letters")
-
-      boat.name = "%%"
-      boat.should_not be_valid
-      boat.errors.on(:name).should_not include("This boat must have name")
-      boat.errors.on(:name).should include("Name must have at least 4 and at most 20 chars")
-      boat.errors.on(:name).should include("Please use only small letters")
-
-      boat.name = "%%asd"
-      boat.should_not be_valid
-      boat.errors.on(:name).should_not include("This boat must have name")
-      boat.errors.on(:name).should_not include("Name must have at least 4 and at most 20 chars")
-      boat.errors.on(:name).should include("Please use only small letters")
-
-      boat.name = "superboat"
-      boat.should be_valid
-      boat.errors.on(:name).should be_nil
-    end
-  end
-end