mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/method_validator.rb

@@ -0,0 +1,68 @@
+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) if !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/gems/dm-validations-0.9.7/lib/dm-validations/numeric_validator.rb

@@ -0,0 +1,83 @@
+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 ||= '%s must be an integer'.t(Extlib::Inflection.humanize(@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 ||= '%s must be a number'.t(Extlib::Inflection.humanize(@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/lib/gems/dm-validations-0.9.7/lib/dm-validations/primitive_validator.rb

@@ -0,0 +1,60 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @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)
+        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)
+        add_error(target, error_message, @field_name)
+
+        false
+      end
+
+      protected
+
+      def default_error(property)
+        "%s must be of type %s".t(Extlib::Inflection.humanize(@field_name), property.primitive)
+      end
+
+    end # class PrimitiveValidator
+
+    module ValidatesIsPrimitive
+
+      ##
+      # 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_is_primitive :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_is_primitive(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::PrimitiveValidator)
+      end
+
+    end # module ValidatesPresent
+  end # module Validate
+end # module DataMapper

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/required_field_validator.rb

@@ -0,0 +1,88 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @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)
+        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? : !value.blank?
+      end
+
+      def default_error(property)
+        actual = boolean_type?(property) ? "nil".t : "blank".t
+        "%s must not be %s".t(Extlib::Inflection.humanize(@field_name), actual)
+      end
+
+      # Is +property+ a boolean property?
+      #
+      # Returns true for Boolean, ParanoidBoolean, TrueClass, etc. properties.
+      # Returns false for other property types.
+      # Returns false for non-properties.
+      def boolean_type?(property)
+        property ? property.primitive == TrueClass : false
+      end
+
+    end # class RequiredFieldValidator
+
+    module ValidatesPresent
+
+      ##
+      # 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_present :required_attribute
+      #     validates_present :another_required, :yet_again
+      #
+      #     # a call to valid? will return false unless
+      #     # all three attributes are !blank?
+      #   end
+      def validates_present(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::RequiredFieldValidator)
+      end
+
+    end # module ValidatesPresent
+  end # module Validate
+end # module DataMapper

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

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

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/uniqueness_validator.rb

@@ -0,0 +1,64 @@
+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 = {
+          :fields    => target.model.key,
+          field_name => target.validation_property_value(field_name)
+        }
+
+        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
+
+        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 !target.new_record? && 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/gems/dm-validations-0.9.7/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/gems/dm-validations-0.9.7/lib/dm-validations/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Validations
+    VERSION = "0.9.7"
+  end
+end

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/within_validator.rb

@@ -0,0 +1,53 @@
+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
+
+        field_name = Extlib::Inflection.humanize(@field_name)
+        if @options[:set].is_a?(Range)
+          if @options[:set].first != -n && @options[:set].last != n
+            error_message = @options[:message] || "%s must be between %s and %s".t(field_name, @options[:set].first, @options[:set].last)
+          elsif @options[:set].first == -n
+            error_message = @options[:message] || "%s must be less than %s".t(field_name, @options[:set].last)
+          elsif @options[:set].last == n
+            error_message = @options[:message] || "%s must be greater than %s".t(field_name, @options[:set].first)
+          end
+        else
+          error_message = "%s must be one of [%s]".t(field_name, @options[:set].join(', '))
+        end
+
+        add_error(target, error_message , @field_name)
+        return false
+      end
+
+      def n
+        1.0/0
+      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