not-naughty 0.6.0 → 0.6.1

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+=== 0.6.1 (2008-10-10)
+* builder/validation cleanups
+* added gemspecs for github
+* added support for predefined format expressions [resolves:#19814]
+
 === 0.6 (2008-10-08)
 * fixed Rakefile
 * removed whitespaces

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "not-naughty"
-VERS = "0.6.0"
+VERS = "0.6.1"
 CLEAN.include %w[ pkg doc coverage ]
 RDOC_OPTS = [
   "--quiet",
@@ -39,7 +39,7 @@ task :doc_rforge => [:doc]
 
 desc "Update docs and upload to rubyforge.org"
 task :doc_rforge do
-  sh %{scp -r doc/rdoc/* boof@rubyforge.org:/var/www/gforge-projects/not-naughty}
+  sh %{scp -r doc/* boof@rubyforge.org:/var/www/gforge-projects/not-naughty}
 end
 
 ##############################################################################

data/lib/not_naughty/builder.rb

@@ -40,26 +40,25 @@ module NotNaughty
 
     class ValidationDelegator < SimpleDelegator #:nodoc:all
       def initialize(receiver, *params)
-        @_sd_obj_opts   = params.extract_options!
-        @_sd_obj_params = params
+        @_sd_obj_opts       = params.extract_options!
+        @_sd_obj_attributes = params
 
         super receiver
       end
       def method_missing(method_sym, *params) #:nodoc:
-        method_sym, params = unless @_sd_obj_params.empty?
-          opts = @_sd_obj_opts.update params.extract_options!
-          [:"validates_#{method_sym}_of", @_sd_obj_params + [opts]]
+        valid = @_sd_obj_opts.merge params.extract_options!
+        valid = Marshal.load Marshal.dump(valid)
+
+        method_sym, params = unless @_sd_obj_attributes.empty?
+          [:"validates_#{ method_sym }_of", @_sd_obj_attributes + [valid]]
         else
-          opts = @_sd_obj_opts.update params.extract_options!
-          [:"validates_#{method_sym}", params + [opts]]
+          [:"validates_#{ method_sym }", params + [valid]]
         end
 
         if @_sd_obj.respond_to? method_sym
-          @_sd_obj.send(method_sym, *params)
-          return true
+          @_sd_obj.send(method_sym, *params); true
         else
-          raise NoMethodError,
-            "unable to evaluate ´#{method_sym}(*#{params.inspect})'"
+          raise NoMethodError, "unable to evaluate ´#{method_sym}(#{ params.map {|p|p.inspect} * ','})'"
         end
       end
     end

data/lib/not_naughty/validations/confirmation_validation.rb

@@ -20,22 +20,30 @@ module NotNaughty
   #   obj.errors.on(:to_s).any? # => true
   class ConfirmationValidation < Validation
 
-    def initialize(opts, attributes) #:nodoc:
-      __message = opts[:message] || '#{"%s".humanize} could not be confirmed.'
+    def initialize(valid, attributes) #:nodoc:
+      valid[:message] ||= '%s could not be confirmed.'
 
-      if opts[:allow_blank] or opts[:allow_nil]
-        __allow = if opts[:allow_blank] then :blank? else :nil? end
-        super opts, attributes do |o, a, v|
-          o.errors.add a, __message unless
-          v.send __allow or o.send(:"#{a}_confirmation").eql? v
-        end
+      if valid[:allow_blank] || valid[:allow_nil]
+        valid[:allow] = valid[:allow_blank] ? :blank? : :nil?
+        super valid, attributes, &confirmation_block_with_exception(valid)
       else
-        super opts, attributes do |o, a, v|
-          o.errors.add a, __message unless
-          o.send(:"#{a}_confirmation").eql? v
-        end
+        super valid, attributes, &confirmation_block(valid)
       end
     end
 
+    protected
+    def confirmation_block_with_exception(valid)
+      proc do |obj, attr, value|
+        value.send valid[:allow] or
+        obj.send(:"#{ attr }_confirmation") == value or
+        obj.errors.add attr, valid[:message]
+      end
+    end
+    def confirmation_block(valid)
+      proc do |obj, attr, value|
+        obj.send(:"#{ attr }_confirmation") == value or
+        obj.errors.add attr, valid[:message]
+      end
+    end
   end
 end

data/lib/not_naughty/validations/format_validation.rb

@@ -16,38 +16,54 @@ module NotNaughty
   #   obj = 'abc'
   #   def obj.errors() @errors ||= NotNauthy::Errors.new end
   #
-  #   FormatValidation.new({:with => /[a-z]/}, :to_s).call obj, :to_s, 'abc'
+  #   FormatValidation.new({:with => /[a-z]/}, :to_s).call obj, :to_s, obj
   #   obj.errors.on(:to_s).any? # => false
   #
-  #   FormatValidation.new({:with => /[A-Z]/}, :to_s).call obj, :to_s, 'abc'
+  #   FormatValidation.new({:with => /[A-Z]/}, :to_s).call obj, :to_s, obj
   #   obj.errors.on(:to_s) # => ["Format of to_s does not match."]
+  #
+  # <b>Use predefined format expressions:</b>
+  #
+  #   obj = 'Valid Address <foo@bar.baz>'
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   FormatValidation.new({:with => :email}, :to_s).call obj, :to_s, obj
+  #   obj.errors.on(:to_s).any? # => false
   class FormatValidation < Validation
 
     # Predefined matchers.
-    DEFINITIONS = {
+    PREDEFINED = {
       :email => /[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/,
       :ip => /(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)/
     }
 
-    def initialize(opts, attributes) #:nodoc:
-      format_matcher = if Symbol === opts[:with] then DEFINITIONS[opts[:with]]
-      elsif opts[:with].respond_to? :match then opts[:with]
-      end or raise ArgumentError, "#{ opts[:with].inspect } doesn't :match"
-
-      msg = opts[:message] || '%s does not match format.'
+    def initialize(valid, attributes) #:nodoc:
+      valid[:with] = PREDEFINED.fetch valid[:with] if valid[:with].is_a? Symbol
+      valid[:with].respond_to? :match or
+      raise ArgumentError, "#{ valid[:with].inspect } doesn't :match"
 
-      if opts[:allow_blank] or opts[:allow_nil]
-        pass = opts[:allow_blank] ? :blank? : :nil?
+      valid[:message] ||= '%s does not match format.'
 
-        super opts, attributes do |obj, attr, val|
-          val.send pass or format_matcher.match val or
-          obj.errors.add attr, msg
-        end
+      if valid[:allow_blank] || valid[:allow_nil]
+        valid[:allow] = valid[:allow_blank] ? :blank? : :nil?
+        super valid, attributes, &matching_block_with_exception(valid)
       else
-        super opts, attributes do |obj, attr, val|
-          format_matcher.match val or
-          obj.errors.add attr, msg
-        end
+        super valid, attributes, &matching_block(valid)
+      end
+    end
+
+    protected
+    def matching_block_with_exception(valid)
+      proc do |obj, attr, value|
+        value.send valid[:allow] or
+        valid[:with].match value or
+        obj.errors.add attr, valid[:message]
+      end
+    end
+    def matching_block(valid)
+      proc do |obj, attr, value|
+        valid[:with].match value or
+        obj.errors.add attr, valid[:message]
       end
     end
 

data/lib/not_naughty/validations/length_validation.rb

@@ -35,60 +35,56 @@ module NotNaughty
   #   LengthValidation.new({:within => 1..4}, :to_a).
   #     call obj, :to_a, %w[a sentence with five words]
   #   obj.errors.on(:to_s).any? # => true
+  #
+  # I'm sorry for using eval here...
   class LengthValidation < Validation
 
-    def initialize(opts, attributes) #:nodoc:
+TEMPLATE = <<-BLOCK
+proc do |obj, attr, value|
+  value.%s or %s value.length or
+  obj.errors.add attr, %s
+end
+BLOCK
 
-      block = build_block opts
+    def initialize(valid, attributes) #:nodoc:
+      super valid, attributes, &build_block(valid)
+    end
 
-      if opts[:allow_blank]
-        super opts, attributes do |o, a, v|
-          block[o, a, v] unless v.blank?
-        end
+    protected
+    def build_block(valid) #:nodoc:
+      if valid[:is] then is_block valid
+      elsif valid[:within] or valid[:minimum] && valid[:maximum] then within_block valid
+      elsif valid[:minimum] then minimum_block valid
+      elsif valid[:maximum] then maximum_block valid
       else
-        super opts, attributes do |o, a, v|
-          block[o, a, v] unless v.nil?
-        end
+        raise ArgumentError, 'no boundary given'
       end
     end
 
-    protected
-    def build_block(opts) #:nodoc:
-      if __length = opts[:is]
-        __message = opts[:message] ||
-          "Length of %s is not equal to #{__length}."
-        proc do |o, a, v|
-          o.errors.add a, __message unless __length.eql? v.length
-        end
-      elsif opts[:within] or opts[:minimum] && opts[:maximum]
-        __range   = opts[:within]
-        __range ||= Range.new opts[:minimum], opts[:maximum]
+    def is_block(valid)
+      valid[:message] ||= "Length of %s is not equal to #{ valid[:is] }."
 
-        __message = opts[:message] ||
-          "Length of %s is not within #{__range.first} and #{__range.last}."
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "#{ valid[:is].inspect } ==", valid[:message].inspect ]
+    end
+    def within_block(valid)
+      valid[:within] ||= Range.new valid[:minimum], valid[:maximum]
+      valid[:message] ||= "Length of %s is not within #{ valid[:within].min } and #{ valid[:within].max }."
 
-        proc do |o, a, v|
-          o.errors.add a, __message unless __range.include? v.length
-        end
-      elsif opts[:minimum]
-        __boundary  = opts[:minimum]
-        __message   = opts[:message] ||
-          "Length of %s is smaller than #{__boundary}."
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "(#{ valid[:within].inspect }).include?", valid[:message].inspect ]
+    end
+    def minimum_block(valid)
+      valid[:message] ||= "Length of %s is less than #{ valid[:minimum] }."
 
-        proc do |o, a, v|
-          o.errors.add a, __message unless __boundary <= v.length
-        end
-      elsif opts[:maximum]
-        __boundary  = opts[:maximum]
-        __message   = opts[:message] ||
-          "Length of %s is greater than #{__boundary}."
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "#{ valid[:minimum].inspect } <=", valid[:message].inspect ]
+    end
+    def maximum_block(valid)
+      valid[:message] ||= "Length of %s is greater than #{ valid[:maximum] }."
 
-        proc do |o, a, v|
-          o.errors.add a, __message unless __boundary >= v.length
-        end
-      else
-        raise ArgumentError, 'no boundary given'
-      end
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "#{ valid[:maximum].inspect } >=", valid[:message].inspect ]
     end
 
   end

data/lib/not_naughty/validations/numericality_validation.rb

@@ -27,16 +27,16 @@ module NotNaughty
   #   obj.errors.on(:to_s).any? # => true
   class NumericalityValidation < FormatValidation
 
-    def initialize(opts, attributes) #:nodoc:
-      opts[:with] = if opts[:only_integer]
-        opts[:message] ||= '#{"%s".humanize} is not an integer.'
+    def initialize(valid, attributes) #:nodoc:
+      valid[:with] = if valid[:only_integer]
+        valid[:message] ||= '%s is not an integer.'
         /^[+-]?\d+$/
       else
-        opts[:message] ||= '#{"%s".humanize} is not a number.'
+        valid[:message] ||= '%s is not a number.'
         /^[+-]?\d*\.?\d+$/
       end
 
-      super opts, attributes
+      super valid, attributes
     end
 
   end

data/lib/not_naughty/validations/presence_validation.rb

@@ -19,11 +19,12 @@ module NotNaughty
   #   obj.errors.on(:to_s) # => ["To s is not present."]
   class PresenceValidation < Validation
 
-    def initialize(opts, attributes) #:nodoc:
-      __message = opts[:message] || '#{"%s".humanize} is not present.'
+    def initialize(valid, attributes) #:nodoc:
+      valid[:message] ||= '%s is not present.'
 
-      super opts, attributes do |o, a, v|
-        o.errors.add a, __message if v.blank?
+      super valid, attributes do |obj, attr, value|
+        value.blank? and
+        obj.errors.add attr, valid[:message]
       end
     end
 

data/spec/spec_helper.rb

@@ -1,4 +1,7 @@
-require File.dirname(__FILE__) + '/../lib/not_naughty.rb'
+require 'rubygems'
+require 'spec'
+
+require "#{ File.dirname __FILE__ }/../lib/not_naughty.rb"
 
 def subject() ::NotNaughty end
 def h(something)

data/spec/validations_spec.rb

@@ -94,10 +94,10 @@ describe FormatExample do
 
   before(:each) { @example = FormatExample.clone }
 
-  it "claims to match 99% of all e-mail addresses out there..." do
+  it "claims to match 99.9% of all e-mail addresses out there..." do
     # Regexp was taken from: http://www.regular-expressions.info/email.html
     @example.validates_format_of :email,
-      :with => /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b/i
+      :with => :email
     @example.new('"Foo Bar" <foo@bar.com>').should be_valid
     @example.new('foo@bar.com').should be_valid
     @example.new('foobarcom').should_not be_valid

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: not-naughty
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors: 
 - "Florian A\xC3\x9Fmann"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-08 00:00:00 +02:00
+date: 2008-10-10 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency