email_address 0.1.2 → 0.2.0

data/lib/email_address/email_address_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ################################################################################
 # ActiveRecord v5.0 Custom Type
 #
@@ -27,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,41 +1,44 @@
-require 'resolv'
-require 'netaddr'
-require 'socket'
+# frozen_string_literal: true
+
+require "resolv"
+require "socket"
 
 module EmailAddress
   class Exchanger
     include Enumerable
 
-    def self.cached(host)
+    def self.cached(host, config = {})
       @host_cache ||= {}
-      @cache_size ||= ENV['EMAIL_ADDRESS_CACHE_SIZE'].to_i || 100
+      @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)
+        @host_cache[host] = new(host, config)
       else
-        @host_cache[host] = new(host)
+        @host_cache[host] = new(host, config)
       end
     end
 
-    def initialize(host, config={})
+    def initialize(host, config = {})
       @host = host
-      @config = config
+      @config = config.is_a?(Hash) ? Config.new(config) : config
+      @dns_disabled = @config[:host_validation] == :syntax || @config[:dns_lookup] == :off
     end
 
     def each(&block)
+      return if @dns_disabled
       mxers.each do |m|
-        yield({host:m[0], ip:m[1], priority:m[2]})
+        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
       return @provider if defined? @provider
-      EmailAddress::Config.providers.each do |provider, config|
-        if config[:exchanger_match] && self.matches?(config[:exchanger_match])
+      Config.providers.each do |provider, config|
+        if config[:exchanger_match] && matches?(config[:exchanger_match])
           return @provider = provider
         end
       end
@@ -44,28 +47,41 @@ module EmailAddress
 
     # 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 []
+    # Returns a dummy record when dns_lookup is turned off since it may exists, though
+    # may not find provider by MX name or IP. I'm not sure about the "0.0.0.0" ip, it should
+    # be good in this context, but in "listen" context it means "all bound IP's"
     def mxers
-      @mxers ||= Resolv::DNS.open do |dns|
-        ress = dns.getresources(@host, Resolv::DNS::Resource::IN::MX)
-        records = ress.map do |r|
-          begin
-            [r.exchange.to_s, IPSocket::getaddress(r.exchange.to_s), r.preference]
-          rescue SocketError # not found, but could also mean network not work or it could mean one record doesn't resolve an address
-            nil
-          end
+      return [["example.com", "0.0.0.0", 1]] if @dns_disabled
+      @mxers ||= Resolv::DNS.open { |dns|
+        dns.timeouts = @config[:dns_timeout] if @config[:dns_timeout]
+
+        ress = begin
+          dns.getresources(@host, Resolv::DNS::Resource::IN::MX)
+        rescue Resolv::ResolvTimeout
+          []
         end
+
+        records = ress.map { |r|
+          if r.exchange.to_s > " "
+            [r.exchange.to_s, IPSocket.getaddress(r.exchange.to_s), r.preference]
+          end
+        }
         records.compact
-      end
+      }
+    # not found, but could also mean network not work or it could mean one record doesn't resolve an address
+    rescue SocketError
+      [["example.com", "0.0.0.0", 1]]
     end
 
     # 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
     def mx_ips
-      mxers.map {|m| m[1] }
+      return ["0.0.0.0"] if @dns_disabled
+      mxers.map { |m| m[1] }
     end
 
     # Simple matcher, takes an array of CIDR addresses (ip/bits) and strings.
@@ -78,9 +94,9 @@ module EmailAddress
       rules = Array(rules)
       rules.each do |rule|
         if rule.include?("/")
-          return rule if self.in_cidr?(rule)
+          return rule if in_cidr?(rule)
         else
-          self.each {|mx| return rule if mx[:host].end_with?(rule) }
+          each { |mx| return rule if mx[:host].end_with?(rule) }
         end
       end
       false
@@ -88,14 +104,9 @@ module EmailAddress
 
     # Given a cidr (ip/bits) and ip address, returns true on match. Caches cidr object.
     def in_cidr?(cidr)
-      c = NetAddr::CIDR.create(cidr)
-      if cidr.include?(":")
-        mx_ips.find { |ip| ip.include?(":") && c.matches?(ip) } ? true : false
-      elsif cidr.include?(".")
-        mx_ips.find { |ip| !ip.include?(":") && c.matches?(ip) } ? true : false
-      else
-        false
-      end
+      net = IPAddr.new(cidr)
+      found = mx_ips.detect { |ip| net.include?(IPAddr.new(ip)) }
+      !!found
     end
   end
 end