email_address 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 865ef9fea556b3de09bffbfc977f751ef806da92
-  data.tar.gz: c647502c488d49962b962090c5b3623bc89c774c
+  metadata.gz: f7c4c2225713bcb8fa68e8c07aba6de9db62e629
+  data.tar.gz: 8c1f4a244a889254825d1325414536564a12abdf
 SHA512:
-  metadata.gz: 85c1508f8e3e73960157d00306db1d0d692e7e9f33db00d8a7ebce75bf1ce56626b670e5fb0f322b54fe78154d79815cefa0350d2f2187c049c13ede4341a828
-  data.tar.gz: 6811f8ec8f1ca8e5253df4cbc58e90d4e6e27ff35014ce56ac59bc70d9a4ed1044d3f09ad0ce3a451238e7328c7eb2721d36840d5f6197616e38bda63c53b2ff
+  metadata.gz: 4927cd30d0302715b8f96a9224f13a85742242c27a1f813ffecdf75eb1896e2954fb36590213cad533d325ba121e096c15f74cb9c416fef191fe2181d668e591
+  data.tar.gz: c5c4426b8749dd1cdd4d8617da291c88d6dbca11040a3bcbb1d729e43b14dabf7a4f4c6bea244fec997bb0d0a21aa47462cf66056fdaf536f181e3702216d5dd

data/README.md

@@ -20,10 +20,6 @@ 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.
 
 ## Quick Start
@@ -53,7 +49,7 @@ provider (such as Google Apps).  Note that `example.com`, while
 a valid domain name, does not have MX records.
 
     EmailAddress.valid? "allen@example.com" #=> false
-    EmailAddress.valid? "allen@example.com", dns_lookup: :off #=> true
+    EmailAddress.valid? "allen@example.com", host_validation: :syntax #=> true
 
 Most mail servers do not yet support Unicode mailboxes, so the default here is ASCII.
 
@@ -359,23 +355,23 @@ 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)
+                     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
+    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)
+    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
+      exchanger_match:   %w(google.com), # Requires host_validation==:mx
       local_size:        5..64,
       mailbox_canonical: ->(m) {m.gsub('.','')})
 
@@ -417,11 +413,6 @@ 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
@@ -478,7 +469,7 @@ 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 (Dangerous: Do not use)
 
 * host_size:          1..253,
   A range specifying the size limit of the host part,

data/lib/email_address.rb

@@ -13,59 +13,45 @@ module EmailAddress
     require "email_address/canonical_email_address_type"
   end
 
+  # @!method self.valid?(options={})
+  #   Proxy method to {EmailAddress::Address#valid?}
+  # @!method self.error
+  #   Proxy method to {EmailAddress::Address#error}
+  # @!method self.normal
+  #   Proxy method to {EmailAddress::Address#normal}
+  # @!method self.redact(digest=:sha1)
+  #   Proxy method to {EmailAddress::Address#redact}
+  # @!method self.munge
+  #   Proxy method to {EmailAddress::Address#munge}
+  # @!method self.canonical
+  #   Proxy method to {EmailAddress::Address#canonical}
+  # @!method self.reference
+  #   Proxy method to {EmailAddress::Address#reference}
+  class << self
+    (%i[valid? error normal redact munge canonical reference] &
+     EmailAddress::Address.public_instance_methods
+    ).each do |proxy_method|
+      define_method(proxy_method) do |*args, &block|
+        EmailAddress::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
 
-  # Given an email address, this returns true if the email validates, false otherwise
-  def self.valid?(email_address, config={})
-    self.new(email_address, config).valid?
-  end
-
-  # Given an email address, this returns nil if the email validates,
-  # or a string with a small error message otherwise
-  def self.error(email_address, config={})
-    self.new(email_address, config).error
-  end
-
-  # Shortcut to normalize the given email address in the given format
-  def self.normal(email_address, config={})
-    EmailAddress::Address.new(email_address, config).to_s
-  end
-
-  # Shortcut to normalize the given email address
-  def self.redact(email_address, config={})
-    EmailAddress::Address.new(email_address, config).redact
-  end
-
-  # Shortcut to munge the given email address for web publishing
-  # returns ma_____@do_____.com
-  def self.munge(email_address, config={})
-    EmailAddress::Address.new(email_address, config).munge
-  end
-
   def self.new_redacted(email_address, config={})
     EmailAddress::Address.new(EmailAddress::Address.new(email_address, config).redact)
   end
 
-  # Returns the Canonical form of the email address. This form is what should
-  # be considered unique for an email account, lower case, and no address tags.
-  def self.canonical(email_address, config={})
-    EmailAddress::Address.new(email_address, config).canonical
-  end
-
   def self.new_canonical(email_address, config={})
     EmailAddress::Address.new(EmailAddress::Address.new(email_address, config).canonical, config)
   end
 
-  # Returns the Reference form of the email address, defined as the MD5
-  # digest of the Canonical form.
-  def self.reference(email_address, config={})
-    EmailAddress::Address.new(email_address, config).reference
-  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)

data/lib/email_address/address.rb

@@ -6,7 +6,7 @@ module EmailAddress
   # (EmailAddress::Local) and Host (Email::AddressHost) parts.
   class Address
     include Comparable
-    attr_accessor :original, :local, :host, :config
+    attr_accessor :original, :local, :host, :config, :reason
 
     CONVENTIONAL_REGEX = /\A#{::EmailAddress::Local::CONVENTIONAL_MAILBOX_WITHIN}
                            @#{::EmailAddress::Host::DNS_HOST_REGEX}\z/x
@@ -230,17 +230,48 @@ module EmailAddress
         return false unless self.local.valid?
         return false unless self.host.valid?
       end
-      if !@config[:address_local] && !self.hostname.include?(".")
-        return set_error :incomplete_domain
+      if @config[:address_validation] == :smtp
+
       end
       true
     end
 
-    def set_error(err)
+    # Connects to host to test if user can receive email. This should NOT be performed
+    # as an email address check, but is provided to assist in problem resolution.
+    # If you abuse this, you *could* be blocked by the ESP.
+    def connect
+      begin
+        smtp = Net::SMTP.new(self.host_name || self.ip_address)
+        smtp.start(@config[:smtp_helo_name] || 'localhost')
+        smtp.mailfrom @config[:smtp_mail_from] || 'postmaster@localhost'
+        smtp.rcptto self.to_s
+        p [:connect]
+        smtp.finish
+        true
+      rescue Net::SMTPUnknownError => e
+        set_error(:address_unknown, e.to_s)
+      rescue Net::SMTPFatalError => e
+        set_error(:address_unknown, e.to_s)
+      rescue SocketError => e
+        set_error(:address_unknown, e.to_s)
+      ensure
+        if smtp && smtp.started?
+          smtp.finish
+        end
+        !!@error
+      end
+    end
+
+    def set_error(err, reason=nil)
       @error = EmailAddress::Config.error_messages.fetch(err) { err }
+      @reason= reason
       false
     end
 
+    def error_message
+      @error
+    end
+
     def error
       self.valid? ? nil : @error
     end

data/lib/email_address/config.rb

@@ -68,6 +68,9 @@ module EmailAddress
   # * host_allow_ip:      false,
   #   Allow IP address format in host: [127.0.0.1], [IPv6:::1]
   #
+  # * host_local:         false,
+  #   Allow localhost, no domain, or local subdomains.
+  #
   # * address_validation: :parts, :smtp, ->(address) { true }
   #   Address validation policy
   #   :parts              Validate local and host.
@@ -77,8 +80,11 @@ module EmailAddress
   # * address_size:       3..254,
   #   A range specifying the size limit of the complete address
   #
-  # * address_local:      false,
-  #   Allow localhost, no domain, or local subdomains.
+  # * address_fqdn_domain: nil || "domain.tld"
+  #   Configure to complete the FQDN (Fully Qualified Domain Name)
+  #   When host is blank, this value is used
+  #   When host is computer name only, a dot and this is appended to get the FQDN
+  #   You probably don't want this unless you have host-local email accounts
   #
   # For provider rules to match to domain names and Exchanger hosts
   # The value is an array of match tokens.
@@ -104,14 +110,15 @@ module EmailAddress
       mailbox_validator:  nil, # nil,  Proc
 
       host_encoding:      :punycode || :unicode,
-      host_validation:    :mx || :a || :connect,
+      host_validation:    :mx || :a || :connect || :syntax,
       host_size:          1..253,
       host_allow_ip:      false,
       host_remove_spaces: false,
+      host_local:         false,
 
       address_validation: :parts, # :parts, :smtp, Proc
       address_size:       3..254,
-      address_localhost:  false,
+      address_fqdn_domain: nil, # Fully Qualified Domain Name = [host].[domain.tld]
     }
 
     @providers = {

data/lib/email_address/host.rb

@@ -1,6 +1,7 @@
 require 'simpleidn'
 require 'resolv'
 require 'netaddr'
+require 'net/smtp'
 
 module EmailAddress
   ##############################################################################
@@ -33,7 +34,7 @@ module EmailAddress
     attr_reader :host_name
     attr_accessor :dns_name, :domain_name, :registration_name,
                   :tld, :tld2, :subdomains, :ip_address, :config, :provider,
-                  :comment, :error_message
+                  :comment, :error_message, :reason
     MAX_HOST_LENGTH = 255
 
     # Sometimes, you just need a Regexp...
@@ -143,7 +144,8 @@ module EmailAddress
     end
 
     def host_name=(name)
-      @host_name = name = name.strip.downcase
+      name = fully_qualified_domain_name(name.downcase)
+      @host_name = name
       if @config[:host_remove_spaces]
         @host_name = @host_name.gsub(' ', '')
       end
@@ -179,6 +181,23 @@ module EmailAddress
       end
     end
 
+    def fully_qualified_domain_name(host_part)
+      dn = @config[:address_fqdn_domain]
+      if !dn
+        if (host_part.nil? || host_part <= " ") && @config[:host_local]
+          'localhost'
+        else
+          host_part
+        end
+      elsif host_part.nil? || host_part <= " "
+        dn
+      elsif !host_part.include?(".")
+        host_part + "." + dn
+      else
+        host_part
+      end
+    end
+
     # True if host is hosted at the provider, not a public provider host name
     def hosted_service?
       return false unless registration_name
@@ -310,7 +329,7 @@ module EmailAddress
 
     # True if the :dns_lookup setting is enabled
     def dns_enabled?
-      EmailAddress::Config.setting(:dns_lookup).equal?(:off) ? false : true
+      [:mx, :a].include?(EmailAddress::Config.setting(:host_validation))
     end
 
     # Returns: [official_hostname, alias_hostnames, address_family, *address_list]
@@ -360,20 +379,22 @@ module EmailAddress
     ############################################################################
 
     # Returns true if the host name is valid according to the current configuration
-    def valid?(rule=@config[:dns_lookup]||:mx)
+    def valid?(rules={})
+      host_validation = rules[:host_validation] || @config[:host_validation] || :mx
+      dns_lookup      = rules[:dns_lookup] || host_validation
       self.error_message = nil
       if self.ip_address
         valid_ip?
       elsif ! valid_format?
         false
-      elsif rule == :mx
+      elsif dns_lookup == :connect
+        valid_mx? && connect
+      elsif dns_lookup == :mx
         valid_mx?
-      elsif rule == :a
+      elsif dns_lookup == :a
         valid_dns?
-      elsif rule == :off
-        true
       else
-        set_error(:domain_bad_validation_rule)
+        true
       end
     end
 
@@ -384,13 +405,21 @@ module EmailAddress
 
     # True if the host name has a DNS A Record
     def valid_dns?
-      dns_a_record.size > 0 || set_error(:domain_unknown)
+      bool = dns_a_record.size > 0 || set_error(:domain_unknown)
+      if self.localhost? && !@config[:host_local]
+        bool = set_error(:domain_no_localhost)
+      end
+      bool
     end
 
     # True if the host name has valid MX servers configured in DNS
     def valid_mx?
       if self.exchangers.mx_ips.size > 0
-        true
+        if self.localhost? && !@config[:host_local]
+          set_error(:domain_no_localhost)
+        else
+          true
+        end
       elsif valid_dns?
         set_error(:domain_does_not_accept_email)
       else
@@ -412,16 +441,53 @@ module EmailAddress
     # is reachable.
     def valid_ip?
       if ! @config[:host_allow_ip]
-        set_error(:ip_address_forbidden)
+        bool = set_error(:ip_address_forbidden)
       elsif self.ip_address.include?(":")
-        self.ip_address =~ Resolv::IPv6::Regex ? true : set_error(:ipv6_address_invalid)
+        bool = self.ip_address =~ Resolv::IPv6::Regex ? true : set_error(:ipv6_address_invalid)
       elsif self.ip_address.include?(".")
-        self.ip_address =~ Resolv::IPv4::Regex ? true : set_error(:ipv4_address_invalid)
+        bool = self.ip_address =~ Resolv::IPv4::Regex ? true : set_error(:ipv4_address_invalid)
+      end
+      if bool && (localhost? && !@config[:host_local])
+        bool = set_error(:ip_address_no_localhost)
+      end
+      bool
+    end
+
+    def localhost?
+      if self.ip_address
+        if self.ip_address.include?(":")
+          return NetAddr::CIDR.create("::1").matches?(self.ip_address)
+        else
+          return NetAddr::CIDR.create("127.0.0.0/8").matches?(self.ip_address)
+        end
+      else
+        self.host_name == 'localhost'
+      end
+    end
+
+    # Connects to host to test it can receive email. This should NOT be performed
+    # as an email address check, but is provided to assist in problem resolution.
+    # If you abuse this, you *could* be blocked by the ESP.
+    def connect
+      begin
+        smtp = Net::SMTP.new(self.host_name || self.ip_address)
+        smtp.start(@config[:helo_name] || 'localhost')
+        smtp.finish
+        true
+      rescue Net::SMTPFatalError => e
+        set_error(:server_not_available, e.to_s)
+      rescue SocketError => e
+        set_error(:server_not_available, e.to_s)
+      ensure
+        if smtp && smtp.started?
+          smtp.finish
+        end
       end
     end
 
-    def set_error(err)
+    def set_error(err, reason=nil)
       @error_message = EmailAddress::Config.error_messages.fetch(err) { err }
+      @reason        = reason
       false
     end
 

data/lib/email_address/version.rb

@@ -1,3 +1,3 @@
 module EmailAddress
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/test/email_address/test_address.rb

@@ -66,15 +66,19 @@ class TestAddress < Minitest::Test
 
   # 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"
+    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"
   end
 
-  def test_no_domain
-    e = EmailAddress.new("User+tag.gmail.ws")
+  def test_localhost
+    e = EmailAddress.new("User+tag.gmail.ws") # No domain means localhost
     assert_equal '', e.hostname
     assert_equal false, e.valid? # localhost not allowed by default
+    assert_equal EmailAddress.error("user1"), :domain_invalid
+    assert_equal EmailAddress.error("user1", host_local:true), :domain_does_not_accept_email
+    assert_equal EmailAddress.error("user1@localhost", host_local:true), :domain_does_not_accept_email
+    assert_equal EmailAddress.error("user2@localhost", host_local:true, dns_lookup: :off, host_validation: :syntax), nil
   end
 
   def test_regexen

data/test/email_address/test_host.rb

@@ -16,10 +16,10 @@ class TestHost < MiniTest::Test
   def test_dns_enabled
     a = EmailAddress::Host.new("example.com")
     assert_instance_of TrueClass, a.dns_enabled?
-    old_setting = EmailAddress::Config.setting(:dns_lookup)
-    EmailAddress::Config.configure(dns_lookup: :off)
+    old_setting = EmailAddress::Config.setting(:host_validation)
+    EmailAddress::Config.configure(host_validation: :off)
     assert_instance_of FalseClass, a.dns_enabled?
-    EmailAddress::Config.configure(dns_lookup: old_setting)
+    EmailAddress::Config.configure(host_validation: old_setting)
   end
 
   def test_foreign_host
@@ -59,13 +59,13 @@ class TestHost < MiniTest::Test
   end
 
   def test_ipv4
-    h = EmailAddress::Host.new("[127.0.0.1]", host_allow_ip:true)
+    h = EmailAddress::Host.new("[127.0.0.1]", host_allow_ip:true, host_local: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)
+    h = EmailAddress::Host.new("[IPv6:::1]", host_allow_ip:true, host_local:true)
     assert_equal "::1", h.ip_address
     assert_equal true, h.valid?
   end
@@ -116,8 +116,8 @@ class TestHost < MiniTest::Test
     assert_equal EmailAddress::Host.new("yahoo.com").error, nil
     assert_equal EmailAddress::Host.new("example.com").error, :domain_does_not_accept_email
     assert_equal EmailAddress::Host.new("yahoo.wtf").error, :domain_unknown
-    assert_equal EmailAddress::Host.new("ajsdfhajshdfklasjhd.wtf", dns_lookup: :off).error, nil
-    assert_equal EmailAddress::Host.new("ya  hoo.com", dns_lookup: :off).error, :domain_invalid
+    assert_equal EmailAddress::Host.new("ajsdfhajshdfklasjhd.wtf", host_validation: :syntax).error, nil
+    assert_equal EmailAddress::Host.new("ya  hoo.com", host_validation: :syntax).error, :domain_invalid
     assert_equal EmailAddress::Host.new("[127.0.0.1]").error, :ip_address_forbidden
     assert_equal EmailAddress::Host.new("[127.0.0.666]", host_allow_ip:true).error, :ipv4_address_invalid
     assert_equal EmailAddress::Host.new("[IPv6::12t]", host_allow_ip:true).error, :ipv6_address_invalid

data/test/test_email_address.rb

@@ -39,7 +39,7 @@ class TestEmailAddress < MiniTest::Test
   def test_cases
     %w( miles.o'brien@yahoo.com first.last@gmail.com a-b.c_d+e@f.gx
     ).each do |address|
-      assert EmailAddress.valid?(address, dns_lookup: :off), "valid?(#{address})"
+      assert EmailAddress.valid?(address, host_validation: :syntax), "valid?(#{address})"
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: email_address
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Allen Fair
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-08 00:00:00.000000000 Z
+date: 2018-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -175,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: This gem provides a ruby language library for working with and validating