email_inquire 0.9.0 → 0.10.0

data/lib/email_inquire/helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EmailInquire
+  module Helper
+
+    extend self
+
+    def first_value(array, &block)
+      array.lazy.map(&block).find(&:itself)
+    end
+
+  end
+end

data/lib/email_inquire/inquirer.rb

@@ -1,181 +1,55 @@
 # frozen_string_literal: true
 
-require "damerau-levenshtein"
-require "set"
+require "email_inquire/helper"
+require "email_inquire/response"
+require "email_inquire/validator/common_provider"
+require "email_inquire/validator/common_provider_mistake"
+require "email_inquire/validator/commonly_mistaken_domain"
+require "email_inquire/validator/commonly_mistaken_tld"
+require "email_inquire/validator/country_code_tld"
+require "email_inquire/validator/custom_invalid_domain"
+require "email_inquire/validator/custom_valid_domain"
+require "email_inquire/validator/email_format"
+require "email_inquire/validator/known_invalid_domain"
+require "email_inquire/validator/one_time_provider"
+require "email_inquire/validator/unique_domain_provider"
 
 module EmailInquire
   class Inquirer
 
-    class << self
-
-      private
-
-      def load_data(filename)
-        data = File.read("#{__dir__}/../../data/#{filename}.txt")
-        lines = data.split("\n")
-        lines.reject! { |line| line[0] == "#" }
-
-        lines.to_set
-      end
-
-    end
-
     def initialize(email)
-      @email = email.downcase
-
-      parse_email
-    end
-
-    attr_reader :domain, :email, :name
-
-    VALIDATORS = %i[
-      validate_custom_valid_domains
-      validate_common_domains
-      validate_one_time_providers
-      validate_known_invalid_domains
-      validate_custom_invalid_domains
-      validate_common_domain_mistakes
-      validate_cc_tld
-      validate_common_tld_mistakes
-      validate_domains_with_unique_tld
-    ].freeze
-
-    def validate
-      email_validator = EmailValidator.new(email)
-      unless email_validator.valid?
-        response.invalid!
-        return response
-      end
-
-      VALIDATORS.each do |validator|
-        send(validator)
-        break if response.valid? || response.invalid?
-      end
-
-      # default
-      response.valid! unless response.status?
-
-      response
-    end
-
-    private
-
-    def parse_email
-      @name, @domain = email.split("@")
-    end
-
-    def response
-      @response ||=
-        Response.new.tap do |response|
-          response.email = email
-        end
-    end
-
-    COMMON_DOMAIN_MISTAKES = {
-      /google(?!mail)/ => "gmail.com",
-      /windows.*\.com/ => "live.com",
-    }.freeze
-
-    def validate_common_domain_mistakes
-      COMMON_DOMAIN_MISTAKES.each do |mistake, reference|
-        break if domain == reference # valid!
-
-        if mistake =~ domain
-          response.hint!(domain: reference)
-          break
-        end
-      end
+      @email = email&.downcase
     end
 
-    COMMON_DOMAINS = load_data("common_providers").freeze
-
-    def validate_common_domains
-      return response.valid! if COMMON_DOMAINS.include?(domain)
+    attr_reader :email
 
-      COMMON_DOMAINS.each do |reference|
-        distance = ::DamerauLevenshtein.distance(domain, reference, 2, 3)
-        if distance <= 1
-          response.hint!(domain: reference)
-          break
-        end
-      end
-    end
+    VALIDATORS = [
+      # Format first
+      EmailInquire::Validator::EmailFormat,
 
-    COMMON_TLD_MISTAKES = {
-      ".combr" => ".com.br",
-      ".cojp" => ".co.jp",
-      ".couk" => ".co.uk",
-      ".com.com" => ".com",
-    }.freeze
+      # Custom overrides
+      EmailInquire::Validator::CustomValidDomain,
+      EmailInquire::Validator::CustomInvalidDomain,
 
-    def validate_common_tld_mistakes
-      COMMON_TLD_MISTAKES.each do |mistake, reference|
-        break if !mistake.end_with?(reference) && domain.end_with?(reference)
+      # Always valid domains
+      EmailInquire::Validator::CommonProvider,
 
-        if domain.end_with?(mistake)
-          response.hint!(domain: domain.gsub(/#{mistake}\z/, reference))
-          break
-        end
-      end
-    end
+      # Invalid domains
+      EmailInquire::Validator::KnownInvalidDomain,
+      EmailInquire::Validator::OneTimeProvider,
 
-    VALID_CC_TLDS = [
-      [".jp", ".co.jp", load_data("jp_tld").freeze],
-      [".uk", ".co.uk", load_data("uk_tld").freeze],
-      [".br", ".com.br", load_data("br_tld").freeze],
+      # Hints
+      EmailInquire::Validator::CommonProviderMistake,
+      EmailInquire::Validator::CommonlyMistakenDomain,
+      EmailInquire::Validator::CommonlyMistakenTld,
+      EmailInquire::Validator::CountryCodeTld,
+      EmailInquire::Validator::UniqueDomainProvider,
     ].freeze
 
-    def validate_cc_tld
-      VALID_CC_TLDS.each do |tld, sld, valid_tlds|
-        next unless domain.end_with?(tld)
-
-        next if valid_tlds.any? do |reference|
-          domain.end_with?(reference)
-        end
-
-        _, com, tld_without_dot = sld.split(".")
-
-        new_domain = domain.dup
-        new_domain.gsub!(/\.[a-z]{2,#{com.length}}\.#{tld_without_dot}\z/, sld)
-        new_domain.gsub!(/(?<!\.)#{com}\.#{tld_without_dot}\z/, sld)
-        new_domain.gsub!(/(?<!\.#{com})\.#{tld_without_dot}\z/, sld)
-        response.hint!(domain: new_domain) if new_domain != domain
-      end
-    end
-
-    UNIQUE_TLD_DOMAINS = load_data("unique_domain_providers").freeze
-
-    def validate_domains_with_unique_tld
-      base, tld = domain.split(".")
-
-      UNIQUE_TLD_DOMAINS.each do |reference|
-        reference_base, reference_tld = reference.split(".")
-
-        if base == reference_base && tld != reference_tld
-          response.hint!(domain: reference)
-          break
-        end
-      end
-    end
-
-    ONE_TIME_EMAIL_PROVIDERS = load_data("one_time_email_providers").freeze
-
-    def validate_one_time_providers
-      response.invalid! if ONE_TIME_EMAIL_PROVIDERS.include?(domain)
-    end
-
-    KNOWN_INVALID_DOMAINS = load_data("known_invalid_domains").freeze
-
-    def validate_known_invalid_domains
-      response.invalid! if KNOWN_INVALID_DOMAINS.include?(domain)
-    end
-
-    def validate_custom_invalid_domains
-      response.invalid! if EmailInquire.custom_invalid_domains.include?(domain)
-    end
+    def validate
+      response = Helper.first_value(VALIDATORS) { |validator| validator.validate(email) }
 
-    def validate_custom_valid_domains
-      response.valid! if EmailInquire.custom_valid_domains.include?(domain)
+      response || Response.new(email: email).valid!
     end
 
   end

data/lib/email_inquire/response.rb

@@ -3,25 +3,34 @@
 module EmailInquire
   class Response
 
-    attr_accessor :email, :replacement, :status
+    attr_reader :email
+    attr_accessor :replacement, :status
 
-    def hint!(domain: nil)
+    def initialize(email:)
+      @email = email
+    end
+
+    def hint!(domain:)
       self.status = :hint
 
       old_name, _old_domain = email.split("@")
-      self.replacement = "#{old_name}@#{domain}" if domain
+      self.replacement = "#{old_name}@#{domain}"
+
+      self
     end
 
     def hint?
-      status == :hint
+      status.equal?(:hint)
     end
 
     def invalid!
       self.status = :invalid
+
+      self
     end
 
     def invalid?
-      status == :invalid
+      status.equal?(:invalid)
     end
 
     def status?
@@ -30,10 +39,12 @@ module EmailInquire
 
     def valid!
       self.status = :valid
+
+      self
     end
 
     def valid?
-      status == :valid
+      status.equal?(:valid)
     end
 
   end

data/lib/email_inquire/validator/base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "set"
+require "email_inquire/response"
+
+module EmailInquire
+  module Validator
+    class Base
+
+      class << self
+
+        def validate(email)
+          new(email).validate
+        end
+
+        private :new
+
+        private
+
+        def load_data(filename)
+          data = File.read("#{__dir__}/../../../data/#{filename}.txt")
+          lines = data.split("\n")
+          lines.reject! { |line| line[0] == "#" }
+
+          lines.to_set
+        end
+
+      end
+
+      def initialize(email)
+        @email = email
+        @name, @domain = email&.split("@", 2)
+      end
+
+      attr_reader :domain, :email, :name
+
+      def validate
+        raise NotImplementedError
+      end
+
+      private
+
+      def response
+        @response ||= Response.new(email: email)
+      end
+
+    end
+  end
+end

data/lib/email_inquire/validator/common_provider.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "damerau-levenshtein"
+require "email_inquire/validator/base"
+
+module EmailInquire
+  module Validator
+    class CommonProvider < Base
+
+      DOMAINS = load_data("common_providers").freeze
+
+      def validate
+        response.valid! if DOMAINS.include?(domain)
+      end
+
+    end
+  end
+end

data/lib/email_inquire/validator/common_provider_mistake.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "damerau-levenshtein"
+require "email_inquire/validator/base"
+require "email_inquire/validator/common_provider"
+
+module EmailInquire
+  module Validator
+    class CommonProviderMistake < Base
+
+      def validate
+        return if CommonProvider::DOMAINS.include?(domain)
+
+        replacement_domain =
+          CommonProvider::DOMAINS.find do |reference|
+            distance = DamerauLevenshtein.distance(domain, reference)
+
+            distance.equal?(1)
+          end
+
+        response.hint!(domain: replacement_domain) if replacement_domain
+      end
+
+    end
+  end
+end

data/lib/email_inquire/validator/commonly_mistaken_domain.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "email_inquire/validator/base"
+
+module EmailInquire
+  module Validator
+    class CommonlyMistakenDomain < Base
+
+      MISTAKES = {
+        /google(?!mail)/ => "gmail.com",
+        /windows.*\.com/ => "live.com",
+      }.freeze
+
+      def validate
+        return response.valid! if MISTAKES.value?(domain)
+
+        _mistake, reference =
+          MISTAKES.find do |mistake, _reference|
+            mistake =~ domain
+          end
+
+        response.hint!(domain: reference) if reference
+      end
+
+    end
+  end
+end

data/lib/email_inquire/validator/commonly_mistaken_tld.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "email_inquire/validator/base"
+
+module EmailInquire
+  module Validator
+    class CommonlyMistakenTld < Base
+
+      MISTAKES = {
+        ".combr" => ".com.br",
+        ".cojp" => ".co.jp",
+        ".couk" => ".co.uk",
+        ".com.com" => ".com",
+      }.freeze
+
+      def validate
+        mistake, reference =
+          MISTAKES.find do |mistake, reference|
+            next if !mistake.end_with?(reference) && domain.end_with?(reference)
+
+            domain.end_with?(mistake)
+          end
+
+        response.hint!(domain: domain.sub(/#{mistake}\z/, reference)) if reference
+      end
+
+    end
+  end
+end

data/lib/email_inquire/validator/country_code_tld.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "email_inquire/helper"
+require "email_inquire/validator/base"
+require "email_inquire/validator/common_provider"
+
+module EmailInquire
+  module Validator
+    class CountryCodeTld < Base
+
+      COUNTRY_CODE_TLDS = [
+        # TLD, generic com, all generic, registration with TLD only is possible
+        ["jp", "co", load_data("country_code_tld/jp").freeze, true].freeze,
+        ["uk", "co", load_data("country_code_tld/uk").freeze, true].freeze,
+        ["br", "com", load_data("country_code_tld/br").freeze, true].freeze,
+      ].freeze
+
+      def initialize(email)
+        super(email)
+
+        *@rest, @sld, @tld = domain.split(".")
+      end
+
+      def validate
+        Helper.first_value(
+          COUNTRY_CODE_TLDS
+        ) do |cctld, generic_com, all_generics, registration_with_cctld|
+          validate_cctld(cctld, generic_com, all_generics, registration_with_cctld)
+        end
+      end
+
+      private
+
+      attr_reader :rest, :sld, :tld
+
+      def hint_for_approx_cctld(cctld, all_generics)
+        matching_generic = all_generics.find { |generic| tld.eql?("#{generic}#{cctld}") }
+        return unless matching_generic
+
+        replacement = [*rest, sld, matching_generic, cctld].join(".")
+        response.hint!(domain: replacement)
+      end
+
+      def hint_for_common_provider(cctld, generic_com)
+        provider_domain = [
+          sld,
+          generic_com,
+          cctld,
+        ].join(".")
+
+        return unless CommonProvider::DOMAINS.include?(provider_domain)
+
+        response.hint!(domain: provider_domain)
+      end
+
+      def hint_for_generic_com(cctld, generic_com)
+        replacement = [
+          *rest,
+          (sld if sld.length > 2),
+          generic_com,
+          cctld,
+        ].compact.join(".")
+
+        response.hint!(domain: replacement)
+      end
+
+      def hint_for_generic_at_end_of_sld(cctld, all_generics)
+        generic_at_end_of_sld = all_generics.find { |generic| sld.end_with?(generic) }
+        return unless generic_at_end_of_sld
+
+        replacement = [
+          *rest,
+          sld.sub(/#{generic_at_end_of_sld}\z/, ""),
+          generic_at_end_of_sld,
+          cctld,
+        ].join(".")
+
+        response.hint!(domain: replacement)
+      end
+
+      def validate_cctld(cctld, generic_com, all_generics, registration_with_cctld)
+        return hint_for_approx_cctld(cctld, all_generics) unless tld.eql?(cctld)
+
+        if all_generics.include?(sld)
+          return response.invalid! if rest.empty?
+
+          return
+        end
+
+        (
+          hint_for_generic_at_end_of_sld(cctld, all_generics) ||
+          hint_for_common_provider(cctld, generic_com)
+        ).tap do |hint|
+          return hint if hint
+        end
+
+        hint_for_generic_com(cctld, generic_com) if sld.length <= 2 || !registration_with_cctld
+      end
+
+    end
+  end
+end