email_address 0.0.1 → 0.0.2

data/lib/email_address/domain_matcher.rb

@@ -0,0 +1,90 @@
+module EmailAddress
+  ##############################################################################
+  # DomainMatcher - Matches a domain to a set of patterns
+  # 
+  # Match Patterns
+  #   hostname      sub.domain.tld
+  #   domain        domain.tld
+  #   registration  domain 
+  #   tld           .tld, .domain.tld
+  ##############################################################################
+  class DomainMatcher
+    attr_reader :host_name, :parts, :domain_name, :registration_name,
+                :tld, :subdomains, :ip_address
+
+    def self.matches?(domain, rule)
+      DomainMatcher.new(domain, rule).matches?
+    end
+
+    def initialize(host_name, rule=nil)
+      @host_name = host_name.downcase
+      @host = EmailAddress::Host.new(@host_name)
+      @rule = rule
+      matches?
+    end
+
+    def matches?(rule=nil)
+      rule ||= @rule
+      case rule
+      when String
+        rule_matches?(rule)
+      when Array
+        list_matches?(rule)
+      else
+        false
+      end
+    end
+
+    def rule_matches?(rule)
+      rule.downcase!
+      @host_name == rule || registration_name_matches?(rule) ||
+        domain_matches?(rule) || tld_matches?(rule)
+    end
+
+    def list_matches?(list)
+      list.each {|rule| return true if rule_matches?(rule) }
+      false
+    end
+
+    # Does "sub.example.com" match "example" registration name
+    def registration_name_matches?(rule)
+      rule.match(/\A(\w+)\z/) && @host.registration_name == rule.downcase ? true : false
+    end
+
+    # Does "sub.example.com" match "example.com" domain name
+    def domain_matches?(rule)
+      rule.match(/\A[^\.]+\.[^\.]+\z/) && @host.domain_name == rule.downcase ? true : false
+    end
+
+    # Does "sub.example.com" match ".com" and ".example.com" top level names?
+    def tld_matches?(rule)
+      rule.match(/\A\..+\z/) && 
+        ( @host_name[-rule.size, rule.size] == rule.downcase || ".#{@host_name}" == rule) \
+        ? true : false
+    end
+
+    # Does an IP of mail exchanger for "sub.example.com" match "xxx.xx.xx.xx/xx"?
+    def ip_cidr_matches?(rule)
+      return false unless rule.match(/\A\d.+\/\d+\z/) && @host.exchanger
+      @host.exchanger.in_cidr?(r) ? true : false
+    end
+
+    #def provider_matches?(rule)
+    #  if rule.downcase.match(/\A\:(\w+)\z/)
+    #    p ["PROVIDER", rule, @host_name, provider_by_domain ]
+    #    prov = provider_by_domain
+    #    prov && prov == $1 ? true : false
+    #  end
+    #end
+
+    ## Match only by
+    #def provider_by_domain
+    #  base = EmailAddress::Config.providers[:default]
+    #  EmailAddress::Config.providers.first do |name, defn|
+    #    defn = base.merge(defn)
+    #    return name if matches?(defn[:domains])
+    #  end
+    #  nil
+    #end
+  end
+end

data/lib/email_address/domain_parser.rb

@@ -0,0 +1,71 @@
+require 'simpleidn'
+
+module EmailAddress
+  ##############################################################################
+  # Builds hash of host name/domain name parts 
+  # For: subdomain.example.co.uk
+  #     host_name:         "subdomain.example.co.uk"
+  #     subdomains:        "subdomain"
+  #     registration_name: "example"
+  #     domain_name:       "example.co.uk"
+  #     tld:               "co.uk"
+  #     ip_address:        nil or "ipaddress" used in [ipaddress] syntax
+  ##############################################################################
+  class DomainParser
+    attr_reader :host_name, :parts, :domain_name, :registration_name,
+                :tld, :subdomains, :ip_address
+
+    def self.parse(domain)
+      EmailAddress::DomainParser.new(domain).parts
+    end
+
+    def initialize(host_name)
+      @host_name = host_name.downcase
+      parse_host(@host_name)
+    end
+
+    def parse_host(host)
+      @host_name  = host.strip.downcase.gsub(' ', '').gsub(/\(.*\)/, '')
+      @subdomains = @registration_name = @domain_name = @tld = ''
+      @ip_address = nil
+
+      # IP Address: [127.0.0.1], [IPV6:.....]
+      if @host_name =~ /\A\[(.+)\]\z/
+        @ip_address = $1
+
+      # Subdomain only (root@localhost)
+      elsif @host_name.index('.').nil?
+        @subdomains = @host_name
+
+      # Split sub.domain from .tld: *.com, *.xx.cc, *.cc
+      elsif @host_name =~ /\A(.+)\.(\w{3,10})\z/ ||
+            @host_name =~ /\A(.+)\.(\w{1,3}\.\w\w)\z/ ||
+            @host_name =~ /\A(.+)\.(\w\w)\z/
+
+        @tld = $2;
+        sld  = $1 # Second level domain
+        if sld =~ /\A(.+)\.(.+)\z/ # is subdomain? sub.example [.tld]
+          @subdomains  = $1
+          @registration_name = $2
+        else
+          @registration_name = sld
+          @domain_name = sld + '.' + @tld
+        end
+        @domain_name = @registration_name + '.' + @tld
+      end
+      @parts = {host_name:@host_name, subdomains:@subdomains, domain_name:@domain_name,
+       registration_name:@registration_name, tld:@tld, ip_address:@ip_address}
+    end
+
+    # Returns provider based on configured domain name matches, or nil if unmatched
+    # For best results, # consider the Exchanger.provider result as well.
+    def provider
+      base = EmailAddress::Config.providers[:default]
+      EmailAddress::Config.providers.each do |name, defn|
+        defn = base.merge(defn)
+        return name if EmailAddress::DomainMatcher.matches?(@host_name, defn[:domains])
+      end
+      nil
+    end
+  end
+end

data/lib/email_address/exchanger.rb

@@ -0,0 +1,67 @@
+require 'resolv'
+require 'netaddr'
+require 'socket'
+
+module EmailAddress
+  class Exchanger
+    include Enumerable
+
+    def initialize(host, options={})
+      @host = host
+      @options = options
+    end
+
+    def each(&block)
+      mxers.each do |m|
+        yield({host:m[0], ip:m[1], priority:m[2]})
+      end
+    end
+
+    # Returns the provider name based on the MX-er host names, or nil if not matched
+    def provider
+      base = EmailAddress::Config.providers[:default]
+      EmailAddress::Config.providers.each do |name, defn|
+        defn = base.merge(defn)
+        self.each do |m|
+         return name if DomainMatcher.matches?(m[:host], defn[:exchangers])
+        end
+      end
+      nil
+    end
+
+    def has_dns_a_record?
+      dns_a_record.size > 0 ? true : false
+    end
+
+    def dns_a_record
+      @_dns_a_record ||= Socket.gethostbyname(@host)
+    rescue SocketError # not found, but could also mean network not work
+      @_dns_a_record ||= []
+    end
+
+    # Returns: [["mta7.am0.yahoodns.net", "66.94.237.139", 1], ["mta5.am0.yahoodns.net", "67.195.168.230", 1], ["mta6.am0.yahoodns.net", "98.139.54.60", 1]]
+    # If not found, returns []
+    def mxers
+      @mxers ||= Resolv::DNS.open do |dns|
+        ress = dns.getresources(@host, Resolv::DNS::Resource::IN::MX)
+        ress.map { |r| [r.exchange.to_s, IPSocket::getaddress(r.exchange.to_s), r.preference] }
+      end
+    end
+
+    # Returns Array of domain names for the MX'ers, used to determine the Provider
+    def domains
+      mxers.map {|m| EmailAddress::DomainParser.new(m.first).domain_name}.sort.uniq
+    end
+
+    # Returns an array of MX IP address (String) for the given email domain
+    def mx_ips
+      mxers(domain).map {|m| m[1] }
+    end
+
+    # Given a cidr (ip/bits) and ip address, returns true on match. Caches cidr object.
+    def in_cidr?(cidr)
+      @cidr ||= NetAddr::CIDR.create(cidr)
+      mx_ips.first { |ip| @cider.matches?(ip) } ? true : false
+    end
+  end
+end

data/lib/email_address/host.rb

@@ -1,6 +1,76 @@
+require 'simpleidn'
+
 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
+  ##############################################################################
   class Host
-    def domain
+    attr_reader :host_name, :parts, :domain_name, :registration_name,
+                :tld, :subdomains, :ip_address
+
+    # 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.downcase
+      @host_type = host_type
+      parse_host(@host_name)
     end
+
+    def to_s
+      @host_name
+    end
+      
+    def parse_host(host)
+      @parser = EmailAddress::DomainParser.new(host)
+      @parts  = @parser.parts
+      @parts.each { |k,v| instance_variable_set("@#{k}", v) }
+    end
+
+    # The host name to send to DNS lookup, Punycode-escaped
+    def dns_host_name
+      @dns_host_name ||= ::SimpleIDN.to_ascii(@host_name)
+    end
+
+    def normalize
+      dns_host_name
+    end
+
+    # The canonical host name is the simplified, DNS host name
+    def canonical
+      dns_host_name
+    end
+
+    def exchanger
+      return nil unless @host_type == :email
+      @exchanger = EmailAddress::Exchanger.new(@host_name)
+    end
+
+    def provider
+      @provider ||= @parser.provider
+      if !@provider && EmailAddress::Config.options[:check_dns]
+        @provider = exchanger.provider
+      end
+      @provider ||= :unknown
+    end
+    
+    def matches?(*names)
+      DomainMatcher.matches?(@host_name, names.flatten)
+    end
+
   end
 end

data/lib/email_address/local.rb

@@ -1,4 +1,101 @@
 module EmailAddress
+  ##############################################################################
+  # EmailAddress Local part consists of
+  # - comments
+  # - mailbox 
+  # - tag
+  #-----------------------------------------------------------------------------
+  # Parsing id provider-dependent, but RFC allows:
+  # Chars: A-Z a-z 0-9 . ! # $ % ' * + - / = ? ^G _ { | } ~
+  # Quoted: space ( ) , : ; < > @ [ ]
+  # Quoted-Backslash-Escaped: \ "
+  # Quote local part or dot-separated sub-parts x."y".z
+  # (comment)mailbox | mailbox(comment)
+  # 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".
+  # Postmaster: must always be case-insensitive
+  # Case: sensitive, but usually treated as equivalent
+  # Local Parts: comment, mailbox tag
+  # Length: up to 64 characters
+  ##############################################################################
   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)
+
+    def initialize(local, provider=nil)
+      @provider = EmailAddress::Config.provider(provider || :default)
+      parse(local)
+    end
+
+    def parse(local)
+      @local = local =~ /\A"(.)"\z/ ? $1 : local
+      @local.gsub!(/\\(.)/, '\1') # Unescape
+      @local.downcase! unless @provider[:case_sensitive]
+      @local.gsub!(' ','') unless @provider[:keep_space]
+
+      @mailbox = @local
+      @comment = @tag = nil
+      parse_comment
+      parse_tag
+    end
+
+    def to_s
+      normalize
+    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)
+    end
+
+    def normalize!
+      parse(normalize)
+    end
+
+    def canonical
+      m= @mailbox.downcase
+      if @provider[:canonical_mailbox]
+        m = @provider[:canonical_mailbox].call(m)
+      end
+      format(m)
+    end
+
+    def canonicalize!
+      parse(canonical)
+    end
+
+    def format(m)
+      m = m.gsub(/([\\\"])/, '\\\1') # Escape \ and "
+      if m =~ /[ \"\(\),:'<>@\[\\\]]/ # Space and "(),:;<>@[\] 
+        m = %Q("#{m}")
+      end
+      m
+    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
+    end
+
+    def parse_tag
+      return unless @provider[:tag_separator]
+      parts = @mailbox.split(@provider[:tag_separator], 2)
+      (@mailbox, @tag) = *parts if parts.size > 1
+    end
+
+    # RFC2142 - Mailbox Names for Common Services, Rules, and Functions
+    def role?
+      ROLE_NAMES.include?(@mailbox)
+    end
   end
 end

data/lib/email_address/validator.rb

@@ -0,0 +1,135 @@
+module EmailAddress
+  class Validator
+    LEGIBLE_LOCAL_REGEX = /\A[a-z0-9]+(([\.\-\_\'\+][a-z0-9]+)+)?\z/
+    DOT_ATOM_REGEX = /[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]/
+
+    def self.validate(address, options={})
+      EmailAddress::Validator.new(address, options).valid?
+    end
+
+    def initialize(address, options={})
+      @address = address
+      @local   = address.local
+      @host    = address.host
+      @options = options
+      @rules   = EmailAddress::Config.provider(@host.provider)
+      @errors  = []
+    end
+
+    def valid?
+      return false unless valid_sizes?
+      if @rules[:valid_mailbox] && ! @rules[:valid_mailbox].call(@local.to_s)
+        #p ["VALIDATOR", @local.to_s, @rules[:valid_mailbox]]
+        return invalid(:mailbox_validator)
+      else
+        return false unless valid_local?
+      end
+      return invalid(:mx) unless valid_mx? || (valid_dns? && @options[:allow_dns_a])
+      true
+    end
+
+    def mailbox_validator(v)
+      return true unless v
+      if v.is_a?(Proc)
+        return invalid(:mailbox_proc) unless @rules[:valid_mailbox].call(@local)
+      elsif v == :legible
+        return legible?
+      elsif v == :rfc
+        return rfc_compliant?
+      end
+    end
+
+    # True if the DNS A record or MX records are defined
+    # Why A record? Some domains are misconfigured with only the A record.
+    def valid_dns?
+      @host.exchanger.has_dns_a_record?
+    end
+
+    # True if the DNS MX records have been defined. More strict than #valid?
+    def valid_mx?
+      @host.exchanger.mxers.size > 0
+    end
+
+    # Allows single, simple punctua3Nz=Xj/7c9 tion character between words
+    def legible?
+      @local.to_s =~ LEGIBLE_LOCAL_REGEX
+    end
+
+    def valid_sizes?
+      return invalid(:address_size) unless @rules[:address_size].include?(@address.to_s.size)
+      return invalid(:domain_size ) unless @rules[:domain_size ].include?(@host.to_s.size)
+      return invalid(:local_size  ) unless @rules[:local_size  ].include?(@local.to_s.size)
+      return invalid(:mailbox_size) unless @rules[:mailbox_size].include?(@local.mailbox.size)
+      true
+    end
+
+    def valid_local?
+      return invalid(:mailbox) unless valid_local_part?(@local.mailbox)
+      return invalid(:comment) unless @local.comment.empty? || valid_local_part?(@local.comment)
+      if @local.tag
+        @local.tag.split(@rules[:tag_separator]).each do |t|
+          return invalid(:tag, t) unless valid_local_part?(t)
+        end
+      end
+      true
+    end
+
+    # Valid within a mailbox, tag, comment
+    def valid_local_part?(p)
+      p =~ LEGIBLE_LOCAL_REGEX
+    end
+
+
+    def invalid(reason, *info)
+      @errors << reason
+      #p "INVALID ----> #{reason} for #{@local.to_s}@#{@host.to_s} #{info.inspect}"
+      false
+    end
+
+    def valid_google_local?
+      true
+    end
+
+    ############################################################################
+    # 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]
+    ############################################################################
+
+  end
+end