email_address 0.1.13 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67dd5ab4cf92d131f566e7cf275073dfd80f92f1024adb0a276e08bc81640878
-  data.tar.gz: fcccbc2f24aa40ee835c3a4cd5ec1a233823c7ab7d08afdb20f94f029b208493
+  metadata.gz: 2a5ff67ec79e4de2d356293664296391fc8296ad6a6ba08f1d1256e93f7c729c
+  data.tar.gz: 5485014c6f886d9a382c046f9025948eeed6c114accde2957424f1f613d1b51b
 SHA512:
-  metadata.gz: 7b28dfd2876f0a01cac862905bdd9b1c30d88505d0457a319469ec4ae35cb87d0b592ac6b028a531c2a115249eb3a6abb527896a63a1e2155ed6712618d2cff4
-  data.tar.gz: 4734fe3a428b07023963e7a01bf3a2853295a52ea4b308ddda8b82f8a0d09614ffabbc8d63c188b477b4a2f0f464ec76c70f6681b7423f7774b8205cbcefa4ad
+  metadata.gz: 336f61eb9e81ccf8fe859b0d05e5e4d1aaf734e06328169ce919a01fdf30caaebdb2f44e673b52cdde99e3790c413c854e486fd97e4c610b5ee6349c1e3dbe40
+  data.tar.gz: c08f83be388d6fdb646ea46439c0a65543091e401b9c9d38e312a7d2dc34313c3269f9c16916340d090f48ae224a1cd18631153d6478f87e32073f38e319ff28

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
 
@@ -446,14 +456,16 @@ EmailAddress::Config.provider(:github,
 You can override the default error messages as follows:
 
 ```ruby
-EmailAddress::Config.error_messages(
+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")
+  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.
 
@@ -540,6 +552,33 @@ 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,10 +35,10 @@ 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] ||
+                       Config.error_messages[:invalid_address] ||
                        "Invalid Email Address")
       end
     end

data/lib/email_address/address.rb

@@ -1,46 +1,45 @@
 # frozen_string_literal: true
 
-require 'digest/sha1'
-require 'digest/md5'
+require "digest/sha1"
+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!
-      @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)
-
-      @host         = EmailAddress::Host.new(host, config)
-      @config       = @host.config
-      @local        = EmailAddress::Local.new(local, @config, @host)
-      @error        = @error_message = nil
+    def initialize(email_address, config = {})
+      @config = Config.new(config)
+      @original = email_address
+      email_address = (email_address || "").strip
+      email_address = parse_rewritten(email_address) unless config[:skip_rewrite]
+      local, host = Address.split_local_host(email_address)
+
+      @host = Host.new(host, @config)
+      @local = Local.new(local, @config, @host)
+      @error = @error_message = nil
     end
 
     # Given an email address, this returns an array of [local, host] parts
     def self.split_local_host(email)
-      if lh = email.match(/(.+)@(.+)/)
-        lh.to_a[1,2]
+      if (lh = email.match(/(.+)@(.+)/))
+        lh.to_a[1, 2]
       else
-        [email, '']
+        [email, ""]
       end
     end
 
@@ -54,26 +53,26 @@ module EmailAddress
 
     # Everything to the left of the @ in the address, called the local part.
     def left
-      self.local.to_s
+      local.to_s
     end
 
     # Returns the mailbox portion of the local port, with no tags. Usually, this
     # can be considered the user account or role account names. Some systems
     # employ dynamic email addresses which don't have the same meaning.
     def mailbox
-      self.local.mailbox
+      local.mailbox
     end
 
     # Returns the tag part of the local address, or nil if not given.
     def tag
-      self.local.tag
+      local.tag
     end
 
     # Retuns any comments parsed from the local part of the email address.
     # This is retained for inspection after construction, even if it is
     # removed from the normalized email address.
     def comment
-      self.local.comment
+      local.comment
     end
 
     ############################################################################
@@ -87,8 +86,8 @@ module EmailAddress
     def host_name
       @host.host_name
     end
-    alias :right :host_name
-    alias :hostname :host_name
+    alias right host_name
+    alias hostname host_name
 
     # Returns the ESP (Email Service Provider) or ISP name derived
     # using the provider configuration rules.
@@ -104,18 +103,18 @@ module EmailAddress
     def normal
       if !@original
         @original
-      elsif self.local.to_s.size == 0
+      elsif local.to_s.size == 0
         ""
-      elsif self.host.to_s.size == 0
-        self.local.to_s
+      elsif host.to_s.size == 0
+        local.to_s
       else
-        "#{self.local.to_s}@#{self.host.to_s}"
+        "#{local}@#{host}"
       end
     end
-    alias :to_s :normal
+    alias to_s normal
 
     def inspect
-      "#<EmailAddress::Address:0x#{self.object_id.to_s(16)} address=\"#{self.to_s}\">"
+      "#<#{self.class}:0x#{object_id.to_s(16)} address=\"#{self}\">"
     end
 
     # Returns the canonical email address according to the provider
@@ -123,56 +122,56 @@ module EmailAddress
     # spaves and comments and tags, and any extraneous part of the address
     # not considered a unique account by the provider.
     def canonical
-      c = self.local.canonical
-      c += "@" + self.host.canonical if self.host.canonical && self.host.canonical > " "
+      c = local.canonical
+      c += "@" + host.canonical if host.canonical && host.canonical > " "
       c
     end
 
     # True if the given address is already in it's canonical form.
     def canonical?
-      self.canonical == self.to_s
+      canonical == to_s
     end
 
     # The base address is the mailbox, without tags, and host.
     def base
-      self.mailbox + "@" + self.hostname
+      mailbox + "@" + hostname
     end
 
     # Returns the redacted form of the address
     # This format is defined by this libaray, and may change as usage increases.
     # Takes either :sha1 (default) or :md5 as the argument
-    def redact(digest=:sha1)
-      raise "Unknown Digest type: #{digest}" unless %i(sha1 md5).include?(digest)
-      return self.to_s if self.local.redacted?
-      r = %Q({#{send(digest)}})
-      r += "@" + self.host.to_s if self.host.to_s && self.host.to_s > " "
+    def redact(digest = :sha1)
+      raise "Unknown Digest type: #{digest}" unless %i[sha1 md5].include?(digest)
+      return to_s if local.redacted?
+      r = %({#{send(digest)}})
+      r += "@" + host.to_s if host.to_s && host.to_s > " "
       r
     end
 
     # True if the address is already in the redacted state.
     def redacted?
-      self.local.redacted?
+      local.redacted?
     end
 
     # Returns the munged form of the address, by default "mailbox@domain.tld"
     # returns "ma*****@do*****".
     def munge
-      [self.local.munge, self.host.munge].join("@")
+      [local.munge, host.munge].join("@")
     end
 
     # Returns and MD5 of the canonical address form. Some cross-system systems
     # use the email address MD5 instead of the actual address to refer to the
     # same shared user identity without exposing the actual address when it
     # is not known in common.
-    def reference(form=:base)
-      Digest::MD5.hexdigest(self.send(form))
+    def reference(form = :base)
+      Digest::MD5.hexdigest(send(form))
     end
-    alias :md5 :reference
+    alias md5 reference
 
     # This returns the SHA1 digest (in a hex string) of the canonical email
     # address. See #md5 for more background.
-    def sha1(form=:base)
-      Digest::SHA1.hexdigest((self.send(form)||"") + (@config[:sha1_secret]||""))
+    def sha1(form = :base)
+      Digest::SHA1.hexdigest((send(form) || "") + (@config[:sha1_secret] || ""))
     end
 
     #---------------------------------------------------------------------------
@@ -182,41 +181,41 @@ module EmailAddress
     # Equal matches the normalized version of each address. Use the Threequal to check
     # for match on canonical or redacted versions of addresses
     def ==(other_email)
-      self.to_s == other_email.to_s
+      to_s == other_email.to_s
     end
-    alias :eql? :==
-    alias :equal? :==
+    alias eql? ==
+    alias equal? ==
 
     # Return the <=> or CMP comparison operator result (-1, 0, +1) on the comparison
     # 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
 
-      self.canonical   == other_email.canonical ||
-        self.redact    == other_email.canonical ||
-        self.canonical == other_email.redact
+      canonical == other_email.canonical ||
+        redact == other_email.canonical ||
+        canonical == other_email.redact
     end
-    alias :include? :same_as?
+    alias include? same_as?
 
     # Return the <=> or CMP comparison operator result (-1, 0, +1) on the comparison
     # of this addres with another, using the normalized form.
     def <=>(other_email)
-      self.to_s <=> other_email.to_s
+      to_s <=> other_email.to_s
     end
 
     # Address matches one of these Matcher rule patterns
     def matches?(*rules)
       rules.flatten!
-      match   = self.local.matches?(rules)
-      match ||= self.host.matches?(rules)
+      match = local.matches?(rules)
+      match ||= host.matches?(rules)
       return match if match
 
       # Does "root@*.com" match "root@example.com" domain name
       rules.each do |r|
-        if r =~ /.+@.+/
-          return r if File.fnmatch?(r, self.to_s)
+        if r.match(/.+@.+/)
+          return r if File.fnmatch?(r, to_s)
         end
       end
       false
@@ -228,24 +227,24 @@ module EmailAddress
 
     # Returns true if this address is considered valid according to the format
     # configured for its provider, It test the normalized form.
-    def valid?(options={})
+    def valid?(options = {})
       @error = nil
-      unless self.local.valid?
-        return set_error self.local.error
+      unless local.valid?
+        return set_error local.error
       end
-      unless self.host.valid?
-        return set_error self.host.error_message
+      unless host.valid?
+        return set_error host.error_message
       end
-      if @config[:address_size] && !@config[:address_size].include?(self.to_s.size)
+      if @config[:address_size] && !@config[:address_size].include?(to_s.size)
         return set_error :exceeds_size
       end
       if @config[:address_validation].is_a?(Proc)
-        unless @config[:address_validation].call(self.to_s)
+        unless @config[:address_validation].call(to_s)
           return set_error :not_allowed
         end
       else
-        return false unless self.local.valid?
-        return false unless self.host.valid?
+        return false unless local.valid?
+        return false unless host.valid?
       end
       true
     end
@@ -254,42 +253,37 @@ module EmailAddress
     # 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 = Net::SMTP.new(host_name || ip_address)
+      smtp.start(@config[:smtp_helo_name] || "localhost")
+      smtp.mailfrom @config[:smtp_mail_from] || "postmaster@localhost"
+      smtp.rcptto 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&.started?
         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
+      !!@error
     end
 
-    def set_error(err, reason=nil)
+    def set_error(err, reason = nil)
       @error = err
-      @reason= reason
-      @error_message = EmailAddress::Config.error_message(err)
+      @reason = reason
+      @error_message = Config.error_message(err)
       false
     end
 
-    def error_message
-      @error_message
-    end
+    attr_reader :error_message
 
     def error
-      self.valid? ? nil : @error_message
+      valid? ? nil : @error_message
     end
-
   end
 end