validates_email_format_of 1.4.5 → 1.4.6

data/README.rdoc

@@ -23,6 +23,11 @@ Or in your Rails 3 Gemfile
    validates_email_format_of :email
  end
 
+ # Rails 3
+ class Person < ActiveRecord::Base
+   validates :email, :email_format => {:message => 'is not looking good'}
+ end
+
 As of version 1.4, it's possible to run e-mail validation tests (including MX 
 checks) without using ActiveRecord or even touching a database.  The 
 <tt>validate_email_format</tt> method will return <tt>nil</tt> on a valid 

data/lib/validates_email_format_of.rb

@@ -1,11 +1,13 @@
 # encoding: utf-8
 module ValidatesEmailFormatOf
   require 'resolv'
-  
+
+  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')
+  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')
 
   def self.validate_email_domain(email)
     domain = email.match(/\@(.+)/)[1]
@@ -14,26 +16,26 @@ module ValidatesEmailFormatOf
     end
     @mx.size > 0 ? true : false
   end
-  
+
   # Validates whether the specified value is a valid email address.  Returns nil if the value is valid, otherwise returns an array
   # containing one or more validation error messages.
   #
   # Configuration options:
-  # * <tt>message</tt> - A custom error message (default is: "does not appear to be a valid e-mail address")
+  # * <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>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 => [:activerecord, :errors, :messages], :default => 'does not appear to be a valid e-mail address'),
+      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 => [:activerecord, :errors, :messages], :default => 'is not routable'),
+                          :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
                           }
-      options.merge!(default_options) {|key, old, new| old}  # merge the default options into the specified options, retaining all specified options
+      opts = options.merge(default_options) {|key, old, new| old}  # merge the default options into the specified options, retaining all specified options
 
       email.strip!
 
@@ -42,55 +44,92 @@ module ValidatesEmailFormatOf
       begin
         domain, local = email.reverse.split('@', 2)
       rescue
-        return [ options[:message] ]
+        return [ opts[:message] ]
       end
 
-      unless email =~ options[:with] and not email =~ /\.\./ and domain.length <= options[:domain_length] and local.length <= options[:local_length]
-        return [ options[:message] ]
+      unless email =~ opts[:with] and not email =~ /\.\./ and domain.length <= opts[:domain_length] and local.length <= opts[:local_length]
+        return [ opts[:message] ]
       end
-      
-      if options[:check_mx] and !ValidatesEmailFormatOf::validate_email_domain(email)
-        return [ options[:mx_message] ]
+
+      if opts[:check_mx] and !ValidatesEmailFormatOf::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
       end
-      
+
       return nil    # represents no validation errors
   end
-end
 
-module ActiveRecord
   module Validations
-    module ClassMethods
-      # Validates whether the value of the specified attribute is a valid email address
-      #
-      #   class User < ActiveRecord::Base
-      #     validates_email_format_of :email, :on => :create
-      #   end
-      #
-      # Configuration options:
-      # * <tt>message</tt> - A custom error message (default is: "does not appear to be a valid e-mail address")
-      # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
-      # * <tt>allow_nil</tt> - Allow nil values (default is false)
-      # * <tt>allow_blank</tt> - Allow blank values (default is false)
-      # * <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>if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   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)
-        options = { :on => :save, 
-                    :allow_nil => false,
-                    :allow_blank => false }
-        options.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-
-        validates_each(attr_names, options) do |record, attr_name, value|
-          v = value.to_s
-          errors = ValidatesEmailFormatOf::validate_email_format(v, options)
-          errors.each do |error|
-            record.errors.add(attr_name, error)
-          end unless errors.nil?
-        end
+    # Validates whether the value of the specified attribute is a valid email address
+    #
+    #   class User < ActiveRecord::Base
+    #     validates_email_format_of :email, :on => :create
+    #   end
+    #
+    # Configuration options:
+    # * <tt>message</tt> - A custom error message (default is: "does not appear to be valid")
+    # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
+    # * <tt>allow_nil</tt> - Allow nil values (default is false)
+    # * <tt>allow_blank</tt> - Allow blank values (default is false)
+    # * <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>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+    #   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)    
+      options = { :on => :save,
+        :allow_nil => false,
+        :allow_blank => false }
+      options.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+
+      validates_each(attr_names, options) do |record, attr_name, value|
+        v = value.to_s
+        errors = ValidatesEmailFormatOf::validate_email_format(v, options)
+        errors.each do |error|
+          record.errors.add(attr_name, error)
+        end unless errors.nil?
       end
-    end   
+    end
+  end
+end
+
+if defined?(ActiveModel)
+  class EmailFormatValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      err = ValidatesEmailFormatOf::validate_email_format(value, options)
+      record.errors[attribute] << err unless err.nil?
+      record.errors[attribute].flatten!
+    end
   end
-end
+
+  module ActiveModel::Validations::HelperMethods
+    def validates_email_format_of(*attr_names)
+      validates_with EmailFormatValidator, _merge_attributes(attr_names)
+    end
+  end
+else
+  class ActiveRecord::Base
+    extend ValidatesEmailFormatOf::Validations
+  end
+end
+

data/rakefile.rb

@@ -17,12 +17,11 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = true
 end
 
-desc 'Generate documentation for the validates_email_format_of plugin.'
+desc 'Generate documentation for the validates_email_format_of plugin and gem.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'validates_email_format_of plugin'
+  rdoc.title    = 'validates_email_format_of plugin and gem'
   rdoc.options << '--line-numbers --inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('TODO')
+  rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/test/fixtures/person.rb

@@ -6,7 +6,19 @@ class Person < ActiveRecord::Base
 end
 
 class MxRecord < ActiveRecord::Base
+  set_table_name 'people'
+  
   validates_email_format_of :email, 
                             :on => :create, 
                             :check_mx => true
 end
+
+if ActiveRecord::VERSION::MAJOR >= 3
+  class Shorthand < ActiveRecord::Base
+    set_table_name 'people'
+
+    validates :email, :email_format => { :message => 'fails with shorthand message' },
+                      :length => { :maximum => 1 }
+
+  end
+end

data/test/schema.rb

@@ -2,9 +2,4 @@ ActiveRecord::Schema.define(:version => 0) do
   create_table :people, :force => true do |t|
     t.column "email", :string
   end
-
-  create_table :mx_records, :force => true do |t|
-    t.column "email", :string
-  end
-
 end

data/test/validates_email_format_of_test.rb

@@ -8,10 +8,17 @@ class ValidatesEmailFormatOfTest < TEST_CASE
     @invalid_email = 'invalid@example.'
   end
 
+  def test_with_activerecord
+    p = create_person(:email => @valid_email)
+    save_passes(p)
+
+    p = create_person(:email => @invalid_email)
+    save_fails(p)
+  end
+
   def test_without_activerecord
-    assert_nil ValidatesEmailFormatOf::validate_email_format('valid@example.com')
-    err = ValidatesEmailFormatOf::validate_email_format('valid@example-com')
-    assert_equal 1, err.size
+    assert_valid(@valid_email)
+    assert_invalid(@invalid_email)
   end
 
   def test_should_allow_valid_email_addresses
@@ -31,6 +38,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
      'valid@example.mobi',
      'valid@example.info',
      'valid-@example.com',
+     'fake@p-t.k12.ok.us',
   # allow single character domain parts
      'valid@mail.x.example.com',
      'valid@x.com',
@@ -43,8 +51,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
   # apostrophes
      "test'test@example.com",
      ].each do |email|
-      p = create_person(:email => email)
-      save_passes(p, email)
+      assert_valid(email)
     end
   end
 
@@ -58,6 +65,8 @@ class ValidatesEmailFormatOfTest < TEST_CASE
      '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-',
@@ -76,22 +85,26 @@ class ValidatesEmailFormatOfTest < TEST_CASE
   # one at a time
      "foo@example.com\nexample@gmail.com",
      'invalid@example.'].each do |email|
-      p = create_person(:email => email)
-      save_fails(p, 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',     
      '"Fred\ Bloggs"@example.com',
      '"Joe.\\Blow"@example.com',
      ].each do |email|
-      p = create_person(:email => email)
-      save_passes(p, 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
@@ -99,8 +112,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
      'Abc\@def+@example.com',
      'Joe.\\Blow@example.com'
      ].each do |email|
-      p = create_person(:email => email)
-      save_fails(p, email)
+      assert_invalid(email)
     end
   end
 
@@ -108,8 +120,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
     ['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@example.com',
      'test@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com'
      ].each do |email|
-      p = create_person(:email => email)
-      save_fails(p, email)
+      assert_invalid(email)
     end
   end
   
@@ -156,14 +167,36 @@ 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')
+      assert !s.save
+      assert_equal 2, s.errors[:email].size
+      assert_block do
+        s.errors[:email].any? do |err|
+        err =~ /fails with shorthand message/
+      end
+      end
+    end
+  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
+    end
 
     def save_passes(p, email = '')
-      assert p.valid?, " validating #{email}"
+      assert p.valid?, " #{email} should pass"
       assert p.save
       if ActiveRecord::VERSION::MAJOR >= 3
         assert p.errors[:email].empty?
@@ -173,7 +206,7 @@ class ValidatesEmailFormatOfTest < TEST_CASE
     end
     
     def save_fails(p, email = '')
-      assert !p.valid?, " validating #{email}"
+      assert !p.valid?, " #{email} should fail"
       assert !p.save
       if ActiveRecord::VERSION::MAJOR >= 3
         assert_equal 1, p.errors[:email].size

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: validates_email_format_of
 version: !ruby/object:Gem::Version 
+  hash: 11
   prerelease: false
   segments: 
   - 1
   - 4
-  - 5
-  version: 1.4.5
+  - 6
+  version: 1.4.6
 platform: ruby
 authors: 
 - Alex Dunae
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-20 00:00:00 -08:00
+date: 2011-05-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -26,13 +27,11 @@ extensions: []
 
 extra_rdoc_files: 
 - README.rdoc
-- CHANGELOG.rdoc
 - MIT-LICENSE
 files: 
 - MIT-LICENSE
 - init.rb
 - rakefile.rb
-- CHANGELOG.rdoc
 - README.rdoc
 - lib/validates_email_format_of.rb
 - test/fixtures/person.rb
@@ -56,6 +55,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -64,6 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"

data/CHANGELOG.rdoc

@@ -1,45 +0,0 @@
-= CHANGELOG
-
-== Version 1.4.4
-
-* https://github.com/alexdunae/validates_email_format_of/compare/1.4.3...1.4.4
-
-== Version 1.4.3
-
-* https://github.com/alexdunae/validates_email_format_of/compare/1.4.2...1.4.3
-
-== Version 1.4.2
-
-* See https://github.com/alexdunae/validates_email_format_of/compare/1.4.1...1.4.2
-
-== Version 1.4.1 (the George Anderson and 'history' edition)
- * don't allow domains with underscores
- * removed extra spaces in validation messages
- * updated tests for Rails 2.3+
-
-== Version 1.4 (the Denis Ahearn edition)
- * added ability to run validation tests without touching ActiveRecord or a database
-
-== Version 1.3.1 (the Github edition)
- * updated for github
-
-== Version 1.3 (the Travis Sinnott edition)
- * added optional MX record check
- * now available as a gem
-
-== Version 1.2.1 (the RTFM edition)
- * added support for quoted local parts
- * added length checks for domain and local parts
- * corrected escaped character support for RFC 3696 Errata
- * added :allow_blank option
- * added :unless option
-
-== Version 1.2 (the Ismael Santos Kafeltz and Michael MacDonald edition)
- * added support for un-escaped and escaped special characters in the local part, per RFC 3696
- * added :allow_nil option
-
-== Version 1.1 (the Francis Hwang edition)
- * moved Regexp out of class methods into the ValidatesEmailFormatOf module
-
-== Version 1.0
- * initial version