ardm-validations 1.2.0

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

@@ -0,0 +1,182 @@
+module DataMapper
+  module Validations
+    # @author Guy van den Berg
+    # @since  0.9
+    class NumericalityValidator < GenericValidator
+
+      def call(target)
+        value = target.validation_property_value(field_name)
+        return true if optional?(value)
+
+        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 integer_only?
+        options[:only_integer] || options.fetch(:integer_only, false)
+      end
+
+      def value_as_string(value)
+        case value
+          # Avoid Scientific Notation in Float to_s
+          when Float      then value.to_d.to_s('F')
+          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?
+
+        # XXX: workaround for jruby. This is needed because the jruby
+        # compiler optimizes a bit too far with magic variables like $~.
+        # the value.send line sends $~. Inserting this line makes sure the
+        # jruby compiler does not optimise here.
+        # see http://jira.codehaus.org/browse/JRUBY-3765
+        $~ = nil if RUBY_PLATFORM[/java/]
+
+        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] || options[:greater_than], :greater_than, errors)
+      end
+
+      def validate_lt(value, errors)
+        validate_with_comparison(value, :<, options[:lt] || options[:less_than], :less_than, errors)
+      end
+
+      def validate_gte(value, errors)
+        validate_with_comparison(value, :>=, options[:gte] || options[:greater_than_or_equal_to], :greater_than_or_equal_to, errors)
+      end
+
+      def validate_lte(value, errors)
+        validate_with_comparison(value, :<=, options[:lte] || options[:less_than_or_equal_to], :less_than_or_equal_to, errors)
+      end
+
+      def validate_eq(value, errors)
+        eq = options[:eq] || options[:equal] || options[:equals] || options[:exactly] || options[:equal_to]
+        validate_with_comparison(value, :==, eq, :equal_to, errors)
+      end
+
+      def validate_ne(value, errors)
+        validate_with_comparison(value, :==, options[:ne] || options[:not_equal_to], :not_equal_to, errors, true)
+      end
+
+    end # class NumericalityValidator
+
+    module ValidatesNumericality
+      extend Deprecate
+
+      # Validate whether a field is numeric.
+      #
+      # @option [Boolean] :allow_nil
+      #   true if number can be nil, false if not.
+      #
+      # @option [Boolean] :allow_blank
+      #   true if number can be blank, false if not.
+      #
+      # @option [String] :message
+      #   Custom error message, also can be a callable object that takes
+      #   an object (for pure Ruby objects) or object and property
+      #   (for DM resources).
+      #
+      # @option [Numeric] :precision
+      #   Required precision of a value.
+      #
+      # @option [Numeric] :scale
+      #   Required scale of a value.
+      #
+      # @option [Numeric] :gte
+      #   'Greater than or equal to' requirement.
+      #
+      # @option [Numeric] :lte
+      #   'Less than or equal to' requirement.
+      #
+      # @option [Numeric] :lt
+      #   'Less than' requirement.
+      #
+      # @option [Numeric] :gt
+      #   'Greater than' requirement.
+      #
+      # @option [Numeric] :eq
+      #   'Equal' requirement.
+      #
+      # @option [Numeric] :ne
+      #   'Not equal' requirement.
+      #
+      # @option [Boolean] :integer_only
+      #   Use to restrict allowed values to integers.
+      #
+      def validates_numericality_of(*fields)
+        validators.add(NumericalityValidator, *fields)
+      end
+
+      deprecate :validates_is_number, :validates_numericality_of
+    end # module ValidatesIsNumber
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,58 @@
+module DataMapper
+  module Validations
+    # @author Dirkjan Bussink
+    # @since  0.9
+    class PrimitiveTypeValidator < GenericValidator
+
+      def call(target)
+        value    = target.validation_property_value(field_name)
+        property = get_resource_property(target, field_name)
+
+        return true if value.nil? || property.primitive?(value)
+
+        error_message = @options[:message] || default_error(property)
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+      protected
+
+      def default_error(property)
+        ValidationErrors.default_error_message(
+          :primitive,
+          field_name,
+          property.primitive
+        )
+      end
+
+    end # class PrimitiveTypeValidator
+
+    module ValidatesPrimitiveType
+      extend Deprecate
+
+      # Validates that the specified attribute is of the correct primitive
+      # type.
+      #
+      # @example Usage
+      #   require 'dm-validations'
+      #
+      #   class Person
+      #     include DataMapper::Resource
+      #
+      #     property :birth_date, Date
+      #
+      #     validates_primitive_type_of :birth_date
+      #
+      #     # a call to valid? will return false unless
+      #     # the birth_date is something that can be properly
+      #     # casted into a Date object.
+      #   end
+      def validates_primitive_type_of(*fields)
+        validators.add(PrimitiveTypeValidator, *fields)
+      end
+
+      deprecate :validates_is_primitive, :validates_primitive_type_of
+    end # module ValidatesPresent
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,83 @@
+module DataMapper
+  module Validations
+    # @author Guy van den Berg
+    # @since  0.9
+    class PresenceValidator < GenericValidator
+
+      def call(target)
+        value    = target.validation_property_value(field_name)
+        property = get_resource_property(target, field_name)
+        return true if present?(value, property)
+
+        error_message = @options[:message] || default_error(property)
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+      protected
+
+      # Boolean property types are considered present if non-nil.
+      # Other property types are considered present if non-blank.
+      # Non-properties are considered present if non-blank.
+      def present?(value, property)
+        boolean_type?(property) ? !value.nil? : !DataMapper::Ext.blank?(value)
+      end
+
+      def default_error(property)
+        actual = boolean_type?(property) ? :nil : :blank
+        ValidationErrors.default_error_message(actual, field_name)
+      end
+
+      # Is the property a boolean property?
+      #
+      # @return [Boolean]
+      #   Returns true for Boolean, ParanoidBoolean, TrueClass and other
+      #   properties. Returns false for other property types or for
+      #   non-properties.
+      def boolean_type?(property)
+        property ? property.primitive == TrueClass : false
+      end
+
+    end # class PresenceValidator
+
+    module ValidatesPresence
+      extend Deprecate
+
+      ##
+      # Validates that the specified attribute is present.
+      #
+      # For most property types "being present" is the same as being "not
+      # blank" as determined by the attribute's #blank? method. However, in
+      # the case of Boolean, "being present" means not nil; i.e. true or
+      # false.
+      #
+      # @note
+      #   dm-core's support lib adds the blank? method to many classes,
+      #
+      # @see lib/dm-core/support/blank.rb (dm-core) for more information.
+      #
+      # @example Usage
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :required_attribute, String
+      #     property :another_required, String
+      #     property :yet_again, String
+      #
+      #     validates_presence_of :required_attribute
+      #     validates_presence_of :another_required, :yet_again
+      #
+      #     # a call to valid? will return false unless
+      #     # all three attributes are !blank?
+      #   end
+      def validates_presence_of(*fields)
+        validators.add(PresenceValidator, *fields)
+      end
+
+      deprecate :validates_present, :validates_presence_of
+    end # module ValidatesPresent
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,67 @@
+module DataMapper
+  module Validations
+    # @author Guy van den Berg
+    # @since  0.9
+    class UniquenessValidator < GenericValidator
+
+      include DataMapper::Assertions
+
+      def initialize(field_name, options = {})
+        if options.has_key?(:scope)
+          assert_kind_of('scope', options[:scope], Array, Symbol)
+        end
+
+        super
+
+        set_optional_by_default
+      end
+
+      def call(target)
+        return true if valid?(target)
+
+        error_message = @options[:message] || ValidationErrors.default_error_message(:taken, field_name)
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+      def valid?(target)
+        value = target.validation_property_value(field_name)
+        return true if optional?(value)
+
+        opts = {
+          :fields    => target.model.key(target.repository.name),
+          field_name => value,
+        }
+
+        Array(@options[:scope]).each { |subject|
+          unless target.respond_to?(subject)
+            raise(ArgumentError,"Could not find property to scope by: #{subject}. Note that :unique does not currently support arbitrarily named groups, for that you should use :unique_index with an explicit validates_uniqueness_of.")
+          end
+
+          opts[subject] = target.__send__(subject)
+        }
+
+        resource = DataMapper.repository(target.repository.name) do
+          target.model.first(opts)
+        end
+
+        return true if resource.nil?
+        target.saved? && resource.key == target.key
+      end
+
+    end # class UniquenessValidator
+
+    module ValidatesUniqueness
+      extend Deprecate
+
+      # Validate the uniqueness of a field
+      #
+      def validates_uniqueness_of(*fields)
+        validators.add(UniquenessValidator, *fields)
+      end
+
+      deprecate :validates_is_unique, :validates_uniqueness_of
+    end # module ValidatesIsUnique
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,74 @@
+module DataMapper
+  module Validations
+    # @author Guy van den Berg
+    # @since  0.9
+    class WithinValidator < GenericValidator
+
+      def initialize(field_name, options={})
+        super
+
+        @options[:set] = [] unless @options.has_key?(:set)
+      end
+
+      def call(target)
+        value = target.validation_property_value(field_name)
+        return true if optional?(value)
+        return true if @options[:set].include?(value)
+
+        n = 1.0/0
+        set = @options[:set]
+        msg = @options[:message]
+
+        if set.is_a?(Range)
+          if set.first != -n && set.last != n
+            error_message = msg || ValidationErrors.default_error_message(:value_between, field_name, set.first, set.last)
+          elsif set.first == -n
+            error_message = msg || ValidationErrors.default_error_message(:less_than_or_equal_to, field_name, set.last)
+          elsif set.last == n
+            error_message = msg || ValidationErrors.default_error_message(:greater_than_or_equal_to, field_name, set.first)
+          end
+        else
+          error_message = msg || ValidationErrors.default_error_message(:inclusion, field_name, set.to_a.join(', '))
+        end
+
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+
+    end # class WithinValidator
+
+    module ValidatesWithin
+      ##
+      # Validates that the value of a field is within a range/set.
+      #
+      # This validation is defined by passing a field along with a :set
+      # parameter. The :set can be a Range or any object which responds
+      # to the #include? method (an array, for example).
+      #
+      # @example Usage
+      #   require 'dm-validations'
+      #
+      #   class Review
+      #     include DataMapper::Resource
+      #
+      #     STATES = ['new', 'in_progress', 'published', 'archived']
+      #
+      #     property :title, String
+      #     property :body, String
+      #     property :review_state, String
+      #     property :rating, Integer
+      #
+      #     validates_within :review_state, :set => STATES
+      #     validates_within :rating,       :set => 1..5
+      #
+      #     # a call to valid? will return false unless
+      #     # the two properties conform to their sets
+      #   end
+      def validates_within(*fields)
+        validators.add(WithinValidator, *fields)
+      end
+    end # module ValidatesWithin
+  end # module Validations
+end # module DataMapper