email_address 0.0.3 → 0.1.0

data/lib/email_address/version.rb

@@ -1,3 +1,3 @@
 module EmailAddress
-    VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/test/activerecord/test_ar.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+require_relative '../test_helper'
+
+class TestAR < MiniTest::Test
+  require_relative 'user.rb'
+
+  def test_validation
+    user = User.new(email:"Pat.Jones+ASDF#GMAIL.com")
+    assert_equal false, user.valid?
+    user = User.new(email:"Pat.Jones+ASDF@GMAIL.com")
+    assert_equal true, user.valid?
+  end
+
+  def test_datatype
+    if defined?(ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 5
+      user = User.new(email:"Pat.Jones+ASDF@GMAIL.com")
+      assert_equal 'pat.jones+asdf@gmail.com', user.email
+      assert_equal 'patjones@gmail.com', user.canonical_email
+    end
+  end
+
+end

data/test/activerecord/user.rb

@@ -0,0 +1,71 @@
+################################################################################
+# ActiveRecord Test Setup ...
+################################################################################
+
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+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
+  )
+else
+  require 'sqlite3'
+  ActiveRecord::Base.establish_connection(
+    :adapter  => 'sqlite3',
+    :database => dbfile
+  )
+end
+
+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)
+end
+
+################################################################################
+# User Model
+################################################################################
+
+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)
+
+  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

data/test/email_address/test_address.rb

@@ -6,47 +6,73 @@ class TestAddress < Minitest::Test
     a = EmailAddress.new("User+tag@example.com")
     assert_equal "user+tag", a.local.to_s
     assert_equal "example.com", a.host.to_s
-    assert_equal :unknown, a.provider
+    assert_equal "us*****@ex*****", a.munge
+    assert_equal :default, a.provider
   end
 
-  def test_noramlize
-    a = EmailAddress.new("User+tag@Example.com")
-    assert_equal "user+tag@example.com", a.normalize
+  # LOCAL
+  def test_local
+    a = EmailAddress.new("User+tag@example.com")
+    assert_equal "user", a.mailbox
+    assert_equal "user+tag", a.left
+    assert_equal "tag", a.tag
+  end
+
+  # HOST
+  def test_host
+    a = EmailAddress.new("User+tag@example.com")
+    assert_equal "example.com", a.hostname
+    #assert_equal :default, a.provider
   end
 
-  def test_canonical
-    a = EmailAddress.new("User+tag@Example.com")
+  # ADDRESS
+  def test_forms
+    a = EmailAddress.new("User+tag@example.com")
+    assert_equal "user+tag@example.com", a.to_s
     assert_equal "user@example.com", a.canonical
-    a = EmailAddress.new("first.last+tag@gmail.com")
-    assert_equal "firstlast@gmail.com", a.canonical
+    assert_equal "{63a710569261a24b3766275b7000ce8d7b32e2f7}@example.com", a.redact
+    assert_equal "b58996c504c5638798eb6b511e6f49af", a.reference
+  end
+
+  # COMPARISON & MATCHING
+  def test_compare
+    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)
+    assert_equal true, n == "user+tag@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_digest
-    a = EmailAddress.new("User+tag@Example.com")
-    assert_equal "b58996c504c5638798eb6b511e6f49af", a.md5
-    assert_equal "63a710569261a24b3766275b7000ce8d7b32e2f7", a.sha1
-    assert_equal "63a710569261a24b3766275b7000ce8d7b32e2f7@example.com", a.redact
+  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*')
   end
 
-  def test_idn
-    a = EmailAddress.new("User+tag@ɹᴉɐℲuǝll∀.ws")
-    assert_equal "user@xn--ull-6eb78cvh231oq7gdzb.ws", a.canonical
-    assert_equal "9c06226d81149f59b4df32bb426c64a0cbafcea5@xn--ull-6eb78cvh231oq7gdzb.ws", a.redact
+  # VALIDATION
+  def test_valid
+    assert EmailAddress.valid?("User+tag@example.com", dns_lookup: :a), "valid 1"
+    assert ! EmailAddress.valid?("User%tag@example.com", dns_lookup: :a), "valid 2"
+    assert EmailAddress.new("ɹᴉɐℲuǝll∀@ɹᴉɐℲuǝll∀.ws", local_encoding: :uncode, dns_lookup: :off ), "valid unicode"
   end
 
   def test_no_domain
     e = EmailAddress.new("User+tag.gmail.ws")
-    assert_equal false, e.valid?
+    assert_equal '', e.hostname
+    assert_equal false, e.valid? # localhost not allowed by default
   end
 
-  def test_equality
-    a = EmailAddress.new("User+tag@Example.com")
-    b = EmailAddress.new("user@Example.com")
-    c = EmailAddress.new( EmailAddress.new("USER@Example.com").redact)
-    assert a != b
-    assert a < b
-    assert b > a
-    assert a.same_as?(b)
-    assert a.same_as?(c)
+  def test_regexen
+    assert "First.Last+TAG@example.com".match(EmailAddress::Address::CONVENTIONAL_REGEX)
+    assert "First.Last+TAG@example.com".match(EmailAddress::Address::STANDARD_REGEX)
+    assert_equal nil, "First.Last+TAGexample.com".match(EmailAddress::Address::STANDARD_REGEX)
+    assert_equal nil, "First#Last+TAGexample.com".match(EmailAddress::Address::CONVENTIONAL_REGEX)
   end
+
 end

data/test/email_address/test_config.rb

@@ -1,13 +1,28 @@
 require_relative '../test_helper'
 
 class TestConfig < MiniTest::Test
-  def test_setup
-    EmailAddress::Config.setup do
-      provider :disposable, domains:%w(mailenator)
-      option   :downcase_mailboxes, true
-    end
-    assert_equal true, EmailAddress::Config.providers.has_key?(:disposable)
-    assert_equal true, EmailAddress::Config.options[:downcase_mailboxes]
+  def test_setting
+    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 false, EmailAddress::Config.setting(:local_downcase)
+    EmailAddress::Config.configure(local_downcase:true, dns_lookup: :mx)
+  end
+
+  def test_provider
+    assert_equal nil, EmailAddress::Config.provider(:github)
+    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)
+    assert_equal nil, EmailAddress::Config.provider(:github)
   end
-  
 end

data/test/email_address/test_exchanger.rb

@@ -3,17 +3,29 @@ require_relative '../test_helper'
 
 class TestExchanger < MiniTest::Test
   def test_exchanger
-    a = EmailAddress::Exchanger.new("example.com")
-    assert_equal true, a.has_dns_a_record? # example.com has no MX'ers
+    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 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
   end
 
-  def test_dns
-    good = EmailAddress::Exchanger.new("gmail.com")
-    bad  = EmailAddress::Exchanger.new("exampldkeie4iufe.com")
-    assert_equal true, good.has_dns_a_record?
-    assert_equal false, bad.has_dns_a_record?
-    assert_equal "gmail.com", good.dns_a_record.first
-    assert(/google.com\z/, good.mxers.first.first)
-    assert_equal 'google.com', good.domains.first
+  def test_not_found
+    e = EmailAddress::Exchanger.new("oops.gmail.com")
+    assert_equal 0, e.mxers.size
   end
+
+    #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?
+  #  assert_equal false, bad.has_dns_a_record?
+  #  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

data/test/email_address/test_host.rb

@@ -9,7 +9,8 @@ class TestHost < MiniTest::Test
     assert_equal "example.com", a.domain_name
     assert_equal "example", a.registration_name
     assert_equal "com", a.tld
-    assert_equal "", a.subdomains
+    assert_equal "ex*****", a.munge
+    assert_equal nil, a.subdomains
   end
 
   def test_foreign_host
@@ -17,27 +18,28 @@ class TestHost < MiniTest::Test
     assert_equal "my.yahoo.co.jp", a.host_name
     assert_equal "yahoo.co.jp", a.domain_name
     assert_equal "yahoo", a.registration_name
-    assert_equal "co.jp", a.tld
+    assert_equal "co.jp", a.tld2
     assert_equal "my", a.subdomains
   end
 
   def test_ip_host
     a = EmailAddress::Host.new("[127.0.0.1]")
-    assert_equal "[127.0.0.1]", a.host_name
+    assert_equal "[127.0.0.1]", a.name
     assert_equal "127.0.0.1", a.ip_address
-    
   end
 
   def test_unicode_host
     a = EmailAddress::Host.new("å.com")
-    assert_equal "xn--5ca.com", a.dns_host_name
+    assert_equal "xn--5ca.com", a.dns_name
+    a = EmailAddress::Host.new("xn--5ca.com", host_encoding: :unicode)
+    assert_equal "å.com", a.to_s
   end
 
   def test_provider
     a = EmailAddress::Host.new("my.yahoo.co.jp")
     assert_equal :yahoo, a.provider
     a = EmailAddress::Host.new("example.com")
-    assert_equal :unknown, a.provider
+    assert_equal :default, a.provider
   end
 
   def test_dmarc
@@ -46,4 +48,43 @@ class TestHost < MiniTest::Test
     d = EmailAddress::Host.new("example.com").dmarc
     assert_equal true, d.empty?
   end
+
+  def test_ipv4
+    h = EmailAddress::Host.new("[127.0.0.1]", host_allow_ip:true)
+    assert_equal "127.0.0.1", h.ip_address
+    assert_equal true, h.valid?
+  end
+
+  def test_ipv6
+    h = EmailAddress::Host.new("[IPv6:::1]", host_allow_ip:true)
+    assert_equal "::1", h.ip_address
+    assert_equal true, h.valid?
+  end
+
+  def test_comment
+    h = EmailAddress::Host.new("(oops)gmail.com")
+    assert_equal 'gmail.com', h.to_s
+    assert_equal 'oops', h.comment
+    h = EmailAddress::Host.new("gmail.com(oops)")
+    assert_equal 'gmail.com', h.to_s
+    assert_equal 'oops', h.comment
+  end
+
+  def test_matches
+    h = EmailAddress::Host.new("yahoo.co.jp")
+    assert_equal false, h.matches?("gmail.com")
+    assert_equal 'yahoo.co.jp', h.matches?("yahoo.co.jp")
+    assert_equal '.co.jp', h.matches?(".co.jp")
+    assert_equal '.jp', h.matches?(".jp")
+    assert_equal 'yahoo.', h.matches?("yahoo.")
+    assert_equal 'yah*.jp', h.matches?("yah*.jp")
+  end
+
+  def test_regexen
+    assert "asdf.com".match EmailAddress::Host::CANONICAL_HOST_REGEX
+    assert "xn--5ca.com".match EmailAddress::Host::CANONICAL_HOST_REGEX
+    assert "[127.0.0.1]".match EmailAddress::Host::STANDARD_HOST_REGEX
+    assert "[IPv6:2001:dead::1]".match EmailAddress::Host::STANDARD_HOST_REGEX
+    assert_equal nil, "[256.0.0.1]".match(EmailAddress::Host::STANDARD_HOST_REGEX)
+  end
 end

data/test/email_address/test_local.rb

@@ -2,30 +2,94 @@
 require_relative '../test_helper'
 
 class TestLocal < MiniTest::Test
-  def test_local
-    a = EmailAddress::Local.new("TestMonkey")
-    assert_equal "testmonkey", a.to_s
+
+  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},
+    ].each do |local|
+      assert EmailAddress::Local.new(local, local_fix: false).standard?, local
+    end
+  end
+
+  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},
+    ].each do |local|
+      assert_equal false, EmailAddress::Local.new(local, local_fix: false).standard?, local
+    end
+  end
+
+  def test_relaxed
+    assert EmailAddress::Local.new("first..last", local_format: :relaxed).valid?, "relax.."
+    assert EmailAddress::Local.new("first.-last", local_format: :relaxed).valid?, "relax.-"
+    assert EmailAddress::Local.new("a", local_format: :relaxed).valid?, "relax single"
+    assert ! EmailAddress::Local.new("firstlast_", local_format: :relaxed).valid?, "last_"
+  end
+
+  def test_unicode
+    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("üñîçøðé3").valid?, "üñîçøðé3 valid"
   end
 
-  def test_tag_comment
-    a = EmailAddress::Local.new("User+tag(comment!)")
-    assert_equal "user", a.mailbox
-    assert_equal "comment!", a.comment
-    assert_equal "tag", a.tag
+
+  def test_valid_conventional
+    %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
+    end
+  end
+
+  def test_valid
+    assert_equal false, EmailAddress::Local.new("first(comment)", local_format: :conventional).valid?
+    assert_equal true, EmailAddress::Local.new("first(comment)", local_format: :standard).valid?
   end
 
   def test_format
-    a = EmailAddress::Local.new("(Comment!)First Last+tag")
-    assert_equal 'firstlast+tag', a.normalize
+    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)
   end
 
-  def test_gmail
-    a = EmailAddress::Local.new("first.last", EmailAddress::Host.new('gmail.com'))
-    assert_equal "firstlast", a.canonical
+  def test_redacted
+    l = "{bea3f3560a757f8142d38d212a931237b218eb5e}"
+    assert EmailAddress::Local.redacted?(l), "redacted? #{l}"
+    assert_equal :redacted, EmailAddress::Local.new(l).format?
   end
 
-  def test_root_name
-    a = EmailAddress::Local.new("superman123", EmailAddress::Host.new('gmail.com'))
-    assert_equal "superman", a.root_name
+  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*@')
   end
+
+  def test_munge
+    assert_equal "us*****", EmailAddress::Local.new("User+tag").munge
+  end
+
 end