validates_email_format_of 1.4.7 → 1.5.0

data/lib/validates_email_format_of.rb

@@ -2,14 +2,11 @@
 module ValidatesEmailFormatOf
   require 'resolv'
 
-  VERSION = '1.4.7'
+  VERSION = '1.5.0'
 
   MessageScope = defined?(ActiveModel) ? :activemodel : :activerecord
 
-  LocalPartSpecialChars = Regexp.escape('!#$%&\'*-/=?+-^_`{|}~')
-  LocalPartUnquoted = '([[:alnum:]' + LocalPartSpecialChars + ']+[\.]+)*[[:alnum:]' + LocalPartSpecialChars + '+]+'
-  LocalPartQuoted = '\"([[:alnum:]' + LocalPartSpecialChars + '\.]|\\\\[\x00-\xFF])*\"'
-  Regex = Regexp.new('\A(' + LocalPartUnquoted + '|' + LocalPartQuoted + '+)@(((\w+\-+[^_])|(\w+\.[a-z0-9-]*))*([a-z0-9\-\.]{1,63})\.[a-z]{2,6}(?:\.[a-z]{2,6})?\Z)', Regexp::EXTENDED | Regexp::IGNORECASE, 'n')
+  LocalPartSpecialChars = /[\!\#\$\%\&\'\*\-\/\=\?\+\-\^\_\`\{\|\}\~]/
 
   def self.validate_email_domain(email)
     domain = email.match(/\@(.+)/)[1]
@@ -26,58 +23,112 @@ module ValidatesEmailFormatOf
   # * <tt>message</tt> - A custom error message (default is: "does not appear to be valid")
   # * <tt>check_mx</tt> - Check for MX records (default is false)
   # * <tt>mx_message</tt> - A custom error message when an MX record validation fails (default is: "is not routable.")
-  # * <tt>with</tt> The regex to use for validating the format of the email address (default is ValidatesEmailFormatOf::Regex)</tt>
+  # * <tt>with</tt> The regex to use for validating the format of the email address (deprecated)
   # * <tt>local_length</tt> Maximum number of characters allowed in the local part (default is 64)
   # * <tt>domain_length</tt> Maximum number of characters allowed in the domain part (default is 255)
   def self.validate_email_format(email, options={})
       default_options = { :message => I18n.t(:invalid_email_address, :scope => [MessageScope, :errors, :messages], :default => 'does not appear to be valid'),
                           :check_mx => false,
                           :mx_message => I18n.t(:email_address_not_routable, :scope => [MessageScope, :errors, :messages], :default => 'is not routable'),
-                          :with => ValidatesEmailFormatOf::Regex ,
                           :domain_length => 255,
                           :local_length => 64
                           }
       opts = options.merge(default_options) {|key, old, new| old}  # merge the default options into the specified options, retaining all specified options
 
-      email.strip! if email
+      email = email.strip if email
 
-      # local part max is 64 chars, domain part max is 255 chars
-      # TODO: should this decode escaped entities before counting?
       begin
         domain, local = email.reverse.split('@', 2)
       rescue
         return [ opts[:message] ]
       end
 
-      unless email =~ opts[:with] and not email =~ /\.\./ and domain.length <= opts[:domain_length] and local.length <= opts[:local_length]
-        return [ opts[:message] ]
+      # need local and domain parts
+      return [ opts[:message] ] unless local and domain
+
+      # check lengths
+      return [ opts[:message] ] unless domain.length <= opts[:domain_length] and local.length <= opts[:local_length]
+
+      local.reverse!
+      domain.reverse!
+
+      if opts.has_key?(:with) # holdover from versions <= 1.4.7
+        return [ opts[:message] ] unless email =~ opts[:with]
+      else
+        return [ opts[:message] ] unless self.validate_local_part_syntax(local) and self.validate_domain_part_syntax(domain)
       end
 
-      if opts[:check_mx] and !ValidatesEmailFormatOf::validate_email_domain(email)
+      if opts[:check_mx] and !self.validate_email_domain(email)
         return [ opts[:mx_message] ]
       end
 
-      local.reverse!
-          
-      # check for proper escaping
-
-      if local[0] == '"'
-        local.gsub!(/\A\"|\"\Z/, '')
-        escaped = false
-        local.each_char do |c|
-          if escaped
-            escaped = false
-          elsif c == '"' # can't have a double quote without a preceding backslash
-            return [ opts[:mx_message] ]
-          else
-            escaped = c == '\\'
-          end
-        end
-
-        return [ opts[:mx_message] ] if escaped
+      return nil    # represents no validation errors
+  end
+  
+
+  def self.validate_local_part_syntax(local)
+    in_quoted_pair = false
+    in_quoted_string = false
+
+    (0..local.length-1).each do |i|
+      ord = local[i].ord
+
+      # accept anything if it's got a backslash before it
+      if in_quoted_pair 
+        in_quoted_pair = false
+        next
+      end
+        
+      # backslash signifies the start of a quoted pair
+      if ord == 92 and i < local.length - 1
+        return false if not in_quoted_string # must be in quoted string per http://www.rfc-editor.org/errata_search.php?rfc=3696
+        in_quoted_pair = true
+        next
+      end
+        
+      # double quote delimits quoted strings
+      if ord == 34
+        in_quoted_string = !in_quoted_string
+        next
+      end    
+
+      next if local[i] =~ /[[:alnum:]]/
+      next if local[i] =~ LocalPartSpecialChars
+      
+      # period must be followed by something
+      if ord == 46
+        return false if i == 0 or i == local.length - 1 # can't be first or last char
+        next unless local[i+1].ord == 46 # can't be followed by a period
       end
 
-      return nil    # represents no validation errors
+      return false
+    end
+    
+    return false if in_quoted_string # unbalanced quotes
+
+    return true
+  end
+  
+  def self.validate_domain_part_syntax(domain)
+    parts = domain.downcase.split('.', -1)
+    
+    return false if parts.length <= 1 # Only one domain part
+
+    # Empty parts (double period) or invalid chars
+    return false if parts.any? { 
+      |part| 
+        part.nil? or 
+        part.empty? or 
+        not part =~ /\A[[:alnum:]\-]+\Z/ or
+        part[0] == '-' or part[-1] == '-' # hyphen at beginning or end of part
+    } 
+        
+    # ipv4
+    return true if parts.length == 4 and parts.all? { |part| part =~ /\A[0-9]+\Z/ and part.to_i.between?(0, 255) }
+        
+    return false if parts[-1].length < 2 or not parts[-1] =~ /[a-z\-]/ # TLD is too short or does not contain a char or hyphen
+    
+    return true
   end
 
   module Validations
@@ -98,7 +149,7 @@ module ValidatesEmailFormatOf
     #   occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
     #   method, proc or string should return or evaluate to a true or false value.
     # * <tt>unless</tt> - See <tt>:if</tt>
-    def validates_email_format_of(*attr_names)    
+    def validates_email_format_of(*attr_names)
       options = { :on => :save,
         :allow_nil => false,
         :allow_blank => false }

data/test/validates_email_format_of_test.rb

@@ -50,6 +50,10 @@ class ValidatesEmailFormatOfTest < TEST_CASE
      '_somename@example.com',
   # apostrophes
      "test'test@example.com",
+  # international domain names
+     'test@xn--bcher-kva.ch',
+     'test@example.xn--0zwm56d',
+     'test@192.192.192.1'
      ].each do |email|
       assert_valid(email)
     end
@@ -64,18 +68,20 @@ class ValidatesEmailFormatOfTest < TEST_CASE
   # period can not appear twice consecutively in local part
      'invali..d@example.com',
   # should not allow underscores in domain names
-     'invalid@ex_mple.com',
-     'invalid@e..example.com',
-     'invalid@p-t..example.com',
-     'invalid@example.com.',
-     'invalid@example.com_',
-     'invalid@example.com-',
-     'invalid-example.com',
-     'invalid@example.b#r.com',
-     'invalid@example.c',
-     'invali d@example.com',
+    'invalid@ex_mple.com',
+    'invalid@e..example.com',
+    'invalid@p-t..example.com',
+    'invalid@example.com.',
+    'invalid@example.com_',
+    'invalid@example.com-',
+    'invalid-example.com',
+    'invalid@example.b#r.com',
+    'invalid@example.c',
+    'invali d@example.com',
+  # TLD can not be only numeric
+    'invalid@example.123',
   # unclosed quote
-     "\"a-17180061943-10618354-1993365053",
+     "\"a-17180061943-10618354-1993365053@example.com",
   # too many special chars used to cause the regexp to hang
      "-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++@foo",
      'invalidexample.com',
@@ -84,27 +90,30 @@ class ValidatesEmailFormatOfTest < TEST_CASE
      'local@sub.#domain.com',
   # one at a time
      "foo@example.com\nexample@gmail.com",
-     'invalid@example.'].each do |email|
+     'invalid@example.',
+     "\"foo\\\\\"\"@bar.com",
+     "foo@mail.com\r\nfoo@mail.com"
+     ].each do |email|
       assert_invalid(email)
     end
   end
-  
+
   # from http://www.rfc-editor.org/errata_search.php?rfc=3696
   def test_should_allow_quoted_characters
-    ['"Abc\@def"@example.com',     
+    ['"Abc\@def"@example.com',
      '"Fred\ Bloggs"@example.com',
      '"Joe.\\Blow"@example.com',
      ].each do |email|
       assert_valid(email)
     end
   end
-  
+
   def test_should_required_balanced_quoted_characters
     assert_valid(%!"example\\\\\\""@example.com!)
     assert_valid(%!"example\\\\"@example.com!)
     assert_invalid(%!"example\\\\""example.com!)
   end
-  
+
   # from http://tools.ietf.org/html/rfc3696, page 5
   # corrected in http://www.rfc-editor.org/errata_search.php?rfc=3696
   def test_should_not_allow_escaped_characters_without_quotes
@@ -123,21 +132,25 @@ class ValidatesEmailFormatOfTest < TEST_CASE
       assert_invalid(email)
     end
   end
-  
+
   def test_overriding_length_checks
     assert_not_nil ValidatesEmailFormatOf::validate_email_format('valid@example.com', :local_length => 1)
     assert_not_nil ValidatesEmailFormatOf::validate_email_format('valid@example.com', :domain_length => 1)
   end
 
+  def test_validating_with_custom_regexp
+    assert_nil ValidatesEmailFormatOf::validate_email_format('012345@789', :with => /[0-9]+\@[0-9]+/)
+  end
+
   def test_should_respect_validate_on_option
     p = create_person(:email => @valid_email)
     save_passes(p)
-    
+
     # we only asked to validate on :create so this should fail
     assert p.update_attributes(:email => @invalid_email)
     assert_equal @invalid_email, p.email
   end
-  
+
   def test_should_allow_custom_error_message
     p = create_person(:email => @invalid_email)
     save_fails(p)
@@ -151,7 +164,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
   def test_should_allow_nil
     p = create_person(:email => nil)
     save_passes(p)
-    
+
     p = PersonForbidNil.new(:email => nil)
     save_fails(p)
   end
@@ -170,7 +183,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
     pmx = MxRecord.new(:email => 'test@code.dunae.ca')
     save_passes(pmx)
   end
-  
+
   def test_shorthand
     if ActiveRecord::VERSION::MAJOR >= 3
       s = Shorthand.new(:email => 'invalid')
@@ -184,15 +197,20 @@ class ValidatesEmailFormatOfTest < TEST_CASE
     end
   end
 
+  def test_frozen_string
+    assert_valid("  #{@valid_email}  ".freeze)
+    assert_invalid("  #{@invalid_email}  ".freeze)
+  end
+
   protected
     def create_person(params)
       Person.new(params)
     end
-    
+
     def assert_valid(email)
       assert_nil ValidatesEmailFormatOf::validate_email_format(email)
     end
-    
+
     def assert_invalid(email)
       err = ValidatesEmailFormatOf::validate_email_format(email)
       assert_equal 1, err.size
@@ -207,7 +225,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
         assert_nil p.errors.on(:email)
       end
     end
-    
+
     def save_fails(p, email = '')
       assert !p.valid?, " #{email} should fail"
       assert !p.save

metadata

@@ -1,28 +1,24 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: validates_email_format_of
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 1.5.0
   prerelease: 
-  version: 1.4.7
 platform: ruby
-authors: 
+authors:
 - Alex Dunae
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-13 00:00:00 Z
+date: 2011-09-07 00:00:00.000000000Z
 dependencies: []
-
 description: Validate e-mail addresses against RFC 2822 and RFC 3696.
 email: code@dunae.ca
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
 - MIT-LICENSE
-files: 
+files:
 - MIT-LICENSE
 - init.rb
 - rakefile.rb
@@ -36,33 +32,31 @@ files:
 - test/fixtures/people.yml
 homepage: https://github.com/alexdunae/validates_email_format_of
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --title
 - validates_email_format_of
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.1
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Validate e-mail addresses against RFC 2822 and RFC 3696.
-test_files: 
+test_files:
 - test/fixtures/person.rb
 - test/schema.rb
 - test/test_helper.rb