sbf-dm-validations 1.3.0.beta

data/lib/data_mapper/validation/message_transformer.rb

@@ -0,0 +1,111 @@
+module DataMapper
+  module Validation
+    # Transforms Violations to error message strings.
+    #
+    # @abstract
+    #   Subclass and override {#transform} to implement a custom message
+    #   transformer. Use {Violation.message_transformer=} to set a new
+    #   message transformer or pass the transformer to {Violation#message}.
+    class MessageTransformer
+
+      # Transforms the specified Violation to an error message string.
+      #
+      # @param [Violation] violation
+      #   The Violation to transform.
+      #
+      # @return [String]
+      #   The transformed message.
+      #
+      # @raise [ArgumentError]
+      #   +violation+ is +nil+.
+      def transform(violation)
+        raise NotImplementedError, "#{self.class}#transform must be implemented"
+      end
+
+
+      class Default < self
+        @error_messages = {
+          :absent                   => '%s must be absent',
+          :inclusion                => '%s must be one of %s',
+          :invalid                  => '%s has an invalid format',
+          :confirmation             => '%s does not match the confirmation',
+          :accepted                 => '%s is not accepted',
+          :nil                      => '%s must not be nil',
+          :blank                    => '%s must not be blank',
+          :length_between           => '%s must be between %s and %s characters long',
+          :too_long                 => '%s must be at most %s characters long',
+          :too_short                => '%s must be at least %s characters long',
+          :wrong_length             => '%s must be %s characters long',
+          :taken                    => '%s is already taken',
+          :not_a_number             => '%s must be a number',
+          :not_an_integer           => '%s must be an integer',
+          :greater_than             => '%s must be greater than %s',
+          :greater_than_or_equal_to => '%s must be greater than or equal to %s',
+          :equal_to                 => '%s must be equal to %s',
+          :not_equal_to             => '%s must not be equal to %s',
+          :less_than                => '%s must be less than %s',
+          :less_than_or_equal_to    => '%s must be less than or equal to %s',
+          :value_between            => '%s must be between %s and %s',
+          :primitive                => '%s must be of type %s'
+        }
+
+        class << self
+          # Gets the hash of error messages used to transform violations.
+          #
+          # @return [Hash{Symbol=>String}]
+          attr_reader :error_messages
+        end
+
+        # Merges the specified +error_messages+ hash into the internal hash of
+        # error messages.
+        #
+        # @param [Hash{Symbol=>String}] error_messages
+        #   The error messages to be merged.
+        def self.error_messages=(error_messages)
+          unless error_messages.is_a?(Hash)
+            raise ArgumentError, "+error_messages+ must be a hash"
+          end
+
+          self.error_messages.merge!(error_messages)
+        end
+
+        def self.error_message(violation_type, attribute_name, violation_values)
+          if message = self.error_messages[violation_type]
+            attribute_name = DataMapper::Inflector.humanize(attribute_name)
+            message % [attribute_name, *violation_values].flatten
+          else
+            violation_type.to_s
+          end
+        end
+
+        def transform(violation)
+          raise ArgumentError, "+violation+ must be specified" if violation.nil?
+
+          attribute_name = violation.attribute_name
+
+          self.class.error_message(violation.type, attribute_name, violation.values)
+        end
+      end # class Default
+
+      class DefaultI18n < self
+        def transform(violation)
+          raise ArgumentError, "+violation+ must be specified" if violation.nil?
+
+          resource       = violation.resource
+          model_name     = resource.model.model_name
+          attribute_name = violation.attribute_name
+
+          options = {
+            :model     => ::I18n.translate("models.#{model_name}"),
+            :attribute => ::I18n.translate("attributes.#{model_name}.#{attribute_name}"),
+            :value     => resource.validation_property_value(attribute_name)
+          }.merge(violation.info)
+
+          ::I18n.translate("errors.#{violation.type}", options)
+        end
+      end # class I18n
+
+    end # class MessageTransformer
+
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/model_extensions.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  module Validation
+    module ModelExtensions
+
+      # @api public
+      def create(attributes = {}, *args)
+        resource = new(attributes)
+        resource.save(*args)
+        resource
+      end
+
+    end # module ModelExtensions
+  end # module Validation
+
+  Model.append_extensions Validation::ModelExtensions
+
+end # module DataMapper

data/lib/data_mapper/validation/resource_extensions.rb

@@ -0,0 +1,131 @@
+require 'data_mapper/core'
+require 'data_mapper/validation'
+require 'data_mapper/validation/context'
+
+module DataMapper
+  module Validation
+
+    module ResourceExtensions
+
+      # TODO: contemplate reworking dm-core to allow hooks to be fired even if
+      #   the hooked event does not transpire (eg., `before :save` when clean)
+      # def self.included(model)
+      #   model.before :save, :validate_or_halt
+      # end
+
+      # Ensures the object is valid for the context provided, and otherwise
+      # throws :halt and returns false.
+      #
+      # @param [Symbol] context
+      #   context for which to validate the Resource, defaulting to
+      #   #default_validation_context
+      #
+      # @return [Boolean]
+      #   whether the Resource was persisted successfully
+      #
+      # TODO: fix this to not change the method signature of #save
+      # TODO: add support for skipping validations by passing nil
+      #
+      # @api public
+      def save(context_name = default_validation_context)
+        validation_rules.assert_valid_context(context_name)
+
+        Context.in_context(context_name) { super() }
+      end
+
+      # @api private
+      def save_self(*)
+        return super unless dirty_self? || new?
+        if Context.any? && !valid?(validation_rules.current_context)
+          false
+        else
+          super
+        end
+      end
+
+      # Ensures the object is valid for the context provided, and otherwise
+      # throws :halt and returns false.
+      #
+      # @param [Hash] attributes
+      #   attribute names and values which will be set on this Resource
+      # @param [Symbol] context
+      #   context for which to validate the Resource, defaulting to
+      #   #default_validation_context
+      #
+      # @return [Boolean]
+      #   whether the Resource attributes were set and persisted successfully
+      #
+      # TODO: fix this to not change the method signature of #update
+      #
+      # @api public
+      def update(attributes = {}, context_name = default_validation_context)
+        validation_rules.assert_valid_context(context_name)
+
+        Context.in_context(context_name) { super(attributes) }
+      end
+
+      # @api public
+      def validate(context_name = default_validation_context)
+        super
+        #validate_parents  # if model.validation_rules.validate_parents?
+        #validate_children # if model.validation_rules.validate_children?
+
+        self
+      end
+
+    private
+
+      # @api private
+      def validate_parents
+        parent_relationships.each do |relationship|
+          next unless relationship.loaded?(self)
+          validate_parent_relationship(relationship)
+        end
+      end
+
+      # @api private
+      def validate_children
+        child_relationships.each do |relationship|
+          next unless relationship.loaded?(self)
+          validate_child_relationship(relationship)
+        end
+      end
+
+      # @api private
+      def validate_parent_relationship(relationship)
+        relationship_name = relationship.name
+        parent_model      = relationship.target_model
+        context_name      = parent_model.validation_rules.current_context
+        parent_resource   = relationship.get(self)
+
+        parent_violations = parent_resource.validation_violations(context_name)
+        parent_violations.each { |v| errors[relationship_name] << v }
+      end
+
+      # @api private
+      def validate_child_relationship(relationship)
+        relationship_name = relationship.name
+        child_model       = relationship.target_model
+        context_name      = child_model.validation_rules.current_context
+        child_collection  = relationship.get_collection(self)
+
+        child_collection.each do |child_resource|
+          child_violations = child_resource.validation_violations(context_name)
+          child_violations.each { |v| errors[relationship_name] << v }
+        end
+      end
+
+      # @see note at self.included, above
+      #
+      # @api private
+      # def validate_or_halt
+      #   throw :halt if Context.any? && !valid?(validation_rules.current_context)
+      # end
+
+    end # module Resource
+  end # module Validation
+
+  Model.append_inclusions Validation
+  Model.append_inclusions Validation::ResourceExtensions
+
+end

data/lib/data_mapper/validation/rule/absence.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'data_mapper/validation/rule'
+
+module DataMapper
+  module Validation
+    class Rule
+
+      class Absence < Rule
+
+        def initialize(attribute_name, options = {})
+          super
+
+          @allow_nil   = false
+          @allow_blank = false
+        end
+
+        def valid?(resource)
+          value = resource.validation_property_value(attribute_name)
+          DataMapper::Ext.blank?(value)
+        end
+
+        def violation_type(resource)
+          :absent
+        end
+
+      end # class Absence
+
+    end # class Rule
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/rule/acceptance.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+require 'data_mapper/validation/rule'
+
+module DataMapper
+  module Validation
+    class Rule
+
+      # TODO: update this to inherit from Rule::Within::Set
+      class Acceptance < Rule
+
+        EQUALIZE_ON = superclass::EQUALIZE_ON.dup << :accept
+
+        equalize *EQUALIZE_ON
+
+        DEFAULT_ACCEPTED_VALUES = [ '1', 1, 'true', true, 't' ]
+
+        attr_reader :accept
+
+        def initialize(attribute_name, options = {})
+          super
+
+          @accept = Array(options.fetch(:accept, DEFAULT_ACCEPTED_VALUES))
+
+          allow_nil! unless defined?(@allow_nil)
+        end
+
+        def valid?(resource)
+          value = resource.validation_property_value(attribute_name)
+          return true if exempt_value?(value)
+          accept.include?(value)
+        end
+
+        def violation_type(resource)
+          :accepted
+        end
+
+      private
+
+        # TODO: isn't this superfluous considering Rule#optional?
+        def exempt_value?(value)
+          allow_nil? && value.nil?
+        end
+
+      end # class Acceptance
+
+    end # class Rule
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/rule/block.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'data_mapper/validation/rule'
+
+module DataMapper
+  module Validation
+    class Rule
+
+      class Block < Rule
+
+        attr_reader :block
+
+        def initialize(attribute_name, options, &block)
+          unless block_given?
+            raise ArgumentError, 'cannot initialize a Block validator without a block'
+          end
+
+          super
+
+          @block = block
+        end
+
+        def validate(resource)
+          result, error_message = resource.instance_eval(&self.block)
+
+          if result
+            nil
+          else
+            Violation.new(resource, error_message, self)
+          end
+        end
+
+      end # class Block
+
+    end # class Rule
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/rule/confirmation.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'data_mapper/validation/rule'
+
+module DataMapper
+  module Validation
+    class Rule
+
+      class Confirmation < Rule
+
+        EQUALIZE_ON = superclass::EQUALIZE_ON.dup << :confirmation_attribute
+
+        attr_reader :confirmation_attribute
+
+
+        def initialize(attribute_name, options = {})
+          super
+
+          @confirm_attribute_name = options.fetch(:confirm) do
+            :"#{attribute_name}_confirmation"
+          end
+
+          allow_nil!   unless defined?(@allow_nil)
+          allow_blank! unless defined?(@allow_blank)
+        end
+
+        def valid?(resource)
+          value = resource.validation_property_value(attribute_name)
+          return true if optional?(value)
+
+          if resource.model.properties.named?(attribute_name)
+            return true unless resource.attribute_dirty?(attribute_name)
+          end
+
+          confirm_value = resource.instance_variable_get("@#{@confirm_attribute_name}")
+          value == confirm_value
+        end
+
+        def violation_type(resource)
+          :confirmation
+        end
+
+      end # class Confirmation
+
+    end # class Rule
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/rule/format/proc.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+require 'data_mapper/validation/rule/format'
+
+module DataMapper
+  module Validation
+    class Rule
+      module Format
+
+        class Proc < Rule
+
+          include Format
+
+          EQUALIZE_ON = superclass::EQUALIZE_ON.dup << :format
+
+          equalize *EQUALIZE_ON
+
+
+          def valid?(resource)
+            value = resource.validation_property_value(attribute_name)
+            return true if optional?(value)
+
+            self.format.call(value)
+          # rescue ::Encoding::CompatibilityError
+          #   # This is to work around a bug in jruby - see formats/email.rb
+          #   false
+          end
+
+        end # class Proc
+
+      end # module Format
+    end # class Rule
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/rule/format/regexp.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'data_mapper/validation/rule/format'
+
+module DataMapper
+  module Validation
+    class Rule
+      module Format
+
+        class Regexp < Rule
+
+          include Format
+
+          EQUALIZE_ON = superclass::EQUALIZE_ON.dup << :format << :format_name
+
+          equalize *EQUALIZE_ON
+
+
+          attr_reader :format_name
+
+          def initialize(attribute_name, options = {})
+            super
+
+            @format_name = options.fetch(:format_name, nil)
+          end
+
+          def valid?(resource)
+            value = resource.validation_property_value(attribute_name)
+            return true if optional?(value)
+
+            value ? value.to_s =~ self.format : false
+          rescue ::Encoding::CompatibilityError
+            # This is to work around a bug in jruby - see formats/email.rb
+            false
+          end
+
+          # TODO: integrate format into error message key?
+          # def error_message_args
+          #   if format_name.is_a?(Symbol)
+          #     [ :"invalid_#{format_name}", attribute_name ]
+          #   else
+          #     [ :invalid, attribute_name ]
+          #   end
+          # end
+
+        end # class Regexp
+
+      end # module Format
+    end # class Rule
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/rule/format.rb

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+require 'data_mapper/validation/rule'
+
+require 'data_mapper/validation/rule/formats/email'
+require 'data_mapper/validation/rule/formats/url'
+
+module DataMapper
+  module Validation
+    class UnknownValidationFormat < ::ArgumentError; end
+
+    class Rule
+
+      module Format
+
+        FORMATS = {
+          :email_address => Formats::EmailAddress,
+          :url           => Formats::Url
+        }
+        # TODO: evaluate re-implementing custom error messages per format type
+        # previously these strings were wrapped in lambdas, which were, at one
+        # point, invoked with #try_call with the humanized attribute name and value
+        FORMAT_MESSAGES = {
+          :email_address => '%s is not a valid email address',
+          :url           => '%s is not a valid URL',
+        }
+
+
+        def self.rules_for(attribute_name, options)
+          Array(new(attribute_name, options))
+        end
+
+        # @raise [UnknownValidationFormat]
+        #   if the :as (or :with) option is a Symbol that is not a key in FORMATS,
+        #   or if the provided format is not a Regexp, Symbol or Proc
+        def self.new(attribute_name, options)
+          format = options.delete(:as) || options.delete(:with)
+
+          case format
+          when Symbol
+            regexp = FORMATS.fetch(format) do
+              raise UnknownValidationFormat, "No such predefined format '#{format}'"
+            end
+            self::Regexp.new(attribute_name, options.merge(:format => regexp, :format_name => format))
+          when ::Regexp
+            self::Regexp.new(attribute_name, options.merge(:format => format))
+          when ::Proc
+            self::Proc.new(attribute_name, options.merge(:format => format))
+          else
+            raise UnknownValidationFormat, "Expected a Regexp, Symbol, or Proc format. Got: #{format.inspect}"
+          end
+        end
+
+
+        attr_reader :format
+
+        def initialize(attribute_name, options)
+          super
+
+          @format = options.fetch(:format)
+
+          allow_nil!   unless defined?(@allow_nil)
+          allow_blank! unless defined?(@allow_blank)
+        end
+
+        def violation_type(resource)
+          :invalid
+        end
+
+        # TODO: integrate format into error message key?
+        # def error_message_args
+        #   if format.is_a?(Symbol)
+        #     [ :"invalid_#{format}", attribute_name ]
+        #   else
+        #     [ :invalid, attribute_name ]
+        #   end
+        # end
+
+      end # class Format
+
+    end # class Rule
+  end # module Validation
+end # module DataMapper
+
+require 'data_mapper/validation/rule/format/proc'
+require 'data_mapper/validation/rule/format/regexp'

data/lib/data_mapper/validation/rule/formats/email.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+module DataMapper
+  module Validation
+    class Rule
+      module Formats
+
+        # Almost RFC2822 (No attribution reference available).
+        #
+        # This differs in that it does not allow local domains (test@localhost).
+        # 99% of the time you do not want to allow these email addresses
+        # in a public web application.
+        EmailAddress = begin
+          if (RUBY_VERSION == '1.9.2' && RUBY_ENGINE == 'jruby' && JRUBY_VERSION <= '1.6.3') || RUBY_VERSION == '1.9.3'
+            # There is an obscure bug in jruby 1.6 that prevents matching
+            # on unicode properties here. Remove this logic branch once
+            # a stable jruby release fixes this.
+            #
+            # http://jira.codehaus.org/browse/JRUBY-5622
+            #
+            # There is a similar bug in preview releases of 1.9.3
+            #
+            # http://redmine.ruby-lang.org/issues/5126
+            letter = 'a-zA-Z'
+          else
+            letter = 'a-zA-Z\p{L}'  # Changed from RFC2822 to include unicode chars
+          end
+          digit          = '0-9'
+          atext          = "[#{letter}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+          dot_atom_text  = "#{atext}+([.]#{atext}*)+"
+          dot_atom       = dot_atom_text
+          no_ws_ctl      = '\x01-\x08\x11\x12\x14-\x1f\x7f'
+          qtext          = "[^#{no_ws_ctl}\\x0d\\x22\\x5c]"  # Non-whitespace, non-control character except for \ and "
+          text           = '[\x01-\x09\x11\x12\x14-\x7f]'
+          quoted_pair    = "(\\x5c#{text})"
+          qcontent       = "(?:#{qtext}|#{quoted_pair})"
+          quoted_string  = "[\"]#{qcontent}+[\"]"
+          atom           = "#{atext}+"
+          word           = "(?:#{atom}|#{quoted_string})"
+          obs_local_part = "#{word}([.]#{word})*"
+          local_part     = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+          dtext          = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+          dcontent       = "(?:#{dtext}|#{quoted_pair})"
+          domain_literal = "\\[#{dcontent}+\\]"
+          obs_domain     = "#{atom}([.]#{atom})+"
+          domain         = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+          addr_spec      = "#{local_part}\@#{domain}"
+          pattern        = /\A#{addr_spec}\z/u
+        end
+
+      end # module Formats
+    end # class Rule
+  end # module Validation
+end # module DataMapper

data/lib/data_mapper/validation/rule/formats/url.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module DataMapper
+  module Validation
+    class Rule
+      module Formats
+
+        Url = %r{\Ahttps?://[a-z\d](?:[-.]?[a-z\d])*\.[a-z]{2,6}(?::\d{1,5})?/?.*\z}ix.freeze
+
+      end # module Formats
+    end # class Rule
+  end # module Validation
+end # module DataMapper