email_address 0.1.19 → 0.2.2

data/test/activerecord/user.rb

@@ -6,35 +6,38 @@ class ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
 end
 
-dbfile = ENV['EMAIL_ADDRESS_TEST_DB'] || "/tmp/email_address.gem.db"
+dbfile = ENV["EMAIL_ADDRESS_TEST_DB"] || "/tmp/email_address.gem.db"
 File.unlink(dbfile) if File.exist?(dbfile)
 
 # Connection: JRuby vs. MRI
-if RUBY_PLATFORM == 'java' # jruby
-  require 'jdbc/sqlite3'
-  require 'java'
-  require 'activerecord-jdbcsqlite3-adapter'
-  Jdbc::SQLite3.load_driver
-  ActiveRecord::Base.establish_connection(
-    :adapter  => 'jdbc',
-    :driver   => "org.sqlite.JDBC",
-    :url      => "jdbc:sqlite:" + dbfile
-  )
+# Disabled JRuby checks... weird CI failures. Hopefully someone can help?
+if RUBY_PLATFORM == "java" # jruby
+  # require "jdbc/sqlite3"
+  # require "java"
+  # require "activerecord-jdbcsqlite3-adapter"
+  # Jdbc::SQLite3.load_driver
+  # ActiveRecord::Base.establish_connection(
+  #   adapter: "jdbc",
+  #   driver: "org.sqlite.JDBC",
+  #   url: "jdbc:sqlite:" + dbfile
+  # )
 else
-  require 'sqlite3'
+  require "sqlite3"
   ActiveRecord::Base.establish_connection(
-    :adapter  => 'sqlite3',
-    :database => dbfile
+    adapter: "sqlite3",
+    database: dbfile
   )
-end
 
-ApplicationRecord.connection.execute(
-  "create table users ( email varchar, canonical_email varchar)")
+  # The following would be executed for both JRuby/MRI
+  ApplicationRecord.connection.execute(
+    "create table users ( email varchar, canonical_email varchar)"
+  )
 
-if defined?(ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 5
-  ActiveRecord::Type.register(:email_address, EmailAddress::EmailAddressType)
-  ActiveRecord::Type.register(:canonical_email_address,
-                              EmailAddress::CanonicalEmailAddressType)
+  if defined?(ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 5
+    ActiveRecord::Type.register(:email_address, EmailAddress::EmailAddressType)
+    ActiveRecord::Type.register(:canonical_email_address,
+      EmailAddress::CanonicalEmailAddressType)
+  end
 end
 
 ################################################################################
@@ -42,30 +45,28 @@ end
 ################################################################################
 
 class User < ApplicationRecord
-
   if defined?(ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 5
     attribute :email, :email_address
     attribute :canonical_email, :canonical_email_address
   end
 
   validates_with EmailAddress::ActiveRecordValidator,
-    fields: %i(email canonical_email)
+    fields: %i[email canonical_email]
 
   def email=(email_address)
     self[:canonical_email] = email_address
-    self[: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 = find_by(email: EmailAddress.normal(email))
+    user ||= find_by(canonical_email: EmailAddress.canonical(email))
+    user ||= find_by(canonical_email: EmailAddress.redacted(email))
     user
   end
 
   def redact!
-    self[:canonical_email] = EmailAddress.redact(self.canonical_email)
-    self[:email]           = self[:canonical_email]
+    self[:canonical_email] = EmailAddress.redact(canonical_email)
+    self[:email] = self[:canonical_email]
   end
-
 end

data/test/email_address/test_address.rb

@@ -1,5 +1,4 @@
-#encoding: utf-8
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 class TestAddress < Minitest::Test
   def test_address
@@ -22,7 +21,7 @@ class TestAddress < Minitest::Test
   def test_host
     a = EmailAddress.new("User+tag@example.com")
     assert_equal "example.com", a.hostname
-    #assert_equal :default, a.provider
+    # assert_equal :default, a.provider
   end
 
   # ADDRESS
@@ -34,7 +33,27 @@ class TestAddress < Minitest::Test
     assert_equal "{63a710569261a24b3766275b7000ce8d7b32e2f7}@example.com", a.redact
     assert_equal "{b58996c504c5638798eb6b511e6f49af}@example.com", a.redact(:md5)
     assert_equal "b58996c504c5638798eb6b511e6f49af", a.reference
-    assert_equal "6bdd00c53645790ad9bbcb50caa93880",  EmailAddress.reference("Gmail.User+tag@gmail.com")
+    assert_equal "6bdd00c53645790ad9bbcb50caa93880", EmailAddress.reference("Gmail.User+tag@gmail.com")
+  end
+
+  def test_sha1
+    a = EmailAddress.new("User+tag@example.com")
+    assert_equal "63a710569261a24b3766275b7000ce8d7b32e2f7", a.sha1
+  end
+
+  def test_sha1_with_secret
+    a = EmailAddress.new("User+tag@example.com", sha1_secret: "test-secret")
+    assert_equal "122df4ec3ce7121db6edc06a9e29eab39a7e8007", a.sha1
+  end
+
+  def test_sha256
+    a = EmailAddress.new("User+tag@example.com")
+    assert_equal "b4c9a289323b21a01c3e940f150eb9b8c542587f1abfd8f0e1cc1ffc5e475514", a.sha256
+  end
+
+  def test_sha256_with_secret
+    a = EmailAddress.new("User+tag@example.com", sha256_secret: "test-secret")
+    assert_equal "480899ff53ccd446cc123f0c5685869644af445e788f1b559054919674307a07", a.sha256
   end
 
   def test_google_hosted
@@ -44,23 +63,23 @@ class TestAddress < Minitest::Test
 
   # COMPARISON & MATCHING
   def test_compare
-    a = ("User+tag@example.com")
-    #e = EmailAddress.new("user@example.com")
+    a = "User+tag@example.com"
+    # e = EmailAddress.new("user@example.com")
     n = EmailAddress.new(a)
     c = EmailAddress.new_canonical(a)
-    #r = EmailAddress.new_redacted(a)
+    # r = EmailAddress.new_redacted(a)
     assert_equal true, n == "user+tag@example.com"
-    assert_equal true, n >  "b@example.com"
+    assert_equal true, n > "b@example.com"
     assert_equal true, n.same_as?(c)
     assert_equal true, n.same_as?(a)
   end
 
   def test_matches
     a = EmailAddress.new("User+tag@gmail.com")
-    assert_equal false,  a.matches?('mail.com')
-    assert_equal 'google',  a.matches?('google')
-    assert_equal 'user+tag@',  a.matches?('user+tag@')
-    assert_equal 'user*@gmail*',  a.matches?('user*@gmail*')
+    assert_equal false, a.matches?("mail.com")
+    assert_equal "google", a.matches?("google")
+    assert_equal "user+tag@", a.matches?("user+tag@")
+    assert_equal "user*@gmail*", a.matches?("user*@gmail*")
   end
 
   def test_empty_address
@@ -74,18 +93,20 @@ class TestAddress < Minitest::Test
   # VALIDATION
   def test_valid
     assert EmailAddress.valid?("User+tag@example.com", host_validation: :a), "valid 1"
-    assert ! EmailAddress.valid?("User%tag@example.com", host_validation: :a), "valid 2"
-    assert EmailAddress.new("ɹᴉɐℲuǝll∀@ɹᴉɐℲuǝll∀.ws", local_encoding: :uncode, host_validation: :syntax ), "valid unicode"
+    assert !EmailAddress.valid?("User%tag@example.com", host_validation: :a), "valid 2"
+    assert EmailAddress.new("ɹᴉɐℲuǝll∀@ɹᴉɐℲuǝll∀.ws", local_encoding: :uncode, host_validation: :syntax), "valid unicode"
   end
 
   def test_localhost
     e = EmailAddress.new("User+tag.gmail.ws") # No domain means localhost
-    assert_equal '', e.hostname
+    assert_equal "", e.hostname
     assert_equal false, e.valid? # localhost not allowed by default
     assert_equal EmailAddress.error("user1"), "Invalid Domain Name"
-    assert_equal EmailAddress.error("user1", host_local:true), "This domain is not configured to accept email"
-    assert_equal EmailAddress.error("user1@localhost", host_local:true), "This domain is not configured to accept email"
-    assert_nil EmailAddress.error("user2@localhost", host_local:true, dns_lookup: :off, host_validation: :syntax)
+    assert_equal EmailAddress.error("user1", host_local: true), "This domain is not configured to accept email"
+    assert_equal EmailAddress.error("user1@localhost", host_local: true), "This domain is not configured to accept email"
+    assert_equal EmailAddress.error("user1@localhost", host_local: false, host_validation: :syntax), "localhost is not allowed for your domain name"
+    assert_equal EmailAddress.error("user1@localhost", host_local: false, dns_lookup: :off), "localhost is not allowed for your domain name"
+    assert_nil EmailAddress.error("user2@localhost", host_local: true, dns_lookup: :off, host_validation: :syntax)
   end
 
   def test_regexen
@@ -97,7 +118,7 @@ class TestAddress < Minitest::Test
   end
 
   def test_srs
-    ea= "first.LAST+tag@gmail.com"
+    ea = "first.LAST+tag@gmail.com"
     e = EmailAddress.new(ea)
     s = e.srs("example.com")
     assert s.match(EmailAddress::Address::SRS_FORMAT_REGEX)
@@ -106,20 +127,20 @@ class TestAddress < Minitest::Test
 
   # Quick Regression tests for addresses that should have been valid (but fixed)
   def test_issues
-    assert true, EmailAddress.valid?('test@jiff.com', dns_lookup: :mx) # #7
+    assert true, EmailAddress.valid?("test@jiff.com", dns_lookup: :mx) # #7
     assert true, EmailAddress.valid?("w.-asdf-_@hotmail.com") # #8
     assert true, EmailAddress.valid?("first_last@hotmail.com") # #8
   end
 
   def test_issue9
-    assert ! EmailAddress.valid?('example.user@foo.')
-    assert ! EmailAddress.valid?('ogog@sss.c')
-    assert ! EmailAddress.valid?('example.user@foo.com/')
+    assert !EmailAddress.valid?("example.user@foo.")
+    assert !EmailAddress.valid?("ogog@sss.c")
+    assert !EmailAddress.valid?("example.user@foo.com/")
   end
 
   def test_relaxed_normal
-    assert ! EmailAddress.new('a.c.m.e.-industries@foo.com').valid?
-    assert true, EmailAddress.new('a.c.m.e.-industries@foo.com', local_format: :relaxed).valid?
+    assert !EmailAddress.new("a.c.m.e.-industries@foo.com").valid?
+    assert true, EmailAddress.new("a.c.m.e.-industries@foo.com", local_format: :relaxed).valid?
   end
 
   def test_nil_address

data/test/email_address/test_config.rb

@@ -1,25 +1,25 @@
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 class TestConfig < MiniTest::Test
   def test_setting
-    assert_equal :mx,  EmailAddress::Config.setting(:dns_lookup)
+    assert_equal :mx, EmailAddress::Config.setting(:dns_lookup)
     assert_equal :off, EmailAddress::Config.setting(:dns_lookup, :off)
     assert_equal :off, EmailAddress::Config.setting(:dns_lookup)
     EmailAddress::Config.setting(:dns_lookup, :mx)
   end
 
   def test_configure
-    assert_equal :mx,   EmailAddress::Config.setting(:dns_lookup)
-    assert_equal true,  EmailAddress::Config.setting(:local_downcase)
-    EmailAddress::Config.configure(local_downcase:false, dns_lookup: :off)
-    assert_equal :off,  EmailAddress::Config.setting(:dns_lookup)
+    assert_equal :mx, EmailAddress::Config.setting(:dns_lookup)
+    assert_equal true, EmailAddress::Config.setting(:local_downcase)
+    EmailAddress::Config.configure(local_downcase: false, dns_lookup: :off)
+    assert_equal :off, EmailAddress::Config.setting(:dns_lookup)
     assert_equal false, EmailAddress::Config.setting(:local_downcase)
-    EmailAddress::Config.configure(local_downcase:true, dns_lookup: :mx)
+    EmailAddress::Config.configure(local_downcase: true, dns_lookup: :mx)
   end
 
   def test_provider
     assert_nil EmailAddress::Config.provider(:github)
-    EmailAddress::Config.provider(:github, host_match: %w(github.com), local_format: :standard)
+    EmailAddress::Config.provider(:github, host_match: %w[github.com], local_format: :standard)
     assert_equal :standard, EmailAddress::Config.provider(:github)[:local_format]
     assert_equal :github, EmailAddress::Host.new("github.com").provider
     EmailAddress::Config.providers.delete(:github)

data/test/email_address/test_exchanger.rb

@@ -1,13 +1,12 @@
-#encoding: utf-8
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 class TestExchanger < MiniTest::Test
   def test_exchanger
     e = EmailAddress::Exchanger.new("gmail.com")
     assert_equal true, e.mxers.size > 1
     assert_equal :google, e.provider
-    assert_equal 'google.com', e.domains.first
-    assert_equal 'google.com', e.matches?("google.com")
+    assert_equal "google.com", e.domains.first
+    assert_equal "google.com", e.matches?("google.com")
     assert_equal false, e.matches?("fa00:1450:4013:c01::1a/16")
     assert_equal false, e.matches?("127.0.0.1/24")
     assert_equal true, e.mx_ips.size > 1
@@ -18,8 +17,8 @@ class TestExchanger < MiniTest::Test
     assert_equal 0, e.mxers.size
   end
 
-    #assert_equal true, a.has_dns_a_record? # example.com has no MX'ers
-  #def test_dns
+  # assert_equal true, a.has_dns_a_record? # example.com has no MX'ers
+  # def test_dns
   #  good = EmailAddress::Exchanger.new("gmail.com")
   #  bad  = EmailAddress::Exchanger.new("exampldkeie4iufe.com")
   #  assert_equal true, good.has_dns_a_record?
@@ -27,5 +26,5 @@ class TestExchanger < MiniTest::Test
   #  assert_equal "gmail.com", good.dns_a_record.first
   #  assert(/google.com\z/, good.mxers.first.first)
   #  #assert_equal 'google.com', good.domains.first
-  #end
+  # end
 end

data/test/email_address/test_host.rb

@@ -110,7 +110,8 @@ class TestHost < MiniTest::Test
   end
 
   def test_hosted_service
-    assert EmailAddress.valid?("test@jiff.com", dns_lookup: :mx)
+    # Is there a gmail-hosted domain that will continue to exist? Removing until then
+    # assert EmailAddress.valid?("test@jiff.com", dns_lookup: :mx)
     assert !EmailAddress.valid?("test@gmail.com", dns_lookup: :mx)
   end
 

data/test/email_address/test_local.rb

@@ -1,22 +1,20 @@
-# encoding: UTF-8
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 class TestLocal < MiniTest::Test
-
   def test_valid_standard
     [ # Via https://en.wikipedia.org/wiki/Email_address
-      %Q{prettyandsimple},
-      %Q{very.common},
-      %Q{disposable.style.email.with+symbol},
-      %Q{other.email-with-dash},
-      %Q{"much.more unusual"},
-      %Q{"(comment)very.unusual.@.unusual.com"},
-      %Q{#!$%&'*+-/=?^_`{}|~},
-      %Q{" "},
-      %Q{"very.(),:;<>[]\\".VERY.\\"very@\\ \\"very\\".unusual"},
-      %Q{"()<>[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"},
-      %Q{token." ".token},
-      %Q{abc."defghi".xyz},
+      %(prettyandsimple),
+      %(very.common),
+      %(disposable.style.email.with+symbol),
+      %(other.email-with-dash),
+      %("much.more unusual"),
+      %{"(comment)very.unusual.@.unusual.com"},
+      %(#!$%&'*+-/=?^_`{}|~),
+      %(" "),
+      %{"very.(),:;<>[]\\".VERY.\\"very@\\ \\"very\\".unusual"},
+      %{"()<>[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"},
+      %(token." ".token),
+      %(abc."defghi".xyz)
     ].each do |local|
       assert EmailAddress::Local.new(local, local_fix: false).standard?, local
     end
@@ -24,15 +22,15 @@ class TestLocal < MiniTest::Test
 
   def test_invalid_standard
     [ # Via https://en.wikipedia.org/wiki/Email_address
-      %Q{A@b@c},
-      %Q{a"b(c)d,e:f;g<h>i[j\k]l},
-      %Q{just"not"right},
-      %Q{this is"not\allowed},
-      %Q{this\ still\"not\\allowed},
-      %Q{john..doe},
-      %Q{ invalid},
-      %Q{invalid },
-      %Q{abc"defghi"xyz},
+      %(A@b@c),
+      %{a"b(c)d,e:f;g<h>i[j\k]l},
+      %(just"not"right),
+      %(this is"not\allowed),
+      %(this\ still\"not\\allowed),
+      %(john..doe),
+      %( invalid),
+      %(invalid ),
+      %(abc"defghi"xyz)
     ].each do |local|
       assert_equal false, EmailAddress::Local.new(local, local_fix: false).standard?, local
     end
@@ -46,22 +44,21 @@ class TestLocal < MiniTest::Test
   end
 
   def test_unicode
-    assert ! EmailAddress::Local.new("üñîçøðé1", local_encoding: :ascii).standard?, "not üñîçøðé1"
+    assert !EmailAddress::Local.new("üñîçøðé1", local_encoding: :ascii).standard?, "not üñîçøðé1"
     assert EmailAddress::Local.new("üñîçøðé2", local_encoding: :unicode).standard?, "üñîçøðé2"
     assert EmailAddress::Local.new("test", local_encoding: :unicode).valid?, "unicode should include ascii"
-    assert ! EmailAddress::Local.new("üñîçøðé3").valid?, "üñîçøðé3 valid"
+    assert !EmailAddress::Local.new("üñîçøðé3").valid?, "üñîçøðé3 valid"
   end
 
-
   def test_valid_conventional
-    %w( first.last first First+Tag o'brien).each do |local|
+    %w[first.last first First+Tag o'brien].each do |local|
       assert EmailAddress::Local.new(local).conventional?, local
     end
   end
 
   def test_invalid_conventional
-    (%w( first;.last +leading trailing+ o%brien) + ["first space"]).each do |local|
-      assert ! EmailAddress::Local.new(local, local_fix:false).conventional?, local
+    (%w[first;.last +leading trailing+ o%brien] + ["first space"]).each do |local|
+      assert !EmailAddress::Local.new(local, local_fix: false).conventional?, local
     end
   end
 
@@ -72,8 +69,8 @@ class TestLocal < MiniTest::Test
 
   def test_format
     assert_equal :conventional, EmailAddress::Local.new("can1").format?
-    assert_equal :standard, EmailAddress::Local.new(%Q{"can1"}).format?
-    assert_equal "can1", EmailAddress::Local.new(%Q{"can1(commment)"}).format(:conventional)
+    assert_equal :standard, EmailAddress::Local.new(%("can1")).format?
+    assert_equal "can1", EmailAddress::Local.new(%{"can1(commment)"}).format(:conventional)
   end
 
   def test_redacted
@@ -84,9 +81,9 @@ class TestLocal < MiniTest::Test
 
   def test_matches
     a = EmailAddress.new("User+tag@gmail.com")
-    assert_equal false,  a.matches?('user')
-    assert_equal false,  a.matches?('user@')
-    assert_equal 'user*@',  a.matches?('user*@')
+    assert_equal false, a.matches?("user")
+    assert_equal false, a.matches?("user@")
+    assert_equal "user*@", a.matches?("user*@")
   end
 
   def test_munge
@@ -105,4 +102,11 @@ class TestLocal < MiniTest::Test
     assert EmailAddress.valid?("username_____@gmail.com")
   end
 
+  def test_tag_punctuation
+    assert EmailAddress.valid?("first.last+foo.bar@gmail.com")
+  end
+
+  def test_relaxed_tag
+    assert EmailAddress.valid? "foo+abc@example.com", host_validation: :syntax, local_format: :relaxed
+  end
 end

data/test/email_address/test_rewriter.rb

@@ -1,14 +1,11 @@
-#encoding: utf-8
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 class TestRewriter < Minitest::Test
-
   def test_srs
-    ea= "first.LAST+tag@gmail.com"
+    ea = "first.LAST+tag@gmail.com"
     e = EmailAddress.new(ea)
     s = e.srs("example.com")
     assert s.match(EmailAddress::Address::SRS_FORMAT_REGEX)
     assert EmailAddress.new(s).to_s == e.to_s
   end
-
 end

data/test/test_aliasing.rb

@@ -1,5 +1,4 @@
-# encoding: UTF-8
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class TestAliasing < MiniTest::Test
   def setup

data/test/test_email_address.rb

@@ -1,44 +1,41 @@
-# encoding: UTF-8
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class TestEmailAddress < MiniTest::Test
-
   def test_new
-    a = EmailAddress.new('user@example.com')
-    assert_equal 'user', a.local.to_s
-    assert_equal 'example.com', a.host.to_s
+    a = EmailAddress.new("user@example.com")
+    assert_equal "user", a.local.to_s
+    assert_equal "example.com", a.host.to_s
   end
 
   def test_canonical
-    assert_equal "firstlast@gmail.com", EmailAddress.canonical('First.Last+TAG@gmail.com')
-    a = EmailAddress.new_canonical('First.Last+TAG@gmail.com')
-    assert_equal 'firstlast', a.local.to_s
+    assert_equal "firstlast@gmail.com", EmailAddress.canonical("First.Last+TAG@gmail.com")
+    a = EmailAddress.new_canonical("First.Last+TAG@gmail.com")
+    assert_equal "firstlast", a.local.to_s
   end
 
   def test_normal
-    assert_equal 'user+tag@gmail.com', EmailAddress.normal('USER+TAG@GMAIL.com')
+    assert_equal "user+tag@gmail.com", EmailAddress.normal("USER+TAG@GMAIL.com")
   end
 
   def test_valid
-    assert_equal true, EmailAddress.valid?('user@yahoo.com')
-    assert_equal true, EmailAddress.valid?('a@yahoo.com')
+    assert_equal true, EmailAddress.valid?("user@yahoo.com")
+    assert_equal true, EmailAddress.valid?("a@yahoo.com")
   end
 
   def test_matches
-    assert_equal 'yahoo.', EmailAddress.matches?('user@yahoo.com', 'yahoo.')
+    assert_equal "yahoo.", EmailAddress.matches?("user@yahoo.com", "yahoo.")
   end
 
   def test_reference
-    assert_equal 'dfeafc750cecde54f9a4775f5713bf01', EmailAddress.reference('user@yahoo.com')
+    assert_equal "dfeafc750cecde54f9a4775f5713bf01", EmailAddress.reference("user@yahoo.com")
   end
 
   def test_redact
-    assert_equal '{e037b6c476357f34f92b8f35b25d179a4f573f1e}@yahoo.com', EmailAddress.redact('user@yahoo.com')
+    assert_equal "{e037b6c476357f34f92b8f35b25d179a4f573f1e}@yahoo.com", EmailAddress.redact("user@yahoo.com")
   end
 
   def test_cases
-    %w( miles.o'brien@yahoo.com first.last@gmail.com a-b.c_d+e@f.gx
-    ).each do |address|
+    %w[miles.o'brien@yahoo.com first.last@gmail.com a-b.c_d+e@f.gx].each do |address|
       assert EmailAddress.valid?(address, host_validation: :syntax), "valid?(#{address})"
     end
   end
@@ -47,5 +44,4 @@ class TestEmailAddress < MiniTest::Test
     assert_equal "", EmailAddress.normal("")
     assert_equal "", EmailAddress.normal(" ")
   end
-
 end

data/test/test_helper.rb

@@ -1,11 +1,12 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
-require 'simplecov'
+require "pry"
+require "simplecov"
 SimpleCov.start
 
-require 'active_record'
-require 'rubygems'
-require 'minitest/autorun'
-require 'minitest/unit'
-require 'minitest/pride'
-require 'email_address'
+require "active_record"
+require "rubygems"
+require "minitest/autorun"
+require "minitest/unit"
+require "minitest/pride"
+require "email_address"