email_address 0.1.13 → 0.1.18

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

@@ -97,67 +97,67 @@ module EmailAddress
   # * exchanger_match:    %w(google.com 127.0.0.1 10.9.8.0/24 ::1/64)
   #
 
-  require 'yaml'
+  require "yaml"
 
   class Config
     @config = {
-      dns_lookup:         :mx,  # :mx, :a, :off
-      dns_timeout:        nil,
-      sha1_secret:        "",
-      munge_string:       "*****",
-
-      local_downcase:     true,
-      local_fix:          false,
-      local_encoding:     :ascii, # :ascii, :unicode,
-      local_parse:        nil,   # nil, Proc
-      local_format:       :conventional, # :conventional, :relaxed, :redacted, :standard, Proc
-      local_size:         1..64,
-      tag_separator:      '+', # nil, character
-      mailbox_size:       1..64, # without tag
-      mailbox_canonical:  nil, # nil,  Proc
-      mailbox_validator:  nil, # nil,  Proc
-
-      host_encoding:      :punycode || :unicode,
-      host_validation:    :mx || :a || :connect || :syntax,
-      host_size:          1..253,
-      host_allow_ip:      false,
+      dns_lookup: :mx, # :mx, :a, :off
+      dns_timeout: nil,
+      sha1_secret: "",
+      munge_string: "*****",
+
+      local_downcase: true,
+      local_fix: false,
+      local_encoding: :ascii, # :ascii, :unicode,
+      local_parse: nil, # nil, Proc
+      local_format: :conventional, # :conventional, :relaxed, :redacted, :standard, Proc
+      local_size: 1..64,
+      tag_separator: "+", # nil, character
+      mailbox_size: 1..64, # without tag
+      mailbox_canonical: nil, # nil,  Proc
+      mailbox_validator: nil, # nil,  Proc
+
+      host_encoding: :punycode || :unicode,
+      host_validation: :mx || :a || :connect || :syntax,
+      host_size: 1..253,
+      host_allow_ip: false,
       host_remove_spaces: false,
-      host_local:         false,
+      host_local: false,
 
       address_validation: :parts, # :parts, :smtp, Proc
-      address_size:       3..254,
-      address_fqdn_domain: nil, # Fully Qualified Domain Name = [host].[domain.tld]
+      address_size: 3..254,
+      address_fqdn_domain: nil # Fully Qualified Domain Name = [host].[domain.tld]
     }
 
     # 2018-04: AOL and Yahoo now under "oath.com", owned by Verizon. Keeping separate for now
     @providers = {
       aol: {
-        host_match:       %w(aol. compuserve. netscape. aim. cs.),
+        host_match: %w[aol. compuserve. netscape. aim. cs.]
       },
       google: {
-        host_match:       %w(gmail.com googlemail.com),
-        exchanger_match:  %w(google.com googlemail.com),
-        local_size:       5..64,
+        host_match: %w[gmail.com googlemail.com],
+        exchanger_match: %w[google.com googlemail.com],
+        local_size: 5..64,
         local_private_size: 1..64, # When hostname not in host_match (private label)
-        mailbox_canonical: ->(m) {m.gsub('.','')},
+        mailbox_canonical: ->(m) { m.delete(".") }
       },
       msn: {
-        host_match:       %w(msn. hotmail. outlook. live.),
-        mailbox_validator: ->(m,t) { m =~ /\A\w[\-\w]*(?:\.[\-\w]+)*\z/i},
+        host_match: %w[msn. hotmail. outlook. live.],
+        exchanger_match: %w[outlook.com],
+        mailbox_validator: ->(m, t) { m =~ /\A\w[\-\w]*(?:\.[\-\w]+)*\z/i }
       },
       yahoo: {
-        host_match:       %w(yahoo. ymail. rocketmail.),
-        exchanger_match:  %w(yahoodns yahoo-inc),
-      },
+        host_match: %w[yahoo. ymail. rocketmail.],
+        exchanger_match: %w[yahoodns yahoo-inc]
+      }
     }
 
-
     # Loads messages: {"en"=>{"email_address"=>{"invalid_address"=>"Invalid Email Address",...}}}
     # Rails/I18n gem: t(email_address.error, scope: "email_address")
-    @errors = YAML.load_file(File.dirname(__FILE__)+"/messages.yaml")
+    @errors = YAML.load_file(File.dirname(__FILE__) + "/messages.yaml")
 
     # Set multiple default configuration settings
-    def self.configure(config={})
+    def self.configure(config = {})
       @config.merge!(config)
     end
 
@@ -168,34 +168,56 @@ module EmailAddress
     end
 
     # Returns the hash of Provider rules
-    def self.providers
-      @providers
+    class << self
+      attr_reader :providers
     end
 
     # Configure or lookup a provider by name.
-    def self.provider(name, config={})
+    def self.provider(name, config = {})
       name = name.to_sym
       if config.size > 0
-        @providers[name] ||= @config.clone
-        @providers[name].merge!(config)
+        @providers[name.to_sym] = config
       end
       @providers[name]
     end
 
-    def self.error_message(name, locale="en")
+    def self.error_message(name, locale = "en")
       @errors[locale]["email_address"][name.to_s] || name.to_s
     end
 
     # Customize your own error message text.
-    def self.error_messages(hash=nil)
-      @errors = @errors.merge(hash) if hash
-      @errors
+    def self.error_messages(hash = {}, locale = "en", *extra)
+      hash = extra.first if extra.first.is_a? Hash
+      unless hash.empty?
+        @errors[locale]["email_address"] = @errors[locale]["email_address"].merge(hash)
+      end
+      @errors[locale]["email_address"]
     end
 
     def self.all_settings(*configs)
       config = @config.clone
-      configs.each {|c| config.merge!(c) }
+      configs.each { |c| config.merge!(c) }
       config
     end
+
+    def initialize(overrides = {})
+      @config = Config.all_settings(overrides)
+    end
+
+    def []=(setting, value)
+      @config[setting.to_sym] = value
+    end
+
+    def [](setting)
+      @config[setting.to_sym]
+    end
+
+    def configure(settings)
+      @config = @config.merge(settings)
+    end
+
+    def to_h
+      @config
+    end
   end
 end

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,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'resolv'
-require 'netaddr'
-require 'socket'
+require "resolv"
+require "netaddr"
+require "socket"
 
 module EmailAddress
   class Exchanger
     include Enumerable
 
-    def self.cached(host, config={})
+    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
@@ -22,22 +22,24 @@ module EmailAddress
       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
@@ -50,40 +52,37 @@ module EmailAddress
     # 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
-      return [["example.com", "0.0.0.0", 1]] if @config[:dns_lookup] == :off
-      @mxers ||= Resolv::DNS.open do |dns|
+      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
-          []
+               rescue Resolv::ResolvTimeout
+                 []
         end
 
-        records = ress.map do |r|
-          begin
-            if r.exchange.to_s > " "
-              [r.exchange.to_s, IPSocket::getaddress(r.exchange.to_s), r.preference]
-            else
-              nil
-            end
-          rescue SocketError # not found, but could also mean network not work or it could mean one record doesn't resolve an address
-            nil
+        records = ress.map { |r|
+          if r.exchange.to_s > " "
+            [r.exchange.to_s, IPSocket.getaddress(r.exchange.to_s), r.preference]
           end
-        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
-      return ["0.0.0.0"] if @config[:dns_lookup] == :off
-      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.
@@ -96,9 +95,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

data/lib/email_address/host.rb

@@ -1,8 +1,7 @@
-
-require 'simpleidn'
-require 'resolv'
-require 'netaddr'
-require 'net/smtp'
+require "simpleidn"
+require "resolv"
+require "netaddr"
+require "net/smtp"
 
 module EmailAddress
   ##############################################################################
@@ -34,12 +33,12 @@ module EmailAddress
   class Host
     attr_reader :host_name
     attr_accessor :dns_name, :domain_name, :registration_name,
-                  :tld, :tld2, :subdomains, :ip_address, :config, :provider,
-                  :comment, :error_message, :reason
+      :tld, :tld2, :subdomains, :ip_address, :config, :provider,
+      :comment, :error_message, :reason
     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.
@@ -85,46 +84,45 @@ module EmailAddress
 
     # host name -
     #   * host type - :email for an email host, :mx for exchanger host
-    def initialize(host_name, config={})
-      @original            = host_name ||= ''
+    def initialize(host_name, config = {})
+      @original = host_name ||= ""
       config[:host_type] ||= :email
-      @config              = config
-      @error               = @error_message = nil
+      @config = config.is_a?(Hash) ? Config.new(config) : config
+      @error = @error_message = nil
       parse(host_name)
     end
 
     # 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}]"
+      if ipv4?
+        "[#{ip_address}]"
+      elsif ipv6?
+        "[IPv6:#{ip_address}]"
       elsif @config[:host_encoding] && @config[:host_encoding] == :unicode
-        ::SimpleIDN.to_unicode(self.host_name)
+        ::SimpleIDN.to_unicode(host_name)
       else
-        self.dns_name
+        dns_name
       end
     end
-    alias :to_s :name
+    alias to_s name
 
     # The canonical host name is the simplified, DNS host name
     def canonical
-      self.dns_name
+      dns_name
     end
 
     # 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] }
+      host_name.sub(/\A(.{1,2}).*/) { |m| $1 + @config[:munge_string] }
     end
 
     ############################################################################
     # Parsing
     ############################################################################
 
-
     def parse(host) # :nodoc:
-      host = self.parse_comment(host)
+      host = parse_comment(host)
 
       if host =~ /\A\[IPv6:(.+)\]/i
         self.ip_address = $1
@@ -149,34 +147,34 @@ module EmailAddress
       name = fully_qualified_domain_name(name.downcase)
       @host_name = name
       if @config[:host_remove_spaces]
-        @host_name = @host_name.gsub(' ', '')
+        @host_name = @host_name.delete(" ")
       end
-      if host_name =~ /[^[:ascii:]]/
-        @dns_name  = ::SimpleIDN.to_ascii(self.host_name)
+      @dns_name = if /[^[:ascii:]]/.match(host_name)
+        ::SimpleIDN.to_ascii(host_name)
       else
-        @dns_name  = self.host_name
+        host_name
       end
 
       # Subdomain only (root@localhost)
-      if name.index('.').nil?
+      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/
+          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
+        self.tld = tld2.sub(/\A.+\./, "") # co.uk => uk
         if sub_and_domain =~ /\A(.+)\.(.+)\z/ # is subdomain? sub.example [.tld2]
-          self.subdomains        = $1
+          self.subdomains = $1
           self.registration_name = $2
         else
           self.registration_name = sub_and_domain
-          #self.domain_name = sub_and_domain + '.' + self.tld2
+          # self.domain_name = sub_and_domain + '.' + self.tld2
         end
-        self.domain_name = self.registration_name + '.' + self.tld2
-        self.find_provider
+        self.domain_name = registration_name + "." + tld2
+        find_provider
       else # Bad format
         self.subdomains = self.tld = self.tld2 = ""
         self.domain_name = self.registration_name = name
@@ -187,7 +185,7 @@ module EmailAddress
       dn = @config[:address_fqdn_domain]
       if !dn
         if (host_part.nil? || host_part <= " ") && @config[:host_local]
-          'localhost'
+          "localhost"
         else
           host_part
         end
@@ -205,39 +203,37 @@ module EmailAddress
       return false unless registration_name
       find_provider
       return false unless config[:host_match]
-      ! matches?(config[:host_match])
+      !matches?(config[:host_match])
     end
 
     def find_provider # :nodoc:
-      return self.provider if self.provider
+      return provider if provider
 
-      EmailAddress::Config.providers.each do |provider, config|
-        if config[:host_match] && self.matches?(config[:host_match])
-          return self.set_provider(provider, config)
+      Config.providers.each do |provider, config|
+        if config[:host_match] && matches?(config[:host_match])
+          return set_provider(provider, config)
         end
       end
 
-      return self.set_provider(:default) unless self.dns_enabled?
+      return set_provider(:default) unless dns_enabled?
 
-      provider = self.exchangers.provider
-      if provider != :default
-        self.set_provider(provider,
-          EmailAddress::Config.provider(provider))
-      end
-
-      self.provider ||= self.set_provider(:default)
+      self.provider ||= set_provider(:default)
     end
 
-    def set_provider(name, provider_config={}) # :nodoc:
-      self.config = EmailAddress::Config.all_settings(provider_config, @config)
-      self.provider = name
+    def set_provider(name, provider_config = {}) # :nodoc:
+      config.configure(provider_config)
+      @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 }
+      {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,}
+    end
+
+    def hosted_provider
+      Exchanger.cached(dns_name).provider
     end
 
     ############################################################################
@@ -246,19 +242,19 @@ module EmailAddress
 
     # Is this a fully-qualified domain name?
     def fqdn?
-      self.tld ? true : false
+      tld ? true : false
     end
 
     def ip?
-      self.ip_address.nil? ? false : true
+      ip_address.nil? ? false : true
     end
 
     def ipv4?
-      self.ip? && self.ip_address.include?(".")
+      ip? && ip_address.include?(".")
     end
 
     def ipv6?
-      self.ip? && self.ip_address.include?(":")
+      ip? && ip_address.include?(":")
     end
 
     ############################################################################
@@ -276,25 +272,25 @@ module EmailAddress
       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 rule == domain_name || rule == 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)
+        return rule if ip_matches?(rule)
       end
       false
     end
 
     # Does "example." match any tld?
     def registration_name_matches?(rule)
-      "#{self.registration_name}." == rule ? true : false
+      rule == "#{registration_name}."
     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
+      rule.match(/\A\.(.+)\z/) && ($1 == tld || $1 == tld2) ? true : false
     end
 
     def provider_matches?(rule)
@@ -305,20 +301,20 @@ module EmailAddress
     # Requires optionally starts with a "@".
     def domain_matches?(rule)
       rule = $1 if rule =~ /\A@(.+)/
-      return rule if File.fnmatch?(rule, self.domain_name) if self.domain_name
-      return rule if File.fnmatch?(rule, self.dns_name) if self.dns_name
+      return rule if domain_name && File.fnmatch?(rule, domain_name)
+      return rule if dns_name && File.fnmatch?(rule, 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
-      if cidr.include?(":") && self.ip_address.include?(":")
-        return cidr if NetAddr::IPv6Net.parse(cidr).contains(NetAddr::IPv6.parse(self.ip_address))
-      elsif cidr.include?(".") && self.ip_address.include?(".")
-        return cidr if NetAddr::IPv4Net.parse(cidr).contains(NetAddr::IPv4.parse(self.ip_address))
+      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
     end
@@ -329,33 +325,36 @@ module EmailAddress
 
     # True if the :dns_lookup setting is enabled
     def dns_enabled?
-      [:mx, :a].include?(EmailAddress::Config.setting(:host_validation))
+      return false if @config[:dns_lookup] == :off
+      return false if @config[:host_validation] == :syntax
+      true
     end
 
     # 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(self.dns_name)
+      @_dns_a_record ||= Socket.gethostbyname(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.
+    # 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(self.dns_name, @config)
+      # return nil if @config[:host_type] != :email || !self.dns_enabled?
+      @_exchangers ||= Exchanger.cached(dns_name, @config)
     end
 
     # Returns a DNS TXT Record
-    def txt(alternate_host=nil)
+    def txt(alternate_host = nil)
+      return nil unless dns_enabled?
       Resolv::DNS.open do |dns|
         dns.timeouts = @config[:dns_timeout] if @config[:dns_timeout]
         records = begin
-          dns.getresources(alternate_host || self.dns_name,
-                         Resolv::DNS::Resource::IN::TXT)
-        rescue Resolv::ResolvTimeout
-          []
+          dns.getresources(alternate_host || dns_name,
+            Resolv::DNS::Resource::IN::TXT)
+                  rescue Resolv::ResolvTimeout
+                    []
         end
 
         records.empty? ? nil : records.map(&:data).join(" ")
@@ -363,13 +362,13 @@ module EmailAddress
     end
 
     # Parses TXT record pairs into a hash
-    def txt_hash(alternate_host=nil)
+    def txt_hash(alternate_host = nil)
       fields = {}
-      record = self.txt(alternate_host)
+      record = txt(alternate_host)
       return fields unless record
 
       record.split(/\s*;\s*/).each do |pair|
-        (n,v) = pair.split(/\s*=\s*/)
+        (n, v) = pair.split(/\s*=\s*/)
         fields[n.to_sym] = v
       end
       fields
@@ -378,7 +377,7 @@ module EmailAddress
     # Returns a hash of the domain's DMARC (https://en.wikipedia.org/wiki/DMARC)
     # settings.
     def dmarc
-      self.dns_name ? self.txt_hash("_dmarc." + self.dns_name) : {}
+      dns_name ? txt_hash("_dmarc." + dns_name) : {}
     end
 
     ############################################################################
@@ -386,13 +385,13 @@ module EmailAddress
     ############################################################################
 
     # Returns true if the host name is valid according to the current configuration
-    def valid?(rules={})
+    def valid?(rules = {})
       host_validation = rules[:host_validation] || @config[:host_validation] || :mx
-      dns_lookup      = rules[:dns_lookup] || host_validation
+      dns_lookup = rules[:dns_lookup] || host_validation
       self.error_message = nil
-      if self.ip_address
+      if ip_address
         valid_ip?
-      elsif ! valid_format?
+      elsif !valid_format?
         false
       elsif dns_lookup == :connect
         valid_mx? && connect
@@ -407,8 +406,9 @@ module EmailAddress
 
     # True if the host name has a DNS A Record
     def valid_dns?
+      return true unless dns_enabled?
       bool = dns_a_record.size > 0 || set_error(:domain_unknown)
-      if self.localhost? && !@config[:host_local]
+      if localhost? && !@config[:host_local]
         bool = set_error(:domain_no_localhost)
       end
       bool
@@ -416,10 +416,11 @@ module EmailAddress
 
     # True if the host name has valid MX servers configured in DNS
     def valid_mx?
-      if self.exchangers.nil?
+      return true unless dns_enabled?
+      if exchangers.nil?
         set_error(:domain_unknown)
-      elsif self.exchangers.mx_ips.size > 0
-        if self.localhost? && !@config[:host_local]
+      elsif exchangers.mx_ips.size > 0
+        if localhost? && !@config[:host_local]
           set_error(:domain_no_localhost)
         else
           true
@@ -433,9 +434,9 @@ module EmailAddress
 
     # True if the host_name passes Regular Expression match and size limits.
     def valid_format?
-      if self.host_name =~ CANONICAL_HOST_REGEX && self.to_s.size <= MAX_HOST_LENGTH
+      if host_name =~ CANONICAL_HOST_REGEX && to_s.size <= MAX_HOST_LENGTH
         return true if localhost?
-        return true if self.host_name.include?(".") # require FQDN
+        return true if host_name.include?(".") # require FQDN
       end
       set_error(:domain_invalid)
     end
@@ -444,12 +445,12 @@ module EmailAddress
     # is a potentially valid IP address. It does not check if the address
     # is reachable.
     def valid_ip?
-      if ! @config[:host_allow_ip]
+      if !@config[:host_allow_ip]
         bool = set_error(:ip_address_forbidden)
-      elsif self.ip_address.include?(":")
-        bool = self.ip_address =~ Resolv::IPv6::Regex ? true : set_error(:ipv6_address_invalid)
-      elsif self.ip_address.include?(".")
-        bool = self.ip_address =~ Resolv::IPv4::Regex ? true : set_error(:ipv4_address_invalid)
+      elsif ip_address.include?(":")
+        bool = ip_address.match(Resolv::IPv6::Regex) ? true : set_error(:ipv6_address_invalid)
+      elsif ip_address.include?(".")
+        bool = ip_address.match(Resolv::IPv4::Regex) ? true : set_error(:ipv4_address_invalid)
       end
       if bool && (localhost? && !@config[:host_local])
         bool = set_error(:ip_address_no_localhost)
@@ -458,20 +459,20 @@ module EmailAddress
     end
 
     def localhost?
-      if self.ip_address
+      if ip_address
         rel =
-          if self.ip_address.include?(":")
-            NetAddr::IPv6Net.parse(""+"::1").rel(
-              NetAddr::IPv6Net.parse(self.ip_address)
+          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(self.ip_address)
+            NetAddr::IPv4Net.parse("" + "127.0.0.0/8").rel(
+              NetAddr::IPv4Net.parse(ip_address)
             )
           end
         !rel.nil? && rel >= 0
       else
-        self.host_name == 'localhost'
+        host_name == "localhost"
       end
     end
 
@@ -479,33 +480,30 @@ module EmailAddress
     # as an email address check, but is provided to assist in problem resolution.
     # If you abuse this, you *could* be blocked by the ESP.
     def connect
-      begin
-        smtp = Net::SMTP.new(self.host_name || self.ip_address)
-        smtp.start(@config[:helo_name] || 'localhost')
+      smtp = Net::SMTP.new(host_name || ip_address)
+      smtp.start(@config[:helo_name] || "localhost")
+      smtp.finish
+      true
+    rescue Net::SMTPFatalError => e
+      set_error(:server_not_available, e.to_s)
+    rescue SocketError => e
+      set_error(:server_not_available, e.to_s)
+    ensure
+      if smtp&.started?
         smtp.finish
-        true
-      rescue Net::SMTPFatalError => e
-        set_error(:server_not_available, e.to_s)
-      rescue SocketError => e
-        set_error(:server_not_available, e.to_s)
-      ensure
-        if smtp && smtp.started?
-          smtp.finish
-        end
       end
     end
 
-    def set_error(err, reason=nil)
-      @error         = err
-      @reason        = reason
-      @error_message = EmailAddress::Config.error_message(err)
+    def set_error(err, reason = nil)
+      @error = err
+      @reason = reason
+      @error_message = Config.error_message(err)
       false
     end
 
     # The inverse of valid? -- Returns nil (falsey) if valid, otherwise error message
     def error
-      self.valid? ? nil : @error_message
+      valid? ? nil : @error_message
     end
-
   end
 end