email_validator 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bd676f012ed7b109082842ed227bc1881aec6ac24f0e1ed4be24772b206b14f
-  data.tar.gz: 6c2f92e0a494f751b690743b15d4d97fd8dd1f9213b8cb2640d6f8f729fca51f
+  metadata.gz: faae1443109b7d1c95aca6addd9d2be7c3cfaf58a771e003d80a1ea75dd0993f
+  data.tar.gz: c1094ac3f9d4887193eb2145c62f46cefe1d4ed0a734a6d7add1cf68222de1dd
 SHA512:
-  metadata.gz: 8dd2ab72b087727acec6c7509d3ffa2a51e35074b99113bc8b105c16fc62e9c3288712516e3fc0f15be125d83e0d7db50d368da269672d7ecdddec9ba21f925e
-  data.tar.gz: e35ab67f7e7337b1bb1cd04d27d0f47dee128b093cdd6015fdade7967b404441d7abc522dcec18bfda8e682e7ae5418a24ba3a400afa9292b6585e796b644c27
+  metadata.gz: e99e6549ebfa01f6fc43b0a8f8bfba80ce0037700f2672be89bb0936b71f929bde127d667fc634a38bc6ea9e26d08a61393c5f261db3581362f8497001305790
+  data.tar.gz: 7e74593c1bb75c71d8864c1db31d9a415ec6fbc4d56a7f190363224f3906b884f0bd39af9208969112f12978b733ae09271e3a94b42ed1fc84b88553cd71df9d

data/CHANGELOG.md

@@ -5,6 +5,13 @@ 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.1 (2020-12-10)
+
+* [karlwilbur] - Modify regexp to:
+    - allow numeric-only hosts [#68]
+    - allow mailbox-only addresses  in `:rfc` mode
+    - enforce the 255-char domain limit (not in `:loose` mode unless using `:domain`)
+
 ## 2.2.0 (2020-12-09)
 
 * [karlwilbur] - Rename `:strict` -> `:rfc`; `:moderate` -> `:strict`

data/README.md

@@ -45,7 +45,7 @@ Add the following to your model:
 validates :my_email_attribute, email: true
 ```
 
-You may wish to allow domains without a FDQN, like `user@somehost`. While this
+You may wish to allow domains without a FQDN, like `user@somehost`. While this
 is technically a valid address, it is uncommon to consider such address valid.
 We will consider them valid by default with the `:loose` checking. Disallowed
 by setting `require_fqdn: true` or by enabling `:strict` checking:

data/lib/email_validator.rb

@@ -30,15 +30,31 @@ class EmailValidator < ActiveModel::EachValidator
     #  https://tools.ietf.org/html/rfc5321 : 4.1.2.  Command Argument Syntax
     def regexp(options = {})
       options = parse_options(options)
-      if options[:mode] == :loose
-        return /\A[^\s]+@[^\s]+\z/ if options[:domain].nil?
-        return /\A[^\s]+@#{domain_pattern(options)}\z/
+      case options[:mode]
+      when :loose
+        loose_regexp(options)
+      when :rfc
+        rfc_regexp(options)
+      else
+        strict_regexp(options)
       end
-      /\A(?>#{local_part_pattern})@#{domain_pattern(options)}\z/i
     end
 
     protected
 
+    def loose_regexp(options = {})
+      return /\A[^\s]+@[^\s]+\z/ if options[:domain].nil?
+      /\A[^\s]+@#{domain_part_pattern(options)}\z/
+    end
+
+    def strict_regexp(options = {})
+      /\A(?>#{local_part_pattern})@#{domain_part_pattern(options)}\z/i
+    end
+
+    def rfc_regexp(options = {})
+      /\A(?>#{local_part_pattern})(?:@#{domain_part_pattern(options)})?\z/i
+    end
+
     def alpha
       '[[:alpha:]]'
     end
@@ -64,8 +80,32 @@ class EmailValidator < ActiveModel::EachValidator
       "\\[(?:#{ipv4}|#{ipv6})\\]"
     end
 
-    def label_pattern
-      "#{alpha}(?:#{alnumhy}{,62}#{alnum})?"
+    def host_label_pattern
+      "#{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}" \
+      ')'
+    end
+
+    def domain_label_starts_with_a_letter_pattern
+      "#{alpha}#{alnumhy}{,61}#{alnum}"
+    end
+
+    def domain_label_ends_with_a_letter_pattern
+      "#{alnum}#{alnumhy}{,61}#{alpha}"
+    end
+
+    def domain_label_contains_a_letter_pattern
+      "(?:[[:digit:]])(?:[[:digit:]]|-)*#{alpha}#{alnumhy}*#{alnum}"
     end
 
     def atom_char
@@ -79,10 +119,14 @@ class EmailValidator < ActiveModel::EachValidator
       "#{atom_char}(?:\\.?#{atom_char}){,63}"
     end
 
-    def domain_pattern(options)
+    def domain_part_pattern(options)
       return options[:domain].sub(/\./, '\.') if options[:domain].present?
-      return "(?:#{label_pattern}\\.)+#{label_pattern}" if options[:require_fqdn]
-      "(?:#{address_literal}|(?:#{label_pattern}\\.)*#{label_pattern})"
+      return fqdn_pattern if options[:require_fqdn]
+      "(?=.{1,255}$)(?:#{address_literal}|(?:#{host_label_pattern}\\.)*#{domain_label_pattern})"
+    end
+
+    def fqdn_pattern
+      "(?=.{1,255}$)(?:#{host_label_pattern}\\.)*#{domain_label_pattern}\\.#{domain_label_pattern}"
     end
 
     private

data/spec/email_validator_spec.rb

@@ -140,7 +140,13 @@ RSpec.describe EmailValidator do
         'someuser@somehost.somedomain',
         'mixed-1234-in-{+^}-local@sld.dev',
         'partially."quoted"@sld.com',
-        'areallylongnameaasdfasdfasdfasdf@asdfasdfasdfasdfasdf.ab.cd.ef.gh.co.ca'
+        'areallylongnameaasdfasdfasdfasdf@asdfasdfasdfasdfasdf.ab.cd.ef.gh.co.ca',
+        'john.doe@2020.example.com',
+        'john.doe@2a.com',
+        'john.doe@a2.com',
+        'john.doe@2020.a-z.com',
+        'john.doe@2020.a2z.com',
+        'john.doe@2020.12345a6789.com'
       ]).flatten.each do |email|
         context 'when using defaults' do
           it "'#{email}' should be valid" do
@@ -260,6 +266,132 @@ RSpec.describe EmailValidator do
       end
     end
 
+    context 'when given the numeric domain' do
+      [
+        'only-numbers-in-domain-label@sub.123.custom'
+      ].each do |email|
+        context 'when using defaults' do
+          it "'#{email}' should be valid" do
+            expect(DefaultUser.new(:email => email)).to be_valid
+          end
+
+          it "'#{email}' should be valid using EmailValidator.valid?" do
+            expect(described_class).to be_valid(email)
+          end
+
+          it "'#{email}' should not be invalid using EmailValidator.invalid?" do
+            expect(described_class).not_to be_invalid(email)
+          end
+
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp)).to be(true)
+          end
+        end
+
+        context 'when in `:strict` mode' do
+          it "'#{email}' should not be valid" do
+            expect(StrictUser.new(:email => email)).not_to be_valid
+          end
+
+          it "'#{email}' should not be valid using EmailValidator.valid?" do
+            expect(described_class).not_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)
+          end
+
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
+          end
+        end
+
+        context 'when in `:rfc` mode' do
+          it "'#{email}' should be valid" do
+            expect(RfcUser.new(:email => email)).to be_valid
+          end
+
+          it "'#{email}' should be valid using EmailValidator.valid?" do
+            expect(described_class).to be_valid(email, :mode => :rfc)
+          end
+
+          it "'#{email}' should not be invalid using EmailValidator.invalid?" do
+            expect(described_class).not_to be_invalid(email, :mode => :rfc)
+          end
+
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(true)
+          end
+        end
+      end
+    end
+
+    context 'when given the valid mailbox-only email' do
+      valid_includable.map { |k, v| [
+        "user-#{v}-#{k}-name"
+      ]}.concat(valid_beginable.map { |k, v| [
+        "#{v}-start-with-#{k}-user"
+      ]}).concat(valid_endable.map { |k, v| [
+        "end-with-#{k}-#{v}"
+      ]}).concat([
+        'user'
+      ]).flatten.each do |email|
+        context 'when using defaults' do
+          it "'#{email}' should not be valid" do
+            expect(DefaultUser.new(:email => email)).not_to be_valid
+          end
+
+          it "'#{email}' should not be valid using EmailValidator.valid?" do
+            expect(described_class).not_to be_valid(email)
+          end
+
+          it "'#{email}' should be invalid using EmailValidator.invalid?" do
+            expect(described_class).to be_invalid(email)
+          end
+
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp)).to be(false)
+          end
+        end
+
+        context 'when in `:strict` mode' do
+          it "'#{email}' should not be valid" do
+            expect(StrictUser.new(:email => email)).not_to be_valid
+          end
+
+          it "'#{email}' should not be valid using EmailValidator.valid?" do
+            expect(described_class).not_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)
+          end
+
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
+          end
+        end
+
+        context 'when in `:rfc` mode' do
+          it "'#{email}' should be valid" do
+            expect(RfcUser.new(:email => email)).to be_valid
+          end
+
+          it "'#{email}' should be valid using EmailValidator.valid?" do
+            expect(described_class).to be_valid(email, :mode => :rfc)
+          end
+
+          it "'#{email}' should not be invalid using EmailValidator.invalid?" do
+            expect(described_class).not_to be_invalid(email, :mode => :rfc)
+          end
+
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(true)
+          end
+        end
+      end
+    end
+
     context 'when given the valid IP address email' do
       [
         'bracketed-IP@[127.0.0.1]',
@@ -334,8 +466,6 @@ RSpec.describe EmailValidator do
         'test@example.com@example.com',
         'missing-sld@.com',
         'missing-tld@sld.',
-        'only-numbers-in-domain-label@sub.123.com',
-        'only-numbers-in-domain-label@123.example.com',
         'unbracketed-IPv6@abcd:ef01:1234:5678:9abc:def0:1234:5678',
         'unbracketed-and-labled-IPv6@IPv6:abcd:ef01:1234:5678:9abc:def0:1234:5678',
         'bracketed-and-unlabeled-IPv6@[abcd:ef01:1234:5678:9abc:def0:1234:5678]',
@@ -347,6 +477,7 @@ RSpec.describe EmailValidator do
         'domain-beginning-with-dash@-example.com',
         'domain-ending-with-dash@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>"
       ]).flatten.each do |email|
         context 'when using defaults' do
@@ -504,8 +635,7 @@ RSpec.describe EmailValidator do
         '@bar.com',
         'test@',
         '@missing-local.dev',
-        ' ',
-        'missing-at-sign.dev'
+        ' '
       ].each do |email|
         context 'when using defaults' do
           it "'#{email}' should not be valid" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: email_validator
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Brian Alexander
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-09 00:00:00.000000000 Z
+date: 2020-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel