email_validator 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc66e9e16fb1ba1babe7b102865ba9b112eb373392057313c9e7aeffcef2bf23
-  data.tar.gz: a4a991392b379b60dbf04105469c28424a8c294d62557095e920cee7d2cf8e27
+  metadata.gz: 0bd676f012ed7b109082842ed227bc1881aec6ac24f0e1ed4be24772b206b14f
+  data.tar.gz: 6c2f92e0a494f751b690743b15d4d97fd8dd1f9213b8cb2640d6f8f729fca51f
 SHA512:
-  metadata.gz: 864e0e44385e3252be96087fd57f76b81e26cfdd4bec1a08a880afaf1335efbba609b7b28ef821cb4df63519776ec95a520d6f6f1910d77b28221cacae8cab28
-  data.tar.gz: bb48dc83509e3a87d581153aa8f3950431a2daf106c4a2bd5be798925a8a3629e054f4397127c748b5f99eba69b55e0084a7b6e0597343d02f3ed617e057f46c
+  metadata.gz: 8dd2ab72b087727acec6c7509d3ffa2a51e35074b99113bc8b105c16fc62e9c3288712516e3fc0f15be125d83e0d7db50d368da269672d7ecdddec9ba21f925e
+  data.tar.gz: e35ab67f7e7337b1bb1cd04d27d0f47dee128b093cdd6015fdade7967b404441d7abc522dcec18bfda8e682e7ae5418a24ba3a400afa9292b6585e796b644c27

data/CHANGELOG.md

@@ -5,6 +5,10 @@ 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

data/README.md

@@ -1,12 +1,12 @@
 # EmailValidator
 
-[![Build Status](https://secure.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/karlwilbur/email_validator/badges/gpa.svg)](https://codeclimate.com/github/karlwilbur/email_validator)
-[![Test Coverage](https://codeclimate.com/github/karlwilbur/email_validator/badges/coverage.svg)](https://codeclimate.com/github/karlwilbur/email_validator/coverage)
+[![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.
+Supports RFC-2822-compliant and RFC-5321-compliant email validation using RFC-3696 validation.
 
 Formerly found at: <https://github.com/balexand/email_validator>
 
@@ -17,11 +17,11 @@ 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 maybe use cases require more stricy validation and this is
-supported by using the `:moderate` validation mode. Additionally, the `:strict`
+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 `:strict` mode but not valid in `:loose` or `:moderate`.
+would be valid in `:rfc` mode but not valid in `:loose` or `:strict`.
 
 ## Installation
 
@@ -48,10 +48,10 @@ validates :my_email_attribute, email: true
 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 `:moderate` checking:
+by setting `require_fqdn: true` or by enabling `:strict` checking:
 
 ```ruby
-validates :my_email_attribute, email: {mode: :moderate, require_fqdn: true}
+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
@@ -86,67 +86,67 @@ end
 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. The `:domain` and `:require_fqdn` option are ignored in `:loose` mode.
+whitespace.
 
-### Moderate mode
+### Strict mode
 
-Enabling `:moderate` checking will check for a "normal" email format that would
-be expected in most common everyday usage. Moderate mode basically checks for a
+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 `:moderate` mode will also enable `:require_fqdn`
+sized and formatted FQDN. Enabling `:strict` mode will also enable `:require_fqdn`
 configuration option.
 
-Moderate mode can be enabled globally by requiring `email_validator/moderate` in
+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', github: 'karlwilbur/email_validator', require: 'email_validator/moderate'
+  gem 'email_validator', require: 'email_validator/strict'
   ```
 
 * `config/initializers/email_validator.rb`:
 
   ```ruby
   if defined?(EmailValidator)
-    EmailValidator.default_options[:mode] = :moderate
+    EmailValidator.default_options[:mode] = :strict
   end
   ```
 
 * `validates` call:
 
   ```ruby
-  validates :my_email_attribute, email: {mode: :moderate}
+  validates :my_email_attribute, email: {mode: :strict}
   ```
 
-### Strict mode
+### RFC mode
 
-In order to have stricter 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 `:strict` 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/strict` in your `Gemfile`,
+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', github: 'karlwilbur/email_validator', require: 'email_validator/strict'
+  gem 'email_validator', require: 'email_validator/rfc'
   ```
 
 * `config/initializers/email_validator.rb`:
 
   ```ruby
   if defined?(EmailValidator)
-    EmailValidator.default_options[:mode] = :strict
+    EmailValidator.default_options[:mode] = :rfc
   end
   ```
 
 * `validates` call:
 
   ```ruby
-  validates :my_email_attribute, email: {mode: :strict}
+  validates :my_email_attribute, email: {mode: :rfc}
   ```
 
 ## Validation outside a model
@@ -173,18 +173,18 @@ EmailValidator.valid?('narf@example.com', domain: 'foo.com') # boolean false
 EmailValidator.invalid?('narf@example.com', domain: 'foo.com') # boolean true
 ```
 
-### Moderate mode
+### Strict mode
 
 ```ruby
-EmailValidator.regexp(mode: :moderate) # returns the regex
-EmailValidator.valid?('narf@example.com', mode: :moderate) # boolean
+EmailValidator.regexp(mode: :strict) # returns the regex
+EmailValidator.valid?('narf@example.com', mode: :strict) # boolean
 ```
 
-### Strict mode
+### RFC mode
 
 ```ruby
-EmailValidator.regexp(mode: :strict) # returns the regex
-EmailValidator.valid?('narf@example.com', mode: :strict) # boolean
+EmailValidator.regexp(mode: :rfc) # returns the regex
+EmailValidator.valid?('narf@example.com', mode: :rfc) # boolean
 ```
 
 ## Thread safety

data/lib/email_validator.rb

@@ -88,8 +88,8 @@ class EmailValidator < ActiveModel::EachValidator
     private
 
     def parse_options(options)
-      # `:moderate` mode enables `:require_fqdn`, unless it is already explicitly disabled
-      options[:require_fqdn] = true if options[:require_fqdn].nil? && options[:mode] == :moderate
+      # `: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

data/spec/email_validator_spec.rb

@@ -4,54 +4,54 @@ class DefaultUser < TestModel
   validates :email, :email => true
 end
 
-class ModerateUser < TestModel
-  validates :email, :email => { :mode => :moderate }
-end
-
 class StrictUser < TestModel
   validates :email, :email => { :mode => :strict }
 end
 
-class AllowNilDefaultUser < TestModel
-  validates :email, :email => { :allow_nil => true }
+class RfcUser < TestModel
+  validates :email, :email => { :mode => :rfc }
 end
 
-class AllowNilModerateUser < TestModel
-  validates :email, :email => { :allow_nil => true, :mode => :moderate }
+class AllowNilDefaultUser < TestModel
+  validates :email, :email => { :allow_nil => true }
 end
 
 class AllowNilStrictUser < TestModel
   validates :email, :email => { :allow_nil => true, :mode => :strict }
 end
 
-class DisallowNilDefaultUser < TestModel
-  validates :email, :email => { :allow_nil => false }
+class AllowNilRfcUser < TestModel
+  validates :email, :email => { :allow_nil => true, :mode => :rfc }
 end
 
-class DisallowNilModerateUser < TestModel
-  validates :email, :email => { :allow_nil => false, :mode => :moderate }
+class DisallowNilDefaultUser < TestModel
+  validates :email, :email => { :allow_nil => false }
 end
 
 class DisallowNilStrictUser < TestModel
   validates :email, :email => { :allow_nil => false, :mode => :strict }
 end
 
-class DomainModerateUser < TestModel
-  validates :email, :email => { :domain => 'example.com', :mode => :moderate }
+class DisallowNilRfcUser < TestModel
+  validates :email, :email => { :allow_nil => false, :mode => :rfc }
 end
 
 class DomainStrictUser < TestModel
   validates :email, :email => { :domain => 'example.com', :mode => :strict }
 end
 
-class NonFqdnModerateUser < TestModel
-  validates :email, :email => { :require_fqdn => false, :mode => :moderate }
+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
@@ -99,9 +99,9 @@ RSpec.describe EmailValidator do
     valid_endable               = valid_special_chars
     invalid_includable          = { :at => '@' }
     whitespace                  = { :newline => "\n", :tab => "\t", :carriage_return => "\r", :space => ' ' }
-    moderatly_invalid_includable = invalid_special_chars
-    moderatly_invalid_beginable  = moderatly_invalid_includable.merge({ :dot => '.' })
-    moderatly_invalid_endable    = moderatly_invalid_beginable
+    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 }
@@ -143,56 +143,56 @@ RSpec.describe EmailValidator do
         'areallylongnameaasdfasdfasdfasdf@asdfasdfasdfasdfasdf.ab.cd.ef.gh.co.ca'
       ]).flatten.each do |email|
         context 'when using defaults' do
-          it "#{email} should be valid" 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
+          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
+          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
+          it "'#{email}' should match the regexp" do
             expect(!!(email.strip =~ described_class.regexp)).to be(true)
           end
         end
 
-        context 'when in `:moderate` mode' do
-          it "#{email} should be valid" do
-            expect(ModerateUser.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 => :moderate)
+          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 => :moderate)
+          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 => :moderate))).to be(true)
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(true)
           end
         end
 
-        context 'when in `:strict` mode' do
-          it "#{email} should be valid" do
-            expect(StrictUser.new(:email => email)).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 => :strict)
+          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 => :strict)
+          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 => :strict))).to be(true)
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(true)
           end
         end
       end
@@ -205,56 +205,56 @@ RSpec.describe EmailValidator do
         'someuser@somehost'
       ].each do |email|
         context 'when using defaults' do
-          it "#{email} should be valid" 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
+          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
+          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
+          it "'#{email}' should match the regexp" do
             expect(!!(email.strip =~ described_class.regexp)).to be(true)
           end
         end
 
-        context 'when in `:moderate` mode' do
-          it "#{email} should not be valid" do
-            expect(ModerateUser.new(:email => email)).not_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 => :moderate)
+          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 => :moderate)
+          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 => :moderate))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
           end
         end
 
-        context 'when in `:strict` mode' do
-          it "#{email} should be valid" do
-            expect(StrictUser.new(:email => email)).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 => :strict)
+          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 => :strict)
+          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 => :strict))).to be(true)
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(true)
           end
         end
       end
@@ -266,56 +266,56 @@ RSpec.describe EmailValidator do
         '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
+          it "'#{email}' should be valid" do
             expect(DefaultUser.new(:email => email)).to be_valid
           end
 
-          it "#{email} should be valid using EmailValidator.valid?" do
+          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
+          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
+          it "'#{email}' should match the regexp" do
             expect(!!(email.strip =~ described_class.regexp)).to be(true)
           end
         end
 
-        context 'when in `:moderate` mode' do
-          it "#{email} should not be valid" do
-            expect(ModerateUser.new(:email => email)).not_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 => :moderate)
+          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 => :moderate)
+          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 strict regexp" do
-            expect(!!(email.strip =~ described_class.regexp(:mode => :moderate))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
           end
         end
 
-        context 'when in `:strict` mode' do
-          it "#{email} should be valid" do
-            expect(StrictUser.new(:email => email)).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 => :strict)
+          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 => :strict)
+          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 strict regexp" do
-            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(true)
+          it "'#{email}' should match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(true)
           end
         end
       end
@@ -350,56 +350,56 @@ RSpec.describe EmailValidator do
         "user@example.com<script>alert('hello')</script>"
       ]).flatten.each do |email|
         context 'when using defaults' do
-          it "#{email} should be valid" 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
+          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
+          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
+          it "'#{email}' should match the regexp" do
             expect(!!(email.strip =~ described_class.regexp)).to be(true)
           end
         end
 
-        context 'when in `:moderate` mode' do
-          it "#{email} should not be valid" do
-            expect(ModerateUser.new(:email => email)).not_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 => :moderate)
+          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 => :moderate)
+          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 strict regexp" do
-            expect(!!(email.strip =~ described_class.regexp(:mode => :moderate))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).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
+        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 => :strict)
+          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 => :strict)
+          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 strict regexp" do
-            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(false)
           end
         end
       end
@@ -443,56 +443,56 @@ RSpec.describe EmailValidator do
         "
       ]).flatten.each do |email|
         context 'when using defaults' do
-          it "#{email} should not be valid" 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
+          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
+          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
+          it "'#{email}' should not match the regexp" do
             expect(!!(email =~ described_class.regexp)).to be(false)
           end
         end
 
-        context 'when in `:moderate` mode' do
-          it "#{email} should not be valid" do
-            expect(ModerateUser.new(:email => email)).not_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 => :moderate)
+          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 => :moderate)
+          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 strict regexp" do
-            expect(!!(email =~ described_class.regexp(:mode => :moderate))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email =~ described_class.regexp(:mode => :strict))).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
+        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 => :strict)
+          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 => :strict)
+          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 strict regexp" do
-            expect(!!(email =~ described_class.regexp(:mode => :strict))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email =~ described_class.regexp(:mode => :rfc))).to be(false)
           end
         end
       end
@@ -508,67 +508,67 @@ RSpec.describe EmailValidator do
         'missing-at-sign.dev'
       ].each do |email|
         context 'when using defaults' do
-          it "#{email} should not be valid" 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
+          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
+          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
+          it "'#{email}' should not match the regexp" do
             expect(!!(email.strip =~ described_class.regexp)).to be(false)
           end
         end
 
-        context 'when in `:moderate` mode' do
-          it "#{email} should not be valid" do
-            expect(ModerateUser.new(:email => email)).not_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 => :moderate)
+          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 => :moderate)
+          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 strict regexp" do
-            expect(!!(email.strip =~ described_class.regexp(:mode => :moderate))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).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
+        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 => :strict)
+          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 => :strict)
+          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 strict regexp" do
-            expect(!!(email.strip =~ described_class.regexp(:mode => :strict))).to be(false)
+          it "'#{email}' should not match the regexp" do
+            expect(!!(email.strip =~ described_class.regexp(:mode => :rfc))).to be(false)
           end
         end
       end
     end
 
-    context 'when given the moderatly invalid email' do
-      moderatly_invalid_includable.map { |k, v| [
+    context 'when given the strictly invalid email' do
+      strictly_invalid_includable.map { |k, v| [
         "include-#{v}-#{k}@invalid-characters-in-local.dev"
-      ]}.concat(moderatly_invalid_beginable.map { |k, v| [
+      ]}.concat(strictly_invalid_beginable.map { |k, v| [
         "#{v}start-with-#{k}@invalid-characters-in-local.dev"
-      ]}).concat(moderatly_invalid_endable.map { |k, v| [
+      ]}).concat(strictly_invalid_endable.map { |k, v| [
         "end-with-#{k}#{v}@invalid-characters-in-local.dev"
       ]}).concat([
         'user..-with-double-dots@example.com',
@@ -593,39 +593,39 @@ RSpec.describe EmailValidator do
           end
         end
 
-        context 'when in `:moderate` mode' do
+        context 'when in `:strict` mode' do
           it "#{email.strip} in a model should be valid" do
-            expect(ModerateUser.new(:email => email)).not_to be_valid
+            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 => :moderate)
+            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 => :moderate)
+            expect(described_class).to be_invalid(email, :mode => :strict)
           end
 
-          it "#{email.strip} should not match the strict regexp" do
-            expect(!!(email =~ described_class.regexp(:mode => :moderate))).to be(false)
+          it "#{email.strip} should not match the regexp" do
+            expect(!!(email =~ described_class.regexp(:mode => :strict))).to be(false)
           end
         end
 
-        context 'when in `:strict` mode' do
+        context 'when in `:rfc` mode' do
           it "#{email.strip} in a model should not be valid" do
-            expect(StrictUser.new(:email => email)).not_to be_valid
+            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 => :strict)
+            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 => :strict)
+            expect(described_class).to be_invalid(email, :mode => :rfc)
           end
 
-          it "#{email.strip} should not match the strict regexp" do
-            expect(!!(email =~ described_class.regexp(:mode => :strict))).to be(false)
+          it "#{email.strip} should not match the regexp" do
+            expect(!!(email =~ described_class.regexp(:mode => :rfc))).to be(false)
           end
         end
       end
@@ -651,11 +651,11 @@ RSpec.describe EmailValidator do
           end
         end
 
-        context 'when in `"moderate` mode' do
-          let(:opts) { { :require_fqdn => false, :mode => :moderate } }
+        context 'when in `:strict` mode' do
+          let(:opts) { { :require_fqdn => false, :mode => :strict } }
 
           it 'is valid' do
-            expect(NonFqdnModerateUser.new(:email => email)).to be_valid
+            expect(NonFqdnStrictUser.new(:email => email)).to be_valid
           end
 
           it 'is valid using EmailValidator.valid?' do
@@ -671,11 +671,11 @@ RSpec.describe EmailValidator do
           end
         end
 
-        context 'when in `:strict` mode' do
-          let(:opts) { { :require_fqdn => false, :mode => :strict } }
+        context 'when in `:rfc` mode' do
+          let(:opts) { { :require_fqdn => false, :mode => :rfc } }
 
-          it 'is valid in strict mode' do
-            expect(NonFqdnStrictUser.new(:email => email)).to be_valid
+          it 'is valid' do
+            expect(NonFqdnRfcUser.new(:email => email)).to be_valid
           end
 
           it 'is valid using EmailValidator.valid?' do
@@ -686,7 +686,7 @@ RSpec.describe EmailValidator do
             expect(described_class).not_to be_invalid(email, opts)
           end
 
-          it 'does not match the strict regexp' do
+          it 'matches the regexp' do
             expect(!!(email =~ described_class.regexp(opts))).to be(true)
           end
         end
@@ -696,7 +696,7 @@ RSpec.describe EmailValidator do
         let(:email) { 'someuser@somehost.somedomain' }
 
         it 'is valid' do
-          expect(NonFqdnModerateUser.new(:email => email)).to be_valid
+          expect(NonFqdnStrictUser.new(:email => email)).to be_valid
         end
 
         # rubocop:disable RSpec/PredicateMatcher
@@ -713,8 +713,8 @@ RSpec.describe EmailValidator do
           expect(!!(email =~ described_class.regexp(opts))).to be(true)
         end
 
-        context 'when in `:strict` mode' do
-          let(:opts) { { :require_fqdn => false, :mode => :strict } }
+        context 'when in `:rfc` mode' do
+          let(:opts) { { :require_fqdn => false, :mode => :rfc } }
 
           # rubocop:disable RSpec/PredicateMatcher
           it 'is valid using EmailValidator.valid?' do
@@ -726,11 +726,11 @@ RSpec.describe EmailValidator do
           end
           # rubocop:enable RSpec/PredicateMatcher
 
-          it 'is valid in strict mode' do
-            expect(NonFqdnStrictUser.new(:email => email)).to be_valid
+          it 'is valid' do
+            expect(NonFqdnRfcUser.new(:email => email)).to be_valid
           end
 
-          it 'does not match the strict regexp' do
+          it 'matches the regexp' do
             expect(!!(email =~ described_class.regexp(opts))).to be(true)
           end
         end
@@ -740,7 +740,7 @@ RSpec.describe EmailValidator do
           let(:opts) { { :domain => domain } }
 
           it 'is not valid' do
-            expect(DomainModerateUser.new(:email => email)).not_to be_valid
+            expect(DomainStrictUser.new(:email => email)).not_to be_valid
           end
 
           it 'is not valid using EmailValidator.valid?' do
@@ -755,8 +755,8 @@ RSpec.describe EmailValidator do
             expect(!!(email =~ described_class.regexp(opts))).to be(false)
           end
 
-          context 'when in `:strict` mode' do
-            let(:opts) { { :domain => domain, :require_fqdn => false, :mode => :strict } }
+          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)
@@ -767,7 +767,7 @@ RSpec.describe EmailValidator do
             end
 
             it 'is not valid' do
-              expect(DomainStrictUser.new(:email => email)).not_to be_valid
+              expect(DomainRfcUser.new(:email => email)).not_to be_valid
             end
 
             it 'does not match the regexp' do
@@ -817,55 +817,68 @@ RSpec.describe EmailValidator do
   end
 
   describe 'limited to a domain' do
-    context 'when in `:moderate` mode' do
+    context 'when in `:strict` mode' do
       it 'is not valid with mismatched domain' do
-        expect(DomainModerateUser.new(:email => 'user@not-matching.io')).not_to be_valid
+        expect(DomainStrictUser.new(:email => 'user@not-matching.io')).not_to be_valid
       end
 
       it 'is valid with matching domain' do
-        expect(DomainModerateUser.new(:email => 'user@example.com')).to be_valid
+        expect(DomainStrictUser.new(:email => 'user@example.com')).to be_valid
       end
 
       it 'does not interpret the dot as any character' do
-        expect(DomainModerateUser.new(:email => 'user@example-com')).not_to be_valid
+        expect(DomainStrictUser.new(:email => 'user@example-com')).not_to be_valid
       end
     end
 
-    context 'when in strict mode' do
+    context 'when in `:rfc` mode' do
       it 'does not interpret the dot as any character' do
-        expect(DomainStrictUser.new(:email => 'user@example-com')).not_to be_valid
+        expect(DomainRfcUser.new(:email => 'user@example-com')).not_to be_valid
       end
 
       it 'is valid with matching domain' do
-        expect(DomainStrictUser.new(:email => 'user@example.com')).to be_valid
+        expect(DomainRfcUser.new(:email => 'user@example.com')).to be_valid
       end
 
       it 'is not valid with mismatched domain' do
-        expect(DomainStrictUser.new(:email => 'user@not-matching.io')).not_to be_valid
+        expect(DomainRfcUser.new(:email => 'user@not-matching.io')).not_to be_valid
       end
     end
   end
 
   describe 'default_options' do
-    let(:email) { 'includes-whitespace-in-otherwise-valid-email@local' }
+    let(:valid_email) { 'valid-email@localhost.localdomain' }
+    let(:invalid_email) { 'invalid email@localhost.localdomain' }
 
-    it 'validates using `:loose` mode' do
-      expect(DefaultUser.new(:email => email)).to be_valid
+    it 'validates valid using `:loose` mode' do
+      expect(DefaultUser.new(:email => valid_email)).to be_valid
     end
 
-    context 'when `email_validator/moderate` has been required' do
-      before { require 'email_validator/moderate' }
-
-      it 'validates using `:moderate` mode' do
-        expect(DefaultUser.new(:email => email)).not_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 'validate using `:strict` mode' do
-        expect(DefaultUser.new(:email => email)).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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: email_validator
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Brian Alexander
@@ -41,7 +41,8 @@ files:
 - spec/email_validator_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/K-and-R/email_validator
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []