email_address 0.1.13 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67dd5ab4cf92d131f566e7cf275073dfd80f92f1024adb0a276e08bc81640878
-  data.tar.gz: fcccbc2f24aa40ee835c3a4cd5ec1a233823c7ab7d08afdb20f94f029b208493
+  metadata.gz: 2f3decf66b46d08f8a8f3528ad331cfb009f7dfa302b8f887558bb535e189210
+  data.tar.gz: a5aac0f73f92ae103cada5c57b5f51a7efb968752dfe5ab8710b72a52705c98a
 SHA512:
-  metadata.gz: 7b28dfd2876f0a01cac862905bdd9b1c30d88505d0457a319469ec4ae35cb87d0b592ac6b028a531c2a115249eb3a6abb527896a63a1e2155ed6712618d2cff4
-  data.tar.gz: 4734fe3a428b07023963e7a01bf3a2853295a52ea4b308ddda8b82f8a0d09614ffabbc8d63c188b477b4a2f0f464ec76c70f6681b7423f7774b8205cbcefa4ad
+  metadata.gz: 6acd7e0c108cadaa5be29dc0d843c3d12311d96791f79130b6c1ed2a1e26c3e3c2838f40034504d74bd2717dd35947e789c39c72fd0c7470aaefec23167983c8
+  data.tar.gz: bf7f061c707cac898ca51fd4bb8a697ad0c491be4a3119ded9c836e9ef8257ad3c513a2562c9803b415bbea8e747e5ae8c54805c00b03cfd4825a7b2754a5229

data/README.md

@@ -446,14 +446,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.
 

data/lib/email_address/address.rb

@@ -1,7 +1,7 @@
 # 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
@@ -14,33 +14,33 @@ module EmailAddress
 
     CONVENTIONAL_REGEX = /\A#{::EmailAddress::Local::CONVENTIONAL_MAILBOX_WITHIN}
                            @#{::EmailAddress::Host::DNS_HOST_REGEX}\z/x
-    STANDARD_REGEX     = /\A#{::EmailAddress::Local::STANDARD_LOCAL_WITHIN}
+    STANDARD_REGEX = /\A#{::EmailAddress::Local::STANDARD_LOCAL_WITHIN}
                            @#{::EmailAddress::Host::DNS_HOST_REGEX}\z/x
-    RELAXED_REGEX      = /\A#{::EmailAddress::Local::RELAXED_MAILBOX_WITHIN}
+    RELAXED_REGEX = /\A#{::EmailAddress::Local::RELAXED_MAILBOX_WITHIN}
                            @#{::EmailAddress::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 # 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
     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 +54,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 +87,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 +104,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}\">"
+      "#<EmailAddress::Address:0x#{object_id.to_s(16)} address=\"#{self}\">"
     end
 
     # Returns the canonical email address according to the provider
@@ -123,56 +123,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,10 +182,10 @@ 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.
@@ -194,29 +194,29 @@ module EmailAddress
         other_email = EmailAddress::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 /.+@.+/.match?(r)
+          return r if File.fnmatch?(r, to_s)
         end
       end
       false
@@ -228,24 +228,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 +254,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
+      @reason = reason
       @error_message = EmailAddress::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

data/lib/email_address/config.rb

@@ -97,67 +97,66 @@ module EmailAddress
   # * exchanger_match:    %w(google.com 127.0.0.1 10.9.8.0/24 ::1/64)
   #
 
-  require 'yaml'
+  require "yaml"
 
   class Config
     @config = {
-      dns_lookup:         :mx,  # :mx, :a, :off
-      dns_timeout:        nil,
-      sha1_secret:        "",
-      munge_string:       "*****",
-
-      local_downcase:     true,
-      local_fix:          false,
-      local_encoding:     :ascii, # :ascii, :unicode,
-      local_parse:        nil,   # nil, Proc
-      local_format:       :conventional, # :conventional, :relaxed, :redacted, :standard, Proc
-      local_size:         1..64,
-      tag_separator:      '+', # nil, character
-      mailbox_size:       1..64, # without tag
-      mailbox_canonical:  nil, # nil,  Proc
-      mailbox_validator:  nil, # nil,  Proc
-
-      host_encoding:      :punycode || :unicode,
-      host_validation:    :mx || :a || :connect || :syntax,
-      host_size:          1..253,
-      host_allow_ip:      false,
+      dns_lookup: :mx, # :mx, :a, :off
+      dns_timeout: nil,
+      sha1_secret: "",
+      munge_string: "*****",
+
+      local_downcase: true,
+      local_fix: false,
+      local_encoding: :ascii, # :ascii, :unicode,
+      local_parse: nil, # nil, Proc
+      local_format: :conventional, # :conventional, :relaxed, :redacted, :standard, Proc
+      local_size: 1..64,
+      tag_separator: "+", # nil, character
+      mailbox_size: 1..64, # without tag
+      mailbox_canonical: nil, # nil,  Proc
+      mailbox_validator: nil, # nil,  Proc
+
+      host_encoding: :punycode || :unicode,
+      host_validation: :mx || :a || :connect || :syntax,
+      host_size: 1..253,
+      host_allow_ip: false,
       host_remove_spaces: false,
-      host_local:         false,
+      host_local: false,
 
       address_validation: :parts, # :parts, :smtp, Proc
-      address_size:       3..254,
-      address_fqdn_domain: nil, # Fully Qualified Domain Name = [host].[domain.tld]
+      address_size: 3..254,
+      address_fqdn_domain: nil # Fully Qualified Domain Name = [host].[domain.tld]
     }
 
     # 2018-04: AOL and Yahoo now under "oath.com", owned by Verizon. Keeping separate for now
     @providers = {
       aol: {
-        host_match:       %w(aol. compuserve. netscape. aim. cs.),
+        host_match: %w[aol. compuserve. netscape. aim. cs.]
       },
       google: {
-        host_match:       %w(gmail.com googlemail.com),
-        exchanger_match:  %w(google.com googlemail.com),
-        local_size:       5..64,
+        host_match: %w[gmail.com googlemail.com],
+        exchanger_match: %w[google.com googlemail.com],
+        local_size: 5..64,
         local_private_size: 1..64, # When hostname not in host_match (private label)
-        mailbox_canonical: ->(m) {m.gsub('.','')},
+        mailbox_canonical: ->(m) { m.delete(".") }
       },
       msn: {
-        host_match:       %w(msn. hotmail. outlook. live.),
-        mailbox_validator: ->(m,t) { m =~ /\A\w[\-\w]*(?:\.[\-\w]+)*\z/i},
+        host_match: %w[msn. hotmail. outlook. live.],
+        mailbox_validator: ->(m, t) { m =~ /\A\w[\-\w]*(?:\.[\-\w]+)*\z/i }
       },
       yahoo: {
-        host_match:       %w(yahoo. ymail. rocketmail.),
-        exchanger_match:  %w(yahoodns yahoo-inc),
-      },
+        host_match: %w[yahoo. ymail. rocketmail.],
+        exchanger_match: %w[yahoodns yahoo-inc]
+      }
     }
 
-
     # Loads messages: {"en"=>{"email_address"=>{"invalid_address"=>"Invalid Email Address",...}}}
     # Rails/I18n gem: t(email_address.error, scope: "email_address")
-    @errors = YAML.load_file(File.dirname(__FILE__)+"/messages.yaml")
+    @errors = YAML.load_file(File.dirname(__FILE__) + "/messages.yaml")
 
     # Set multiple default configuration settings
-    def self.configure(config={})
+    def self.configure(config = {})
       @config.merge!(config)
     end
 
@@ -168,12 +167,12 @@ module EmailAddress
     end
 
     # Returns the hash of Provider rules
-    def self.providers
-      @providers
+    class << self
+      attr_reader :providers
     end
 
     # Configure or lookup a provider by name.
-    def self.provider(name, config={})
+    def self.provider(name, config = {})
       name = name.to_sym
       if config.size > 0
         @providers[name] ||= @config.clone
@@ -182,19 +181,22 @@ module EmailAddress
       @providers[name]
     end
 
-    def self.error_message(name, locale="en")
+    def self.error_message(name, locale = "en")
       @errors[locale]["email_address"][name.to_s] || name.to_s
     end
 
     # Customize your own error message text.
-    def self.error_messages(hash=nil)
-      @errors = @errors.merge(hash) if hash
-      @errors
+    def self.error_messages(hash = {}, locale = "en", *extra)
+      hash = extra.first if extra.first.is_a? Hash
+      unless hash.empty?
+        @errors[locale]["email_address"] = @errors[locale]["email_address"].merge(hash)
+      end
+      @errors[locale]["email_address"]
     end
 
     def self.all_settings(*configs)
       config = @config.clone
-      configs.each {|c| config.merge!(c) }
+      configs.each { |c| config.merge!(c) }
       config
     end
   end