email_address 0.1.14 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f3decf66b46d08f8a8f3528ad331cfb009f7dfa302b8f887558bb535e189210
-  data.tar.gz: a5aac0f73f92ae103cada5c57b5f51a7efb968752dfe5ab8710b72a52705c98a
+  metadata.gz: adfafdd9c68cbc88c13f77175ab945fce253b0c67d93cbf92f27d95358d9286d
+  data.tar.gz: 07ea20d4fddbc9a2626a870b40162fe5ecaedfd7f588ba56f8d9efffce9a4eac
 SHA512:
-  metadata.gz: 6acd7e0c108cadaa5be29dc0d843c3d12311d96791f79130b6c1ed2a1e26c3e3c2838f40034504d74bd2717dd35947e789c39c72fd0c7470aaefec23167983c8
-  data.tar.gz: bf7f061c707cac898ca51fd4bb8a697ad0c491be4a3119ded9c836e9ef8257ad3c513a2562c9803b415bbea8e747e5ae8c54805c00b03cfd4825a7b2754a5229
+  metadata.gz: 45005aaae90329115140e038aa9f17325d66a939de376a2efc0fdda6542a1b47850ae40b80503fd69e1308f3cfe2fb5392904d2ca5ba0f997b00b6712e01ccb9
+  data.tar.gz: e69900c156e676aac54f5f2d3ca395f08f08d07f768913df990d8b3c012e12e5cda678145f1dcdb0d141691ebf93d2beb85ba3b8dd654522fbb121962529585c

data/.travis.yml

@@ -1,9 +1,8 @@
 language: ruby
 rvm:
   - 2.7.0
-  - 2.3.7
+  - 2.3.0
   - jruby-9.2.9.0
-  #- rbx
 
 addons:
   code_climate:

data/README.md

@@ -50,7 +50,7 @@ It does not check:
 By default, MX records are required in DNS. MX or "mail exchanger" records
 tell where to deliver email for the domain. Many domains run their
 website on one provider (ISP, Heroku, etc.), and email on a different
-provider (such as Google Apps).  Note that `example.com`, while
+provider (such as G Suite).  Note that `example.com`, while
 a valid domain name, does not have MX records.
 
 ```ruby
@@ -248,6 +248,16 @@ EmailAddress.normal("HIRO@こんにちは世界.com")
 EmailAddress.normal("hiro@xn--28j2a3ar1pp75ovm7c.com", host_encoding: :unicode)
                     #=> "hiro@こんにちは世界.com"
 ```
+As of release 0.1.17, exchanger_match is no longer used for host provider
+determination, which designated the set of rules for that domain.
+Sometimes, as in Google-hosted domains, the address
+rules are different, notably the optional dots in mailboxes for gmail.com
+accounts do not apply to other private domains hosted at google.
+
+To access the provider service, you can now call:
+
+    EmailAddress.new("user@hosteddomain.com").host.hosted_provider
+
 
 #### Rails Validator
 
@@ -534,14 +544,38 @@ For the mailbox (AKA account, role), without the tag
 * address_size:       3..254,
   A range specifying the size limit of the complete address
 
-* address_local:      false,
-  Allow localhost, no domain, or local subdomains.
-
 For provider rules to match to domain names and Exchanger hosts
 The value is an array of match tokens.
 * host_match:         %w(.org example.com hotmail. user*@ sub.*.com)
 * exchanger_match:    %w(google.com 127.0.0.1 10.9.8.0/24 ::1/64)
 
+### Namespace conflict resolution
+
+If your application already uses the `EmailAddress` class name,
+it's possible to create an alias prior to loading your code:
+
+For a Rails application, you can do this in `config/application.rb`
+after the `Bundler.require` line, usually:
+
+```ruby
+Bundler.require(*Rails.groups)
+```
+
+Add these lines immediately after that point:
+
+```ruby
+EmailAddressValidator = EmailAddress
+Object.send(:remove_const, :EmailAddress)
+```
+
+Then your application loads with your EmailAddress class. You may
+then use this gem with `EmailAddressValidator` or whatever name you
+gave it above:
+
+```ruby
+EmailAddressValidator.valid?("clark.kent@gmail.com") # => true
+```
+
 ## Notes
 
 #### Internationalization

data/email_address.gemspec

@@ -13,6 +13,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/afair/email_address"
   spec.license       = "MIT"
 
+  #spec.required_ruby_version = ">= 2.3.0"
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})

data/lib/email_address.rb

@@ -40,31 +40,30 @@ module EmailAddress
   #   secret to use in options[:secret]
   class << self
     (%i[valid? error normal redact munge canonical reference base srs] &
-     EmailAddress::Address.public_instance_methods
+     Address.public_instance_methods
     ).each do |proxy_method|
       define_method(proxy_method) do |*args, &block|
-        EmailAddress::Address.new(*args).public_send(proxy_method, &block)
+        Address.new(*args).public_send(proxy_method, &block)
       end
     end
-  end
-
 
-  # Creates an instance of this email address.
-  # This is a short-cut to Email::Address::Address.new
-  def self.new(email_address, config={})
-    EmailAddress::Address.new(email_address, config)
-  end
+    # Creates an instance of this email address.
+    # This is a short-cut to EmailAddress::Address.new
+    def new(email_address, config={})
+      Address.new(email_address, config)
+    end
 
-  def self.new_redacted(email_address, config={})
-    EmailAddress::Address.new(EmailAddress::Address.new(email_address, config).redact)
-  end
+    def new_redacted(email_address, config={})
+      Address.new(Address.new(email_address, config).redact)
+    end
 
-  def self.new_canonical(email_address, config={})
-    EmailAddress::Address.new(EmailAddress::Address.new(email_address, config).canonical, config)
-  end
+    def new_canonical(email_address, config={})
+      Address.new(Address.new(email_address, config).canonical, config)
+    end
 
-  # Does the email address match any of the given rules
-  def self.matches?(email_address, rules, config={})
-    EmailAddress::Address.new(email_address, config).matches?(rules)
+    # Does the email address match any of the given rules
+    def matches?(email_address, rules, config={})
+      Address.new(email_address, config).matches?(rules)
+    end
   end
 end

data/lib/email_address/active_record_validator.rb

@@ -35,11 +35,12 @@ module EmailAddress
 
     def validate_email(r,f)
       return if r[f].nil?
-      e = EmailAddress.new(r[f])
+      e = Address.new(r[f])
       unless e.valid?
-        r.errors[f] << (@opt[:message] ||
-                       EmailAddress::Config.error_messages[:invalid_address] ||
-                       "Invalid Email Address")
+        error_message = @opt[:message] ||
+                        Config.error_messages[:invalid_address] ||
+                        "Invalid Email Address"
+        r.errors.add(f, error_message)
       end
     end
 

data/lib/email_address/address.rb

@@ -5,33 +5,32 @@ require "digest/md5"
 
 module EmailAddress
   # Implements the Email Address container, which hold the Local
-  # (EmailAddress::Local) and Host (Email::AddressHost) parts.
+  # (EmailAddress::Local) and Host (EmailAddress::Host) parts.
   class Address
     include Comparable
-    include EmailAddress::Rewriter
+    include Rewriter
 
     attr_accessor :original, :local, :host, :config, :reason
 
-    CONVENTIONAL_REGEX = /\A#{::EmailAddress::Local::CONVENTIONAL_MAILBOX_WITHIN}
-                           @#{::EmailAddress::Host::DNS_HOST_REGEX}\z/x
-    STANDARD_REGEX = /\A#{::EmailAddress::Local::STANDARD_LOCAL_WITHIN}
-                           @#{::EmailAddress::Host::DNS_HOST_REGEX}\z/x
-    RELAXED_REGEX = /\A#{::EmailAddress::Local::RELAXED_MAILBOX_WITHIN}
-                           @#{::EmailAddress::Host::DNS_HOST_REGEX}\z/x
+    CONVENTIONAL_REGEX = /\A#{Local::CONVENTIONAL_MAILBOX_WITHIN}
+                           @#{Host::DNS_HOST_REGEX}\z/x
+    STANDARD_REGEX = /\A#{Local::STANDARD_LOCAL_WITHIN}
+                           @#{Host::DNS_HOST_REGEX}\z/x
+    RELAXED_REGEX = /\A#{Local::RELAXED_MAILBOX_WITHIN}
+                           @#{Host::DNS_HOST_REGEX}\z/x
 
     # Given an email address of the form "local@hostname", this sets up the
     # instance, and initializes the address to the "normalized" format of the
     # address. The original string is available in the #original method.
     def initialize(email_address, config = {})
-      @config = config # This needs refactoring!
+      @config = Config.new(config)
       @original = email_address
       email_address = (email_address || "").strip
       email_address = parse_rewritten(email_address) unless config[:skip_rewrite]
-      local, host = EmailAddress::Address.split_local_host(email_address)
+      local, host = Address.split_local_host(email_address)
 
-      @host = EmailAddress::Host.new(host, config)
-      @config = @host.config
-      @local = EmailAddress::Local.new(local, @config, @host)
+      @host = Host.new(host, @config)
+      @local = Local.new(local, @config, @host)
       @error = @error_message = nil
     end
 
@@ -115,7 +114,7 @@ module EmailAddress
     alias to_s normal
 
     def inspect
-      "#<EmailAddress::Address:0x#{object_id.to_s(16)} address=\"#{self}\">"
+      "#<#{self.class}:0x#{object_id.to_s(16)} address=\"#{self}\">"
     end
 
     # Returns the canonical email address according to the provider
@@ -191,7 +190,7 @@ module EmailAddress
     # of this addres with another, using the canonical or redacted forms.
     def same_as?(other_email)
       if other_email.is_a?(String)
-        other_email = EmailAddress::Address.new(other_email)
+        other_email = Address.new(other_email)
       end
 
       canonical == other_email.canonical ||
@@ -215,7 +214,7 @@ module EmailAddress
 
       # Does "root@*.com" match "root@example.com" domain name
       rules.each do |r|
-        if /.+@.+/.match?(r)
+        if r.match(/.+@.+/)
           return r if File.fnmatch?(r, to_s)
         end
       end
@@ -277,7 +276,7 @@ module EmailAddress
     def set_error(err, reason = nil)
       @error = err
       @reason = reason
-      @error_message = EmailAddress::Config.error_message(err)
+      @error_message = Config.error_message(err)
       false
     end
 

data/lib/email_address/canonical_email_address_type.rb

@@ -29,20 +29,22 @@
 #    user.canonical_email #=> "patsmith@gmail.com"
 ################################################################################
 
-class EmailAddress::CanonicalEmailAddressType < ActiveRecord::Type::Value
+module EmailAddress
+  class CanonicalEmailAddressType < ActiveRecord::Type::Value
 
-  # From user input, setter
-  def cast(value)
-    super(EmailAddress.canonical(value))
-  end
+    # From user input, setter
+    def cast(value)
+      super(Address.new(value).canonical)
+    end
 
-  # From a database value
-  def deserialize(value)
-    value && EmailAddress.normal(value)
-  end
+    # From a database value
+    def deserialize(value)
+      value && Address.new(value).normal
+    end
 
-  # To a database value (string)
-  def serialize(value)
-    value && EmailAddress.normal(value)
+    # To a database value (string)
+    def serialize(value)
+      value && Address.new(value).normal
+    end
   end
 end

data/lib/email_address/config.rb

@@ -143,6 +143,7 @@ module EmailAddress
       },
       msn: {
         host_match: %w[msn. hotmail. outlook. live.],
+        exchanger_match: %w[outlook.com],
         mailbox_validator: ->(m, t) { m =~ /\A\w[\-\w]*(?:\.[\-\w]+)*\z/i }
       },
       yahoo: {
@@ -175,8 +176,7 @@ module EmailAddress
     def self.provider(name, config = {})
       name = name.to_sym
       if config.size > 0
-        @providers[name] ||= @config.clone
-        @providers[name].merge!(config)
+        @providers[name.to_sym] = config
       end
       @providers[name]
     end
@@ -199,5 +199,25 @@ module EmailAddress
       configs.each { |c| config.merge!(c) }
       config
     end
+
+    def initialize(overrides = {})
+      @config = Config.all_settings(overrides)
+    end
+
+    def []=(setting, value)
+      @config[setting.to_sym] = value
+    end
+
+    def [](setting)
+      @config[setting.to_sym]
+    end
+
+    def configure(settings)
+      @config = @config.merge(settings)
+    end
+
+    def to_h
+      @config
+    end
   end
 end

data/lib/email_address/email_address_type.rb

@@ -29,20 +29,22 @@
 #    user.canonical_email #=> "patsmith@gmail.com"
 ################################################################################
 
-class EmailAddress::EmailAddressType < ActiveRecord::Type::Value
+module EmailAddress
+  class EmailAddressType < ActiveRecord::Type::Value
 
-  # From user input, setter
-  def cast(value)
-    super(EmailAddress.normal(value))
-  end
+    # From user input, setter
+    def cast(value)
+      super(Address.new(value).normal)
+    end
 
-  # From a database value
-  def deserialize(value)
-    value && EmailAddress.normal(value)
-  end
-  #
-  # To a database value (string)
-  def serialize(value)
-    value && EmailAddress.normal(value)
+    # From a database value
+    def deserialize(value)
+      value && Address.new(value).normal
+    end
+
+    # To a database value (string)
+    def serialize(value)
+      value && Address.new(value).normal
+    end
   end
 end

data/lib/email_address/exchanger.rb

@@ -24,7 +24,7 @@ module EmailAddress
 
     def initialize(host, config = {})
       @host = host
-      @config = config
+      @config = config.is_a?(Hash) ? Config.new(config) : config
       @dns_disabled = @config[:host_validation] == :syntax || @config[:dns_lookup] == :off
     end
 
@@ -38,7 +38,7 @@ module EmailAddress
     # Returns the provider name based on the MX-er host names, or nil if not matched
     def provider
       return @provider if defined? @provider
-      EmailAddress::Config.providers.each do |provider, config|
+      Config.providers.each do |provider, config|
         if config[:exchanger_match] && matches?(config[:exchanger_match])
           return @provider = provider
         end
@@ -76,7 +76,7 @@ module EmailAddress
 
     # Returns Array of domain names for the MX'ers, used to determine the Provider
     def domains
-      @_domains ||= mxers.map { |m| EmailAddress::Host.new(m.first).domain_name }.sort.uniq
+      @_domains ||= mxers.map { |m| Host.new(m.first).domain_name }.sort.uniq
     end
 
     # Returns an array of MX IP address (String) for the given email domain

data/lib/email_address/host.rb

@@ -87,7 +87,7 @@ module EmailAddress
     def initialize(host_name, config = {})
       @original = host_name ||= ""
       config[:host_type] ||= :email
-      @config = config
+      @config = config.is_a?(Hash) ? Config.new(config) : config
       @error = @error_message = nil
       parse(host_name)
     end
@@ -149,7 +149,7 @@ module EmailAddress
       if @config[:host_remove_spaces]
         @host_name = @host_name.delete(" ")
       end
-      @dns_name = if /[^[:ascii:]]/.match?(host_name)
+      @dns_name = if /[^[:ascii:]]/.match(host_name)
         ::SimpleIDN.to_ascii(host_name)
       else
         host_name
@@ -209,7 +209,7 @@ module EmailAddress
     def find_provider # :nodoc:
       return provider if provider
 
-      EmailAddress::Config.providers.each do |provider, config|
+      Config.providers.each do |provider, config|
         if config[:host_match] && matches?(config[:host_match])
           return set_provider(provider, config)
         end
@@ -217,25 +217,23 @@ module EmailAddress
 
       return set_provider(:default) unless dns_enabled?
 
-      provider = exchangers.provider
-      if provider != :default
-        set_provider(provider,
-          EmailAddress::Config.provider(provider))
-      end
-
       self.provider ||= set_provider(:default)
     end
 
     def set_provider(name, provider_config = {}) # :nodoc:
-      self.config = EmailAddress::Config.all_settings(provider_config, @config)
-      self.provider = name
+      config.configure(provider_config)
+      @provider = name
     end
 
     # Returns a hash of the parts of the host name after parsing.
     def parts
       {host_name: host_name, dns_name: dns_name, subdomain: subdomains,
        registration_name: registration_name, domain_name: domain_name,
-       tld2: tld2, tld: tld, ip_address: ip_address}
+       tld2: tld2, tld: tld, ip_address: ip_address,}
+    end
+
+    def hosted_provider
+      Exchanger.cached(dns_name).provider
     end
 
     ############################################################################
@@ -286,7 +284,7 @@ module EmailAddress
 
     # Does "example." match any tld?
     def registration_name_matches?(rule)
-      "#{registration_name}." == rule
+      rule == "#{registration_name}."
     end
 
     # Does "sub.example.com" match ".com" and ".example.com" top level names?
@@ -340,11 +338,11 @@ module EmailAddress
       @_dns_a_record ||= []
     end
 
-    # Returns an array of EmailAddress::Exchanger hosts configured in DNS.
+    # Returns an array of Exchanger hosts configured in DNS.
     # The array will be empty if none are configured.
     def exchangers
       # return nil if @config[:host_type] != :email || !self.dns_enabled?
-      @_exchangers ||= EmailAddress::Exchanger.cached(dns_name, @config)
+      @_exchangers ||= Exchanger.cached(dns_name, @config)
     end
 
     # Returns a DNS TXT Record
@@ -450,9 +448,9 @@ module EmailAddress
       if !@config[:host_allow_ip]
         bool = set_error(:ip_address_forbidden)
       elsif ip_address.include?(":")
-        bool = Resolv::IPv6::Regex.match?(ip_address) ? true : set_error(:ipv6_address_invalid)
+        bool = ip_address.match(Resolv::IPv6::Regex) ? true : set_error(:ipv6_address_invalid)
       elsif ip_address.include?(".")
-        bool = Resolv::IPv4::Regex.match?(ip_address) ? true : set_error(:ipv4_address_invalid)
+        bool = ip_address.match(Resolv::IPv4::Regex) ? true : set_error(:ipv4_address_invalid)
       end
       if bool && (localhost? && !@config[:host_local])
         bool = set_error(:ip_address_no_localhost)
@@ -499,7 +497,7 @@ module EmailAddress
     def set_error(err, reason = nil)
       @error = err
       @reason = reason
-      @error_message = EmailAddress::Config.error_message(err)
+      @error_message = Config.error_message(err)
       false
     end
 

data/lib/email_address/local.rb

@@ -107,7 +107,7 @@ module EmailAddress
       %r/^([\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+)$/i.freeze
 
     def initialize(local, config={}, host=nil)
-      self.config   = config.empty? ? EmailAddress::Config.all_settings : config
+      @config = config.is_a?(Hash) ? Config.new(config) : config
       self.local    = local
       @host         = host
       @error        = @error_message = nil
@@ -130,10 +130,10 @@ module EmailAddress
     def parse(raw)
       if raw =~ /\A\"(.*)\"\z/ # Quoted
         raw = $1
-        raw.gsub!(/\\(.)/, '\1') # Unescape
+        raw = raw.gsub(/\\(.)/, '\1') # Unescape
       elsif @config[:local_fix] && @config[:local_format] != :standard
-        raw.gsub!(' ','')
-        raw.gsub!(',','.')
+        raw = raw.gsub(' ','')
+        raw = raw.gsub(',','.')
         #raw.gsub!(/([^\p{L}\p{N}]{2,10})/) {|s| s[0] } # Stutter punctuation typo
       end
       raw, comment = self.parse_comment(raw)
@@ -226,7 +226,7 @@ module EmailAddress
     def relax
       form = self.mailbox
       form += @config[:tag_separator] + self.tag if self.tag
-      form.gsub!(/[ \"\(\),:<>@\[\]\\]/,'')
+      form = form.gsub(/[ \"\(\),:<>@\[\]\\]/,'')
       form
     end
 
@@ -235,7 +235,7 @@ module EmailAddress
       form = self.mailbox
       form += @config[:tag_separator] + self.tag if self.tag
       form += "(" + self.comment + ")" if self.comment
-      form.gsub!(/([\\\"])/, '\\\1') # Escape \ and "
+      form = form.gsub(/([\\\"])/, '\\\1') # Escape \ and "
       if form =~ /[ \"\(\),:<>@\[\\\]]/ # Space and "(),:;<>@[\]
         form = %Q("#{form}")
       end
@@ -388,7 +388,7 @@ module EmailAddress
     def set_error(err, reason=nil)
       @error = err
       @reason= reason
-      @error_message = EmailAddress::Config.error_message(err)
+      @error_message = Config.error_message(err)
       false
     end
 

data/lib/email_address/version.rb

@@ -1,3 +1,3 @@
 module EmailAddress
-  VERSION = "0.1.14"
+  VERSION = "0.1.19"
 end

data/test/email_address/test_address.rb

@@ -37,6 +37,11 @@ class TestAddress < Minitest::Test
     assert_equal "6bdd00c53645790ad9bbcb50caa93880",  EmailAddress.reference("Gmail.User+tag@gmail.com")
   end
 
+  def test_google_hosted
+    a = EmailAddress.new("Ex.am.ple+tag@boomer.com")
+    assert_equal a.canonical, "ex.am.ple@boomer.com"
+  end
+
   # COMPARISON & MATCHING
   def test_compare
     a = ("User+tag@example.com")

data/test/test_aliasing.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+require_relative 'test_helper'
+
+class TestAliasing < MiniTest::Test
+  def setup
+    Object.send(:const_set, :EmailAddressValidator, EmailAddress)
+    Object.send(:remove_const, :EmailAddress)
+  end
+
+  def test_email_address_not_defined
+    assert_nil defined?(EmailAddress)
+    assert_nil defined?(EmailAddress::Address)
+    assert_nil defined?(EmailAddress::Config)
+    assert_nil defined?(EmailAddress::Exchanger)
+    assert_nil defined?(EmailAddress::Host)
+    assert_nil defined?(EmailAddress::Local)
+    assert_nil defined?(EmailAddress::Rewriter)
+  end
+
+  def test_alias_defined
+    assert_equal defined?(EmailAddressValidator), "constant"
+    assert_equal defined?(EmailAddressValidator::Address), "constant"
+    assert_equal defined?(EmailAddressValidator::Config), "constant"
+    assert_equal defined?(EmailAddressValidator::Exchanger), "constant"
+    assert_equal defined?(EmailAddressValidator::Host), "constant"
+    assert_equal defined?(EmailAddressValidator::Local), "constant"
+    assert_equal defined?(EmailAddressValidator::Rewriter), "constant"
+  end
+
+  def test_alias_class_methods
+    assert_equal true, EmailAddressValidator.valid?("user@yahoo.com")
+  end
+
+  def test_alias_host_methods
+    assert_equal true, EmailAddressValidator::Host.new("yahoo.com").valid?
+  end
+
+  def test_alias_address_methods
+    assert_equal true, EmailAddressValidator::Address.new("user@yahoo.com").valid?
+  end
+
+  def test_alias_config_methods
+    assert Hash, EmailAddressValidator::Config.new.to_h
+  end
+
+  def test_alias_local_methods
+    assert_equal true, EmailAddressValidator::Local.new("user").valid?
+  end
+
+  def teardown
+    Object.send(:const_set, :EmailAddress, EmailAddressValidator)
+    Object.send(:remove_const, :EmailAddressValidator)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: email_address
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.19
 platform: ruby
 authors:
 - Allen Fair
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-17 00:00:00.000000000 Z
+date: 2020-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -162,13 +162,14 @@ files:
 - test/email_address/test_host.rb
 - test/email_address/test_local.rb
 - test/email_address/test_rewriter.rb
+- test/test_aliasing.rb
 - test/test_email_address.rb
 - test/test_helper.rb
 homepage: https://github.com/afair/email_address
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -183,8 +184,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: This gem provides a ruby language library for working with and validating
   email addresses. By default, it validates against conventional usage, the format
@@ -199,5 +200,6 @@ test_files:
 - test/email_address/test_host.rb
 - test/email_address/test_local.rb
 - test/email_address/test_rewriter.rb
+- test/test_aliasing.rb
 - test/test_email_address.rb
 - test/test_helper.rb