email_assessor 0.4.13 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e89762778af30f339adc30aaf6cec13e2d31ab19
-  data.tar.gz: c955f0aa4424bb6b83070baa7aea8e3f92eee78b
+SHA256:
+  metadata.gz: 28e8db711b1571f9f105f0e341b8798bf557edcdd21bfa9af93b97a2fc6e7989
+  data.tar.gz: 697a161767368eed35a1cf12eaca2fc9c129b6e27f4ab48a4bd07362597a678c
 SHA512:
-  metadata.gz: 0e0671fd2e0aa2d3c8abacc0e11a949a71e9107445a0fa77e5377e3cbd6638217351e09eccb79d0abce202fc700bb38484b617c222d4f2e79633a93cf1979d13
-  data.tar.gz: b25571d50af7636c25670c1758d932c52db506759c2624c5c4e3ce917dc4db20aba60cec4005f2b1957b043d9a0fc6ed363b0c4de71548533ae5d4ef0cdbb090
+  metadata.gz: ac12ac0944a707a72b3d7f507b016c0d4dad6cd3cd924c1f229178e8dd806cff1e2bdf4eca887566c2271c15ea4a9210f02b2f6e24e26d768c85e47e73104fdb
+  data.tar.gz: fd148a7343b485d42f320c0e7fcc2265a636f2973faacf3e928d5315c39e8b909c970809c6ebd07b3d929484a2239b33be3c7b2bb38ef0aeb0bd3648e2288db4

data/email_assessor.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 2.4.0"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.4"
   spec.add_runtime_dependency "mail", "~> 2.5"

data/lib/email_assessor/address.rb

@@ -7,6 +7,82 @@ module EmailAssessor
   class Address
     attr_accessor :address
 
+    PROHIBITED_DOMAIN_PREFIXES = [
+      '.',
+      '-',
+    ].freeze
+
+    PROHIBITED_DOMAIN_CONTENT = [
+      '+',
+      '!',
+      '_',
+      '/',
+      ' ',
+      '..',
+      '-.',
+      "'",
+    ].freeze
+
+    PROHIBITED_DOMAIN_SUFFIXES = [
+      # none
+    ].freeze
+
+    PROHIBITED_LOCAL_PREFIXES = [
+      '.',
+    ].freeze
+
+    PROHIBITED_LOCAL_CONTENT = [
+      '..',
+    ].freeze
+
+    PROHIBITED_LOCAL_SUFFIXES = [
+      '.',
+    ].freeze
+
+    class << self
+      def prohibited_domain_regex
+        @prohibited_domain_content_regex ||= make_regex(
+          prefixes: PROHIBITED_DOMAIN_PREFIXES,
+          content: PROHIBITED_DOMAIN_CONTENT,
+          suffixes: PROHIBITED_DOMAIN_SUFFIXES
+        )
+      end
+
+      def prohibited_local_regex
+        @prohibited_local_content_regex ||= make_regex(
+          prefixes: PROHIBITED_LOCAL_PREFIXES,
+          content: PROHIBITED_LOCAL_CONTENT,
+          suffixes: PROHIBITED_LOCAL_SUFFIXES
+        )
+      end
+
+      private
+
+      def make_regex(prefixes: nil, content: nil, suffixes: nil)
+        parts = []
+
+        unless prefixes.nil?
+          prefixes.each do |prefix|
+            parts << "\\A#{Regexp.escape(prefix)}"
+          end
+        end
+
+        unless content.nil?
+          content.each do |prefix|
+            parts << Regexp.escape(prefix)
+          end
+        end
+
+        unless suffixes.nil?
+          suffixes.each do |prefix|
+            parts << "#{Regexp.escape(prefix)}\\z"
+          end
+        end
+
+        Regexp.new(parts.join("|"), Regexp::IGNORECASE)
+      end
+    end
+
     def initialize(address)
       @parse_error = false
       @raw_address = address
@@ -19,18 +95,19 @@ module EmailAssessor
     end
 
     def valid?
+      return @valid unless @valid.nil?
       return false if @parse_error
 
-      if address.domain && address.address == @raw_address
-        domain = address.domain
+      @valid =
+        if address.domain && address.address == @raw_address
+          domain = address.domain
 
-        domain.match?(%r{\.}) && # Valid address domain must contain a period
-          !domain.match?(%r{\.{2,}}) && # Valid address domain cannot have consecutive periods
-          !domain.match?(%r{\A\.}) && # Valid address domain cannot start with a period
-          domain.match?(%r{[a-z]\z}i) # Valid address domain must end with letters
-      else
-        false
-      end
+          domain.include?('.') &&
+            !domain.match?(self.class.prohibited_domain_regex) &&
+            !address.local.match?(self.class.prohibited_local_regex)
+        else
+          false
+        end
     end
 
     def disposable?
@@ -42,15 +119,24 @@ module EmailAssessor
     end
 
     def valid_mx?
-      return false unless valid?
+      valid? && mx_servers.any?
+    end
 
-      mx = []
+    def mx_server_is_in?(domain_list_file)
+      mx_servers.any? do |mx_server|
+        return false unless mx_server.respond_to?(:exchange)
+        mx_server = mx_server.exchange.to_s
 
-      Resolv::DNS.open do |dns|
-        mx.concat dns.getresources(address.domain, Resolv::DNS::Resource::IN::MX)
+        EmailAssessor.domain_in_file?(mx_server, domain_list_file)
       end
+    end
 
-      mx.any?
+    def mx_servers
+      @mx_servers ||= Resolv::DNS.open do |dns|
+        mx_servers = dns.getresources(address.domain, Resolv::DNS::Resource::IN::MX)
+        (mx_servers.any? && mx_servers) ||
+          dns.getresources(address.domain, Resolv::DNS::Resource::IN::A)
+      end
     end
   end
 end

data/lib/email_assessor/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module EmailAssessor
-  VERSION = "0.4.13"
+  VERSION = "0.7.1"
 end

data/lib/email_assessor.rb

@@ -13,14 +13,14 @@ module EmailAssessor
     domain_in_file?(domain, BLACKLISTED_DOMAINS_FILE_NAME)
   end
 
-  protected
-
   def self.domain_in_file?(domain, file_name)
     file_name ||= ""
     domain = domain.downcase
 
-    # Using String#end_with? here would lead to unexpected quirks and false positives.
-    # For instance, hotmail.com is valid but tmail.com is not.
-    File.foreach(file_name).any? { |line| domain.match?(%r{\A(?:.+\.)*?#{line.chomp}\z}i) }
+    File.foreach(file_name, chomp: true).any? do |line|
+      # String#end_with? is used as a cheaper initial check but due to potential false positives
+      # (hotmail.com is valid but tmail.com is not) regex is also necessary.
+      domain.end_with?(line) && domain.match?(%r{\A(?:.*\.)?#{line}\z}i)
+    end
   end
 end

data/pull_mailchecker_emails.rb

@@ -5,16 +5,17 @@ require "yaml"
 
 require "json"
 require "net/http"
+require "set"
 
 whitelisted_domains = %w(poczta.onet.pl fastmail.fm hushmail.com naver.com qq.com nus.edu.sg)
 
 existing_domains = File.readlines("vendor/disposable_domains.txt")
 
-url = "https://raw.githubusercontent.com/FGRibreau/mailchecker/master/list.json"
+url = "https://raw.githubusercontent.com/FGRibreau/mailchecker/master/list.txt"
 resp = Net::HTTP.get_response(URI.parse(url))
 
-remote_domains = JSON.parse(resp.body).flatten - whitelisted_domains
+remote_domains = (resp.body.split("\n")) - whitelisted_domains
 
-result_domains = (existing_domains + remote_domains).map { |domain| domain.strip.downcase }.uniq.sort
+result_domains = SortedSet.new((existing_domains + remote_domains).map! { |domain| domain.strip.downcase })
 
-File.open("vendor/disposable_domains.txt", "w") { |f| f.write result_domains.join("\n") }
+File.open("vendor/disposable_domains.txt", "w") { |f| f.write result_domains.to_a.join("\n") }

data/spec/email_assessor_spec.rb

@@ -32,55 +32,107 @@ describe EmailAssessor do
   describe "basic validation" do
     subject(:user) { plain_user }
 
-    it "should be valid when email is empty" do
+    it "is valid when email is empty" do
       is_expected.to be_valid
     end
 
-    it "should not be valid when domain is missing" do
+    it "is invalid if the address starts with a dot" do
+      user = TestUser.new(email: ".foo@bar.com")
+      expect(user.valid?).to be_falsey
+    end
+
+    it "is invalid if the address contains consecutive dots" do
+      user = TestUser.new(email: "foo..bar@gmail.com")
+      expect(user.valid?).to be_falsey
+    end
+
+    it "is invalid if the address ends with a dot" do
+      user = TestUser.new(email: "foo.@bar.com")
+      expect(user.valid?).to be_falsey
+    end
+
+    it "is invalid when domain is missing" do
       user.email = "foo@.com"
       is_expected.to be_invalid
     end
 
-    it "should be invalid when email is malformed" do
+    it "is invalid when domain starts with a dot" do
+      user.email = "foo@.example.com"
+      is_expected.to be_invalid
+    end
+
+    it "is invalid when email is malformed" do
       user.email = "foo@bar"
       is_expected.to be_invalid
     end
 
-    it "should be invalid when email contains a trailing symbol" do
+    it "is invalid when email contains a trailing symbol" do
       user.email = "foo@bar.com/"
       is_expected.to be_invalid
     end
 
-    it "should be invalid if Mail::AddressListsParser raises exception" do
+    it "is invalid if Mail::AddressListsParser raises exception" do
       allow(Mail::Address).to receive(:new).and_raise(Mail::Field::ParseError.new(nil, nil, nil))
       user.email = "foo@gmail.com"
       is_expected.to be_invalid
     end
 
-    it "shouldn't be valid if the domain constains consecutives dots" do
+    it "is invalid if the domain constains consecutives dots" do
       user.email = "foo@bar..com"
       is_expected.to be_invalid
     end
+
+    it "is invalid if the domain contains emoticons" do
+      user.email = "foo🙈@gmail.com"
+      is_expected.to be_invalid
+    end
+
+    it "is invalid if the domain contains spaces" do
+      user.email = "user@gmail .com"
+      is_expected.to be_invalid
+    end
+
+    it "is invalid if the domain contains '.@'" do
+      user.email = "foo.@gmail.com"
+      expect(user.valid?).to be_falsy
+    end
+
+    it "is invalid if the domain begins with a hyphen" do
+      user.email = "foo@-gmail.com"
+      expect(user.valid?).to be_falsy
+    end
+
+    it "is invalid if the domain name ends with a hyphen" do
+      user.email = "foo@gmail-.com"
+      expect(user.valid?).to be_falsy
+    end
+
+    %w[+ _ ! / \  '].each do |invalid_character|
+      it "is invalid if domain contains a \"#{invalid_character}\" character" do
+        user.email = "foo@google#{invalid_character}yahoo.com"
+        is_expected.to be_invalid
+      end
+    end
   end
 
   describe "disposable domains" do
     subject(:user) { disposable_user }
 
-    it "should be valid when email is not in the list of disposable domains" do
+    it "is valid when email is not in the list of disposable domains" do
       is_expected.to be_valid
     end
 
-    it "should be invalid when email is in the list of disposable domains" do
+    it "is invalid when email is in the list of disposable domains" do
       user.email = "foo@#{disposable_domain}"
       is_expected.to be_invalid
     end
 
-    it "should be invalid when email is in the list of disposable domains regardless of case" do
+    it "is invalid when email is in the list of disposable domains regardless of case" do
       user.email = "foo@#{disposable_domain.upcase}"
       is_expected.to be_invalid
     end
 
-    it "should be invalid when email is in the list of disposable domains regardless of subdomain" do
+    it "is invalid when email is in the list of disposable domains regardless of subdomain" do
       user.email = "foo@abc123.#{disposable_domain}"
       is_expected.to be_invalid
     end
@@ -89,21 +141,21 @@ describe EmailAssessor do
   describe "blacklisted domains" do
     subject(:user) { blacklist_user }
 
-    it "should be valid when email domain is not in the blacklist" do
+    it "is valid when email domain is not in the blacklist" do
       is_expected.to be_valid
     end
 
-    it "should be invalid when email domain is in the blacklist" do
+    it "is invalid when email domain is in the blacklist" do
       user.email = "foo@#{blacklisted_domain}"
       is_expected.to be_invalid
     end
 
-    it "should be invalid when email is in the blacklist regardless of case" do
+    it "is invalid when email is in the blacklist regardless of case" do
       user.email = "foo@#{blacklisted_domain.upcase}"
       is_expected.to be_invalid
     end
 
-    it "should be invalid when email domain is in the blacklist regardless of subdomain" do
+    it "is invalid when email domain is in the blacklist regardless of subdomain" do
       user.email = "foo@abc123.#{blacklisted_domain}"
       is_expected.to be_invalid
     end
@@ -112,11 +164,11 @@ describe EmailAssessor do
   describe "mx lookup" do
     subject(:user) { mx_user }
 
-    it "should be valid if mx records are found" do
+    it "is valid if mx records are found" do
       is_expected.to be_valid
     end
 
-    it "should be invalid if no mx records are found" do
+    it "is invalid if no mx records are found" do
       user.email = "foo@subdomain.gmail.com"
       is_expected.to be_invalid
     end