email_validator 2.2.2 → 2.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f5010b8d56592e8febeda1e96b6fa35a27e2dae75dab6277fbade5f35b74b18
-  data.tar.gz: 50bbb4a9c6abea2db5c2e887ba67a88739afccdb445c56be74c063b10993cef3
+  metadata.gz: c6952edf85fc0eafbe159b4a3b812731c81361ee0a15f22927e270a3eb885c9d
+  data.tar.gz: 8b5a56e059f652f1822c93cbcec0be9da23842433e9c7e5f97478496ba888ff9
 SHA512:
-  metadata.gz: b520404b2777c72ac87eaccaaacb073b340ebca043d104d531d8d78c74fd413d2f0e1c5ef6b7d08529a23d2aad913c7e1d15ab16989ea5777b5f41d37539365b
-  data.tar.gz: 100eb11eaff2bd530d7a6c554655d93649a45aa6a5e5718a31cfa0c994f8e5341b57964d01c7f256ce4e8e927c3ba8e5610694cd293dda2d3241a2f2c187e1b9
+  metadata.gz: 158307d4196989b8d73872fa91c302ee9eab174b25f0686f3d61fe395796fa0b8e6c1c08185a4accf6c9581e23ba66bbebb8e3e8dc46b7ded935ed80a2484b53
+  data.tar.gz: 7f9ccf405a9bcf08d809fa58819d9e6d8489871a52020115802f3c755eddc3962b3533928f8f7c40e8122b055ad185c6f72cf1878ad6c920ba1b86872c0362a8

data/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.4 (2022-11-09)
+
+* [karlwilbur] - Remove Ruby 2.4 from tested versions; add Ruby 3.0 and 3.1 to tested versions
+* [karlwilbur] - Fix issue where `domain: ''` wasn't requiring empty domain
+* [karlwilbur] - Remove checks for double hyphens (fixes [#87](https://github.com/K-and-R/email_validator/issues/87))
+* [dependabot] - Security updates
+    - [#89](https://github.com/K-and-R/email_validator/pull/89)
+        + Bump `minimist` from `1.2.5` to `1.2.7`
+    - [#86](https://github.com/K-and-R/email_validator/pull/86)
+        + Bump `node-fetch` from `2.6.1` to `2.6.7`
+        + Add `whatwg-url` at `5.0.0`
+        + Add `tr46` at `0.0.3`
+        + Add `webidl-conversions` at `3.0.0`
+    - [#80](https://github.com/K-and-R/email_validator/pull/80)
+        + Bump `tar` from `6.0.5` to `6.1.11`
+        + Bump `minipass` from `3.1.3` to `3.1.5`
+    - [#79](https://github.com/K-and-R/email_validator/pull/79)
+        + Bump `path-parse` from `1.0.6` to `1.0.7`
+    - [#76](https://github.com/K-and-R/email_validator/pull/76)
+        + Bump `lodash` from `4.17.20` to `4.17.21`
+    - [#75](https://github.com/K-and-R/email_validator/pull/75)
+        + Bump `hosted-git-info` from `2.8.8` to `2.8.9`
+* [msands] - Fix URL in `README.md` [#81](https://github.com/K-and-R/email_validator/pull/81)
+* [kerolloz] - Fix typo in `README.md` [#73](https://github.com/K-and-R/email_validator/pull/73)
+
+## 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

@@ -14,7 +14,7 @@ Formerly found at: <https://github.com/balexand/email_validator>
 
 The default validation provided by this gem (the `:loose` configuration option)
 is extremely loose. It just checks that there's an `@` with something before and
-after it without any whitespace. See [this article by David Gilbertson](https://hackernoon.com/the-100-correct-way-to-validate-email-addresses-7c4818f24643)
+after it without any whitespace. See [this article by David Gilbertson](https://medium.com/hackernoon/the-100-correct-way-to-validate-email-addresses-7c4818f24643)
 for an explanation of why.
 
 We understand that many use cases require an increased level of validation. This
@@ -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'}
@@ -68,7 +68,7 @@ Default configuration can be overridden by setting options in `config/initialize
 
 ```ruby
 if defined?(EmailValidator)
-  # To completly override the defaults
+  # To completely override the defaults
   EmailValidator.default_options = {
     allow_nil: false,
     domain: nil,
@@ -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
@@ -18,6 +27,8 @@ class EmailValidator < ActiveModel::EachValidator
       options = parse_options(options)
       return true if value.nil? && options[:allow_nil] == true
       return false if value.nil?
+      # quickly fail if domain is required but doesn't match
+      return false unless options[:domain].nil? || value[/^.*@#{regexp_safe_domain(options)}$/]
       !!(value =~ regexp(options))
     end
 
@@ -35,8 +46,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 +95,33 @@ class EmailValidator < ActiveModel::EachValidator
     end
 
     def host_label_pattern
+      "#{label_is_correct_length}" \
       "#{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
 
-    def domain_label_starts_with_a_letter_pattern
-      "#{alpha}#{alnumhy}{,61}#{alnum}"
+    # 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_ends_with_a_letter_pattern
-      "#{alnum}#{alnumhy}{,61}#{alpha}"
+    def label_is_correct_length
+      '(?=[^.]{1,63}(?:\.|$))'
     end
 
-    def domain_label_contains_a_letter_pattern
-      "(?:[[:digit:]])(?:[[:digit:]]|-)*#{alpha}#{alnumhy}*#{alnum}"
+    def domain_part_is_correct_length
+      '(?=.{1,255}$)'
     end
 
     def atom_char
@@ -120,13 +136,13 @@ class EmailValidator < ActiveModel::EachValidator
     end
 
     def domain_part_pattern(options)
-      return options[:domain].sub(/\./, '\.') if options[:domain].present?
+      return regexp_safe_domain(options) unless options[:domain].nil?
       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
@@ -136,6 +152,10 @@ class EmailValidator < ActiveModel::EachValidator
       options[:require_fqdn] = true if options[:require_fqdn].nil? && options[:mode] == :strict
       default_options.merge(options)
     end
+
+    def regexp_safe_domain(options)
+      options[:domain].sub(/\./, '\.')
+    end
   end
 
   def validate_each(record, attribute, value)

data/spec/email_validator_spec.rb

@@ -52,6 +52,18 @@ class NonFqdnRfcUser < TestModel
   validates :email, :email => { :require_fqdn => false, :mode => :rfc }
 end
 
+class RequireFqdnWithEmptyDomainUser < TestModel
+  validates :email_address, :email => { :require_fqdn => true, :domain => '' }
+end
+
+class RequireEmptyDomainStrictUser < TestModel
+  validates :email_address, :email => { :require_fqdn => true, :domain => '', :mode => :strict }
+end
+
+class RequireEmptyDomainRfcUser < TestModel
+  validates :email_address, :email => { :require_fqdn => true, :domain => '', :mode => :rfc }
+end
+
 class DefaultUserWithMessage < TestModel
   validates :email_address, :email => { :message => 'is not looking very good!' }
 end
@@ -146,7 +158,10 @@ 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',
+        'test@umläut.com', # non-ASCII
+        'test@xn--umlut-ira.com' # ASCII-compatibale encoding of non-ASCII
       ]).flatten.each do |email|
         context 'when using defaults' do
           it "'#{email}' should be valid" do
@@ -289,20 +304,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
 
@@ -703,7 +718,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
@@ -724,7 +740,7 @@ RSpec.describe EmailValidator do
         end
 
         context 'when in `:strict` mode' do
-          it "#{email.strip} in a model should be valid" do
+          it "#{email.strip} in a model should not be valid" do
             expect(StrictUser.new(:email => email)).not_to be_valid
           end
 
@@ -761,6 +777,68 @@ RSpec.describe EmailValidator do
       end
     end
 
+    context 'when `require_fqdn` is explicitly enabled with a blank domain' do
+      let(:opts) { { :require_fqdn => true, :domain => '' } }
+
+      context 'when given a email containing any domain' do
+        let(:email) { 'someuser@somehost' }
+
+        context 'when using defaults' do
+          it 'is not valid in a model' do
+            expect(RequireFqdnWithEmptyDomainUser.new(:email => email)).not_to be_valid
+          end
+
+          it 'is not using EmailValidator.valid?' do
+            expect(described_class).not_to be_valid(email, opts)
+          end
+
+          it 'is invalid using EmailValidator.invalid?' do
+            expect(described_class).to be_invalid(email, opts)
+          end
+
+          it 'does not match the regexp' do
+            expect(!!(email =~ described_class.regexp(opts))).to be(false)
+          end
+        end
+
+        context 'when in `:strict` mode' do
+          it 'is not valid in a model' do
+            expect(RequireEmptyDomainStrictUser.new(:email => email)).not_to be_valid
+          end
+
+          it 'is not using EmailValidator.valid?' do
+            expect(described_class).not_to be_valid(email, opts.merge({ :mode => :strict }))
+          end
+
+          it 'is invalid using EmailValidator.invalid?' do
+            expect(described_class).to be_invalid(email, opts.merge({ :mode => :strict }))
+          end
+
+          it 'does not match the regexp' do
+            expect(!!(email =~ described_class.regexp(opts.merge({ :mode => :strict })))).to be(false)
+          end
+        end
+
+        context 'when in `:rfc` mode' do
+          it 'is not valid in a model' do
+            expect(RequireEmptyDomainRfcUser.new(:email => email)).not_to be_valid
+          end
+
+          it 'is not using EmailValidator.valid?' do
+            expect(described_class).not_to be_valid(email, opts.merge({ :mode => :rfc }))
+          end
+
+          it 'is invalid using EmailValidator.invalid?' do
+            expect(described_class).to be_invalid(email, opts.merge({ :mode => :rfc }))
+          end
+
+          it 'does not match the regexp' do
+            expect(!!(email =~ described_class.regexp(opts.merge({ :mode => :rfc })))).to be(false)
+          end
+        end
+      end
+    end
+
     context 'when `require_fqdn` is explicitly disabled' do
       let(:opts) { { :require_fqdn => false } }
 
@@ -781,23 +859,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 +1091,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.4
 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: 2022-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -61,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: An email validator for Rails 3+.