email_address 0.0.3 → 0.1.0

data/lib/email_address/host.rb

@@ -1,82 +1,322 @@
 require 'simpleidn'
+require 'resolv'
+require 'netaddr'
 
 module EmailAddress
   ##############################################################################
-  # Hostname management for the email address
-  # IPv6/IPv6: [128.0.0.1], [IPv6:2001:db8:1ff::a0b:dbd0]
-  # Comments: (comment)example.com, example.com(comment)
-  # Internationalized: Unicode to Punycode
-  # Length: up to 255 characters
-  # Parts for: subdomain.example.co.uk
-  #     host_name:         "subdomain.example.co.uk"
-  #     subdomain:         "subdomain"
-  #     registration_name: "example"
-  #     domain_name:       "example.co.uk"
-  #     tld:               "co.uk"
-  #     ip_address:        nil or "ipaddress" used in [ipaddress] syntax
+  # The EmailAddress Host is found on the right-hand side of the "@" symbol.
+  # It can be:
+  # * Host name (domain name with optional subdomain)
+  # * International Domain Name, in Unicode (Display) or Punycode (DNS) format
+  # * IP Address format, either IPv4 or IPv6, enclosed in square brackets.
+  #   This is not Conventionally supported, but is part of the specification.
+  # * It can contain an optional comment, enclosed in parenthesis, either at
+  #   beginning or ending of the host name. This is not well defined, so it not
+  #   supported here, expect to parse it off, if found.
+  #
+  # For matching and query capabilities, the host name is parsed into these
+  # parts (with example data for "subdomain.example.co.uk"):
+  # * host_name:         "subdomain.example.co.uk"
+  # * dns_name:          punycode("subdomain.example.co.uk")
+  # * subdomain:         "subdomain"
+  # * registration_name: "example"
+  # * domain_name:       "example.co.uk"
+  # * tld:               "uk"
+  # * tld2:              "co.uk" (the 1 or 2 term TLD we could guess)
+  # * ip_address:        nil or "ipaddress" used in [ipaddress] syntax
+  #
+  # The provider (Email Service Provider or ESP) is looked up according to the
+  # provider configuration rules, setting the config attribute to values of
+  # that provider.
   ##############################################################################
   class Host
-    attr_reader :host_name, :parts, :domain_name, :registration_name,
-                :tld, :subdomains, :ip_address
+    attr_accessor :host_name, :dns_name, :domain_name, :registration_name,
+                  :tld, :tld2, :subdomains, :ip_address, :config, :provider,
+                  :comment
+    MAX_HOST_LENGTH = 255
+
+    # Sometimes, you just need a Regexp...
+    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:
+      (?: (?:(?x-mi:
+      (?:[0-9A-Fa-f]{1,4}:){7}
+         [0-9A-Fa-f]{1,4}
+      )) |
+      (?:(?x-mi:
+      (?: (?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
+      (?: (?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)
+      )) |
+      (?:(?x-mi:
+      (?: (?:[0-9A-Fa-f]{1,4}:){6,6})
+      (?: \d+)\.(?: \d+)\.(?: \d+)\.(?: \d+)
+      )) |
+      (?:(?x-mi:
+      (?: (?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
+      (?: (?:[0-9A-Fa-f]{1,4}:)*)
+      (?: \d+)\.(?: \d+)\.(?: \d+)\.(?: \d+)
+      )))\]/ix
+
+    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
+               |1(?:[0-9][0-9]?)?
+               |2(?:[0-4][0-9]?|5[0-5]?|[6-9])?
+               |[3-9][0-9]?))\.((?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
+               |1(?:[0-9][0-9]?)?
+               |2(?:[0-4][0-9]?|5[0-5]?|[6-9])?
+               |[3-9][0-9]?))\]/x
+
+    # Matches conventional host name and punycode: domain.tld, x--punycode.tld
+    CANONICAL_HOST_REGEX = /\A #{DNS_HOST_REGEX} \z/x
+
+    # Matches Host forms: DNS name, IPv4, or IPv6 formats
+    STANDARD_HOST_REGEX = /\A (?: #{DNS_HOST_REGEX}
+                              | #{IPv4_HOST_REGEX} | #{IPv6_HOST_REGEX}) \z/ix
 
     # host name -
-    #   * full domain name after @ for email types
-    #   * fully-qualified domain name
-    # host type -
-    #   :email - email address domain
-    #   :mx    - email exchanger domain
-    def initialize(host_name, host_type=:email)
-      host_name||= ''
-      @host_name = host_name.downcase
-      @host_type = host_type
-      parse_host(@host_name)
+    #   * host type - :email for an email host, :mx for exchanger host
+    def initialize(host_name, config={})
+      @original            = host_name ||= ''
+      config[:host_type] ||= :email
+      @config              = config
+      parse(host_name)
     end
 
-    def to_s
-      @host_name
+    # Returns the String representation of the host name (or IP)
+    def name
+      if self.ipv4?
+        "[#{self.ip_address}]"
+      elsif self.ipv6?
+        "[IPv6:#{self.ip_address}]"
+      elsif @config[:host_encoding] && @config[:host_encoding] == :unicode
+        ::SimpleIDN.to_unicode(self.host_name)
+      else
+        self.dns_name
+      end
     end
-    alias :name :to_s
+    alias :to_s :name
 
-    def parse_host(host)
-      @parser = EmailAddress::DomainParser.new(host)
-      @parts  = @parser.parts
-      @parts.each { |k,v| instance_variable_set("@#{k}", v) }
+    # The canonical host name is the simplified, DNS host name
+    def canonical
+      self.dns_name
     end
 
-    # The host name to send to DNS lookup, Punycode-escaped
-    def dns_host_name
-      @dns_host_name ||= ::SimpleIDN.to_ascii(@host_name)
+    # Returns the munged version of the name, replacing everything after the
+    # initial two characters with "*****" or the configured "munge_string".
+    def munge
+      self.host_name.sub(/\A(.{1,2}).*/) { |m| $1 + @config[:munge_string] }
     end
 
-    def normalize
-      dns_host_name
+    ############################################################################
+    # Parsing
+    ############################################################################
+
+
+    def parse(host) # :nodoc:
+      host = self.parse_comment(host)
+
+      if host =~ /\A\[IPv6:(.+)\]/i
+        self.ip_address = $1
+      elsif host =~ /\A\[(\d{1,3}(\.\d{1,3}){3})\]/ # IPv4
+        self.ip_address = $1
+      else
+        self.host_name = host
+      end
     end
 
-    # The canonical host name is the simplified, DNS host name
-    def canonical
-      dns_host_name
+    def parse_comment(host) # :nodoc:
+      if host =~ /\A\((.+?)\)(.+)/ # (comment)domain.tld
+        self.comment, host = $1, $2
+      end
+      if host =~ /\A(.+)\((.+?)\)\z/ # domain.tld(comment)
+        host, self.comment = $1, $2
+      end
+      host
+    end
+
+    def host_name=(name)
+      @host_name = name = name.strip.downcase.gsub(' ', '').gsub(/\(.*\)/, '')
+      @dns_name  = ::SimpleIDN.to_ascii(self.host_name)
+
+      # Subdomain only (root@localhost)
+      if name.index('.').nil?
+        self.subdomains = name
+
+      # Split sub.domain from .tld: *.com, *.xx.cc, *.cc
+      elsif name =~ /\A(.+)\.(\w{3,10})\z/ ||
+            name =~ /\A(.+)\.(\w{1,3}\.\w\w)\z/ ||
+            name =~ /\A(.+)\.(\w\w)\z/
+
+        sub_and_domain, self.tld2 = [$1, $2] # sub+domain, com || co.uk
+        self.tld = self.tld2.sub(/\A.+\./, '') # co.uk => uk
+        if sub_and_domain =~ /\A(.+)\.(.+)\z/ # is subdomain? sub.example [.tld2]
+          self.subdomains        = $1
+          self.registration_name = $2
+        else
+          self.registration_name = sub_and_domain
+          #self.domain_name = sub_and_domain + '.' + self.tld2
+        end
+        self.domain_name = self.registration_name + '.' + self.tld2
+        self.find_provider
+      end
+    end
+
+    def find_provider # :nodoc:
+      return self.provider if self.provider
+
+      EmailAddress::Config.providers.each do |provider, config|
+        if config[:host_match] && self.matches?(config[:host_match])
+          return self.set_provider(provider, config)
+        end
+      end
+
+      return self.set_provider(:default) unless self.dns_enabled?
+
+      provider = self.exchangers.provider
+      if provider != :default
+        self.set_provider(provider,
+          EmailAddress::Config.provider(self.provider))
+      end
+
+      self.provider ||= self.set_provider(:default)
+    end
+
+    def set_provider(name, provider_config={}) # :nodoc:
+      self.config = EmailAddress::Config.all_settings(provider_config, @config)
+      self.provider = name
+    end
+
+    # Returns a hash of the parts of the host name after parsing.
+    def parts
+      { host_name:self.host_name, dns_name:self.dns_name, subdomain:self.subdomains,
+        registration_name:self.registration_name, domain_name:self.domain_name,
+        tld2:self.tld2, tld:self.tld, ip_address:self.ip_address }
     end
 
-    def exchanger
-      return nil unless @host_type == :email
-      @exchanger = EmailAddress::Exchanger.cached(self.dns_host_name)
+    ############################################################################
+    # Access and Queries
+    ############################################################################
+
+    # Is this a fully-qualified domain name?
+    def fqdn?
+      self.tld ? true : false
+    end
+
+    def ip?
+      self.ip_address.nil? ? false : true
+    end
+
+    def ipv4?
+      self.ip? && self.ip_address.include?(".")
+    end
+
+    def ipv6?
+      self.ip? && self.ip_address.include?(":")
+    end
+
+    ############################################################################
+    # Matching
+    ############################################################################
+
+    # Takes a email address string, returns true if it matches a rule
+    # Rules of the follow formats are evaluated:
+    # * "example."  => registration name
+    # * ".com"      => top-level domain name
+    # * "google"    => email service provider designation
+    # * "@goog*.com" => Glob match
+    # * IPv4 or IPv6 or CIDR Address
+    def matches?(rules)
+      rules = Array(rules)
+      return false if rules.empty?
+      rules.each do |rule|
+        return rule if rule == self.domain_name || rule == self.dns_name
+        return rule if registration_name_matches?(rule)
+        return rule if tld_matches?(rule)
+        return rule if domain_matches?(rule)
+        return rule if self.provider && provider_matches?(rule)
+        return rule if self.ip_matches?(rule)
+      end
+      false
+    end
+
+    # Does "example." match any tld?
+    def registration_name_matches?(rule)
+      self.registration_name + '.' == rule ? true : false
+    end
+
+    # 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 == self.tld || $1 == self.tld2) ? true : false
+    end
+
+    def provider_matches?(rule)
+      rule.to_s =~ /\A[\w\-]*\z/ && self.provider && self.provider == rule.to_sym
     end
 
-    def provider
-      @provider ||= @parser.provider
-      if !@provider && EmailAddress::Config.options[:check_dns]
-        @provider = exchanger.provider
+    # Does domain == rule or glob matches? (also tests the DNS (punycode) name)
+    # Requires optionally starts with a "@".
+    def domain_matches?(rule)
+      rule = $1 if rule =~ /\A@(.+)/
+      return rule if File.fnmatch?(rule, self.domain_name)
+      return rule if File.fnmatch?(rule, self.dns_name)
+      false
+    end
+
+    # True if the host is an IP Address form, and that address matches
+    # the passed CIDR string ("10.9.8.0/24" or "2001:..../64")
+    def ip_matches?(cidr)
+      return false unless self.ip_address
+      return cidr if !cidr.include?("/") && cidr == self.ip_address
+
+      c = NetAddr::CIDR.create(cidr)
+      if cidr.include?(":") && self.ip_address.include?(":")
+        return cidr if c.matches?(self.ip_address)
+      elsif cidr.include?(".") && self.ip_address.include?(".")
+        return cidr if c.matches?(self.ip_address)
       end
-      @provider ||= :unknown
+      false
     end
 
-    def matches?(*names)
-      DomainMatcher.matches?(@host_name, names.flatten)
+    ############################################################################
+    # DNS
+    ############################################################################
+
+    # True if the :dns_lookup setting is enabled
+    def dns_enabled?
+      EmailAddress::Config.setting(:dns_lookup)
     end
 
+    # True if the host name has a DNS A Record
+    def has_dns_a_record?
+      dns_a_record.size > 0 ? true : false
+    end
+
+    # Returns: [official_hostname, alias_hostnames, address_family, *address_list]
+    def dns_a_record
+      @_dns_a_record ||= Socket.gethostbyname(self.dns_name)
+    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.
+    # 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(self.dns_name)
+    end
+
+    # Returns a DNS TXT Record
     def txt(alternate_host=nil)
       Resolv::DNS.open do |dns|
-        records = dns.getresources(alternate_host || self.dns_host_name,
+        records = dns.getresources(alternate_host || self.dns_name,
                          Resolv::DNS::Resource::IN::TXT)
         records.empty? ? nil : records.map(&:data).join(" ")
       end
@@ -95,8 +335,44 @@ module EmailAddress
       fields
     end
 
+    # Returns a hash of the domain's DMARC (https://en.wikipedia.org/wiki/DMARC)
+    # settings.
     def dmarc
-      self.txt_hash("_dmarc." + self.dns_host_name)
+      self.dns_name ? self.txt_hash("_dmarc." + self.dns_name) : {}
+    end
+
+    ############################################################################
+    # Validation
+    ############################################################################
+
+    # Returns true if the host name is valid according to the current configuration
+    def valid?(rule=@config[:dns_lookup]||:mx)
+      if self.provider != :default # well known
+        true
+      elsif self.ip_address
+        @config[:host_allow_ip] && self.valid_ip?
+      elsif rule == :mx
+        self.exchangers.mx_ips.size > 0
+      elsif rule == :a
+        self.has_dns_a_record?
+      elsif rule == :off
+        self.to_s.size <= MAX_HOST_LENGTH
+      else
+        false
+      end
+    end
+
+    # Returns true if the IP address given in that form of the host name
+    # is a potentially valid IP address. It does not check if the address
+    # is reachable.
+    def valid_ip?
+      if self.ip_address.nil?
+        false
+      elsif self.ip_address.include?(":")
+        self.ip_address =~ Resolv::IPv6::Regex
+      elsif self.ip_address.include?(".")
+        self.ip_address =~ Resolv::IPv4::Regex
+      end
     end
 
   end

data/lib/email_address/local.rb

@@ -10,7 +10,10 @@ module EmailAddress
   # Quoted: space ( ) , : ; < > @ [ ]
   # Quoted-Backslash-Escaped: \ "
   # Quote local part or dot-separated sub-parts x."y".z
+  # RFC-5321 warns "a host that expects to receive mail SHOULD avoid defining mailboxes
+  #     where the Local-part requires (or uses) the Quoted-string form".
   # (comment)mailbox | mailbox(comment)
+  # . can not appear at beginning or end, or appear consecutively
   # 8-bit/UTF-8: allowed but mail-system defined
   # RFC 5321 also warns that "a host that expects to receive mail SHOULD avoid
   #   defining mailboxes where the Local-part requires (or uses) the Quoted-string form".
@@ -18,90 +21,339 @@ module EmailAddress
   # Case: sensitive, but usually treated as equivalent
   # Local Parts: comment, mailbox tag
   # Length: up to 64 characters
+  # Note: gmail does allow ".." against RFC because they are ignored. This will
+  #   be fixed by collapsing consecutive punctuation in conventional formats,
+  #   and consider them typos.
   ##############################################################################
+  # RFC5322 Rules (Oct 2008):
+  #---------------------------------------------------------------------------
+  # addr-spec       =   local-part "@" domain
+  # local-part      =   dot-atom / quoted-string / obs-local-part
+  # domain          =   dot-atom / domain-literal / obs-domain
+  # domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
+  # dtext           =   %d33-90 /          ; Printable US-ASCII
+  #                     %d94-126 /         ;  characters not including
+  #                     obs-dtext          ;  "[", "]", or "\"
+  # atext           =   ALPHA / DIGIT /    ; Printable US-ASCII
+  #                        "!" / "#" /        ;  characters not including
+  #                        "$" / "%" /        ;  specials.  Used for atoms.
+  #                        "&" / "'" /
+  #                        "*" / "+" /
+  #                        "-" / "/" /
+  #                        "=" / "?" /
+  #                        "^" / "_" /
+  #                        "`" / "{" /
+  #                        "|" / "}" /
+  #                        "~"
+  # atom            =   [CFWS] 1*atext [CFWS]
+  # dot-atom-text   =   1*atext *("." 1*atext)
+  # dot-atom        =   [CFWS] dot-atom-text [CFWS]
+  # specials        =   "(" / ")" /        ; Special characters that do
+  #                        "<" / ">" /        ;  not appear in atext
+  #                        "[" / "]" /
+  #                        ":" / ";" /
+  #                        "@" / "\" /
+  #                        "," / "." /
+  #                        DQUOTE
+  # qtext           =   %d33 /             ; Printable US-ASCII
+  #                        %d35-91 /          ;  characters not including
+  #                        %d93-126 /         ;  "\" or the quote character
+  #                        obs-qtext
+  # qcontent        =   qtext / quoted-pair
+  # quoted-string   =   [CFWS]
+  #                        DQUOTE *([FWS] qcontent) [FWS] DQUOTE
+  #                        [CFWS]
+  ############################################################################
   class Local
-    attr_accessor :mailbox, :comment, :tag, :local
-    ROLE_NAMES = %w(info marketing sales support abuse noc security postmaster
-                    hostmaster usenet news webmaster www uucp ftp)
+    attr_accessor :mailbox, :comment, :tag, :local, :config, :original
+    attr_accessor :syntax
 
-    def initialize(local, host=nil)
-      @provider = EmailAddress::Config.provider(host ? host.provider : :default)
-      parse(local)
+    # 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
+
+    # 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
+
+    # Relaxed: same characters, relaxed order
+    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 \! \x23-\x5B \x5D-\x7E \p{L} \p{N}] )+ \" )
+      ( \.  ( [\p{L}\p{N}\!\#\$\%\&\'\*\+\-\/\=\?\^\_\`\{\|\}\~\(\)]+
+              | \" ( \\[\" \\] | [\x20 \! \x23-\x5B \x5D-\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}
+
+    def initialize(local, config={})
+      self.config   = config.empty? ? EmailAddress::Config.all_settings : config
+      self.local    = local
+    end
+
+    def local=(raw)
+      self.original = raw
+      raw.downcase! if @config[:local_downcase].nil? || @config[:local_downcase]
+      @local = raw
+
+      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)
+      end
+
+      self.format
     end
 
-    def parse(local)
-      local ||= ''
-      @local = local =~ /\A"(.)"\z/ ? $1 : local
-      @local.gsub!(/\\(.)/, '\1') # Unescape
-      @local.downcase! unless @provider[:case_sensitive]
-      @local.gsub!(' ','') unless @provider[:keep_space]
+    def parse(raw)
+      if raw =~ /\A\"(.*)\"\z/ # Quoted
+        raw = $1
+        raw.gsub!(/\\(.)/, '\1') # Unescape
+      elsif @config[:local_fix]
+        raw.gsub!(' ','')
+        raw.gsub!(',','.')
+        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)
+      mailbox ||= ""
+      [mailbox, tag, comment]
+    end
 
-      @mailbox = @local
-      @comment = @tag = nil
-      parse_comment
-      parse_tag
+    # "(comment)mailbox" or "mailbox(comment)", only one comment
+    # RFC Doesn't say what to do if 2 comments occur, so last wins
+    def parse_comment(raw)
+      c = nil
+      if raw =~ /\A\((.+?)\)(.+)\z/
+        c, raw = [$2, $1]
+      end
+      if raw =~ /\A(.+)\((.+?)\)\z/
+        raw, c = [$1, $2]
+      end
+      [raw, c]
+    end
+
+    def parse_tag(raw)
+      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?
+    end
+
+    # True if the the value contains non-Latin Unicde characters
+    def unicode?
+      self.local =~ /[^\p{InBasicLatin}]/ ? true : false
+    end
+
+    # Returns true if the value matches the Redacted format
+    def redacted?
+      self.local =~ REDACTED_REGEX ? true : false
+    end
+
+    # Returns true if the value matches the Redacted format
+    def self.redacted?(local)
+      local =~ REDACTED_REGEX ? true : false
+    end
+
+    # Is the address for a common system or business role account?
+    def special?
+      SPECIAL_MAILBOXES.include?(mailbox)
     end
 
     def to_s
-      normalize
+      self.format
     end
 
-    def normalize
-      m = @mailbox
-      m+= @provider[:tag_separator] + @tag if @tag && !@tag.empty?
-      m+= "(#{@comment})" if @comment && !@comment.empty? && @provider[:keep_comment]
-      format(m)
+    # Builds the local string according to configurations
+    def format(form=@config[:local_format]||:conventional)
+      if @config[:local_format].is_a?(Proc)
+        @config[:local_format].call(self)
+      elsif form == :conventional
+        self.conventional
+      elsif form == :canonical
+        self.canonical
+      elsif form == :relax
+        self.relax
+      elsif form == :standard
+        self.standard
+      end
     end
 
-    def normalize!
-      parse(normalize)
+    # Returns a conventional form of the address
+    def conventional
+      if self.tag
+        [self.mailbox, self.tag].join(@config[:tag_separator])
+      else
+        self.mailbox
+      end
     end
 
+    # Returns a canonical form of the address
     def canonical
-      m= @mailbox.downcase
-      if @provider[:canonical_mailbox]
-        m = @provider[:canonical_mailbox].call(m)
+      if @config[:mailbox_canonical]
+        @config[:mailbox_canonical].call(self.mailbox)
+      else
+        self.mailbox.downcase
       end
-      format(m)
     end
 
-    def canonicalize!
-      parse(canonical)
+    # 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.gsub!(/[ \"\(\),:<>@\[\]\\]/,'')
+      form
     end
 
-    def format(m)
-      m = m.gsub(/([\\\"])/, '\\\1') # Escape \ and "
-      if m =~ /[ \"\(\),:<>@\[\\\]]/ # Space and "(),:;<>@[\]
-        m = %Q("#{m}")
+    # 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.gsub!(/([\\\"])/, '\\\1') # Escape \ and "
+      if form =~ /[ \"\(\),:<>@\[\\\]]/ # Space and "(),:;<>@[\]
+        form = %Q("#{form}")
       end
-      m
+      form
     end
 
-    def parse_comment
-      if @mailbox =~ /\A\((.+?)\)(.+)\z/
-        (@comment, @mailbox) = [$1, $2]
-      elsif @mailbox =~ /\A(.+)\((.+?)\)\z/
-        (@mailbox, @comment) = [$1, $2]
-      else
-        @comment = '';
-        @mailbox = @local
-      end
+    # Sets the part to be the conventional form
+    def conventional!
+      self.local = self.conventional
+    end
+
+    # Sets the part to be the canonical form
+    def canonical!
+      self.local = self.canonical
     end
 
-    def parse_tag
-      return unless @provider[:tag_separator]
-      parts = @mailbox.split(@provider[:tag_separator], 2)
-      (@mailbox, @tag) = *parts if parts.size > 1
+    # Dropps unusual  parts of Standard form to form a relaxed version.
+    def relax!
+      self.local = self.relax
     end
 
-    # RFC2142 - Mailbox Names for Common Services, Rules, and Functions
-    def role?
-      ROLE_NAMES.include?(@mailbox)
+    # Returns the munged form of the address, like "ma*****"
+    def munge
+      self.to_s.sub(/\A(.{1,2}).*/) { |m| $1 + @config[:munge_string] }
     end
 
     # Mailbox with trailing numbers removed
     def root_name
-      canonical =~ /\A(.+?)\d+\z/ ? $1 : canonical
+      self.mailbox =~ /\A(.+?)\d+\z/ ? $1 : self.mailbox
+    end
+
+    ############################################################################
+    # Validations
+    ############################################################################
+
+    # True if the part is valid according to the configurations
+    def valid?(format=@config[:local_format]||:conventional)
+      if @config[:mailbox_validator].is_a?(Proc)
+        @config[:mailbox_validator].call(self.mailbox, self.tag)
+      elsif format.is_a?(Proc)
+        format.call(self)
+      elsif format == :conventional
+        self.conventional?
+      elsif format == :relaxed
+        self.relaxed?
+      elsif format == :redacted
+        self.redacted?
+      elsif format == :standard
+        self.standard?
+      elsif format == :none
+        true
+      else
+        raise "Unknown format #{format}"
+      end
+    end
+
+    # Returns the format of the address
+    def format?
+      # if :custom
+      if self.conventional?
+        :conventional
+      elsif self.relaxed?
+        :relax
+      elsif self.redacted?
+        :redacted
+      elsif self.standard?
+        :standard
+      else
+        :invalid
+      end
+    end
+
+    def valid_size?
+      return false if @config[:local_size] && !@config[:local_size].include?(self.local.size)
+      return false if @config[:mailbox_size] && !@config[:mailbox_size].include?(self.mailbox.size)
+      return false if self.local.size > STANDARD_MAX_SIZE
+      true
+    end
+
+    def valid_encoding?(enc=@config[:local_encoding]||:ascii)
+      return false if enc == :ascii && self.unicode?
+      return false if enc == :unicode && self.ascii?
+      true
+    end
+
+    # True if the part matches the conventional format
+    def conventional?
+      self.syntax = :invalid
+      self.local =~ CONVENTIONAL_MAILBOX_REGEX or return false
+      self.valid_size? or return false
+      self.valid_encoding? or return false
+      self.syntax = :conventional
+      true
+    end
+
+    # 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.local =~ RELAXED_MAILBOX_REGEX
+        self.syntax = :relaxed
+        true
+      else
+        false
+      end
+    end
+
+    # 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
+        self.syntax = :standard
+        true
+      else
+        false
+      end
+    end
+
+    # Matches configured formated form against File glob strings given.
+    # Rules must end in @ to distinguish themselves from other email part matches.
+    def matches?(*rules)
+      rules.flatten.each do |r|
+        if r =~ /(.+)@\z/
+          return r if File.fnmatch?($1, self.local)
+        end
+      end
+      false
     end
   end
 end