dm-validations 1.0.2 → 1.1.0.rc1

data/lib/dm-validations.rb

@@ -1,43 +1,48 @@
 require 'dm-core'
 
 begin
-
+  # We need array for extract_options! which attr_accessors uses, at least in AS
+  # 2.3.3.
+  require 'active_support/core_ext/array'
   require 'active_support/core_ext/class/attribute_accessors'
-  require 'active_support/core_ext/object/blank'
-  require 'active_support/ordered_hash'
-
-  class Object
-    # If receiver is callable, calls it and
-    # returns result. If not, just returns receiver
-    # itself
-    #
-    # @return [Object]
-    def try_call(*args)
-      if self.respond_to?(:call)
-        self.call(*args)
-      else
-        self
-      end
-    end
-  end
+rescue LoadError
+  require 'extlib/class'
+end
 
+begin
+  require 'active_support/core_ext/object/blank'
 rescue LoadError
+  require 'extlib/blank'
+end
 
-  require 'extlib/class'
+begin
+  require 'active_support/ordered_hash'
+rescue LoadError
   require 'extlib/dictionary'
-  require 'extlib/blank'
-  require 'extlib/try_dup'
-  require 'extlib/object'
 
-  module ActiveSupport
-    OrderedHash = Dictionary
+  module ::ActiveSupport
+    OrderedHash = ::Dictionary
   end
+end
 
+class Object
+  # If receiver is callable, calls it and
+  # returns result. If not, just returns receiver
+  # itself
+  #
+  # @return [Object]
+  def try_call(*args)
+    if self.respond_to?(:call)
+      self.call(*args)
+    else
+      self
+    end
+  end
 end
 
 module DataMapper
   class Property
-    def self.new(model, name, options = {}, type = nil)
+    def self.new(model, name, options = {})
       property = super
       property.model.auto_generate_validations(property)
 
@@ -77,16 +82,6 @@ module DataMapper
     extend Chainable
 
     def self.included(model)
-      model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.create(attributes = {}, *args)
-          resource = new(attributes)
-          resource.save(*args)
-          resource
-        end
-      RUBY
-
-      # models that are non DM resources must get .validators
-      # and other methods, too
       model.extend ClassMethods
     end
 
@@ -181,6 +176,12 @@ module DataMapper
         end
       end
 
+      def create(attributes = {}, *args)
+        resource = new(attributes)
+        resource.save(*args)
+        resource
+      end
+
       private
 
       # Clean up the argument list and return a opts hash, including the

data/lib/dm-validations/auto_validate.rb

@@ -130,11 +130,16 @@ module DataMapper
       end
 
       def infer_length_validation_for(property, options)
-        return unless [ DataMapper::Property::String, DataMapper::Property::Text ].include?(property.class)
+        return unless [ DataMapper::Property::String, DataMapper::Property::Text ].any? { |klass| property.kind_of?(klass) }
 
-        case length = property.options.fetch(:length, DataMapper::Property::String::DEFAULT_LENGTH)
-          when Range then options[:within]  = length
-          else            options[:maximum] = length
+        length = property.options.fetch(:length, DataMapper::Property::String::DEFAULT_LENGTH)
+
+
+        if length.is_a?(Range)
+          raise ArgumentError, "Infinity is no valid upper bound for a length range" if length.last == Infinity
+          options[:within]  = length
+        else
+          options[:maximum] = length
         end
 
         validates_length_of property.name, options_with_message(options, property, :length)
@@ -170,7 +175,7 @@ module DataMapper
       end
 
       def infer_type_validation_for(property, options)
-        return if property.custom?
+        return if property.respond_to?(:custom?) && property.custom?
 
         if property.kind_of?(Property::Numeric)
           options[:gte] = property.min if property.min

data/lib/dm-validations/contextual_validators.rb

@@ -43,7 +43,9 @@ module DataMapper
         contexts.clear
       end
 
-      # Execute all validators in the named context against the target
+      # Execute all validators in the named context against the target.  Load
+      # together any properties that are designated lazy but are not yet loaded.
+      # Optionally only validate dirty properties.
       #
       # @param [Symbol]
       #   named_context the context we are validating against
@@ -54,9 +56,44 @@ module DataMapper
       def execute(named_context, target)
         target.errors.clear!
 
-        context(named_context).map do |validator|
-          validator.execute?(target) ? validator.call(target) : true
-        end.all?
+        runnable_validators = context(named_context).select{ |validator| validator.execute?(target) }
+        validators = runnable_validators.dup
+
+        # By default we start the list with the full set of runnable validators.
+        #
+        # In the case of a new Resource or regular ruby class instance,
+        # everything needs to be validated completely, and no eager-loading
+        # logic should apply.
+        #
+        # In the case of a DM::Resource that isn't new, we optimize:
+        #
+        #   1. Eager-load all lazy, not-yet-loaded properties that need
+        #      validation, all at once.
+        #
+        #   2. Limit run validators to
+        #      - those applied to dirty attributes only,
+        #      - those that should always run (presence/absence)
+        #      - those that don't reference any real properties (field-less
+        #        block validators)
+
+        if target.kind_of?(DataMapper::Resource) and !target.new?
+          dirty_attrs = target.dirty_attributes.keys.map{ |p| p.name }
+          validators  = runnable_validators.select{ |v| dirty_attrs.include?(v.field_name) }
+
+          # Load all lazy, not-yet-loaded properties that need validation, all at once.
+          fields_to_load = validators.map{ |v| target.class.properties[v.field_name] }.select{ |p| p.lazy? && !p.loaded?(target) }
+          target.__send__(:eager_load, fields_to_load)
+
+          # Finally include any validators that should always run or don't
+          # reference any real properties (field-less block vaildators).
+          validators |= runnable_validators.select do |v|
+            [ MethodValidator, PresenceValidator, AbsenceValidator ].any? do |klass|
+              v.kind_of?(klass)
+            end
+          end
+        end
+
+        validators.map { |validator| validator.call(target) }.all?
       end
 
     end # module ContextualValidators

data/lib/dm-validations/formats/email.rb

@@ -1,4 +1,4 @@
-# encoding: binary
+# encoding: UTF-8
 
 module DataMapper
   module Validations
@@ -11,14 +11,19 @@ module DataMapper
           )
         end
 
-        # RFC2822 (No attribution reference available)
+        # 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
-            alpha = "a-zA-Z"
+            alpha = "a-zA-Z\\p{Lu}\\p{Ll}" # Alpha characters, changed from RFC2822 to include unicode chars
             digit = "0-9"
             atext = "[#{alpha}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
-            dot_atom_text = "#{atext}+([.]#{atext}*)*"
+            dot_atom_text = "#{atext}+([.]#{atext}*)+" # Last char changed from * to +
             dot_atom = "#{dot_atom_text}"
-            qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+            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})"
@@ -27,14 +32,13 @@ module DataMapper
             word = "(?:#{atom}|#{quoted_string})"
             obs_local_part = "#{word}([.]#{word})*"
             local_part = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
-            no_ws_ctl = "\\x01-\\x08\\x11\\x12\\x14-\\x1f\\x7f"
             dtext = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
             dcontent = "(?:#{dtext}|#{quoted_pair})"
             domain_literal = "\\[#{dcontent}+\\]"
-            obs_domain = "#{atom}([.]#{atom})*"
+            obs_domain = "#{atom}([.]#{atom})+" # Last char changed from * to +
             domain = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
             addr_spec = "#{local_part}\@#{domain}"
-            pattern = /^#{addr_spec}$/
+            pattern = /^#{addr_spec}$/u
         end
 
       end # module Email

data/lib/dm-validations/validation_errors.rb

@@ -109,6 +109,10 @@ module DataMapper
         errors.send(meth, *args, &block)
       end
 
+      def respond_to?(method)
+        super || errors.respond_to?(method)
+      end
+
       def [](property_name)
         if property_errors = errors[property_name.to_sym]
           property_errors

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

@@ -32,6 +32,10 @@ module DataMapper
         return true if allow_nil?(value)
         @options[:accept].include?(value)
       end
+
+      def allow_nil?(value)
+        @options[:allow_nil] && value.nil?
+      end
     end # class AcceptanceValidator
 
     module ValidatesAcceptance

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

@@ -1,8 +1,8 @@
 #require File.dirname(__FILE__) + '/formats/email'
 
 require 'pathname'
-require Pathname(__FILE__).dirname.expand_path + ".." + 'formats/email'
-require Pathname(__FILE__).dirname.expand_path + ".." + 'formats/url'
+require 'dm-validations/formats/email'
+require 'dm-validations/formats/url'
 
 module DataMapper
   module Validations
@@ -70,7 +70,7 @@ module DataMapper
       # @option :as<Format, Proc, Regexp>   the pre-defined format, Proc or Regexp to validate against
       # @option :with<Format, Proc, Regexp> an alias for :as
       #
-      #   :email_address (format is specified in DataMapper::Validations::Format::Email)
+      #   :email_address (format is specified in DataMapper::Validations::Format::Email - note that unicode emails will *not* be matched under MRI1.8.7)
       #   :url (format is specified in DataMapper::Validations::Format::Url)
       #
       # @example [Usage]

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

@@ -90,30 +90,18 @@ module DataMapper
         end
       end
 
-      # Test the value to see if it is blank or nil, and if it is allowed
+      # Test the value to see if it is blank or nil, and if it is allowed.
+      # Note that allowing blank without explicitly denying nil allows nil
+      # values, since nil.blank? is true.
       #
       # @param <Object> value to test
       # @return <Boolean> true if blank/nil is allowed, and the value is blank/nil
       def optional?(value)
-        return allow_nil?(value)   if value.nil?
-        return allow_blank?(value) if value.blank?
-        false
-      end
-
-      # Test if the value is nil and is allowed
-      #
-      # @param <Object> value to test
-      # @return <Boolean> true if nil is allowed and value is nil
-      def allow_nil?(value)
-        @options[:allow_nil] if value.nil?
-      end
-
-      # Test if the value is blank and is allowed
-      #
-      # @param <Object> value to test
-      # @return <Boolean> true if blank is allowed and value is blank
-      def allow_blank?(value)
-        @options[:allow_blank] if value.blank?
+        if value.nil?
+          @options[:allow_nil] || (@options[:allow_blank] && !@options.has_key?(:allow_nil))
+        elsif value.blank?
+          @options[:allow_blank]
+        end
       end
 
       # Returns true if validators are equal

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

@@ -94,7 +94,13 @@ module DataMapper
       #
       # @api private
       def value_length(value)
-        value.to_str.split(//u).size
+        value.to_str.length
+      end
+
+      if RUBY_VERSION < '1.9'
+        def value_length(value)
+          value.to_str.scan(/./u).size
+        end
       end
 
       # Validate the value length is equal to the expected length

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

@@ -29,11 +29,17 @@ module DataMapper
         return true if optional?(value)
 
         opts = {
-          :fields    => target.model.key,
+          :fields    => target.model.key(target.repository.name),
           field_name => value,
         }
 
-        Array(@options[:scope]).each { |subject| opts[subject] = target.__send__(subject) }
+        Array(@options[:scope]).each {|subject|
+          if target.respond_to?(subject)
+            opts[subject] = target.__send__(subject)
+          else
+            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
+        }
 
         resource = DataMapper.repository(target.repository.name) { target.model.first(opts) }
 

data/spec/fixtures/mittelschnauzer.rb

@@ -1,6 +1,7 @@
 module DataMapper
   module Validations
     module Fixtures
+      # Mittelschauzer is a type of dog. The More You Know.
       class Mittelschnauzer
 
         #

data/spec/integration/automatic_validation/inferred_boolean_properties_validation_spec.rb

@@ -6,57 +6,55 @@ describe "A model with a Boolean property" do
     @model = HasNullableBoolean.new(:id => 1)
   end
 
-  describe "assigned to true" do
+  describe "assigned a true" do
     before :all do
-      @model.set(:bool => true)
+      @model.bool = true
     end
 
     it_should_behave_like "valid model"
   end
 
-  describe "assigned to false" do
+  describe "assigned a false" do
     before :all do
-      @model.set(:bool => false)
+      @model.bool = false
     end
 
     it_should_behave_like "valid model"
   end
 
-  describe "assigned to a nil" do
+  describe "assigned a nil" do
     before :all do
-      @model.set(:bool => nil)
+      @model.bool = nil
     end
 
     it_should_behave_like "valid model"
   end
 end
 
-
-
 describe "A model with a required Boolean property" do
   before :all do
-    @model = HasNotNullableBoolean.new(:id => 1)
+    @model = HasRequiredBoolean.new(:id => 1)
   end
 
-  describe "assigned to true" do
+  describe "assigned a true" do
     before :all do
-      @model.set(:bool => true)
+      @model.bool = true
     end
 
     it_should_behave_like "valid model"
   end
 
-  describe "assigned to false" do
+  describe "assigned a false" do
     before :all do
-      @model.set(:bool => false)
+      @model.bool = false
     end
 
     it_should_behave_like "valid model"
   end
 
-  describe "assigned to a nil" do
+  describe "assigned a nil" do
     before :all do
-      @model.set(:bool => nil)
+      @model.bool = nil
     end
 
     it_should_behave_like "invalid model"
@@ -67,32 +65,30 @@ describe "A model with a required Boolean property" do
   end
 end
 
-
-
 describe "A model with a required paranoid Boolean property" do
   before :all do
-    @model = HasNotNullableParanoidBoolean.new(:id => 1)
+    @model = HasRequiredParanoidBoolean.new(:id => 1)
   end
 
-  describe "assigned to true" do
+  describe "assigned a true" do
     before :all do
-      @model.set(:bool => true)
+      @model.bool = true
     end
 
     it_should_behave_like "valid model"
   end
 
-  describe "assigned to false" do
+  describe "assigned a false" do
     before :all do
-      @model.set(:bool => false)
+      @model.bool = false
     end
 
     it_should_behave_like "valid model"
   end
 
-  describe "assigned to a nil" do
+  describe "assigned a nil" do
     before :all do
-      @model.set(:bool => nil)
+      @model.bool = nil
     end
 
     it_should_behave_like "invalid model"