email_address 0.0.2 → 0.0.3

data/lib/email_address/config.rb

@@ -42,6 +42,10 @@ module EmailAddress
       @providers
     end
 
+    #def provider(name, defn={})
+    #  EmailAddress::Config.providers[name] = defn
+    #end
+
     def self.options
       @options
     end

data/lib/email_address/domain_matcher.rb

@@ -1,11 +1,14 @@
 module EmailAddress
   ##############################################################################
+  #
+  # DEPRECATING... See EmailAddress::Matcher now
+  #
   # DomainMatcher - Matches a domain to a set of patterns
-  # 
+  #
   # Match Patterns
   #   hostname      sub.domain.tld
   #   domain        domain.tld
-  #   registration  domain 
+  #   registration  domain
   #   tld           .tld, .domain.tld
   ##############################################################################
   class DomainMatcher
@@ -38,7 +41,7 @@ module EmailAddress
     def rule_matches?(rule)
       rule.downcase!
       @host_name == rule || registration_name_matches?(rule) ||
-        domain_matches?(rule) || tld_matches?(rule)
+        domain_matches?(rule) || tld_matches?(rule) || glob_matches?(rule)
     end
 
     def list_matches?(list)
@@ -46,6 +49,11 @@ module EmailAddress
       false
     end
 
+    # Matches a rule as a glob match, with * and ? characters
+    def glob_matches?(rule)
+      File.fnmatch?(rule, @host_name)
+    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
@@ -58,7 +66,7 @@ module EmailAddress
 
     # Does "sub.example.com" match ".com" and ".example.com" top level names?
     def tld_matches?(rule)
-      rule.match(/\A\..+\z/) && 
+      rule.match(/\A\..+\z/) &&
         ( @host_name[-rule.size, rule.size] == rule.downcase || ".#{@host_name}" == rule) \
         ? true : false
     end

data/lib/email_address/domain_parser.rb

@@ -60,9 +60,7 @@ module EmailAddress
     # 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

data/lib/email_address/email_address_type.rb

@@ -0,0 +1,62 @@
+################################################################################
+# ActiveRecord v5.0 Custom Type
+# This class is not automatically loaded by the gem.
+#-------------------------------------------------------------------------------
+# 1) Register this type
+#
+#    # config/initializers.types.rb
+#    require "email_address/email_address_type"
+#    ActiveRecord::Type.register(:email_address, EmailAddress::Address)
+#    ActiveRecord::Type.register(:canonical_email_address,
+#                                EmailAddress::CanonicalEmailAddressType)
+#
+# 2) Define your email address columns in your model class
+#
+#    class User < ActiveRecord::Base
+#      attribute :email, :email_address
+#      attribute :unique_email, :canonical_email_address
+#    end
+#
+# 3) Profit!
+#
+#    user = User.new(email:"Pat.Smith+registrations@gmail.com",
+#                    unique_email:"Pat.Smith+registrations@gmail.com")
+#    user.email        #=> "pat.smith+registrations@gmail.com"
+#    user.unique_email #=> "patsmith@gmail.com"
+################################################################################
+
+class EmailAddress::EmailAddressType < ActiveRecord::Type::Value
+
+  # From user input, setter
+  def cast(value)
+    super(EmailAddress.normal(value))
+  end
+
+  # From a database value
+  def deserialize(value)
+    EmailAddress.normal(value)
+  end
+  #
+  # To a database value (string)
+  def serialize(value)
+    EmailAddress.normal(value)
+  end
+end
+
+class CanonicalEmailAddressType < EmailAddress::EmailAddressType
+
+  # From user input, setter
+  def cast(value)
+    super(EmailAddress.canonical(value))
+  end
+
+  # From a database value
+  def deserialize(value)
+    EmailAddress.canonical(value)
+  end
+
+  # To a database value (string)
+  def serialize(value)
+    EmailAddress.canonical(value)
+  end
+end

data/lib/email_address/exchanger.rb

@@ -6,6 +6,20 @@ module EmailAddress
   class Exchanger
     include Enumerable
 
+    def self.cached(host)
+      @host_cache ||= {}
+      @cache_size ||= ENV['EMAIL_ADDRESS_CACHE_SIZE'].to_i || 100
+      if @host_cache.has_key?(host)
+        o = @host_cache.delete(host)
+        @host_cache[host] = o # LRU cache, move to end
+      elsif @host_cache.size >= @cache_size
+        @host_cache.delete(@host_cache.keys.first)
+        @host_cache[host] = new(host)
+      else
+        @host_cache[host] = new(host)
+      end
+    end
+
     def initialize(host, options={})
       @host = host
       @options = options
@@ -46,6 +60,8 @@ module EmailAddress
         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
+    rescue SocketError # not found, but could also mean network not work
+      @_dns_a_record ||= []
     end
 
     # Returns Array of domain names for the MX'ers, used to determine the Provider
@@ -55,13 +71,29 @@ module EmailAddress
 
     # Returns an array of MX IP address (String) for the given email domain
     def mx_ips
-      mxers(domain).map {|m| m[1] }
+      mxers.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
+      if cidr.include?(":")
+        in_ipv6_cidr?(cidr)
+      else
+        in_ipv4_cidr?(cidr)
+      end
     end
+
+    private
+
+    def in_ipv4_cidr?(cidr)
+      cidr = NetAddr::CIDR.create(cidr)
+      mx_ips.find { |ip| !ip.include?(":") && cidr.matches?(ip) } ? true : false
+    end
+
+    def in_ipv6_cidr?(cidr)
+      cidr = NetAddr::CIDR.create(cidr)
+      mx_ips.find { |ip| ip.include?(":") && cidr.matches?(ip) } ? true : false
+    end
+
   end
 end

data/lib/email_address/host.rb

@@ -22,10 +22,11 @@ module EmailAddress
     # host name -
     #   * full domain name after @ for email types
     #   * fully-qualified domain name
-    # host type - 
+    # 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)
@@ -34,7 +35,8 @@ module EmailAddress
     def to_s
       @host_name
     end
-      
+    alias :name :to_s
+
     def parse_host(host)
       @parser = EmailAddress::DomainParser.new(host)
       @parts  = @parser.parts
@@ -57,7 +59,7 @@ module EmailAddress
 
     def exchanger
       return nil unless @host_type == :email
-      @exchanger = EmailAddress::Exchanger.new(@host_name)
+      @exchanger = EmailAddress::Exchanger.cached(self.dns_host_name)
     end
 
     def provider
@@ -67,10 +69,35 @@ module EmailAddress
       end
       @provider ||= :unknown
     end
-    
+
     def matches?(*names)
       DomainMatcher.matches?(@host_name, names.flatten)
     end
 
+    def txt(alternate_host=nil)
+      Resolv::DNS.open do |dns|
+        records = dns.getresources(alternate_host || self.dns_host_name,
+                         Resolv::DNS::Resource::IN::TXT)
+        records.empty? ? nil : records.map(&:data).join(" ")
+      end
+    end
+
+    # Parses TXT record pairs into a hash
+    def txt_hash(alternate_host=nil)
+      fields = {}
+      record = self.txt(alternate_host)
+      return fields unless record
+
+      record.split(/\s*;\s*/).each do |pair|
+        (n,v) = pair.split(/\s*=\s*/)
+        fields[n.to_sym] = v
+      end
+      fields
+    end
+
+    def dmarc
+      self.txt_hash("_dmarc." + self.dns_host_name)
+    end
+
   end
 end

data/lib/email_address/local.rb

@@ -2,7 +2,7 @@ module EmailAddress
   ##############################################################################
   # EmailAddress Local part consists of
   # - comments
-  # - mailbox 
+  # - mailbox
   # - tag
   #-----------------------------------------------------------------------------
   # Parsing id provider-dependent, but RFC allows:
@@ -12,7 +12,7 @@ module EmailAddress
   # 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 
+  # 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
@@ -24,12 +24,13 @@ module EmailAddress
     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)
+    def initialize(local, host=nil)
+      @provider = EmailAddress::Config.provider(host ? host.provider : :default)
       parse(local)
     end
 
     def parse(local)
+      local ||= ''
       @local = local =~ /\A"(.)"\z/ ? $1 : local
       @local.gsub!(/\\(.)/, '\1') # Unescape
       @local.downcase! unless @provider[:case_sensitive]
@@ -70,7 +71,7 @@ module EmailAddress
 
     def format(m)
       m = m.gsub(/([\\\"])/, '\\\1') # Escape \ and "
-      if m =~ /[ \"\(\),:'<>@\[\\\]]/ # Space and "(),:;<>@[\] 
+      if m =~ /[ \"\(\),:<>@\[\\\]]/ # Space and "(),:;<>@[\]
         m = %Q("#{m}")
       end
       m
@@ -97,5 +98,10 @@ module EmailAddress
     def role?
       ROLE_NAMES.include?(@mailbox)
     end
+
+    # Mailbox with trailing numbers removed
+    def root_name
+      canonical =~ /\A(.+?)\d+\z/ ? $1 : canonical
+    end
   end
 end

data/lib/email_address/matcher.rb

@@ -0,0 +1,119 @@
+module EmailAddress
+  ##############################################################################
+  # Matcher - Allows matching of an email address against a list of matching
+  #           tokens.
+  #
+  # Match Patterns
+  #   * Top-Level-Domain:         .org
+  #   * Domain Name:              example.com
+  #   * Registration Name:        hotmail.   (matches any TLD)
+  #   * Domain Glob:              *.exampl?.com
+  #   * Provider Name:            google
+  #   * Mailbox Name or Glob:     user00*@
+  #   * Address or Glob:          postmaster@domain*.com
+  #   * Provider or Registration: msn (?? Possible combo for either match?)
+  #
+  # Usage:
+  #   m = EmailAddress::Matcher.new(".org example.com hotmail. google user*@ root@*.com")
+  #   m.include?("pat@example.com")
+  ##############################################################################
+
+  class Matcher
+    attr_reader :rules, :email
+
+    def self.matches?(rule, email)
+      EmailAddress::Matcher.new(rule).matches?(email)
+    end
+
+    def initialize(rules=[], empty_rules_return=false)
+      self.rules = rules
+      @empty_rules_return = empty_rules_return
+    end
+
+    def rules=(r)
+      @rules = r.is_a?(Array) ? r : r.split(/\s+/)
+      @rules = @rules.map(&:downcase)
+    end
+
+    def email=(e)
+      e = EmailAddress.new(e) if e.is_a?(String)
+      if e.is_a?(EmailAddress::Address)
+        @email_address    = e
+        @email            = e.normalize
+        @mailbox          = e.mailbox
+        @domain           = e.host.name
+        @domain_parts     = e.host.parts
+        @provider         = e.provider
+      elsif e.is_a?(Hash)
+        @email            = e[:email]
+        @mailbox          = e[:mailbox]
+        @domain           = e[:domain]
+        @domain_parts     = EmailAddress::DomainParser.new(@domain).parts
+        @provider         = e[:provider]
+      end
+    end
+
+    # Takes a email address string, returns true if it matches a rule
+    def include?(email_address)
+      self.email = email_address
+      return @empty_rules_return if @rules.empty?
+      @rules.each do |rule|
+        return true if registration_name_matches?(rule)
+        return true if tld_matches?(rule)
+        return true if provider_matches?(rule)
+        return true if domain_matches?(rule)
+        return true if email_matches?(rule)
+        return true if @email_address && ip_cidr_matches?(rule)
+      end
+      false
+    end
+
+    # Does "example." match any tld?
+    def registration_name_matches?(rule)
+      @domain_parts[:registration_name]+'.' == rule ? true : false
+    end
+
+    # Does "sub.example.com" match ".com" and ".example.com" top level names?
+    def tld_matches?(rule)
+      rule.match(/\A\..+\z/) &&
+        ( @domain[-rule.size, rule.size] == rule || ".#{@domain}" == rule) \
+        ? true : false
+    end
+
+    def provider_matches?(rule)
+      rule =~ /\A[\w\-]*\z/ && self.provider == rule.to_sym
+    end
+
+    def provider
+      @provider ||= EmailAddress::Config.providers.each do |prov, defn|
+        if defn.has_key?(:domains) && !defn[:domains].empty?
+          defn[:domains].each do |d|
+            if domain_matches?(d) || registration_name_matches?(d)
+              return @provider = prov
+            end
+          end
+        end
+      end
+      @provider ||= :unknown
+    end
+
+    # Does domain == rule or glob matches?
+    def domain_matches?(rule, domain=@domain)
+      return false if rule.include?("@")
+      domain == rule || File.fnmatch?(rule, domain)
+    end
+
+    # Does "root@*.com" match "root@example.com" domain name
+    def email_matches?(rule)
+      return false unless rule.include?("@")
+      @email == rule || File.fnmatch?(rule, @email)
+    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/) && @email_address.host.exchanger
+      @email_address.host.exchanger.in_cidr?(rule) ? true : false
+    end
+
+  end
+end

data/lib/email_address/validator.rb

@@ -2,6 +2,8 @@ module EmailAddress
   class Validator
     LEGIBLE_LOCAL_REGEX = /\A[a-z0-9]+(([\.\-\_\'\+][a-z0-9]+)+)?\z/
     DOT_ATOM_REGEX = /[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]/
+    ERRORS = %i(bad_syntax bad_email bad_mailbox bad_domain bad_exchanger bad_recipient)
+    attr_reader :error
 
     def self.validate(address, options={})
       EmailAddress::Validator.new(address, options).valid?
@@ -13,25 +15,29 @@ module EmailAddress
       @host    = address.host
       @options = options
       @rules   = EmailAddress::Config.provider(@host.provider)
-      @errors  = []
+      @error   = nil
     end
 
+    # Returns true if email address seems valid, false otherwise.
+    # For error, call #error method to get error code (symbol).
     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)
+        return invalid(:bad_mailbox)
       else
         return false unless valid_local?
       end
-      return invalid(:mx) unless valid_mx? || (valid_dns? && @options[:allow_dns_a])
+      if EmailAddress::Config.options[:check_dns]
+        return invalid(:bad_exchanger) unless valid_mx? || (valid_dns? && @options[:allow_dns_a])
+      end
       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)
+        return invalid(:bad_mailbox) unless @rules[:valid_mailbox].call(@local)
       elsif v == :legible
         return legible?
       elsif v == :rfc
@@ -56,19 +62,19 @@ module EmailAddress
     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)
+      return invalid(:bad_email) unless @rules[:address_size].include?(@address.to_s.size)
+      return invalid(:bad_mailbox) unless @rules[:local_size  ].include?(@local.to_s.size)
+      return invalid(:bad_mailbox) unless @rules[:mailbox_size].include?(@local.mailbox.size)
+      return invalid(:bad_domain ) unless @rules[:domain_size ].include?(@host.to_s.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)
+      return invalid(:bad_mailbox) unless valid_local_part?(@local.mailbox)
+      return invalid(:bad_mailbox) 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)
+          return invalid(:bad_mailbox, t) unless valid_local_part?(t)
         end
       end
       true
@@ -81,7 +87,7 @@ module EmailAddress
 
 
     def invalid(reason, *info)
-      @errors << reason
+      @error = reason
       #p "INVALID ----> #{reason} for #{@local.to_s}@#{@host.to_s} #{info.inspect}"
       false
     end