lib/truemail/configuration.rb in truemail-2.3.4 vs lib/truemail/configuration.rb in truemail-2.4.0

@@ -13,17 +13,18 @@
       connection_timeout
       response_timeout
       connection_attempts
       whitelisted_domains
       blacklisted_domains
+      blacklisted_mx_ip_addresses
+      dns
     ].freeze
 
     attr_reader :verifier_email,
                 :verifier_domain,
                 :default_validation_type,
                 :validation_type_by_domain,
-                :dns,
                 :logger,
                 *Truemail::Configuration::SETTERS
 
     attr_accessor :whitelist_validation, :not_rfc_mx_lookup_flow, :smtp_fail_fast, :smtp_safe_check
 
@@ -53,30 +54,25 @@
     def validation_type_for=(settings)
       validate_validation_type(settings)
       validation_type_by_domain.merge!(settings)
     end
 
-    def argument_consistent?(argument)
+    def argument_consistent?(method, argument)
       case argument
-      when ::Array then check_domain_list(argument)
+      when ::Array then items_match_regex?(argument, regex_by_method(method))
       when ::Integer then argument.positive?
       when ::Regexp then true
       end
     end
 
     Truemail::Configuration::SETTERS.each do |method|
       define_method("#{method}=") do |argument|
-        raise_unless(argument, __method__, argument_consistent?(argument))
+        raise_unless(argument, __method__, argument_consistent?(method, argument))
         instance_variable_set(:"@#{method}", argument)
       end
     end
 
-    def dns=(argument)
-      raise_unless(argument, __method__, argument.is_a?(::Array) && check_dns_settings(argument))
-      @dns = argument
-    end
-
     def logger=(options)
       tracking_event, stdout, log_absolute_path = logger_options(options)
       valid_event = Truemail::Log::Event::TRACKING_EVENTS.key?(tracking_event)
       stdout_only = stdout && log_absolute_path.nil?
       file_only = log_absolute_path.is_a?(::String)
@@ -102,10 +98,11 @@
         default_validation_type: Truemail::Configuration::DEFAULT_VALIDATION_TYPE,
         validation_type_by_domain: {},
         whitelisted_domains: [],
         whitelist_validation: false,
         blacklisted_domains: [],
+        blacklisted_mx_ip_addresses: [],
         dns: [],
         not_rfc_mx_lookup_flow: false,
         smtp_fail_fast: false,
         smtp_safe_check: false
       }
@@ -113,44 +110,42 @@
 
     def raise_unless(argument_context, argument_name, condition)
       raise Truemail::ArgumentError.new(argument_context, argument_name) unless condition
     end
 
+    def match_regex?(regex_pattern, object)
+      regex_pattern.match?(object.to_s)
+    end
+
     def validate_arguments(argument, method)
-      constant = Truemail::RegexConstant.const_get("regex_#{method[/\A.+_(.+)=\z/, 1]}_pattern".upcase)
-      raise_unless(argument, method, constant.match?(argument.to_s))
+      regex_pattern = Truemail::RegexConstant.const_get("regex_#{method[/\A.+_(.+)=\z/, 1]}_pattern".upcase)
+      raise_unless(argument, method, match_regex?(regex_pattern, argument))
     end
 
     def default_verifier_domain
       self.verifier_domain ||= verifier_email[Truemail::RegexConstant::REGEX_EMAIL_PATTERN, 3]
     end
 
-    def domain_matcher
-      ->(domain) { Truemail::RegexConstant::REGEX_DOMAIN_PATTERN.match?(domain.to_s) }
+    def regex_by_method(method)
+      return Truemail::RegexConstant::REGEX_IP_ADDRESS_PATTERN if method.eql?(:blacklisted_mx_ip_addresses)
+      return Truemail::RegexConstant::REGEX_DNS_SERVER_ADDRESS_PATTERN if method.eql?(:dns)
+      Truemail::RegexConstant::REGEX_DOMAIN_PATTERN
     end
 
-    def check_domain(domain)
-      raise_unless(domain, 'domain', domain_matcher.call(domain))
+    def items_match_regex?(items, regex_pattern)
+      items.all? { |item| match_regex?(regex_pattern, item) }
     end
 
-    def check_domain_list(domains)
-      domains.all?(&domain_matcher)
-    end
-
     def check_validation_type(validation_type)
       raise_unless(validation_type, 'validation type', Truemail::Validator::VALIDATION_TYPES.include?(validation_type))
     end
 
     def validate_validation_type(settings)
       raise_unless(settings, 'hash with settings', settings.is_a?(::Hash))
       settings.each do |domain, validation_type|
-        check_domain(domain)
+        raise_unless(domain, 'domain', match_regex?(Truemail::RegexConstant::REGEX_DOMAIN_PATTERN, domain))
         check_validation_type(validation_type)
       end
-    end
-
-    def check_dns_settings(dns_servers)
-      dns_servers.all? { |dns_server| Truemail::RegexConstant::REGEX_DNS_SERVER_ADDRESS_PATTERN.match?(dns_server.to_s) }
     end
 
     def logger_options(current_options)
       Truemail::Configuration::DEFAULT_LOGGER_OPTIONS.merge(current_options).values
     end