email_validator 1.5.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 46498bfe9a730667a04d6defd887df5d2db1e2d9
-  data.tar.gz: 8d82a1910be79a0301fb8bea538e48ce39e1783e
+SHA256:
+  metadata.gz: 0bd676f012ed7b109082842ed227bc1881aec6ac24f0e1ed4be24772b206b14f
+  data.tar.gz: 6c2f92e0a494f751b690743b15d4d97fd8dd1f9213b8cb2640d6f8f729fca51f
 SHA512:
-  metadata.gz: 5021fee86809281a8931171f82cde476dc5aff110c904c0a6d1c1aa57b8c06757dcd77215d28c5c66cd43e27da643b58e241bfb1a930da0d5110f86a976a28a5
-  data.tar.gz: 90b1b4a2b6b6cc9a7a80edbbf5adabd15ce0bb0218a289da766c40fe3d4ab53de192641cbaf946e769ce3dcf606ff0b7df638ac16b1e7181daf28c8e74d60847
+  metadata.gz: 8dd2ab72b087727acec6c7509d3ffa2a51e35074b99113bc8b105c16fc62e9c3288712516e3fc0f15be125d83e0d7db50d368da269672d7ecdddec9ba21f925e
+  data.tar.gz: e35ab67f7e7337b1bb1cd04d27d0f47dee128b093cdd6015fdade7967b404441d7abc522dcec18bfda8e682e7ae5418a24ba3a400afa9292b6585e796b644c27

data/CHANGELOG.md

@@ -0,0 +1,85 @@
+# CHANGELOG
+
+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.0 (2020-12-09)
+
+* [karlwilbur] - Rename `:strict` -> `:rfc`; `:moderate` -> `:strict`
+
+## 2.1.0 (2020-12-09)
+
+* [karlwilbur] - Add linters and commit hooks to validate code prior to commits
+* [karlwilbur] - Add `:mode` config option; values `:loose`, `:moderate`, `:strict`; default to `:loose`
+* [karlwilbur] - Merge in changes from <https://github.com/karlwilbur/email_validator> fork
+
+## 1.9.0.pre (2020-10-14)
+
+* [karlwilbur] - Add `require_fqdn` option, require FQDN by default
+* [karlwilbur] - Add support for IPv4 and IPv6 address hosts
+* [karlwilbur] - Add Rubocop, `.editorconfig`; code cleanup/linting
+
+## 1.8.0 (2019-06-14)
+
+* [karlwilbur] - Refactor class methods for readability
+* [karlwilbur] - `gemspec` meta updates
+* [karlwilbur] - Use POSIX classes for better performance
+* [karlwilbur] - Refactored tests to check specical characters one at a time
+* [karlwilbur] - Refactored validation regex to be more techincally correct
+* [karlwilbur] - Add this `CHANGELOG`
+
+## 1.7.0 (2019-04-20)
+
+* [karlwilbur] - Added test coverage badge to README
+* [karlwilbur] - Added I18n directive to remove warning message in testing
+* [karlwilbur] - Added RFC-2822 reference
+* [karlwilbur] - Ignore local rspec config file
+* [karlwilbur] - Check for invalid double dots in strict mode
+* [karlwilbur] - Updated spec_helper to remove Code Climate Test Reporter; it is to be run separately now
+* [karlwilbur] - Allow leading/trailing whitespace in normal, not strict
+* [karlwilbur] - Added `invalid?` as inverse of `valid?`
+* [karlwilbur] - Add the ability to limit to a domain
+* [karlwilbur] - Removed CodeShip badge
+* [karlwilbur] - Make the dot in the domain part non-conditional
+* [karlwilbur] - Fix domain label pattern to allow numbers per rfc5321
+
+## 1.6.0 (2015-06-14)
+
+* [karlwilbur] - Fixed validation to be closer to RFC-5321
+* [karlwilbur] - Updated specs to use Rspec 3 syntax
+* [karlwilbur] - Added unicode suport to validation regexp
+* [karlwilbur] - Added class access to regexp, and `valid?` calss method
+* [karlwilbur] - Simplified code using new methods
+* [karlwilbur] - Added CodeClimate and SimpleCov
+* [karlwilbur] - Updated version and contact info
+
+*** Forked from <https://github.com/balexand/email_validator>
+
+## 2.0.1 (2019-03-09)
+
+* Add email value to error details [f1sherman #50]
+* CI doesn't test Ruby versions that no longer receive updates [f1sherman #51]
+
+## 2.0.0 (2019-03-02)
+
+* Looser validation [#49]
+
+## 1.6.0 (2015-05-12)
+
+* Unicode characters support [i7an #24]
+
+## 1.5.0 (2014-12-08)
+
+* Add a class method for simpler validation [TiteiKo and cluesque #19]
+* RSpec 3.0 syntax [strivedi183 #17]
+* Create Changes.md
+
+---
+
+Check the [Markdown Syntax Guide](http://daringfireball.net/projects/markdown/syntax)
+for help with Markdown.
+
+The [Github Flavored Markdown page](http://github.github.com/github-flavored-markdown/)
+describes the differences between markdown on github and standard markdown.

data/README.md

@@ -1,6 +1,29 @@
-[![Build Status](https://secure.travis-ci.org/balexand/email_validator.png)](http://travis-ci.org/balexand/email_validator)
+# EmailValidator
 
-## Usage
+[![Build Status](https://travis-ci.com/K-and-R/email_validator.svg?branch=master)](http://travis-ci.com/K-and-R/email_validator)
+[![Code Climate](https://codeclimate.com/github/K-and-R/email_validator/badges/gpa.svg)](https://codeclimate.com/github/K-and-R/email_validator)
+[![Test Coverage](https://codeclimate.com/github/K-and-R/email_validator/badges/coverage.svg)](https://codeclimate.com/github/K-and-R/email_validator/coverage)
+
+An email validator for Rails 3+.
+
+Supports RFC-2822-compliant and RFC-5321-compliant email validation using RFC-3696 validation.
+
+Formerly found at: <https://github.com/balexand/email_validator>
+
+## Validation philosophy
+
+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)
+for an explanation of why.
+
+We understand that many use cases require an increased level of validation. This
+is supported by using the `:strict` validation mode. Additionally, the `:rfc`
+RFC-compliant mode will consider technically valid emails address as valid which
+may not be wanted, such as the valid `user` or `user@somehost` addresses. These
+would be valid in `:rfc` mode but not valid in `:loose` or `:strict`.
+
+## Installation
 
 Add to your Gemfile:
 
@@ -10,54 +33,181 @@ gem 'email_validator'
 
 Run:
 
-```
+```bash
 bundle install
 ```
 
-Then add the following to your model:
+## Usage
+
+Add the following to your model:
 
 ```ruby
-validates :my_email_attribute, :email => true
+validates :my_email_attribute, email: true
 ```
 
-## Strict mode
+You may wish to allow domains without a FDQN, 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:
+
+```ruby
+validates :my_email_attribute, email: {mode: :strict, require_fqdn: true}
+```
 
-In order to have stricter validation (according to http://www.remote.org/jochen/mail/info/chars.html) enable strict mode. You can do this globally by adding the following to your Gemfile:
+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):
 
 ```ruby
-gem 'email_validator', :require => 'email_validator/strict'
+validates :my_email_attribute, email: {domain: 'example.com'}
 ```
 
-Or you can do this in a specific `validates` call:
+## Configuration
+
+Default configuration can be overridden by setting options in `config/initializers/email_validator.rb`:
 
 ```ruby
-validates :my_email_attribute, :email => {:strict_mode => true}
+if defined?(EmailValidator)
+  # To completly override the defaults
+  EmailValidator.default_options = {
+    allow_nil: false,
+    domain: nil,
+    require_fqdn: nil,
+    mode: :loose
+  }
+
+  # or just a few options
+  EmailValidator.default_options.merge!({ domain: 'mydomain.com' })
+end
 ```
 
+### Loose mode
+
+This it the default validation mode of this gem. It is intentionally extremely
+loose (see the [Validation Philosophy section](#validation_philosophy) above. It
+just checks that there's an `@` with something before and after it without any
+whitespace.
+
+### Strict mode
+
+Enabling `:strict` checking will check for a "normal" email format that would
+be expected in most common everyday usage. Strict mode basically checks for a
+properly sized and formatted mailbox label, a single "@" symbol, and a properly
+sized and formatted FQDN. Enabling `:strict` mode will also enable `:require_fqdn`
+configuration option.
+
+Strict mode can be enabled globally by requiring `email_validator/strict` in
+your `Gemfile`, by setting the option in `config/initializers/email_validator.rb`,
+or by specifying the option in a specific `validates` call.
+
+* `Gemfile`:
+
+  ```ruby
+  gem 'email_validator', require: 'email_validator/strict'
+  ```
+
+* `config/initializers/email_validator.rb`:
+
+  ```ruby
+  if defined?(EmailValidator)
+    EmailValidator.default_options[:mode] = :strict
+  end
+  ```
+
+* `validates` call:
+
+  ```ruby
+  validates :my_email_attribute, email: {mode: :strict}
+  ```
+
+### RFC mode
+
+In order to have RFC-compliant validation (according to [http://www.remote.org/jochen/mail/info/chars.html](https://web.archive.org/web/20150508102948/http://www.remote.org/jochen/mail/info/chars.html)),
+enable `:rfc` mode.
+
+You can do this globally by requiring `email_validator/rfc` in your `Gemfile`,
+by setting the options in `config/initializers/email_validator.rb`, or you can do
+this in a specific `validates` call.
+
+* `Gemfile`:
+
+  ```ruby
+  gem 'email_validator', require: 'email_validator/rfc'
+  ```
+
+* `config/initializers/email_validator.rb`:
+
+  ```ruby
+  if defined?(EmailValidator)
+    EmailValidator.default_options[:mode] = :rfc
+  end
+  ```
+
+* `validates` call:
+
+  ```ruby
+  validates :my_email_attribute, email: {mode: :rfc}
+  ```
+
 ## Validation outside a model
 
-If you need to validate an email outside a model, you can get the regexp :
+If you need to validate an email outside a model, you can get the regexp:
 
-### Normal mode
+### Loose/default mode
 
 ```ruby
-EmailValidator.regexp # returns the regex
 EmailValidator.valid?('narf@example.com') # boolean
 ```
 
+### Requiring a FQDN
+
+```ruby
+EmailValidator.valid?('narf@somehost') # boolean false
+EmailValidator.invalid?('narf@somehost', require_fqdn: false) # boolean true
+```
+
+### Requiring a specific domain
+
+```ruby
+EmailValidator.valid?('narf@example.com', domain: 'foo.com') # boolean false
+EmailValidator.invalid?('narf@example.com', domain: 'foo.com') # boolean true
+```
+
 ### Strict mode
 
 ```ruby
-EmailValidator.regexp(:strict_mode => true)
+EmailValidator.regexp(mode: :strict) # returns the regex
+EmailValidator.valid?('narf@example.com', mode: :strict) # boolean
+```
+
+### RFC mode
+
+```ruby
+EmailValidator.regexp(mode: :rfc) # returns the regex
+EmailValidator.valid?('narf@example.com', mode: :rfc) # boolean
 ```
 
 ## Thread safety
 
-This gem is thread safe, with one caveat: `EmailValidator.default_options` must be configured before use in a multi-threaded environment. If you configure `default_options` in a Rails initializer file, then you're good to go since initializers are run before worker threads are spawned.
+This gem is thread safe, with one caveat: `EmailValidator.default_options` must
+be configured before use in a multi-threaded environment. If you configure
+`default_options` in a Rails initializer file, then you're good to go since
+initializers are run before worker threads are spawned.
+
+## Alternative gems
+
+Do you prefer a different email validation gem? If so, open an issue with a brief
+explanation of how it differs from this gem. I'll add a link to it in this README.
+
+* [`email_address`](https://github.com/afair/email_address) (<https://github.com/K-and-R/email_validator/issues/58>)
+* [`email_verifier`](https://github.com/kamilc/email_verifier) (<https://github.com/K-and-R/email_validator/issues/65>)
 
-## Credit
+## Maintainers
 
-Based on http://thelucid.com/2010/01/08/sexy-validation-in-edge-rails-rails-3
+All thanks is given to [Brian Alexander (balexand)](https://github.com/balexand)
+for is initial work on this gem.
 
-Regular Expression based on http://fightingforalostcause.net/misc/2006/compare-email-regex.php tests.
+Currently maintained by:
 
+* Karl Wilbur (<https://github.com/karlwilbur>)
+* K&R Software (<https://github.com/K-and-R>)

data/lib/email_validator.rb

@@ -1,28 +1,101 @@
 # Based on work from http://thelucid.com/2010/01/08/sexy-validation-in-edge-rails-rails-3/
 class EmailValidator < ActiveModel::EachValidator
-  @@default_options = {}
+  # rubocop:disable Style/ClassVars
+  @@default_options = {
+    :allow_nil => false,
+    :domain => nil,
+    :require_fqdn => nil,
+    :mode => :loose
+  }
+  # rubocop:enable Style/ClassVars
 
-  def self.regexp(options = {})
-    options = default_options.merge(options)
+  class << self
+    def default_options
+      @@default_options
+    end
 
-    name_validation = options[:strict_mode] ? "-a-z0-9+._" : "^@\\s"
+    def valid?(value, options = {})
+      options = parse_options(options)
+      return true if value.nil? && options[:allow_nil] == true
+      return false if value.nil?
+      !!(value =~ regexp(options))
+    end
 
-    /\A\s*([#{name_validation}]{1,64})@((?:[-a-z0-9]+\.)+[a-z]{2,})\s*\z/i
-  end
+    def invalid?(value, options = {})
+      !valid?(value, options)
+    end
 
-  def self.valid?(value, options = {})
-    !!(value =~ regexp(options))
-  end
+    # Refs:
+    #  https://tools.ietf.org/html/rfc2822 : 3.2. Lexical Tokens, 3.4.1. Addr-spec specification
+    #  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/
+      end
+      /\A(?>#{local_part_pattern})@#{domain_pattern(options)}\z/i
+    end
+
+    protected
+
+    def alpha
+      '[[:alpha:]]'
+    end
+
+    def alnum
+      '[[:alnum:]]'
+    end
+
+    def alnumhy
+      "(?:#{alnum}|-)"
+    end
+
+    def ipv4
+      '\d{1,3}(?:\.\d{1,3}){3}'
+    end
 
-  def self.default_options
-    @@default_options
+    def ipv6
+      # only supporting full IPv6 addresses right now
+      'IPv6:[[:xdigit:]]{1,4}(?::[[:xdigit:]]{1,4}){7}'
+    end
+
+    def address_literal
+      "\\[(?:#{ipv4}|#{ipv6})\\]"
+    end
+
+    def label_pattern
+      "#{alpha}(?:#{alnumhy}{,62}#{alnum})?"
+    end
+
+    def atom_char
+      # The `atext` spec
+      # We are looking at this without whitespace; no whitespace support here
+      "[-#{alpha}#{alnum}+_!\"'#$%^&*{}/=?`|~]"
+    end
+
+    def local_part_pattern
+      # the `dot-atom-text` spec, but with a 64 character limit
+      "#{atom_char}(?:\\.?#{atom_char}){,63}"
+    end
+
+    def domain_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})"
+    end
+
+    private
+
+    def parse_options(options)
+      # `:strict` mode enables `:require_fqdn`, unless it is already explicitly disabled
+      options[:require_fqdn] = true if options[:require_fqdn].nil? && options[:mode] == :strict
+      default_options.merge(options)
+    end
   end
 
   def validate_each(record, attribute, value)
     options = @@default_options.merge(self.options)
-
-    unless self.class.valid?(value, self.options)
-      record.errors.add(attribute, options[:message] || :invalid)
-    end
+    record.errors.add(attribute, options[:message] || :invalid) unless self.class.valid?(value, options)
   end
 end

data/spec/email_validator_spec.rb

@@ -1,198 +1,884 @@
 require 'spec_helper'
 
-class TestUser < TestModel
+class DefaultUser < TestModel
   validates :email, :email => true
 end
 
 class StrictUser < TestModel
-  validates :email, :email => {:strict_mode => true}
+  validates :email, :email => { :mode => :strict }
 end
 
-class TestUserAllowsNil < TestModel
-  validates :email, :email => {:allow_nil => true}
+class RfcUser < TestModel
+  validates :email, :email => { :mode => :rfc }
 end
 
-class TestUserAllowsNilFalse < TestModel
-  validates :email, :email => {:allow_nil => false}
+class AllowNilDefaultUser < TestModel
+  validates :email, :email => { :allow_nil => true }
 end
 
-class TestUserWithMessage < TestModel
-  validates :email_address, :email => {:message => 'is not looking very good!'}
+class AllowNilStrictUser < TestModel
+  validates :email, :email => { :allow_nil => true, :mode => :strict }
 end
 
-describe EmailValidator do
+class AllowNilRfcUser < TestModel
+  validates :email, :email => { :allow_nil => true, :mode => :rfc }
+end
 
-  describe "validation" do
-    context "given the valid emails" do
-      [
-        "a+b@plus-in-local.com",
-        "a_b@underscore-in-local.com",
-        "user@example.com",
-        " user@example.com ",
-        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@letters-in-local.org",
-        "01234567890@numbers-in-local.net",
-        "a@single-character-in-local.org",
-        "one-character-third-level@a.example.com",
-        "single-character-in-sld@x.org",
-        "local@dash-in-sld.com",
-        "letters-in-sld@123.com",
-        "one-letter-sld@x.org",
-        "uncommon-tld@sld.museum",
-        "uncommon-tld@sld.travel",
-        "uncommon-tld@sld.mobi",
-        "country-code-tld@sld.uk",
-        "country-code-tld@sld.rw",
-        "local@sld.newTLD",
-        "local@sub.domains.com",
-        "aaa@bbb.co.jp",
-        "nigel.worthington@big.co.uk",
-        "f@c.com",
-        "areallylongnameaasdfasdfasdfasdf@asdfasdfasdfasdfasdf.ab.cd.ef.gh.co.ca"
-      ].each do |email|
+class DisallowNilDefaultUser < TestModel
+  validates :email, :email => { :allow_nil => false }
+end
+
+class DisallowNilStrictUser < TestModel
+  validates :email, :email => { :allow_nil => false, :mode => :strict }
+end
+
+class DisallowNilRfcUser < TestModel
+  validates :email, :email => { :allow_nil => false, :mode => :rfc }
+end
+
+class DomainStrictUser < TestModel
+  validates :email, :email => { :domain => 'example.com', :mode => :strict }
+end
 
-        it "#{email.inspect} should be valid" do
-          expect(TestUser.new(:email => email)).to be_valid
+class DomainRfcUser < TestModel
+  validates :email, :email => { :domain => 'example.com', :mode => :rfc }
+end
+
+class NonFqdnStrictUser < TestModel
+  validates :email, :email => { :require_fqdn => false, :mode => :strict }
+end
+
+class NonFqdnRfcUser < TestModel
+  validates :email, :email => { :require_fqdn => false, :mode => :rfc }
+end
+
+class DefaultUserWithMessage < TestModel
+  validates :email_address, :email => { :message => 'is not looking very good!' }
+end
+
+RSpec.describe EmailValidator do
+  describe 'validation' do
+    valid_special_chars = {
+      :ampersand => '&',
+      :asterisk => '*',
+      :backtick => '`',
+      :braceleft => '{',
+      :braceright => '}',
+      :caret => '^',
+      :dollar => '$',
+      :equals => '=',
+      :exclaim => '!',
+      :hash => '#',
+      :hyphen => '-',
+      :percent => '%',
+      :plus => '+',
+      :pipe => '|',
+      :question => '?',
+      :quotedouble => '"',
+      :quotesingle => "'",
+      :slash => '/',
+      :tilde => '~',
+      :underscore => '_'
+    }
+
+    invalid_special_chars = {
+      :backslash => '\\',
+      :braketleft => '[',
+      :braketright => ']',
+      :colon => ':',
+      :comma => ',',
+      :greater => '>',
+      :lesser => '<',
+      :parenleft => '(',
+      :parenright => ')',
+      :semicolon => ';'
+    }
+
+    valid_includable            = valid_special_chars.merge({ :dot => '.' })
+    valid_beginable             = valid_special_chars
+    valid_endable               = valid_special_chars
+    invalid_includable          = { :at => '@' }
+    whitespace                  = { :newline => "\n", :tab => "\t", :carriage_return => "\r", :space => ' ' }
+    strictly_invalid_includable = invalid_special_chars
+    strictly_invalid_beginable  = strictly_invalid_includable.merge({ :dot => '.' })
+    strictly_invalid_endable    = strictly_invalid_beginable
+    domain_invalid_beginable    = invalid_special_chars.merge(valid_special_chars)
+    domain_invalid_endable      = domain_invalid_beginable
+    domain_invalid_includable   = domain_invalid_beginable.reject { |k, _v| k == :hyphen }
+
+    # rubocop:disable Layout/BlockEndNewline, Layout/MultilineBlockLayout, Layout/MultilineMethodCallBraceLayout, Style/BlockDelimiters, Style/MultilineBlockChain
+    context 'when given the valid email' do
+      valid_includable.map { |k, v| [
+        "include-#{v}-#{k}@valid-characters-in-local.dev"
+      ]}.concat(valid_beginable.map { |k, v| [
+        "#{v}start-with-#{k}@valid-characters-in-local.dev"
+      ]}).concat(valid_endable.map { |k, v| [
+        "end-with-#{k}-#{v}@valid-characters-in-local.dev"
+      ]}).concat([
+        'a+b@plus-in-local.com',
+        'a_b@underscore-in-local.com',
+        'user@example.com',
+        'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@letters-in-local.dev',
+        '01234567890@numbers-in-local.dev',
+        'a@single-character-in-local.dev',
+        'one-character-third-level@a.example.com',
+        'single-character-in-sld@x.dev',
+        'local@dash-in-sld.com',
+        'numbers-in-sld@s123.com',
+        'one-letter-sld@x.dev',
+        'uncommon-tld@sld.museum',
+        'uncommon-tld@sld.travel',
+        'uncommon-tld@sld.mobi',
+        'country-code-tld@sld.uk',
+        'country-code-tld@sld.rw',
+        'local@sld.newTLD',
+        'local@sub.domains.com',
+        'aaa@bbb.co.jp',
+        'nigel.worthington@big.co.uk',
+        'f@c.com',
+        'f@s.c',
+        'someuser@somehost.somedomain',
+        'mixed-1234-in-{+^}-local@sld.dev',
+        'partially."quoted"@sld.com',
+        'areallylongnameaasdfasdfasdfasdf@asdfasdfasdfasdfasdf.ab.cd.ef.gh.co.ca'
+      ]).flatten.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
 
-        it "#{email.inspect} should be valid in strict_mode" do
-          expect(StrictUser.new(:email => email)).to be_valid
+        context 'when in `:strict` mode' do
+          it "'#{email}' should be valid" do
+            expect(StrictUser.new(:email => email)).to be_valid
+          end
+
+          it "'#{email}' should be valid using EmailValidator.valid?" do
+            expect(described_class).to be_valid(email, :mode => :strict)
+          end
+
+          it "'#{email}' should not be invalid using EmailValidator.valid?" do
+            expect(described_class).not_to be_invalid(email, :mode => :strict)
+          end
+
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(true)
+          end
         end
 
-        it "#{email.inspect} should match the regexp" do
-          expect(email =~ EmailValidator.regexp).to be_truthy
+        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
 
-        it "#{email.inspect} should match the strict regexp" do
-          expect(email =~ EmailValidator.regexp(:strict_mode => true)).to be_truthy
+    context 'when given the valid host-only email' do
+      [
+        'f@s',
+        'user@localhost',
+        'someuser@somehost'
+      ].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
 
-        it "#{email.inspect} should pass the class tester" do
-          expect(EmailValidator.valid?(email)).to be_truthy
+        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
 
-      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 "given the invalid emails" do
+    context 'when given the valid IP address email' do
       [
-        "",
-        "f@s",
-        "f@s.c",
-        "@bar.com",
-        "test@example.com@example.com",
-        "test@",
-        "@missing-local.org",
-        "a b@space-in-local.com",
-        "! \#$%\`|@invalid-characters-in-local.org",
-        "<>@[]\`|@even-more-invalid-characters-in-local.org",
-        "missing-sld@.com",
-        "invalid-characters-in-sld@! \"\#$%(),/;<>_[]\`|.org",
-        "missing-dot-before-tld@com",
-        "missing-tld@sld.",
-        " ",
-        "missing-at-sign.net",
-        "unbracketed-IP@127.0.0.1",
-        "invalid-ip@127.0.0.1.26",
-        "another-invalid-ip@127.0.0.256",
-        "IP-and-port@127.0.0.1:25",
-        "the-local-part-is-invalid-if-it-is-longer-than-sixty-four-characters@sld.net",
-        "user@example.com\n<script>alert('hello')</script>"
+        'bracketed-IP@[127.0.0.1]',
+        'bracketed-and-labeled-IPv6@[IPv6:abcd:ef01:1234:5678:9abc:def0:1234:5678]'
       ].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.inspect} should not be valid" do
-          expect(TestUser.new(:email => email)).not_to be_valid
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
+          end
         end
 
-        it "#{email.inspect} should not be valid in strict_mode" do
-          expect(StrictUser.new(:email => email)).not_to be_valid
+        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 invalid email' do
+      invalid_includable.map { |k, v| [
+        "include-#{v}-#{k}@invalid-characters-in-local.dev"
+      ]}.concat(domain_invalid_beginable.map { |k, v| [
+        "start-with-#{k}@#{v}invalid-characters-in-domain.dev"
+      ]}).concat(domain_invalid_endable.map { |k, v| [
+        "end-with-#{k}@invalid-characters-in-domain#{v}.dev"
+      ]}).concat(domain_invalid_includable.map { |k, v| [
+        "include-#{k}@invalid-characters-#{v}-in-domain.dev"
+      ]}).concat([
+        '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]',
+        'unbracketed-IPv4@127.0.0.1',
+        'invalid-IPv4@127.0.0.1.26',
+        'another-invalid-IPv4@127.0.0.256',
+        'IPv4-and-port@127.0.0.1:25',
+        'host-beginning-with-dot@.example.com',
+        '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',
+        "user@example.com<script>alert('hello')</script>"
+      ]).flatten.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
 
-        it "#{email.inspect} should not match the regexp" do
-          expect(email =~ EmailValidator.regexp).to be_falsy
+        context 'when in `:rfc` mode' do
+          it "'#{email}' should not be valid" do
+            expect(RfcUser.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 => :rfc)
+          end
+
+          it "'#{email}' should be invalid using EmailValidator.invalid?" do
+            expect(described_class).to be_invalid(email, :mode => :rfc)
+          end
+
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(false)
+          end
         end
+      end
+    end
 
-        it "#{email.inspect} should not match the strict regexp" do
-          expect(email =~ EmailValidator.regexp(:strict_mode => true)).to be_falsy
+    context 'when given the invalid email with whitespace in parts' do
+      whitespace.map { |k, v| [
+        "include-#{v}-#{k}@invalid-characters-in-local.dev"
+      ]}.concat([
+        'foo @bar.com',
+        "foo\t@bar.com",
+        "foo\n@bar.com",
+        "foo\r@bar.com",
+        'test@ example.com',
+        'user@example .com',
+        "user@example\t.com",
+        "user@example\n.com",
+        "user@example\r.com",
+        'user@exam ple.com',
+        "user@exam\tple.com",
+        "user@exam\nple.com",
+        "user@exam\rple.com",
+        'us er@example.com',
+        "us\ter@example.com",
+        "us\ner@example.com",
+        "us\rer@example.com",
+        "user@example.com\n<script>alert('hello')</script>",
+        "user@example.com\t<script>alert('hello')</script>",
+        "user@example.com\r<script>alert('hello')</script>",
+        "user@example.com <script>alert('hello')</script>",
+        ' leading-whitespace@example.com',
+        'trailing-whitespace@example.com ',
+        ' leading-and-trailing-whitespace@example.com ',
+        ' user-with-leading-whitespace-space@example.com',
+        "\tuser-with-leading-whitespace-tab@example.com",
+        "
+        user-with-leading-whitespace-newline@example.com",
+        'domain-with-trailing-whitespace-space@example.com ',
+        "domain-with-trailing-whitespace-tab@example.com\t",
+        "domain-with-trailing-whitespace-newline@example.com
+        "
+      ]).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 =~ described_class.regexp)).to be(false)
+          end
         end
 
-        it "#{email.inspect} should fail the class tester" do
-          expect(EmailValidator.valid?(email)).to be_falsy
+        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 =~ described_class.regexp(:mode => :strict))).to be(false)
+          end
         end
 
+        context 'when in `:rfc` mode' do
+          it "'#{email}' should not be valid" do
+            expect(RfcUser.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 => :rfc)
+          end
+
+          it "'#{email}' should be invalid using EmailValidator.invalid?" do
+            expect(described_class).to be_invalid(email, :mode => :rfc)
+          end
+
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email =~ described_class.regexp(:mode => :rfc))).to be(false)
+          end
+        end
       end
     end
 
-    context "given the emails that should be invalid in strict_mode but valid in normal mode" do
+    context 'when given the invalid email with missing parts' do
       [
-        "hans,peter@example.com",
-        "hans(peter@example.com",
-        "hans)peter@example.com",
-        "partially.\"quoted\"@sld.com",
-        "&'*+-./=?^_{}~@other-valid-characters-in-local.net",
-        "mixed-1234-in-{+^}-local@sld.net"
+        '',
+        '@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
+            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
 
-        it "#{email.inspect} should be valid" do
-          expect(TestUser.new(:email => email)).to be_valid
+        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
 
-        it "#{email.inspect} should not be valid in strict_mode" do
-          expect(StrictUser.new(:email => email)).not_to be_valid
+        context 'when in `:rfc` mode' do
+          it "'#{email}' should not be valid" do
+            expect(RfcUser.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 => :rfc)
+          end
+
+          it "'#{email}' should be invalid using EmailValidator.invalid?" do
+            expect(described_class).to be_invalid(email, :mode => :rfc)
+          end
+
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(false)
+          end
         end
+      end
+    end
 
-        it "#{email.inspect} should match the regexp" do
-          expect(email =~ EmailValidator.regexp).to be_truthy
+    context 'when given the strictly invalid email' do
+      strictly_invalid_includable.map { |k, v| [
+        "include-#{v}-#{k}@invalid-characters-in-local.dev"
+      ]}.concat(strictly_invalid_beginable.map { |k, v| [
+        "#{v}start-with-#{k}@invalid-characters-in-local.dev"
+      ]}).concat(strictly_invalid_endable.map { |k, v| [
+        "end-with-#{k}#{v}@invalid-characters-in-local.dev"
+      ]}).concat([
+        'user..-with-double-dots@example.com',
+        '.user-beginning-with-dot@example.com',
+        'user-ending-with-dot.@example.com'
+      ]).flatten.each do |email|
+        context 'when using defaults' do
+          it "#{email.strip} in a model should be valid" do
+            expect(DefaultUser.new(:email => email)).to be_valid
+          end
+
+          it "#{email.strip} should be valid using EmailValidator.valid?" do
+            expect(described_class).to be_valid(email)
+          end
+
+          it "#{email.strip} should not be invalid using EmailValidator.invalid?" do
+            expect(described_class).not_to be_invalid(email)
+          end
+
+          it "#{email.strip} should match the regexp" do
+            expect(!!(email =~ described_class.regexp)).to be(true)
+          end
         end
 
-        it "#{email.inspect} should not match the strict regexp" do
-          expect(email =~ EmailValidator.regexp(:strict_mode => true)).to be_falsy
+        context 'when in `:strict` mode' do
+          it "#{email.strip} in a model should be valid" do
+            expect(StrictUser.new(:email => email)).not_to be_valid
+          end
+
+          it "#{email.strip} should not be valid using EmailValidator.valid?" do
+            expect(described_class).not_to be_valid(email, :mode => :strict)
+          end
+
+          it "#{email.strip} should be invalid using EmailValidator.invalid?" do
+            expect(described_class).to be_invalid(email, :mode => :strict)
+          end
+
+          it "#{email.strip} should not match the regexp" do
+            expect(!!(email =~ described_class.regexp(:mode => :strict))).to be(false)
+          end
         end
 
+        context 'when in `:rfc` mode' do
+          it "#{email.strip} in a model should not be valid" do
+            expect(RfcUser.new(:email => email)).not_to be_valid
+          end
+
+          it "#{email.strip} should not be valid using EmailValidator.valid?" do
+            expect(described_class).not_to be_valid(email, :mode => :rfc)
+          end
+
+          it "#{email.strip} should be invalid using EmailValidator.invalid?" do
+            expect(described_class).to be_invalid(email, :mode => :rfc)
+          end
+
+          it "#{email.strip} should not match the regexp" do
+            expect(!!(email =~ described_class.regexp(:mode => :rfc))).to be(false)
+          end
+        end
+      end
+    end
+
+    context 'when `require_fqdn` is explicitly disabled' do
+      let(:opts) { { :require_fqdn => false } }
+
+      context 'when given a valid hostname-only email' do
+        let(:email) { 'someuser@somehost' }
+
+        context 'when using defaults' do
+          it 'is valid using EmailValidator.valid?' do
+            expect(described_class).to be_valid(email, opts)
+          end
+
+          it 'is not invalid using EmailValidator.invalid?' do
+            expect(described_class).not_to be_invalid(email, opts)
+          end
+
+          it 'matches the regexp' do
+            expect(!!(email =~ described_class.regexp(opts))).to be(true)
+          end
+        end
+
+        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
+          end
+
+          it 'is valid using EmailValidator.valid?' do
+            expect(described_class).to be_valid(email, opts)
+          end
+
+          it 'is not invalid using EmailValidator.invalid?' do
+            expect(described_class).not_to be_invalid(email, opts)
+          end
+
+          it 'matches the regexp' do
+            expect(!!(email =~ described_class.regexp(opts))).to be(true)
+          end
+        end
+
+        context 'when in `:rfc` mode' do
+          let(:opts) { { :require_fqdn => false, :mode => :rfc } }
+
+          it 'is valid' do
+            expect(NonFqdnRfcUser.new(:email => email)).to be_valid
+          end
+
+          it 'is valid using EmailValidator.valid?' do
+            expect(described_class).to be_valid(email, opts)
+          end
+
+          it 'is not invalid using EmailValidator.invalid?' do
+            expect(described_class).not_to be_invalid(email, opts)
+          end
+
+          it 'matches the regexp' do
+            expect(!!(email =~ described_class.regexp(opts))).to be(true)
+          end
+        end
+      end
+
+      context 'when given a valid email using an FQDN' do
+        let(:email) { 'someuser@somehost.somedomain' }
+
+        it 'is valid' do
+          expect(NonFqdnStrictUser.new(:email => email)).to be_valid
+        end
+
+        # rubocop:disable RSpec/PredicateMatcher
+        it 'is valid using EmailValidator.valid?' do
+          expect(described_class.valid?(email, opts)).to be(true)
+        end
+
+        it 'is not invalid using EmailValidator.invalid?' do
+          expect(described_class.invalid?(email, opts)).to be(false)
+        end
+        # rubocop:enable RSpec/PredicateMatcher
+
+        it 'matches the regexp' do
+          expect(!!(email =~ described_class.regexp(opts))).to be(true)
+        end
+
+        context 'when in `:rfc` mode' do
+          let(:opts) { { :require_fqdn => false, :mode => :rfc } }
+
+          # rubocop:disable RSpec/PredicateMatcher
+          it 'is valid using EmailValidator.valid?' do
+            expect(described_class.valid?(email, opts)).to be(true)
+          end
+
+          it 'is not invalid using EmailValidator.invalid?' do
+            expect(described_class.invalid?(email, opts)).to be(false)
+          end
+          # rubocop:enable RSpec/PredicateMatcher
+
+          it 'is valid' do
+            expect(NonFqdnRfcUser.new(:email => email)).to be_valid
+          end
+
+          it 'matches the regexp' do
+            expect(!!(email =~ described_class.regexp(opts))).to be(true)
+          end
+        end
+
+        context 'when requiring a non-matching domain' do
+          let(:domain) { 'example.com' }
+          let(:opts) { { :domain => domain } }
+
+          it 'is not valid' do
+            expect(DomainStrictUser.new(:email => email)).not_to be_valid
+          end
+
+          it 'is not valid 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 matches the regexp' do
+            expect(!!(email =~ described_class.regexp(opts))).to be(false)
+          end
+
+          context 'when in `:rfc` mode' do
+            let(:opts) { { :domain => domain, :require_fqdn => false, :mode => :rfc } }
+
+            it 'is not valid 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 'is not valid' do
+              expect(DomainRfcUser.new(:email => email)).not_to be_valid
+            end
+
+            it 'does not match the regexp' do
+              expect(!!(email =~ described_class.regexp(opts))).to be(false)
+            end
+          end
+        end
       end
     end
   end
+  # rubocop:enable Layout/BlockEndNewline, Layout/MultilineBlockLayout, Layout/MultilineMethodCallBraceLayout, Style/BlockDelimiters, Style/MultilineBlockChain
+
+  describe 'error messages' do
+    context 'when the message is not defined' do
+      let(:model) { DefaultUser.new :email => 'invalidemail@' }
 
-  describe "error messages" do
-    context "when the message is not defined" do
-      subject { TestUser.new :email => 'invalidemail@' }
-      before { subject.valid? }
+      before { model.valid? }
 
-      it "should add the default message" do
-        expect(subject.errors[:email]).to include "is invalid"
+      it 'adds the default message' do
+        expect(model.errors[:email]).to include 'is invalid'
       end
     end
 
-    context "when the message is defined" do
-      subject { TestUserWithMessage.new :email_address => 'invalidemail@' }
-      before { subject.valid? }
+    context 'when the message is defined' do
+      let(:model) { DefaultUserWithMessage.new :email_address => 'invalidemail@' }
 
-      it "should add the customized message" do
-        expect(subject.errors[:email_address]).to include "is not looking very good!"
+      before { model.valid? }
+
+      it 'adds the customized message' do
+        expect(model.errors[:email_address]).to include 'is not looking very good!'
       end
     end
   end
 
-  describe "nil email" do
-    it "should not be valid when :allow_nil option is missing" do
-      expect(TestUser.new(:email => nil)).not_to be_valid
+  describe 'nil email' do
+    it 'is not valid when :allow_nil option is missing' do
+      expect(DefaultUser.new(:email => nil)).not_to be_valid
     end
 
-    it "should be valid when :allow_nil options is set to true" do
-      expect(TestUserAllowsNil.new(:email => nil)).to be_valid
+    it 'is valid when :allow_nil options is set to true' do
+      expect(AllowNilDefaultUser.new(:email => nil)).to be_valid
     end
 
-    it "should not be valid when :allow_nil option is set to false" do
-      expect(TestUserAllowsNilFalse.new(:email => nil)).not_to be_valid
+    it 'is not valid when :allow_nil option is set to false' do
+      expect(DisallowNilDefaultUser.new(:email => nil)).not_to be_valid
     end
   end
 
-  describe "default_options" do
-    context "when 'email_validator/strict' has been required" do
+  describe 'limited to a domain' do
+    context 'when in `:strict` mode' do
+      it 'is not valid with mismatched domain' do
+        expect(DomainStrictUser.new(:email => 'user@not-matching.io')).not_to be_valid
+      end
+
+      it 'is valid with matching domain' do
+        expect(DomainStrictUser.new(:email => 'user@example.com')).to be_valid
+      end
+
+      it 'does not interpret the dot as any character' do
+        expect(DomainStrictUser.new(:email => 'user@example-com')).not_to be_valid
+      end
+    end
+
+    context 'when in `:rfc` mode' do
+      it 'does not interpret the dot as any character' do
+        expect(DomainRfcUser.new(:email => 'user@example-com')).not_to be_valid
+      end
+
+      it 'is valid with matching domain' do
+        expect(DomainRfcUser.new(:email => 'user@example.com')).to be_valid
+      end
+
+      it 'is not valid with mismatched domain' do
+        expect(DomainRfcUser.new(:email => 'user@not-matching.io')).not_to be_valid
+      end
+    end
+  end
+
+  describe 'default_options' do
+    let(:valid_email) { 'valid-email@localhost.localdomain' }
+    let(:invalid_email) { 'invalid email@localhost.localdomain' }
+
+    it 'validates valid using `:loose` mode' do
+      expect(DefaultUser.new(:email => valid_email)).to be_valid
+    end
+
+    it 'invalidates invalid using `:loose` mode' do
+      expect(DefaultUser.new(:email => invalid_email)).to be_invalid
+    end
+
+    context 'when `email_validator/strict` has been required' do
       before { require 'email_validator/strict' }
 
-      it "should validate using strict mode" do
-        expect(TestUser.new(:email => "&'*+-./=?^_{}~@other-valid-characters-in-local.net")).not_to be_valid
+      it 'validates valid using `:strict` mode' do
+        expect(DefaultUser.new(:email => valid_email)).to be_valid
+      end
+
+      it 'invalidates invalid using `:strict` mode' do
+        expect(DefaultUser.new(:email => invalid_email)).to be_invalid
+      end
+    end
+
+    context 'when `email_validator/rfc` has been required' do
+      before { require 'email_validator/rfc' }
+
+      it 'validates valid using `:rfc` mode' do
+        expect(DefaultUser.new(:email => valid_email)).to be_valid
+      end
+
+      it 'invalidates invalid using `:rfc` mode' do
+        expect(DefaultUser.new(:email => invalid_email)).to be_invalid
       end
     end
   end