email_address 0.1.16 → 0.2.0

data/lib/email_address/canonical_email_address_type.rb

@@ -29,20 +29,22 @@
 #    user.canonical_email #=> "patsmith@gmail.com"
 ################################################################################
 
-class EmailAddress::CanonicalEmailAddressType < ActiveRecord::Type::Value
+module EmailAddress
+  class CanonicalEmailAddressType < ActiveRecord::Type::Value
 
-  # From user input, setter
-  def cast(value)
-    super(EmailAddress.canonical(value))
-  end
+    # From user input, setter
+    def cast(value)
+      super(Address.new(value).canonical)
+    end
 
-  # From a database value
-  def deserialize(value)
-    value && EmailAddress.normal(value)
-  end
+    # From a database value
+    def deserialize(value)
+      value && Address.new(value).normal
+    end
 
-  # To a database value (string)
-  def serialize(value)
-    value && EmailAddress.normal(value)
+    # To a database value (string)
+    def serialize(value)
+      value && Address.new(value).normal
+    end
   end
 end

data/lib/email_address/config.rb

@@ -17,6 +17,11 @@ module EmailAddress
   #   the SHA1 Digest, making it unique to your application so it can't easily be
   #   discovered by comparing against a known list of email/sha1 pairs.
   #
+  # * sha256_secret         ""
+  #   This application-level secret is appended to the email_address to compute
+  #   the SHA256 Digest, making it unique to your application so it can't easily be
+  #   discovered by comparing against a known list of email/sha256 pairs.
+  #
   # For local part configuration:
   # * local_downcase:     true
   #   Downcase the local part. You probably want this for uniqueness.
@@ -104,6 +109,7 @@ module EmailAddress
       dns_lookup: :mx, # :mx, :a, :off
       dns_timeout: nil,
       sha1_secret: "",
+      sha256_secret: "",
       munge_string: "*****",
 
       local_downcase: true,
@@ -143,6 +149,7 @@ module EmailAddress
       },
       msn: {
         host_match: %w[msn. hotmail. outlook. live.],
+        exchanger_match: %w[outlook.com],
         mailbox_validator: ->(m, t) { m =~ /\A\w[\-\w]*(?:\.[\-\w]+)*\z/i }
       },
       yahoo: {
@@ -187,9 +194,14 @@ module EmailAddress
     # Customize your own error message text.
     def self.error_messages(hash = {}, locale = "en", *extra)
       hash = extra.first if extra.first.is_a? Hash
-      unless hash.empty?
+
+      @errors[locale] ||= {}
+      @errors[locale]["email_address"] ||= {}
+
+      unless hash.nil? || hash.empty?
         @errors[locale]["email_address"] = @errors[locale]["email_address"].merge(hash)
       end
+
       @errors[locale]["email_address"]
     end
 
@@ -200,7 +212,7 @@ module EmailAddress
     end
 
     def initialize(overrides = {})
-      @config = EmailAddress::Config.all_settings(overrides)
+      @config = Config.all_settings(overrides)
     end
 
     def []=(setting, value)

data/lib/email_address/email_address_type.rb

@@ -29,20 +29,22 @@
 #    user.canonical_email #=> "patsmith@gmail.com"
 ################################################################################
 
-class EmailAddress::EmailAddressType < ActiveRecord::Type::Value
+module EmailAddress
+  class EmailAddressType < ActiveRecord::Type::Value
 
-  # From user input, setter
-  def cast(value)
-    super(EmailAddress.normal(value))
-  end
+    # From user input, setter
+    def cast(value)
+      super(Address.new(value).normal)
+    end
 
-  # From a database value
-  def deserialize(value)
-    value && EmailAddress.normal(value)
-  end
-  #
-  # To a database value (string)
-  def serialize(value)
-    value && EmailAddress.normal(value)
+    # From a database value
+    def deserialize(value)
+      value && Address.new(value).normal
+    end
+
+    # To a database value (string)
+    def serialize(value)
+      value && Address.new(value).normal
+    end
   end
 end

data/lib/email_address/exchanger.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "resolv"
-require "netaddr"
 require "socket"
 
 module EmailAddress
@@ -24,7 +23,7 @@ module EmailAddress
 
     def initialize(host, config = {})
       @host = host
-      @config = config.is_a?(Hash) ? EmailAddress::Config.new(config) : config
+      @config = config.is_a?(Hash) ? Config.new(config) : config
       @dns_disabled = @config[:host_validation] == :syntax || @config[:dns_lookup] == :off
     end
 
@@ -38,7 +37,7 @@ module EmailAddress
     # Returns the provider name based on the MX-er host names, or nil if not matched
     def provider
       return @provider if defined? @provider
-      EmailAddress::Config.providers.each do |provider, config|
+      Config.providers.each do |provider, config|
         if config[:exchanger_match] && matches?(config[:exchanger_match])
           return @provider = provider
         end
@@ -58,8 +57,8 @@ module EmailAddress
 
         ress = begin
           dns.getresources(@host, Resolv::DNS::Resource::IN::MX)
-               rescue Resolv::ResolvTimeout
-                 []
+        rescue Resolv::ResolvTimeout
+          []
         end
 
         records = ress.map { |r|
@@ -76,7 +75,7 @@ module EmailAddress
 
     # Returns Array of domain names for the MX'ers, used to determine the Provider
     def domains
-      @_domains ||= mxers.map { |m| EmailAddress::Host.new(m.first).domain_name }.sort.uniq
+      @_domains ||= mxers.map { |m| Host.new(m.first).domain_name }.sort.uniq
     end
 
     # Returns an array of MX IP address (String) for the given email domain
@@ -105,22 +104,9 @@ module EmailAddress
 
     # Given a cidr (ip/bits) and ip address, returns true on match. Caches cidr object.
     def in_cidr?(cidr)
-      if cidr.include?(":")
-        c = NetAddr::IPv6Net.parse(cidr)
-        return true if mx_ips.find do |ip|
-          next unless ip.include?(":")
-          rel = c.rel NetAddr::IPv6Net.parse(ip)
-          !rel.nil? && rel >= 0
-        end
-      elsif cidr.include?(".")
-        c = NetAddr::IPv4Net.parse(cidr)
-        return true if mx_ips.find do |ip|
-          next if ip.include?(":")
-          rel = c.rel NetAddr::IPv4Net.parse(ip)
-          !rel.nil? && rel >= 0
-        end
-      end
-      false
+      net = IPAddr.new(cidr)
+      found = mx_ips.detect { |ip| net.include?(IPAddr.new(ip)) }
+      !!found
     end
   end
 end

data/lib/email_address/host.rb

@@ -1,6 +1,5 @@
 require "simpleidn"
 require "resolv"
-require "netaddr"
 require "net/smtp"
 
 module EmailAddress
@@ -34,15 +33,15 @@ module EmailAddress
     attr_reader :host_name
     attr_accessor :dns_name, :domain_name, :registration_name,
       :tld, :tld2, :subdomains, :ip_address, :config, :provider,
-      :comment, :error_message, :reason
+      :comment, :error_message, :reason, :locale
     MAX_HOST_LENGTH = 255
 
     # Sometimes, you just need a Regexp...
-    DNS_HOST_REGEX = / [\p{L}\p{N}]+ (?: (?: \-{1,2} | \.) [\p{L}\p{N}]+ )*/x
+    DNS_HOST_REGEX = / [\p{L}\p{N}]+ (?: (?: -{1,2} | \.) [\p{L}\p{N}]+ )*/x
 
     # The IPv4 and IPv6 were lifted from Resolv::IPv?::Regex and tweaked to not
     # \A...\z anchor at the edges.
-    IPv6_HOST_REGEX = /\[IPv6:
+    IPV6_HOST_REGEX = /\[IPv6:
       (?: (?:(?x-mi:
       (?:[0-9A-Fa-f]{1,4}:){7}
          [0-9A-Fa-f]{1,4}
@@ -61,7 +60,7 @@ module EmailAddress
       (?: \d+)\.(?: \d+)\.(?: \d+)\.(?: \d+)
       )))\]/ix
 
-    IPv4_HOST_REGEX = /\[((?x-mi:0
+    IPV4_HOST_REGEX = /\[((?x-mi:0
                |1(?:[0-9][0-9]?)?
                |2(?:[0-4][0-9]?|5[0-5]?|[6-9])?
                |[3-9][0-9]?))\.((?x-mi:0
@@ -80,14 +79,15 @@ module EmailAddress
 
     # Matches Host forms: DNS name, IPv4, or IPv6 formats
     STANDARD_HOST_REGEX = /\A (?: #{DNS_HOST_REGEX}
-                              | #{IPv4_HOST_REGEX} | #{IPv6_HOST_REGEX}) \z/ix
+                              | #{IPV4_HOST_REGEX} | #{IPV6_HOST_REGEX}) \z/ix
 
     # host name -
     #   * host type - :email for an email host, :mx for exchanger host
-    def initialize(host_name, config = {})
+    def initialize(host_name, config = {}, locale = "en")
       @original = host_name ||= ""
+      @locale = locale
       config[:host_type] ||= :email
-      @config = config.is_a?(Hash) ? EmailAddress::Config.new(config) : config
+      @config = config.is_a?(Hash) ? Config.new(config) : config
       @error = @error_message = nil
       parse(host_name)
     end
@@ -104,7 +104,7 @@ module EmailAddress
         dns_name
       end
     end
-    alias to_s name
+    alias_method :to_s, :name
 
     # The canonical host name is the simplified, DNS host name
     def canonical
@@ -149,7 +149,7 @@ module EmailAddress
       if @config[:host_remove_spaces]
         @host_name = @host_name.delete(" ")
       end
-      @dns_name = if /[^[:ascii:]]/.match(host_name)
+      @dns_name = if /[^[:ascii:]]/.match?(host_name)
         ::SimpleIDN.to_ascii(host_name)
       else
         host_name
@@ -209,7 +209,7 @@ module EmailAddress
     def find_provider # :nodoc:
       return provider if provider
 
-      EmailAddress::Config.providers.each do |provider, config|
+      Config.providers.each do |provider, config|
         if config[:host_match] && matches?(config[:host_match])
           return set_provider(provider, config)
         end
@@ -217,12 +217,6 @@ module EmailAddress
 
       return set_provider(:default) unless dns_enabled?
 
-      provider = exchangers.provider
-      if provider != :default
-        set_provider(provider,
-          EmailAddress::Config.provider(provider))
-      end
-
       self.provider ||= set_provider(:default)
     end
 
@@ -235,7 +229,11 @@ module EmailAddress
     def parts
       {host_name: host_name, dns_name: dns_name, subdomain: subdomains,
        registration_name: registration_name, domain_name: domain_name,
-       tld2: tld2, tld: tld, ip_address: ip_address,}
+       tld2: tld2, tld: tld, ip_address: ip_address}
+    end
+
+    def hosted_provider
+      Exchanger.cached(dns_name).provider
     end
 
     ############################################################################
@@ -248,7 +246,7 @@ module EmailAddress
     end
 
     def ip?
-      ip_address.nil? ? false : true
+      !!ip_address
     end
 
     def ipv4?
@@ -292,7 +290,7 @@ module EmailAddress
     # Does "sub.example.com" match ".com" and ".example.com" top level names?
     # Matches TLD (uk) or TLD2 (co.uk)
     def tld_matches?(rule)
-      rule.match(/\A\.(.+)\z/) && ($1 == tld || $1 == tld2) ? true : false
+      rule.match(/\A\.(.+)\z/) && ($1 == tld || $1 == tld2) # ? true : false
     end
 
     def provider_matches?(rule)
@@ -312,13 +310,8 @@ module EmailAddress
     # the passed CIDR string ("10.9.8.0/24" or "2001:..../64")
     def ip_matches?(cidr)
       return false unless ip_address
-      return cidr if !cidr.include?("/") && cidr == ip_address
-      if cidr.include?(":") && ip_address.include?(":")
-        return cidr if NetAddr::IPv6Net.parse(cidr).contains(NetAddr::IPv6.parse(ip_address))
-      elsif cidr.include?(".") && ip_address.include?(".")
-        return cidr if NetAddr::IPv4Net.parse(cidr).contains(NetAddr::IPv4.parse(ip_address))
-      end
-      false
+      net = IPAddr.new(cidr)
+      net.include?(IPAddr.new(ip_address))
     end
 
     ############################################################################
@@ -335,16 +328,16 @@ module EmailAddress
     # Returns: [official_hostname, alias_hostnames, address_family, *address_list]
     def dns_a_record
       @_dns_a_record = "0.0.0.0" if @config[:dns_lookup] == :off
-      @_dns_a_record ||= Socket.gethostbyname(dns_name)
+      @_dns_a_record ||= Addrinfo.getaddrinfo(dns_name, 80) # Port 80 for A rec, 25 for MX
     rescue SocketError # not found, but could also mean network not work
       @_dns_a_record ||= []
     end
 
-    # Returns an array of EmailAddress::Exchanger hosts configured in DNS.
+    # Returns an array of Exchanger hosts configured in DNS.
     # The array will be empty if none are configured.
     def exchangers
       # return nil if @config[:host_type] != :email || !self.dns_enabled?
-      @_exchangers ||= EmailAddress::Exchanger.cached(dns_name, @config)
+      @_exchangers ||= Exchanger.cached(dns_name, @config)
     end
 
     # Returns a DNS TXT Record
@@ -355,8 +348,8 @@ module EmailAddress
         records = begin
           dns.getresources(alternate_host || dns_name,
             Resolv::DNS::Resource::IN::TXT)
-                  rescue Resolv::ResolvTimeout
-                    []
+        rescue Resolv::ResolvTimeout
+          []
         end
 
         records.empty? ? nil : records.map(&:data).join(" ")
@@ -461,21 +454,9 @@ module EmailAddress
     end
 
     def localhost?
-      if ip_address
-        rel =
-          if ip_address.include?(":")
-            NetAddr::IPv6Net.parse("" + "::1").rel(
-              NetAddr::IPv6Net.parse(ip_address)
-            )
-          else
-            NetAddr::IPv4Net.parse("" + "127.0.0.0/8").rel(
-              NetAddr::IPv4Net.parse(ip_address)
-            )
-          end
-        !rel.nil? && rel >= 0
-      else
-        host_name == "localhost"
-      end
+      return true if host_name == "localhost"
+      return false unless ip_address
+      IPAddr.new(ip_address).loopback?
     end
 
     # Connects to host to test it can receive email. This should NOT be performed
@@ -499,7 +480,7 @@ module EmailAddress
     def set_error(err, reason = nil)
       @error = err
       @reason = reason
-      @error_message = EmailAddress::Config.error_message(err)
+      @error_message = Config.error_message(err, locale)
       false
     end
 

data/lib/email_address/local.rb

@@ -67,50 +67,51 @@ module EmailAddress
   #                        [CFWS]
   ############################################################################
   class Local
-    attr_reader   :local
+    attr_reader :local
     attr_accessor :mailbox, :comment, :tag, :config, :original
-    attr_accessor :syntax
+    attr_accessor :syntax, :locale
 
     # RFC-2142: MAILBOX NAMES FOR COMMON SERVICES, ROLES AND FUNCTIONS
-    BUSINESS_MAILBOXES = %w(info marketing sales support)
-    NETWORK_MAILBOXES  = %w(abuse noc security)
-    SERVICE_MAILBOXES  = %w(postmaster hostmaster usenet news webmaster www uucp ftp)
-    SYSTEM_MAILBOXES   = %w(help mailer-daemon root) # Not from RFC-2142
-    ROLE_MAILBOXES     = %w(staff office orders billing careers jobs) # Not from RFC-2142
-    SPECIAL_MAILBOXES  = BUSINESS_MAILBOXES + NETWORK_MAILBOXES + SERVICE_MAILBOXES +
-                         SYSTEM_MAILBOXES + ROLE_MAILBOXES
-    STANDARD_MAX_SIZE  = 64
+    BUSINESS_MAILBOXES = %w[info marketing sales support]
+    NETWORK_MAILBOXES = %w[abuse noc security]
+    SERVICE_MAILBOXES = %w[postmaster hostmaster usenet news webmaster www uucp ftp]
+    SYSTEM_MAILBOXES = %w[help mailer-daemon root] # Not from RFC-2142
+    ROLE_MAILBOXES = %w[staff office orders billing careers jobs] # Not from RFC-2142
+    SPECIAL_MAILBOXES = BUSINESS_MAILBOXES + NETWORK_MAILBOXES + SERVICE_MAILBOXES +
+      SYSTEM_MAILBOXES + ROLE_MAILBOXES
+    STANDARD_MAX_SIZE = 64
 
     # Conventional : word([.-+'_]word)*
-    CONVENTIONAL_MAILBOX_REGEX  = /\A [\p{L}\p{N}_]+ (?: [\.\-\+\'_] [\p{L}\p{N}_]+ )* \z/x
-    CONVENTIONAL_MAILBOX_WITHIN = /[\p{L}\p{N}_]+ (?: [\.\-\+\'_] [\p{L}\p{N}_]+ )*/x
+    CONVENTIONAL_MAILBOX_REGEX = /\A [\p{L}\p{N}_]+ (?: [.\-+'_] [\p{L}\p{N}_]+ )* \z/x
+    CONVENTIONAL_MAILBOX_WITHIN = /[\p{L}\p{N}_]+ (?: [.\-+'_] [\p{L}\p{N}_]+ )*/x
 
     # Relaxed: same characters, relaxed order
-    RELAXED_MAILBOX_WITHIN = /[\p{L}\p{N}_]+ (?: [\.\-\+\'_]+ [\p{L}\p{N}_]+ )*/x
-    RELAXED_MAILBOX_REGEX = /\A [\p{L}\p{N}_]+ (?: [\.\-\+\'_]+ [\p{L}\p{N}_]+ )* \z/x
+    RELAXED_MAILBOX_WITHIN = /[\p{L}\p{N}_]+ (?: [.\-+'_]+ [\p{L}\p{N}_]+ )*/x
+    RELAXED_MAILBOX_REGEX = /\A [\p{L}\p{N}_]+ (?: [.\-+'_]+ [\p{L}\p{N}_]+ )* \z/x
 
     # RFC5322 Token: token."token".token (dot-separated tokens)
     #   Quoted Token can also have: SPACE \" \\ ( ) , : ; < > @ [ \ ] .
     STANDARD_LOCAL_WITHIN = /
-      (?: [\p{L}\p{N}\!\#\$\%\&\'\*\+\-\/\=\?\^\_\`\{\|\}\~\(\)]+
-        | \" (?: \\[\" \\] | [\x20-\x21\x23-\x2F\x3A-\x40\x5B\x5D-\x60\x7B-\x7E\p{L}\p{N}] )+ \" )
-      (?: \.  (?: [\p{L}\p{N}\!\#\$\%\&\'\*\+\-\/\=\?\^\_\`\{\|\}\~\(\)]+
-              | \" (?: \\[\" \\] | [\x20-\x21\x23-\x2F\x3A-\x40\x5B\x5D-\x60\x7B-\x7E\p{L}\p{N}] )+ \" ) )* /x
+      (?: [\p{L}\p{N}!\#$%&'*+\-\/=?\^_`{|}~()]+
+        | " (?: \\[" \\] | [\x20-\x21\x23-\x2F\x3A-\x40\x5B\x5D-\x60\x7B-\x7E\p{L}\p{N}] )+ " )
+      (?: \.  (?: [\p{L}\p{N}!\#$%&'*+\-\/=?\^_`{|}~()]+
+              | " (?: \\[" \\] | [\x20-\x21\x23-\x2F\x3A-\x40\x5B\x5D-\x60\x7B-\x7E\p{L}\p{N}] )+ " ) )* /x
 
     STANDARD_LOCAL_REGEX = /\A #{STANDARD_LOCAL_WITHIN} \z/x
 
     REDACTED_REGEX = /\A \{ [0-9a-f]{40} \} \z/x # {sha1}
 
-    CONVENTIONAL_TAG_REGEX  = #  AZaz09_!'+-/=
-      %r/^([\w\!\'\+\-\/\=]+)$/i.freeze
-    RELAXED_TAG_REGEX  = #  AZaz09_!#$%&'*+-/=?^`{|}~
-      %r/^([\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+)$/i.freeze
+    CONVENTIONAL_TAG_REGEX = #  AZaz09_!'+-/=
+      %r{^([\w!'+\-/=.]+)$}i
+    RELAXED_TAG_REGEX = #  AZaz09_!#$%&'*+-/=?^`{|}~
+      %r/^([\w.!\#$%&'*+\-\/=?\^`{|}~]+)$/i
 
-    def initialize(local, config={}, host=nil)
-      @config = config.is_a?(Hash) ? EmailAddress::Config.new(config) : config
-      self.local    = local
-      @host         = host
-      @error        = @error_message = nil
+    def initialize(local, config = {}, host = nil, locale = "en")
+      @config = config.is_a?(Hash) ? Config.new(config) : config
+      self.local = local
+      @host = host
+      @locale = locale
+      @error = @error_message = nil
     end
 
     def local=(raw)
@@ -121,23 +122,23 @@ module EmailAddress
       if @config[:local_parse].is_a?(Proc)
         self.mailbox, self.tag, self.comment = @config[:local_parse].call(raw)
       else
-        self.mailbox, self.tag, self.comment = self.parse(raw)
+        self.mailbox, self.tag, self.comment = parse(raw)
       end
 
       self.format
     end
 
     def parse(raw)
-      if raw =~ /\A\"(.*)\"\z/ # Quoted
+      if raw =~ /\A"(.*)"\z/ # Quoted
         raw = $1
         raw = raw.gsub(/\\(.)/, '\1') # Unescape
       elsif @config[:local_fix] && @config[:local_format] != :standard
-        raw = raw.gsub(' ','')
-        raw = raw.gsub(',','.')
-        #raw.gsub!(/([^\p{L}\p{N}]{2,10})/) {|s| s[0] } # Stutter punctuation typo
+        raw = raw.delete(" ")
+        raw = raw.tr(",", ".")
+        # raw.gsub!(/([^\p{L}\p{N}]{2,10})/) {|s| s[0] } # Stutter punctuation typo
       end
-      raw, comment = self.parse_comment(raw)
-      mailbox, tag = self.parse_tag(raw)
+      raw, comment = parse_comment(raw)
+      mailbox, tag = parse_tag(raw)
       mailbox ||= ""
       [mailbox, tag, comment]
     end
@@ -156,28 +157,28 @@ module EmailAddress
     end
 
     def parse_tag(raw)
-      separator = @config[:tag_separator] ||= '+'
+      separator = @config[:tag_separator] ||= "+"
       raw.split(separator, 2)
     end
 
     # True if the the value contains only Latin characters (7-bit ASCII)
     def ascii?
-      ! self.unicode?
+      !unicode?
     end
 
     # True if the the value contains non-Latin Unicde characters
     def unicode?
-      self.local =~ /[^\p{InBasicLatin}]/ ? true : false
+      /[^\p{InBasicLatin}]/.match?(local)
     end
 
     # Returns true if the value matches the Redacted format
     def redacted?
-      self.local =~ REDACTED_REGEX ? true : false
+      REDACTED_REGEX.match?(local)
     end
 
     # Returns true if the value matches the Redacted format
     def self.redacted?(local)
-      local =~ REDACTED_REGEX ? true : false
+      REDACTED_REGEX.match?(local)
     end
 
     # Is the address for a common system or business role account?
@@ -190,81 +191,80 @@ module EmailAddress
     end
 
     # Builds the local string according to configurations
-    def format(form=@config[:local_format]||:conventional)
+    def format(form = @config[:local_format] || :conventional)
       if @config[:local_format].is_a?(Proc)
         @config[:local_format].call(self)
       elsif form == :conventional
-        self.conventional
+        conventional
       elsif form == :canonical
-        self.canonical
+        canonical
       elsif form == :relaxed
-        self.relax
+        relax
       elsif form == :standard
-        self.standard
+        standard
       end
     end
 
     # Returns a conventional form of the address
     def conventional
-      if self.tag
-        [self.mailbox, self.tag].join(@config[:tag_separator])
+      if tag
+        [mailbox, tag].join(@config[:tag_separator])
       else
-        self.mailbox
+        mailbox
       end
     end
 
     # Returns a canonical form of the address
     def canonical
       if @config[:mailbox_canonical]
-        @config[:mailbox_canonical].call(self.mailbox)
+        @config[:mailbox_canonical].call(mailbox)
       else
-        self.mailbox.downcase
+        mailbox.downcase
       end
     end
 
     # Relaxed format: mailbox and tag, no comment, no extended character set
     def relax
-      form = self.mailbox
-      form += @config[:tag_separator] + self.tag if self.tag
-      form = form.gsub(/[ \"\(\),:<>@\[\]\\]/,'')
-      form
+      form = mailbox
+      form += @config[:tag_separator] + tag if tag
+      form.gsub(/[ "(),:<>@\[\]\\]/, "")
     end
 
     # Returns a normalized version of the standard address parts.
     def standard
-      form = self.mailbox
-      form += @config[:tag_separator] + self.tag if self.tag
-      form += "(" + self.comment + ")" if self.comment
-      form = form.gsub(/([\\\"])/, '\\\1') # Escape \ and "
-      if form =~ /[ \"\(\),:<>@\[\\\]]/ # Space and "(),:;<>@[\]
-        form = %Q("#{form}")
+      form = mailbox
+      form += @config[:tag_separator] + tag if tag
+      form += "(" + comment + ")" if comment
+      form = form.gsub(/([\\"])/, '\\\1') # Escape \ and "
+      if /[ "(),:<>@\[\\\]]/.match?(form) # Space and "(),:;<>@[\]
+        form = %("#{form}")
       end
       form
     end
 
     # Sets the part to be the conventional form
     def conventional!
-      self.local = self.conventional
+      self.local = conventional
     end
 
     # Sets the part to be the canonical form
     def canonical!
-      self.local = self.canonical
+      self.local = canonical
     end
 
     # Dropps unusual  parts of Standard form to form a relaxed version.
     def relax!
-      self.local = self.relax
+      self.local = relax
     end
 
     # Returns the munged form of the address, like "ma*****"
     def munge
-      self.to_s.sub(/\A(.{1,2}).*/) { |m| $1 + @config[:munge_string] }
+      to_s.sub(/\A(.{1,2}).*/) { |m| $1 + @config[:munge_string] }
     end
 
     # Mailbox with trailing numbers removed
     def root_name
-      self.mailbox =~ /\A(.+?)\d+\z/ ? $1 : self.mailbox
+      mailbox =~ /\A(.+?)\d+\z/ ? $1 : mailbox
     end
 
     ############################################################################
@@ -272,19 +272,19 @@ module EmailAddress
     ############################################################################
 
     # True if the part is valid according to the configurations
-    def valid?(format=@config[:local_format]||:conventional)
+    def valid?(format = @config[:local_format] || :conventional)
       if @config[:mailbox_validator].is_a?(Proc)
-        @config[:mailbox_validator].call(self.mailbox, self.tag)
+        @config[:mailbox_validator].call(mailbox, tag)
       elsif format.is_a?(Proc)
         format.call(self)
       elsif format == :conventional
-        self.conventional?
+        conventional?
       elsif format == :relaxed
-        self.relaxed?
+        relaxed?
       elsif format == :redacted
-        self.redacted?
+        redacted?
       elsif format == :standard
-        self.standard?
+        standard?
       elsif format == :none
         true
       else
@@ -295,13 +295,13 @@ module EmailAddress
     # Returns the format of the address
     def format?
       # if :custom
-      if self.conventional?
+      if conventional?
         :conventional
-      elsif self.relaxed?
+      elsif relaxed?
         :relax
-      elsif self.redacted?
+      elsif redacted?
         :redacted
-      elsif self.standard?
+      elsif standard?
         :standard
       else
         :invalid
@@ -309,38 +309,38 @@ module EmailAddress
     end
 
     def valid_size?
-      return set_error(:local_size_long) if self.local.size > STANDARD_MAX_SIZE
-      if @host && @host.hosted_service?
+      return set_error(:local_size_long) if local.size > STANDARD_MAX_SIZE
+      if @host&.hosted_service?
         return false if @config[:local_private_size] && !valid_size_checks(@config[:local_private_size])
-      else
-        return false if @config[:local_size] && !valid_size_checks(@config[:local_size])
+      elsif @config[:local_size] && !valid_size_checks(@config[:local_size])
+        return false
       end
       return false if @config[:mailbox_size] && !valid_size_checks(@config[:mailbox_size])
       true
     end
 
     def valid_size_checks(range)
-      return set_error(:local_size_short) if self.mailbox.size < range.first
-      return set_error(:local_size_long)  if self.mailbox.size > range.last
+      return set_error(:local_size_short) if mailbox.size < range.first
+      return set_error(:local_size_long) if mailbox.size > range.last
       true
     end
 
-    def valid_encoding?(enc=@config[:local_encoding]||:ascii)
-      return false if enc == :ascii && self.unicode?
+    def valid_encoding?(enc = @config[:local_encoding] || :ascii)
+      return false if enc == :ascii && unicode?
       true
     end
 
     # True if the part matches the conventional format
     def conventional?
       self.syntax = :invalid
-      if self.tag
-        return false unless self.mailbox =~ CONVENTIONAL_MAILBOX_REGEX &&
-          self.tag =~ CONVENTIONAL_TAG_REGEX
+      if tag
+        return false unless mailbox =~ CONVENTIONAL_MAILBOX_REGEX &&
+          tag =~ CONVENTIONAL_TAG_REGEX
       else
-        return false unless self.local =~ CONVENTIONAL_MAILBOX_REGEX
+        return false unless CONVENTIONAL_MAILBOX_REGEX.match?(local)
       end
-      self.valid_size? or return false
-      self.valid_encoding? or return false
+      valid_size? or return false
+      valid_encoding? or return false
       self.syntax = :conventional
       true
     end
@@ -348,12 +348,12 @@ module EmailAddress
     # Relaxed conventional is not so strict about character order.
     def relaxed?
       self.syntax = :invalid
-      self.valid_size? or return false
-      self.valid_encoding? or return false
-      if self.tag
-        return false unless self.mailbox =~ RELAXED_MAILBOX_REGEX &&
-          self.tag =~ RELAXED_TAG_REGEX
-      elsif self.local =~ RELAXED_MAILBOX_REGEX
+      valid_size? or return false
+      valid_encoding? or return false
+      if tag
+        return false unless mailbox =~ RELAXED_MAILBOX_REGEX &&
+          tag =~ RELAXED_TAG_REGEX
+      elsif RELAXED_MAILBOX_REGEX.match?(local)
         self.syntax = :relaxed
         true
       else
@@ -364,9 +364,9 @@ module EmailAddress
     # True if the part matches the RFC standard format
     def standard?
       self.syntax = :invalid
-      self.valid_size? or return false
-      self.valid_encoding? or return false
-      if self.local =~ STANDARD_LOCAL_REGEX
+      valid_size? or return false
+      valid_encoding? or return false
+      if STANDARD_LOCAL_REGEX.match?(local)
         self.syntax = :standard
         true
       else
@@ -379,26 +379,23 @@ module EmailAddress
     def matches?(*rules)
       rules.flatten.each do |r|
         if r =~ /(.+)@\z/
-          return r if File.fnmatch?($1, self.local)
+          return r if File.fnmatch?($1, local)
         end
       end
       false
     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, locale)
       false
     end
 
-    def error_message
-      @error_message
-    end
+    attr_reader :error_message
 
     def error
-      self.valid? ? nil : ( @error || :local_invalid)
+      valid? ? nil : (@error || :local_invalid)
     end
-
   end
 end