email_address 0.1.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b6a59891931ddfd551f8ead37a376795d22e70eb
-  data.tar.gz: 8b71384418e8b1a4eb505faa5e95e021f0b30b7d
+SHA256:
+  metadata.gz: dc99a156cbc12320e084571723e8633c5c1f8a3e92a9e47258d9521c0f27fcc6
+  data.tar.gz: '05302795638cad6027f50b778253484f390ef2cd697c665150d1e5a2d214172d'
 SHA512:
-  metadata.gz: 62af3189a51354059a4d05e03c294e12a3e76839bb4cafd0697231fae638cbe5959324034cbdeea4d83f8a10303e6f7e6bad4c7aa0d2bd90bd7ef3bbafc0c930
-  data.tar.gz: 34d7af8021c044f4cc4e1e00c4d2aa0e0066881178f7300c6322ccad52dd7787448b0929efb1148cfc582e6b073d9ae318fe515937bab9085a94e6ddfa98ab3b
+  metadata.gz: 58c0ec4c8260854d9f7bacaf6c7891e661c9953f57c678d9bd03ab7e14e69b5a48902ca651ec29105a1fd13b08942187473340dace11cf81533af5ef1093dadc
+  data.tar.gz: 4d6ff21b55ed86a0d04ca8011d85a4f0c0f69637c80e9d2b6dc393717051fb15e703630bd531531c5453b3e8c0e301e34917fa48b3be1123f1c6ff3cd105e957

data/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI Build
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: [2.6, 2.7, 3.0, 3.1, jruby]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs `bundle install` and caches installed gems automatically
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rake

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in email_address.gemspec
 gemspec

data/README.md

@@ -1,7 +1,7 @@
 # Email Address
 
 [![Gem Version](https://badge.fury.io/rb/email_address.svg)](http://rubygems.org/gems/email_address)
-[![Build Status](https://travis-ci.org/afair/email_address.svg?branch=v0.1)](https://travis-ci.org/afair/email_address)
+[![CI Build](https://github.com/afair/email_address/actions/workflows/ci.yml/badge.svg)](https://github.com/afair/email_address/actions/workflows/ci.yml)
 [![Code Climate](https://codeclimate.com/github/afair/email_address/badges/gpa.svg)](https://codeclimate.com/github/afair/email_address)
 
 The `email_address` gem provides a ruby language library for working
@@ -20,12 +20,51 @@ and can deal with gmail's "optional dots" in addresses.
 It provides Active Record (Rails) extensions, including an
 address validator and attributes API custom datatypes.
 
-*Note:* Version 0.1.0 contains significant API and internal changes over the 0.0.3
-version. If you have been using the 0.0.x series of the gem, you may
-want to continue using with your current version.
-
 Requires Ruby 2.0 or later.
 
+Looking for a Javascript version of this library? Check out the
+[email_address](https://www.npmjs.com/package/email_address) npm module.
+
+## Quick Start
+
+To quickly validate email addresses, use the valid? and error helpers.
+`valid?` returns a boolean, and `error` returns nil if valid, otherwise
+a basic error message.
+
+```ruby
+EmailAddress.valid? "allen@google.com" #=> true
+EmailAddress.error "allen@bad-d0main.com" #=> "Invalid Host/Domain Name"
+```
+
+`EmailAddress` deeply validates your email addresses. It checks:
+
+* Host name format and DNS setup
+* Mailbox format according to "conventional" form. This matches most used user
+  email accounts, but is a subset of the RFC specification.
+
+It does not check:
+
+* The mail server is configured to accept connections
+* The mailbox is valid and accepts email.
+
+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 G Suite).  Note that `example.com`, while
+a valid domain name, does not have MX records.
+
+```ruby
+EmailAddress.valid? "allen@example.com" #=> false
+EmailAddress.valid? "allen@example.com", host_validation: :syntax #=> true
+```
+
+Most mail servers do not yet support Unicode mailboxes, so the default here is ASCII.
+
+```ruby
+EmailAddress.error "Pelé@google.com" #=> "Invalid Recipient/Mailbox"
+EmailAddress.valid? "Pelé@google.com", local_encoding: :unicode #=> true
+```
+
 ## Background
 
 The email address specification is complex and often not what you want
@@ -58,15 +97,20 @@ introduces terms to distinguish types of email addresses.
 
     madness!."()<>[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a(comment )"@example.org
 
+* *Base* - A unique mailbox without tags. For gmail, is uses the incoming
+  punctation, essential when building an MD5, SHA1, or SHA256 to match services
+  like Gravatar, and email address digest interchange.
+
 * *Canonical* - An unique account address, lower-cased, without the
   tag, and with irrelevant characters stripped.
 
     clark.kent+scoops@gmail.com => clarkkent@gmail.com
 
-* *Reference* - The MD5 of the Canonical format, used to share account
+* *Reference* - The MD5 of the Base format, used to share account
   references without exposing the private email address directly.
 
-    Clark.Kent+scoops@gmail.com => c5be3597c391169a5ad2870f9ca51901
+    Clark.Kent+scoops@gmail.com =>
+    clark.kent@gmail.com => 1429a1dfc797d6e93075fef011c373fb
 
 * *Redacted* - A form of the email address where it is replaced by
   a SHA1-based version to remove the original address from the
@@ -150,8 +194,10 @@ If you are not using Bundler, you need to install the gem yourself.
 
 Require the gem inside your script.
 
-    require 'rubygems'
-    require 'email_address'
+```ruby
+require 'rubygems'
+require 'email_address'
+```
 
 ## Usage
 
@@ -161,41 +207,58 @@ instantiate an object to inspect the address.
 These top-level helpers return edited email addresses and validation
 check.
 
-    address = "Clark.Kent+scoops@gmail.com"
-    EmailAddress.valid?(address)    #=> true
-    EmailAddress.normal(address)    #=> "clark.kent+scoops@gmail.com"
-    EmailAddress.canonical(address) #=> "clarkkent@gmail.com"
-    EmailAddress.reference(address) #=> "c5be3597c391169a5ad2870f9ca51901"
-    EmailAddress.redact(address)    #=> "{bea3f3560a757f8142d38d212a931237b218eb5e}@gmail.com"
-    EmailAddress.munge(address)     #=> "cl*****@gm*****"
-    EmailAddress.matches?(address, 'google') #=> 'google' (true)
-    EmailAddress.error("#bad@example.com") #=> "Invalid Mailbox"
+```ruby
+address = "Clark.Kent+scoops@gmail.com"
+EmailAddress.valid?(address)    #=> true
+EmailAddress.normal(address)    #=> "clark.kent+scoops@gmail.com"
+EmailAddress.canonical(address) #=> "clarkkent@gmail.com"
+EmailAddress.reference(address) #=> "c5be3597c391169a5ad2870f9ca51901"
+EmailAddress.redact(address)    #=> "{bea3f3560a757f8142d38d212a931237b218eb5e}@gmail.com"
+EmailAddress.munge(address)     #=> "cl*****@gm*****"
+EmailAddress.matches?(address, 'google') #=> 'google' (true)
+EmailAddress.error("#bad@example.com") #=> "Invalid Mailbox"
+```
 
 Or you can create an instance of the email address to work with it.
 
-    email = EmailAddress.new(address) #=> #<EmailAddress::Address:0x007fe6ee150540 ...>
-    email.normal        #=> "clark.kent+scoops@gmail.com"
-    email.canonical     #=> "clarkkent@gmail.com"
-    email.original      #=> "Clark.Kent+scoops@gmail.com"
-    email.valid?        #=> true
+```ruby
+email = EmailAddress.new(address) #=> #<EmailAddress::Address:0x007fe6ee150540 ...>
+email.normal        #=> "clark.kent+scoops@gmail.com"
+email.canonical     #=> "clarkkent@gmail.com"
+email.original      #=> "Clark.Kent+scoops@gmail.com"
+email.valid?        #=> true
+```
 
 Here are some other methods that are available.
 
-    email.redact        #=> "{bea3f3560a757f8142d38d212a931237b218eb5e}@gmail.com"
-    email.sha1          #=> "bea3f3560a757f8142d38d212a931237b218eb5e"
-    email.md5           #=> "c5be3597c391169a5ad2870f9ca51901"
-    email.host_name     #=> "gmail.com"
-    email.provider      #=> :google
-    email.mailbox       #=> "clark.kent"
-    email.tag           #=> "scoops"
+```ruby
+email.redact        #=> "{bea3f3560a757f8142d38d212a931237b218eb5e}@gmail.com"
+email.sha1          #=> "bea3f3560a757f8142d38d212a931237b218eb5e"
+email.sha256        #=> "9e2a0270f2d6778e5f647fc9eaf6992705ca183c23d1ed1166586fd54e859f75"
+email.md5           #=> "c5be3597c391169a5ad2870f9ca51901"
+email.host_name     #=> "gmail.com"
+email.provider      #=> :google
+email.mailbox       #=> "clark.kent"
+email.tag           #=> "scoops"
+
+email.host.exchanger.first[:ip] #=> "2a00:1450:400b:c02::1a"
+email.host.txt_hash #=> {:v=>"spf1", :redirect=>"\_spf.google.com"}
+
+EmailAddress.normal("HIRO@こんにちは世界.com")
+                    #=> "hiro@xn--28j2a3ar1pp75ovm7c.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:
 
-    email.host.exchanger.first[:ip] #=> "2a00:1450:400b:c02::1a"
-    email.host.txt_hash #=> {:v=>"spf1", :redirect=>"\_spf.google.com"}
+    EmailAddress.new("user@hosteddomain.com").host.hosted_provider
 
-    EmailAddress.normal("HIRO@こんにちは世界.com")
-                        #=> "hiro@xn--28j2a3ar1pp75ovm7c.com"
-    EmailAddress.normal("hiro@xn--28j2a3ar1pp75ovm7c.com", host_encoding: :unicode)
-                        #=> "hiro@こんにちは世界.com"
 
 #### Rails Validator
 
@@ -204,9 +267,30 @@ Specify your email address attributes with `field: :user_email`, or
 `fields: [:email1, :email2]`. If neither is given, it assumes to use the
 `email` or `email_address` attribute.
 
-    class User < ActiveRecord::Base
-      validates_with EmailAddress::ActiveRecordValidator, field: :email
-    end
+```ruby
+class User < ActiveRecord::Base
+  validates_with EmailAddress::ActiveRecordValidator, field: :email
+end
+```
+
+#### Rails I18n
+
+Copy and adapt `lib/email_address/messages.yaml` into your locales and
+create an after initialization callback:
+
+```ruby
+# config/initializers/email_address.rb
+
+Rails.application.config.after_initialize do
+  I18n.available_locales.each do |locale|
+    translations = I18n.t(:email_address, locale: locale)
+
+    next unless translations.is_a? Hash
+
+    EmailAddress::Config.error_messages translations.transform_keys(&:to_s), locale.to_s
+  end
+end
+```
 
 #### Rails Email Address Type Attribute
 
@@ -216,9 +300,11 @@ First, you need to register the type in
 `config/initializers/email_address.rb` along with any global
 configurations you want.
 
-    ActiveRecord::Type.register(:email_address, EmailAddress::EmailAddressType)
-    ActiveRecord::Type.register(:canonical_email_address,
-                                EmailAddress::CanonicalEmailAddressType)
+```ruby
+ActiveRecord::Type.register(:email_address, EmailAddress::EmailAddressType)
+ActiveRecord::Type.register(:canonical_email_address,
+                            EmailAddress::CanonicalEmailAddressType)
+```
 
 Assume the Users table contains the columns "email" and "canonical_email".
 We want to normalize the address in "email" and store the canonical/unique
@@ -227,39 +313,42 @@ the email attribute is assigned. With the canonical_email column,
 we can look up the User, even it the given email address didn't exactly
 match the registered version.
 
-    class User < ApplicationRecord
-      attribute :email, :email_address
-      attribute :canonical_email, :canonical_email_address
-
-      validates_with EmailAddress::ActiveRecordValidator,
-                     fields: %i(email canonical_email)
-
-      def email=(email_address)
-        self[:canonical_email] = email_address
-        self[:email] = email_address
-      end
-
-      def self.find_by_email(email)
-        user   = self.find_by(email: EmailAddress.normal(email))
-        user ||= self.find_by(canonical_email: EmailAddress.canonical(email))
-        user ||= self.find_by(canonical_email: EmailAddress.redacted(email))
-        user
-      end
-
-      def redact!
-        self[:canonical_email] = EmailAddress.redact(self.canonical_email)
-        self[:email]           = self[:canonical_email]
-      end
-    end
+```ruby
+class User < ApplicationRecord
+  attribute :email, :email_address
+  attribute :canonical_email, :canonical_email_address
+
+  validates_with EmailAddress::ActiveRecordValidator,
+                 fields: %i(email canonical_email)
+
+  def email=(email_address)
+    self[:canonical_email] = email_address
+    self[:email] = email_address
+  end
+
+  def self.find_by_email(email)
+    user   = self.find_by(email: EmailAddress.normal(email))
+    user ||= self.find_by(canonical_email: EmailAddress.canonical(email))
+    user ||= self.find_by(canonical_email: EmailAddress.redacted(email))
+    user
+  end
+
+  def redact!
+    self[:canonical_email] = EmailAddress.redact(self.canonical_email)
+    self[:email]           = self[:canonical_email]
+  end
+end
+```
 
 Here is how the User model works:
 
-    user = User.create(email:"Pat.Smith+registrations@gmail.com")
-    user.email           #=> "pat.smith+registrations@gmail.com"
-    user.canonical_email #=> "patsmith@gmail.com"
-    User.find_by_email("PAT.SMITH@GMAIL.COM")
-                    #=> #<User email="pat.smith+registrations@gmail.com">
-
+```ruby
+user = User.create(email:"Pat.Smith+registrations@gmail.com")
+user.email           #=> "pat.smith+registrations@gmail.com"
+user.canonical_email #=> "patsmith@gmail.com"
+User.find_by_email("PAT.SMITH@GMAIL.COM")
+                     #=> #<User email="pat.smith+registrations@gmail.com">
+```
 
 The `find_by_email` method looks up a given email address by the
 normalized form (lower case), then by the canonical form, then finally
@@ -282,17 +371,19 @@ which syntax and network validations to perform.
 
 You can compare email addresses:
 
-    e1 = EmailAddress.new("Clark.Kent@Gmail.com")
-    e2 = EmailAddress.new("clark.kent+Superman@Gmail.com")
-    e3 = EmailAddress.new(e2.redact)
-    e1.to_s           #=> "clark.kent@gmail.com"
-    e2.to_s           #=> "clark.kent+superman@gmail.com"
-    e3.to_s           #=> "{bea3f3560a757f8142d38d212a931237b218eb5e}@gmail.com"
+```ruby
+e1 = EmailAddress.new("Clark.Kent@Gmail.com")
+e2 = EmailAddress.new("clark.kent+Superman@Gmail.com")
+e3 = EmailAddress.new(e2.redact)
+e1.to_s           #=> "clark.kent@gmail.com"
+e2.to_s           #=> "clark.kent+superman@gmail.com"
+e3.to_s           #=> "{bea3f3560a757f8142d38d212a931237b218eb5e}@gmail.com"
 
-    e1 == e2          #=> false (Matches by normalized address)
-    e1.same_as?(e2)   #=> true  (Matches as canonical address)
-    e1.same_as?(e3)   #=> true  (Matches as redacted address)
-    e1 < e2           #=> true  (Compares using normalized address)
+e1 == e2          #=> false (Matches by normalized address)
+e1.same_as?(e2)   #=> true  (Matches as canonical address)
+e1.same_as?(e3)   #=> true  (Matches as redacted address)
+e1 < e2           #=> true  (Compares using normalized address)
+```
 
 #### Matching
 
@@ -309,13 +400,15 @@ Matching addresses by simple patterns:
 
 Usage:
 
-    e = EmailAddress.new("Clark.Kent@Gmail.com")
-    e.matches?("gmail.com") #=> true
-    e.matches?("google")    #=> true
-    e.matches?(".org")      #=> false
-    e.matches?("g*com")     #=> true
-    e.matches?("gmail.")    #=> true
-    e.matches?("*kent*@")   #=> true
+```ruby
+e = EmailAddress.new("Clark.Kent@Gmail.com")
+e.matches?("gmail.com") #=> true
+e.matches?("google")    #=> true
+e.matches?(".org")      #=> false
+e.matches?("g*com")     #=> true
+e.matches?("gmail.")    #=> true
+e.matches?("*kent*@")   #=> true
+```
 
 ### Configuration
 
@@ -323,26 +416,34 @@ You can pass an options hash on the `.new()` and helper class methods to
 control how the library treats that address. These can also be
 configured during initialization by provider and default (see below).
 
-    EmailAddress.new("clark.kent@gmail.com",
-                     dns_lookup::off, host_encoding: :unicode)
+```ruby
+EmailAddress.new("clark.kent@gmail.com",
+                 host_validation: :syntax, host_encoding: :unicode)
+```
 
 Globally, you can change and query configuration options:
 
-    EmailAddress::Config.setting(:dns_lookup, :mx)
-    EmailAddress::Config.setting(:dns_lookup) #=> :mx
+```ruby
+EmailAddress::Config.setting(:host_validation, :mx)
+EmailAddress::Config.setting(:host_validation) #=> :mx
+```
 
 Or set multiple settings at once:
 
-    EmailAddress::Config.configure(local_downcase:false, dns_lookup: :off)
+```ruby
+EmailAddress::Config.configure(local_downcase: false, host_validation: :syntax)
+```
 
 You can add special rules by domain or provider. It takes the options
 above and adds the :domain_match and :exchanger_match rules.
 
-    EmailAddress.define_provider('google',
-      domain_match:      %w(gmail.com googlemail.com),
-      exchanger_match:   %w(google.com), # Requires dns_lookup==:mx
-      local_size:        5..64,
-      mailbox_canonical: ->(m) {m.gsub('.','')})
+```ruby
+EmailAddress.define_provider('google',
+  domain_match:      %w(gmail.com googlemail.com),
+  exchanger_match:   %w(google.com), # Requires host_validation==:mx
+  local_size:        5..64,
+  mailbox_canonical: ->(m) {m.gsub('.','')})
+```
 
 The library ships with the most common set of provider rules. It is not meant
 to house a database of all providers, but a separate `email_address-providers`
@@ -358,40 +459,48 @@ matches against the Mail Exchanger (SMTP receivers) hosts defined in
 DNS. If you specify an exchanger pattern, but requires a DNS MX lookup.
 
 For Rails application, create an initializer file with your default
-configuration options:
-
-    # ./config/initializers/email_address.rb
-    EmailAddress::Config.setting( local_format: :relaxed )
-    EmailAddress::Config.provider(:github,
-           host_match: %w(github.com), local_format: :standard)
+configuration options.
+EmailAddress::Config.setting takes a single setting name and value,
+while EmailAddress::Config.configure takes a hash of multiple settings.
+
+```ruby
+# ./config/initializers/email_address.rb
+EmailAddress::Config.setting( :local_format, :relaxed )
+EmailAddress::Config.configure( local_format: :relaxed, ... )
+EmailAddress::Config.provider(:github,
+       host_match: %w(github.com), local_format: :standard)
+```
 
 #### Override Error Messaegs
 
 You can override the default error messages as follows:
 
-    EmailAddress::Config.error_messages(
-      invalid_address:    "Invalid Email Address",
-      invalid_mailbox:    "Invalid Recipient/Mailbox",
-      invalid_host:       "Invalid Host/Domain Name",
-      exceeds_size:       "Address too long",
-      not_allowed:        "Address is not allowed",
-      incomplete_domain:  "Domain name is incomplete")
+```ruby
+EmailAddress::Config.error_messages({
+  invalid_address:    "Invalid Email Address",
+  invalid_mailbox:    "Invalid Recipient/Mailbox",
+  invalid_host:       "Invalid Host/Domain Name",
+  exceeds_size:       "Address too long",
+  not_allowed:        "Address is not allowed",
+  incomplete_domain:  "Domain name is incomplete"}, 'en')
+```
+Note: Release 0.1.14 fixed setting error messages by locale.
+Also, it will accept a ruby "collected" hash as before,
 
 Full translation support would be ideal though.
 
-
 ### Available Configuration Settings
 
-* dns_lookup: Enables DNS lookup for validation by
-    * :mx       - DNS MX Record lookup
-    * :a        - DNS A Record lookup (as some domains don't specify an MX incorrectly)
-    * :off      - Do not perform DNS lookup (Test mode, network unavailable)
-
 * sha1_secret -
   This application-level secret is appended to the email_address to compute
   the SHA1 Digest, making it unique to your application so it can't easily be
   discovered by comparing against a known list of email/sha1 pairs.
 
+* sha256_secret -
+  This application-level secret is appended to the email_address to compute
+  the SHA256 Digest, making it unique to your application so it can't easily be
+  discovered by comparing against a known list of email/sha256 pairs.
+
 * munge_string - "*****", the string to replace into munged addresses.
 
 For local part configuration:
@@ -443,7 +552,9 @@ For the mailbox (AKA account, role), without the tag
   :mx                 Ensure host is configured with DNS MX records
   :a                  Ensure host is known to DNS (A Record)
   :syntax             Validate by syntax only, no Network verification
-  :connect            Attempt host connection (not implemented, BAD!)
+  :connect            Attempt host connection (Experimental and Dangerous: Do not use)
+                      The :host_timeout setting is the maximum number
+                      of seconds to wait during the :connect validation
 
 * host_size:          1..253,
   A range specifying the size limit of the host part,
@@ -460,14 +571,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
@@ -487,7 +622,6 @@ Proper personal identity can still be provided using
 [MIME Encoded-Words](http://en.wikipedia.org/wiki/MIME#Encoded-Word)
 in Email headers.
 
-
 #### Email Addresses as Sensitive Data
 
 Like Social Security and Credit Card Numbers, email addresses are

data/Rakefile

@@ -1,10 +1,9 @@
 require "bundler/gem_tasks"
 
-require "bundler/gem_tasks"
 require "bundler/setup"
-require 'rake/testtask'
+require "rake/testtask"
 
-task :default => :test
+task default: :test
 
 desc "Run the Test Suite, toot suite"
 Rake::TestTask.new do |t|

data/email_address.gemspec

@@ -1,31 +1,37 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'email_address/version'
+require "email_address/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "email_address"
-  spec.version       = EmailAddress::VERSION
-  spec.authors       = ["Allen Fair"]
-  spec.email         = ["allen.fair@gmail.com"]
-  spec.description   = %q{The EmailAddress Gem to work with and validate email addresses.}
-  spec.summary       = %q{This gem provides a ruby language library for working with and validating email addresses. By default, it validates against conventional usage, the format preferred for user email addresses. It can be configured to validate against RFC “Standard” formats, common email service provider formats, and perform DNS validation.}
-  spec.homepage      = "https://github.com/afair/email_address"
-  spec.license       = "MIT"
+  spec.name = "email_address"
+  spec.version = EmailAddress::VERSION
+  spec.authors = ["Allen Fair"]
+  spec.email = ["allen.fair@gmail.com"]
+  spec.description = "The EmailAddress Gem to work with and validate email addresses."
+  spec.summary = "This gem provides a ruby language library for working with and validating email addresses. By default, it validates against conventional usage, the format preferred for user email addresses. It can be configured to validate against RFC “Standard” formats, common email service provider formats, and perform DNS validation."
+  spec.homepage = "https://github.com/afair/email_address"
+  spec.license = "MIT"
 
-  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)/})
+  spec.required_ruby_version = ">= 2.5", "< 4"
+  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)/})
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest",     "~> 5.8.3"
-  spec.add_development_dependency "bundler",      "~> 1.3"
-  spec.add_development_dependency "activerecord", "~> 5.0.1"         if RUBY_PLATFORM != 'java'
-  spec.add_development_dependency "activerecord", "~> 4.2.5"         if RUBY_PLATFORM == 'java'
-  spec.add_development_dependency "sqlite3"                          if RUBY_PLATFORM != 'java'
-  spec.add_development_dependency "activerecord-jdbcsqlite3-adapter" if RUBY_PLATFORM == 'java'
-  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "minitest", "~> 5.11"
+  spec.add_development_dependency "bundler" # ,      "~> 1.16.0"
+  if RUBY_PLATFORM == "java"
+    spec.add_development_dependency "activerecord", "~> 5.2.6"
+    spec.add_development_dependency "activerecord-jdbcsqlite3-adapter", "~> 52.7"
+  else
+    spec.add_development_dependency "activerecord", "~> 6.1.4"
+    spec.add_development_dependency "sqlite3"
+    spec.add_development_dependency "standard", "~> 1.5.0"
+  end
+  spec.add_development_dependency "net-smtp"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "pry"
+
   spec.add_dependency "simpleidn"
-  spec.add_dependency "netaddr"
 end