dm-validations 0.9.11 → 0.10.0

data/lib/dm-validations/validators/numeric_validator.rb

@@ -0,0 +1,171 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class NumericValidator < GenericValidator
+
+      def call(target)
+        value = target.send(field_name)
+        return true if allow_nil? && value.blank?
+
+        errors = []
+
+        validate_with(integer_only? ? :integer : :numeric, value, errors)
+
+        add_errors(target, errors)
+
+        # if the number is invalid, skip further tests
+        return false if errors.any?
+
+        [ :gt, :lt, :gte, :lte, :eq, :ne ].each do |validation_type|
+          validate_with(validation_type, value, errors)
+        end
+
+        add_errors(target, errors)
+
+        errors.empty?
+      end
+
+      private
+
+      def allow_nil?
+        options.fetch(:allow_nil, false)
+      end
+
+      def integer_only?
+        options.fetch(:integer_only, false)
+      end
+
+      def value_as_string(value)
+        case value
+          when Float      then value.to_d.to_s('F')  # Avoid Scientific Notation in Float to_s
+          when BigDecimal then value.to_s('F')
+          else value.to_s
+        end
+      end
+
+      def add_errors(target, errors)
+        return if errors.empty?
+
+        if options.key?(:message)
+          add_error(target, options[:message], field_name)
+        else
+          errors.each do |error_message|
+            add_error(target, error_message, field_name)
+          end
+        end
+      end
+
+      def validate_with(validation_type, value, errors)
+        send("validate_#{validation_type}", value, errors)
+      end
+
+      def validate_with_comparison(value, cmp, expected, error_message_name, errors, negated = false)
+        return if expected.nil?
+
+        comparison = value.send(cmp, expected)
+        return if negated ? !comparison : comparison
+
+        errors << ValidationErrors.default_error_message(error_message_name, field_name, expected)
+      end
+
+      def validate_integer(value, errors)
+        validate_with_comparison(value_as_string(value), :=~, /\A[+-]?\d+\z/, :not_an_integer, errors)
+      end
+
+      def validate_numeric(value, errors)
+        precision = options[:precision]
+        scale     = options[:scale]
+
+        regexp = if precision && scale
+          if precision > scale && scale == 0
+            /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/
+          elsif precision > scale
+            /\A[+-]?(?:\d{1,#{precision - scale}}|\d{0,#{precision - scale}}\.\d{1,#{scale}})\z/
+          elsif precision == scale
+            /\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
+        else
+          /\A[+-]?(?:\d+|\d*\.\d+)\z/
+        end
+
+        validate_with_comparison(value_as_string(value), :=~, regexp, :not_a_number, errors)
+      end
+
+      def validate_gt(value, errors)
+        validate_with_comparison(value, :>, options[:gt], :greater_than, errors)
+      end
+
+      def validate_lt(value, errors)
+        validate_with_comparison(value, :<, options[:lt], :less_than, errors)
+      end
+
+      def validate_gte(value, errors)
+        validate_with_comparison(value, :>=, options[:gte], :greater_than_or_equal_to, errors)
+      end
+
+      def validate_lte(value, errors)
+        validate_with_comparison(value, :<=, options[:lte], :less_than_or_equal_to, errors)
+      end
+
+      def validate_eq(value, errors)
+        eq = options[:eq] || options[:equal] || options[:equals] || options[:exactly]
+        validate_with_comparison(value, :==, eq, :equal_to, errors)
+      end
+
+      def validate_ne(value, errors)
+        validate_with_comparison(value, :==, options[:ne], :not_equal_to, errors, true)
+      end
+    end # class NumericValidator
+
+    module ValidatesIsNumber
+
+      # Validate whether a field is numeric
+      #
+      # @details
+      #
+      # Options are:
+      #
+      # :message => "Error message for %s"
+      #   Custom error message, also can be a callable object that takes
+      #   an object (for pure Ruby objects) or object and property (for DM resources)
+      #
+      # :precision => 2
+      #   Required precision of a value
+      #
+      # :scale => 2
+      #   Required scale of a value
+      #
+      # :gte => 5.75
+      #   'Greater than or greater' requirement
+      #
+      # :lte => 5.75
+      #   'Less than or greater' requirement
+      #
+      # :lt => 5.75
+      #   'Less than' requirement
+      #
+      # :gt => 5.75
+      #   'Greater than' requirement
+      #
+      # :eq => 5.75
+      #   'Equal' requirement
+      #
+      # :ne => 5.75
+      #   'Not equal' requirement
+      #
+      # :integer_only => true
+      #   Use to restrict allowed values to integers
+      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/lib/dm-validations/{primitive_validator.rb → validators/primitive_validator.rb}

@@ -6,15 +6,10 @@ module DataMapper
     # @author Dirkjan Bussink
     # @since  0.9
     class PrimitiveValidator < GenericValidator
-
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-      end
-
       def call(target)
-        value = target.validation_property_value(field_name)
+        value    = target.validation_property_value(field_name)
         property = target.validation_property(field_name)
+
         return true if value.nil? || value.kind_of?(property.primitive) || property.primitive == TrueClass && value.kind_of?(FalseClass)
 
         error_message = @options[:message] || default_error(property)

data/lib/dm-validations/{required_field_validator.rb → validators/required_field_validator.rb}

@@ -6,12 +6,6 @@ module DataMapper
     # @author Guy van den Berg
     # @since  0.9
     class RequiredFieldValidator < GenericValidator
-
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-      end
-
       def call(target)
         value = target.validation_property_value(field_name)
         property = target.validation_property(field_name)

data/lib/dm-validations/{uniqueness_validator.rb → validators/uniqueness_validator.rb}

@@ -11,42 +11,31 @@ module DataMapper
       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
+
+        @options[:allow_nil] = true unless @options.include?(:allow_nil)
       end
 
       def call(target)
-        scope = Array(@options[:scope])
-
-        return true if @options[:allow_nil] && target.send(field_name).nil?
+        value = target.send(field_name)
 
-        repository_name = target.repository.name
+        return true if @options[:allow_nil] && value.blank?
 
         opts = {
           :fields    => target.model.key,
-          field_name => target.validation_property_value(field_name)
+          field_name => value,
         }
 
-        scope.each do |item|
-          if target.model.properties(repository_name).has_property?(item)
-            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
+        Array(@options[:scope]).each { |subject| opts[subject] = target.send(subject) }
 
-        resource = repository(repository_name) { target.model.first(opts) }
+        resource = DataMapper.repository(target.repository.name) { target.model.first(opts) }
 
         return true if resource.nil?
-
-        # is target and found resource identic? same instance... but not ==
-        return true if !target.new_record? && resource.repository.name == repository_name && resource.model == target.model && resource.key == target.key
+        return true if target.saved? && resource.key == target.key
 
         error_message = @options[:message] || ValidationErrors.default_error_message(:taken, field_name)
         add_error(target, error_message, field_name)
 
-        return false
+        false
       end
     end # class UniquenessValidator
 

data/lib/dm-validations/{within_validator.rb → validators/within_validator.rb}

@@ -9,13 +9,13 @@ module DataMapper
 
       def initialize(field_name, options={})
         super
-        @field_name, @options = field_name, options
+
         @options[:set] = [] unless @options.has_key?(:set)
       end
 
       def call(target)
         value = target.send(field_name)
-        return true if @options[:allow_nil] && value.nil?
+        return true if @options[:allow_nil] && value.blank?
         return true if @options[:set].include?(value)
 
         set = @options[:set]
@@ -29,7 +29,7 @@ module DataMapper
             error_message = msg || ValidationErrors.default_error_message(:greater_than_or_equal_to, field_name, set.first)
           end
         else
-          error_message = ValidationErrors.default_error_message(:inclusion, field_name, set.join(', '))
+          error_message = msg || ValidationErrors.default_error_message(:inclusion, field_name, set.join(', '))
         end
 
         add_error(target, error_message, field_name)
@@ -43,7 +43,7 @@ module DataMapper
 
     module ValidatesWithin
 
-      # Validate the absence of a field
+      # Validate that value of a field if within a range/set
       #
       def validates_within(*fields)
         opts = opts_from_validator_args(fields)

data/lib/dm-validations/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module Validations
-    VERSION = '0.9.11'
+    VERSION = '0.10.0'.freeze
   end
 end

data/spec/fixtures/barcode.rb

@@ -0,0 +1,32 @@
+module DataMapper
+  module Validate
+    module Fixtures
+      class Barcode
+
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        without_auto_validations do
+          property :code, String, :key => true
+        end
+
+        #
+        # Validations
+        #
+
+        validates_length :code, :max => 10
+
+        def self.valid_instance
+          new(:code => "3600029145")
+        end
+      end # Barcode
+    end
+  end
+end

data/spec/fixtures/basketball_court.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validate
+    module Fixtures
+      class BasketballCourt
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,     Serial
+
+        without_auto_validations do
+          property :name,   String
+
+          property :length, Float
+          property :width,  Float
+
+          property :three_point_line_distance,  Float
+          property :free_throw_line_distance,   Float
+          property :rim_height,                 Float
+        end
+
+        #
+        # Validations
+        #
+
+        # obviously these are all metrics
+        validates_is_number :length, :gte => 15.0,  :lte => 15.24
+        validates_is_number :width,  :gte => 25.28, :lte => 28.65
+
+        # 3 pt line distance may use :gte and :lte, but for
+        # sake of spec example we make it up a little
+        validates_is_number :three_point_line_distance, :gt => 6.7, :lt => 7.24
+        validates_is_number :free_throw_line_distance,  :equals => 4.57
+        validates_is_number :rim_height,                :eq     => 3.05
+
+        def self.valid_instance(overrides = {})
+          defaults = {
+            :length                    => 15.24,
+            :width                     => 28.65,
+            :free_throw_line_distance  => 4.57,
+            :rim_height                => 3.05,
+            :three_point_line_distance => 6.9
+          }
+
+          new(defaults.merge(overrides))
+        end
+      end
+    end # Fixtures
+  end # Validate
+end # DataMapper

data/spec/fixtures/basketball_player.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validate
+    module Fixtures
+      class BasketballPlayer
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,     Serial
+
+        without_auto_validations do
+          property :name,   String
+          property :height, Float
+          property :weight, Float
+        end
+
+        #
+        # Validations
+        #
+
+        # precision and scale need to be defined for length to be validated
+        validates_is_number :height, :weight, :precision => 10
+      end
+      BasketballPlayer.auto_migrate!
+
+
+    end # Fixtures
+  end # Validate
+end # DataMapper

data/spec/fixtures/beta_tester_account.rb

@@ -0,0 +1,33 @@
+module DataMapper
+  module Validate
+    module Fixtures
+      class BetaTesterAccount
+        #
+        # Behaviors
+        #
+
+        include ::DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,             Serial
+        property :full_name,      String, :auto_validation => false
+        property :email,          String, :auto_validation => false
+
+        property :user_agreement,    Boolean, :auto_validation => false
+        property :newsletter_signup, String,  :auto_validation => false
+        property :privacy_agreement, String,  :auto_validation => false
+
+        #
+        # Validations
+        #
+
+        validates_is_accepted :user_agreement, :allow_nil => false
+        validates_is_accepted :newsletter_signup
+        validates_is_accepted :privacy_agreement, :accept => %w(agreed accept), :message => "You must accept this agreement in order to proceed"
+      end # BetaTesterAccount
+    end
+  end
+end