email_validator 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f5010b8d56592e8febeda1e96b6fa35a27e2dae75dab6277fbade5f35b74b18
-  data.tar.gz: 50bbb4a9c6abea2db5c2e887ba67a88739afccdb445c56be74c063b10993cef3
+  metadata.gz: 46bd723714c6aa3a844e584e986e5989920b6d3f212a44d800183d118c561cb7
+  data.tar.gz: bb58e5bf862c4be796e3ce59727dcf3fd2e28267e7c6077014f01d25dc841580
 SHA512:
-  metadata.gz: b520404b2777c72ac87eaccaaacb073b340ebca043d104d531d8d78c74fd413d2f0e1c5ef6b7d08529a23d2aad913c7e1d15ab16989ea5777b5f41d37539365b
-  data.tar.gz: 100eb11eaff2bd530d7a6c554655d93649a45aa6a5e5718a31cfa0c994f8e5341b57964d01c7f256ce4e8e927c3ba8e5610694cd293dda2d3241a2f2c187e1b9
+  metadata.gz: 2ece91a44bd82bd79c5484a17729996731787148b6813af0c4e41804715242a9cbfb4c0d661b08e0c904753dd59f23560d11aed7bf9044986802445e36f69438
+  data.tar.gz: 1b91bf21ce112f86f9b97138573d20fe14b67f075935136c3b19a620f155d50c5d5cf5ff9566e4c101429b8d7ce80ccb80709a2a15eeb07f4caeaac34f2b86b0

data/CHANGELOG.md

@@ -5,6 +5,16 @@ This file is used to list changes made in `email_validator`.
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## 2.2.3 (2021-04-05)
+
+* [karlwilbur] - Fix regexp for numeric domains (fixes [#72](https://github.com/K-and-R/email_validator/issues/72))
+    - [delphaber] - Add checks for numeric-only domains in tests (should be considered valid)
+    - [karlwilbur] - Fix specs for numeric-only domains labels (should be considered valid)
+    - [karlwilbur] - Add checks for numeric-only TLDs in tests (should be considered invalid)
+    - [karlwilbur] - Add tests to ensure that `regexp` returns expected value
+    - [karlwilbur] - Add checks for double dash in domain (should be considered invalid)
+    - [karlwilbur] - Add `EmailValidator::Error` class, raise `EmailValidator::Error` when invalid `mode`
+
 ## 2.2.2 (2020-12-10)
 
 * [karlwilbur] - Fix includes for `:rfc` and `:strict` modes from `Gemfile`

data/README.md

@@ -54,9 +54,9 @@ by setting `require_fqdn: true` or by enabling `:strict` checking:
 validates :my_email_attribute, email: {mode: :strict, require_fqdn: true}
 ```
 
-You can also limit to a single domain (e.g: this might help if, for example, you
-have separate `User` and `AdminUser` models and want to ensure that `AdminUser`
-emails are on a specific domain):
+You can also limit to a single domain (e.g: you have separate `User` and
+`AdminUser` models and want to ensure that `AdminUser` emails are on a specific
+domain):
 
 ```ruby
 validates :my_email_attribute, email: {domain: 'example.com'}
@@ -166,6 +166,10 @@ EmailValidator.valid?('narf@somehost') # boolean false
 EmailValidator.invalid?('narf@somehost', require_fqdn: false) # boolean true
 ```
 
+_NB: Enabling strict mode (`mode: :strict`) enables `require_fqdn`
+(`require_fqdn: true`), overridding any `require_fqdn: false` while
+`mode: :strict` is set._
+
 ### Requiring a specific domain
 
 ```ruby

data/lib/email_validator.rb

@@ -1,4 +1,6 @@
 # Based on work from http://thelucid.com/2010/01/08/sexy-validation-in-edge-rails-rails-3/
+
+# EmailValidator class
 class EmailValidator < ActiveModel::EachValidator
   # rubocop:disable Style/ClassVars
   @@default_options = {
@@ -9,6 +11,13 @@ class EmailValidator < ActiveModel::EachValidator
   }
   # rubocop:enable Style/ClassVars
 
+  # EmailValidator::Error class
+  class Error < StandardError
+    def initialize(msg = 'EmailValidator error')
+      super
+    end
+  end
+
   class << self
     def default_options
       @@default_options
@@ -35,8 +44,11 @@ class EmailValidator < ActiveModel::EachValidator
         loose_regexp(options)
       when :rfc
         rfc_regexp(options)
-      else
+      when :strict
+        options[:require_fqdn] = true
         strict_regexp(options)
+      else
+        fail EmailValidator::Error, "Validation mode '#{options[:mode]}' is not supported by EmailValidator"
       end
     end
 
@@ -81,31 +93,38 @@ class EmailValidator < ActiveModel::EachValidator
     end
 
     def host_label_pattern
+      "#{label_is_correct_length}" \
+      "#{label_contains_no_more_than_one_consecutive_hyphen}" \
       "#{alnum}(?:#{alnumhy}{,61}#{alnum})?"
     end
 
     # splitting this up into separate regex pattern for performance; let's not
     # try the "contains" pattern unless we have to
     def domain_label_pattern
-      '(?=[^.]{1,63}(?:\.|$))' \
-      '(?:' \
-        "#{alpha}" \
-        "|#{domain_label_starts_with_a_letter_pattern}" \
-        "|#{domain_label_ends_with_a_letter_pattern}" \
-        "|#{domain_label_contains_a_letter_pattern}" \
-      ')'
+      "#{host_label_pattern}\\.#{tld_label_pattern}"
+    end
+
+    # While, techincally, TLDs can be numeric-only, this is not allowed by ICANN
+    # Ref: ICANN Application Guidebook for new TLDs (June 2012)
+    #      says the following starting at page 64:
+    #
+    #      > The ASCII label must consist entirely of letters (alphabetic characters a-z)
+    #
+    #      -- https://newgtlds.icann.org/en/applicants/agb/guidebook-full-04jun12-en.pdf
+    def tld_label_pattern
+      "#{alpha}{1,64}"
     end
 
-    def domain_label_starts_with_a_letter_pattern
-      "#{alpha}#{alnumhy}{,61}#{alnum}"
+    def label_is_correct_length
+      '(?=[^.]{1,63}(?:\.|$))'
     end
 
-    def domain_label_ends_with_a_letter_pattern
-      "#{alnum}#{alnumhy}{,61}#{alpha}"
+    def domain_part_is_correct_length
+      '(?=.{1,255}$)'
     end
 
-    def domain_label_contains_a_letter_pattern
-      "(?:[[:digit:]])(?:[[:digit:]]|-)*#{alpha}#{alnumhy}*#{alnum}"
+    def label_contains_no_more_than_one_consecutive_hyphen
+      '(?!.*?--.*$)'
     end
 
     def atom_char
@@ -122,11 +141,11 @@ class EmailValidator < ActiveModel::EachValidator
     def domain_part_pattern(options)
       return options[:domain].sub(/\./, '\.') if options[:domain].present?
       return fqdn_pattern if options[:require_fqdn]
-      "(?=.{1,255}$)(?:#{address_literal}|(?:#{host_label_pattern}\\.)*#{domain_label_pattern})"
+      "#{domain_part_is_correct_length}(?:#{address_literal}|(?:#{host_label_pattern}\\.)*#{tld_label_pattern})"
     end
 
     def fqdn_pattern
-      "(?=.{1,255}$)(?:#{host_label_pattern}\\.)*#{domain_label_pattern}\\.#{domain_label_pattern}"
+      "(?=.{1,255}$)(?:#{host_label_pattern}\\.)*#{domain_label_pattern}"
     end
 
     private

data/spec/email_validator_spec.rb

@@ -146,7 +146,8 @@ RSpec.describe EmailValidator do
         'john.doe@a2.com',
         'john.doe@2020.a-z.com',
         'john.doe@2020.a2z.com',
-        'john.doe@2020.12345a6789.com'
+        'john.doe@2020.12345a6789.com',
+        'jonh.doe@163.com'
       ]).flatten.each do |email|
         context 'when using defaults' do
           it "'#{email}' should be valid" do
@@ -289,20 +290,20 @@ RSpec.describe EmailValidator do
         end
 
         context 'when in `:strict` mode' do
-          it "'#{email}' should not be valid" do
-            expect(StrictUser.new(:email => email)).not_to be_valid
+          it "'#{email}' should be valid" do
+            expect(StrictUser.new(:email => email)).to be_valid
           end
 
-          it "'#{email}' should not be valid using EmailValidator.valid?" do
-            expect(described_class).not_to be_valid(email, :mode => :strict)
+          it "'#{email}' should be valid using EmailValidator.valid?" do
+            expect(described_class).to be_valid(email, :mode => :strict)
           end
 
-          it "'#{email}' should be invalid using EmailValidator.invalid?" do
-            expect(described_class).to be_invalid(email, :mode => :strict)
+          it "'#{email}' should be not invalid using EmailValidator.invalid?" do
+            expect(described_class).not_to be_invalid(email, :mode => :strict)
           end
 
-          it "'#{email}' should not match the regexp" do
-            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(true)
           end
         end
 
@@ -476,6 +477,7 @@ RSpec.describe EmailValidator do
         'host-beginning-with-dot@.example.com',
         'domain-beginning-with-dash@-example.com',
         'domain-ending-with-dash@example-.com',
+        'domain-contains-double-dash@foo--example.com',
         'the-local-part-is-invalid-if-it-is-longer-than-sixty-four-characters@sld.dev',
         "domain-too-long@t#{".#{'o' * 63}" * 5}.long",
         "user@example.com<script>alert('hello')</script>"
@@ -703,7 +705,8 @@ RSpec.describe EmailValidator do
       ]}).concat([
         'user..-with-double-dots@example.com',
         '.user-beginning-with-dot@example.com',
-        'user-ending-with-dot.@example.com'
+        'user-ending-with-dot.@example.com',
+        'fully-numeric-tld@example.123'
       ]).flatten.each do |email|
         context 'when using defaults' do
           it "#{email.strip} in a model should be valid" do
@@ -781,23 +784,24 @@ RSpec.describe EmailValidator do
           end
         end
 
+        # Strict mode enables `require_fqdn` anyway
         context 'when in `:strict` mode' do
           let(:opts) { { :require_fqdn => false, :mode => :strict } }
 
-          it 'is valid' do
-            expect(NonFqdnStrictUser.new(:email => email)).to be_valid
+          it 'is not valid' do
+            expect(NonFqdnStrictUser.new(:email => email)).not_to be_valid
           end
 
-          it 'is valid using EmailValidator.valid?' do
-            expect(described_class).to be_valid(email, opts)
+          it 'is not valid using EmailValidator.valid?' do
+            expect(described_class).not_to be_valid(email, opts)
           end
 
-          it 'is not invalid using EmailValidator.invalid?' do
-            expect(described_class).not_to be_invalid(email, opts)
+          it 'is invalid using EmailValidator.invalid?' do
+            expect(described_class).to be_invalid(email, opts)
           end
 
           it 'matches the regexp' do
-            expect(!!(email =~ described_class.regexp(opts))).to be(true)
+            expect(!!(email =~ described_class.regexp(opts))).to be(false)
           end
         end
 
@@ -1012,4 +1016,36 @@ RSpec.describe EmailValidator do
       end
     end
   end
+
+  context 'with regexp' do
+    it 'returns a regexp when asked' do
+      expect(described_class.regexp).to be_a(Regexp)
+    end
+
+    it 'returns a strict regexp when asked' do
+      expect(described_class.regexp(:mode => :strict)).to be_a(Regexp)
+    end
+
+    it 'returns a RFC regexp when asked' do
+      expect(described_class.regexp(:mode => :rfc)).to be_a(Regexp)
+    end
+
+    it 'has different regexp for strict and loose' do
+      expect(described_class.regexp(:mode => :strict)).not_to eq(described_class.regexp(:mode => :loose))
+    end
+
+    it 'has different regexp for RFC and loose' do
+      expect(described_class.regexp(:mode => :rfc)).not_to eq(described_class.regexp(:mode => :loose))
+    end
+
+    it 'has different regexp for RFC and strict' do
+      expect(described_class.regexp(:mode => :rfc)).not_to eq(described_class.regexp(:mode => :strict))
+    end
+  end
+
+  context 'with invalid `:mode`' do
+    it 'raises an error' do
+      expect { described_class.regexp(:mode => :invalid) }.to raise_error(EmailValidator::Error)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: email_validator
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Brian Alexander
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-11 00:00:00.000000000 Z
+date: 2021-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel