validators 3.0.5 → 3.3.0

data/lib/validators.rb

@@ -8,6 +8,9 @@ module Validators
   require "validators/tld"
   require "validators/hostname"
   require "validators/disposable_hostnames"
+  require "validators/disposable_emails"
+  require "validators/reserved_subdomains"
+
   require "validators/validates_datetime"
   require "validators/validates_ip_address"
   require "validators/validates_email_format_of"
@@ -18,4 +21,8 @@ module Validators
   require "validators/validates_ssh_private_key"
   require "validators/validates_ssh_public_key"
   require "validators/validates_hostname_format_of"
+  require "validators/validates_subdomain"
+  require "validators/validates_username"
+
+  I18n.load_path += Dir[File.join(__dir__, "validators/locale/*.yml")]
 end

data/lib/validators/constants.rb

@@ -2,7 +2,7 @@
 
 module Validators
   EMAIL_FORMAT = /\A[a-z0-9]+([-._][a-z0-9]+)*(\+[^@]+)?@[a-z0-9]+([.-][a-z0-9]+)*\.[a-z]{2,}\z/i.freeze
-  MICROSOFT_EMAIL_FORMAT = /\A[\w][\w\d._-]*[\w\d_-]+(\+[\w\d]+)?@(hotmail|outlook).com\z/i.freeze
+  MICROSOFT_EMAIL_FORMAT = /\A[a-z0-9][a-z0-9._-]*[a-z0-9_-]+(\+[a-z0-9]+)?@(hotmail|outlook).com\z/i.freeze
 
   # Source: https://github.com/henrik/validates_url_format_of
   IPV4_PART = /\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]/.freeze # 0-255

data/lib/validators/disposable_emails.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Validators
+  class DisposableEmails
+    FILE_PATH = File.expand_path("../../data/disposable_emails.txt", __dir__)
+
+    def self.all
+      @all ||= File.read(FILE_PATH).lines.map(&:chomp)
+    end
+
+    def self.include?(email)
+      mailbox, domain = email.to_s.split("@")
+      mailbox = mailbox.to_s.gsub(".", "")
+      mailbox = mailbox.gsub(/\+(.+)?\Z/, "")
+
+      all.include?("#{mailbox}@#{domain}")
+    end
+  end
+end

data/lib/validators/disposable_hostnames.rb

@@ -2,10 +2,10 @@
 
 module Validators
   class DisposableHostnames
-    FILE_PATH = File.expand_path("../../data/disposable.json", __dir__)
+    FILE_PATH = File.expand_path("../../data/disposable_domains.txt", __dir__)
 
     def self.all
-      @all ||= JSON.parse(File.read(FILE_PATH))
+      @all ||= File.read(FILE_PATH).lines.map(&:chomp)
     end
   end
 end

data/lib/validators/locale/en.yml

@@ -0,0 +1,30 @@
+---
+en:
+  activemodel: &activemodel
+    errors:
+      messages:
+        disposable_email: "is not allowed (high-bounce email)"
+        disposable_domain: "is not allowed (high-bounce domain)"
+        invalid_cnpj: "is not a valid CNPJ"
+        invalid_cpf: "is not a valid CPF"
+        invalid_date: "is not a valid date"
+        invalid_date_after: "needs to be after %{date}"
+        invalid_date_before: "needs to be before %{date}"
+        invalid_email: "is not a valid address"
+        invalid_hostname: "does not have a valid hostname"
+        invalid_ip_address: "is not a valid IP address"
+        invalid_ipv4_address: "is not a valid IPv4 address"
+        invalid_ipv6_address: "is not a valid IPv6 address"
+        invalid_owner: "is not associated with your user"
+        invalid_ssh_private_key: "is not a valid private SSH key"
+        invalid_ssh_private_key_bits: "needs to be at least %{required} bits; got %{value} bits instead"
+        invalid_ssh_private_key_type: "must be a %{value} key"
+        invalid_ssh_public_key: "is not a valid public SSH key"
+        invalid_url: "is not a valid address"
+        reserved_subdomain: "%{value} is a reserved subdomain"
+        invalid_subdomain: "is invalid"
+        reserved_username: "%{value} is a reserved username"
+        invalid_username: "is invalid"
+
+  activerecord:
+    <<: *activemodel

data/lib/validators/locale/pt-BR.yml

@@ -0,0 +1,28 @@
+---
+pt-BR:
+  activemodel: &activemodel
+    errors:
+      messages:
+        disposable_email: "não é permitido (e-mail temporário)"
+        disposable_domain: "não é permitido (e-mail temporário)"
+        invalid_cnpj: "não é um CNPJ válido"
+        invalid_cpf: "não é um CPF válido"
+        invalid_date: "não é uma data válida"
+        invalid_date_after: "precisa ser depois de %{date}"
+        invalid_date_before: "precisa ser antes de %{date}"
+        invalid_email: "não parece ser um e-mail válido"
+        invalid_hostname: "não é um hostname válido"
+        invalid_ip_address: "não é um endereço IP válido"
+        invalid_ipv4_address: "não é um endereço IPv4 válido"
+        invalid_ipv6_address: "não é um endereço IPv6 válido"
+        invalid_owner: "não está associado ao seu usuário"
+        invalid_ssh_private_key: "não é uma chave privada de SSH válida"
+        invalid_ssh_private_key_bits: "precisa ter pelo menos %{required} bits; a sua chave tem %{value} bits"
+        invalid_ssh_private_key_type: "precisa ser uma chave %{value}"
+        invalid_ssh_public_key: "não é uma chave pública de SSH válida"
+        invalid_url: "não parece ser uma URL válida"
+        reserved_hostname: "%{value} é um hostname reservado"
+        reserved_username: "%{value} é nome de usuário reservado"
+
+  activerecord:
+    <<: *activemodel

data/lib/validators/reserved_subdomains.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Validators
+  class ReservedSubdomains
+    FILE_PATH = File.expand_path("../../data/reserved_subdomains.txt", __dir__)
+
+    def self.reserved?(hostname, matchers = nil)
+      matchers = parse_list(matchers) if matchers
+      matchers ||= all
+      match_any?(matchers, hostname)
+    end
+
+    def self.all
+      @all ||= File.read(FILE_PATH).lines.map {|matcher| parse(matcher.chomp) }
+    end
+
+    def self.parse(matcher)
+      return matcher unless matcher.start_with?("/")
+
+      Regexp.compile(matcher[%r{/(.*?)/}, 1])
+    end
+
+    def self.parse_list(matchers)
+      matchers.map {|matcher| parse(matcher) }
+    end
+
+    def self.match_any?(matchers, hostname)
+      hostname = normalize(hostname)
+      matchers.any? {|matcher| match?(matcher, hostname) }
+    end
+
+    def self.normalize(hostname)
+      hostname.downcase.gsub(/[_-]/, "")
+    end
+
+    def self.match?(matcher, hostname)
+      case matcher
+      when String
+        matcher == hostname
+      when Regexp
+        hostname =~ matcher
+      else
+        raise "Unknown matcher type: #{matcher.class}"
+      end
+    end
+  end
+end

data/lib/validators/tld.rb

@@ -2,10 +2,10 @@
 
 module Validators
   class TLD
-    FILE_PATH = File.expand_path("../../data/tld.json", __dir__)
+    FILE_PATH = File.expand_path("../../data/tld.txt", __dir__)
 
     def self.all
-      @all ||= JSON.parse(File.read(FILE_PATH))
+      @all ||= File.read(FILE_PATH).lines.map(&:chomp)
     end
 
     def self.host_with_valid_tld?(host)

data/lib/validators/validates_email_format_of.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "root_domain"
+
 module ActiveModel
   module Validations
     class EmailValidator < EachValidator
@@ -14,6 +16,7 @@ module ActiveModel
 
         validate_tld(record, attribute, value, options) if check_tld
         validate_email_format(record, attribute, value, options)
+        validate_disposable_domain(record, attribute, value, options) unless allow_disposable
         validate_disposable_email(record, attribute, value, options) unless allow_disposable
       end
 
@@ -41,12 +44,24 @@ module ActiveModel
         )
       end
 
-      def validate_disposable_email(record, attribute, value, _options)
+      def validate_disposable_domain(record, attribute, value, _options)
+        return unless value
+
         hostname = value.to_s.split(AT_SIGN).last.to_s.downcase
+        root_domain = RootDomain.call(hostname)
 
-        return if Validators::DisposableHostnames.all.none? do |disposable_hostname|
-          hostname == disposable_hostname || hostname.end_with?(".#{disposable_hostname}")
-        end
+        return unless Validators::DisposableHostnames.all.include?(root_domain)
+
+        record.errors.add(
+          attribute,
+          :disposable_domain,
+          value: value
+        )
+      end
+
+      def validate_disposable_email(record, attribute, value, _options)
+        return unless value
+        return unless Validators::DisposableEmails.include?(value)
 
         record.errors.add(
           attribute,

data/lib/validators/validates_subdomain.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class SubdomainValidator < EachValidator
+      def validate_each(record, attribute, value)
+        return if value.blank? && options[:allow_blank]
+        return if value.nil? && options[:allow_nil]
+
+        value = value.to_s
+
+        validate_reserved_subdomain(record, attribute, value)
+        validate_format(record, attribute, value)
+      end
+
+      def reserved?(subdomain)
+        ::Validators::ReservedSubdomains.reserved?(subdomain, options[:in])
+      end
+
+      def validate_reserved_subdomain(record, attribute, value)
+        return unless options.fetch(:reserved, true)
+        return unless reserved?(value)
+
+        record.errors.add(
+          attribute,
+          :"reserved_#{options[:error_name]}",
+          message: options[:message],
+          value: value
+        )
+      end
+
+      def validate_format(record, attribute, value)
+        return if Validators::Hostname.valid_label?(value)
+
+        record.errors.add(
+          attribute,
+          :"invalid_#{options[:error_name]}",
+          message: options[:message],
+          value: value
+        )
+      end
+    end
+
+    module ClassMethods
+      # Validates whether or not the specified host label is valid.
+      # The `in: array` can have strings and patterns. A pattern is everything
+      # that starts with `/` and will be parsed as a regular expression.
+      #
+      # Notice that subdomains will be normalized; it'll be downcased and have
+      # its underscores and hyphens stripped before validating.
+      #
+      #   class User < ActiveRecord::Base
+      #     # Validates format and rejects reserved subdomains.
+      #     validates_subdomain :subdomain
+      #
+      #     # Validates against a custom list.
+      #     validates_subdomain :subdomain, in: %w[www]
+      #
+      #     # Rejects reserved domains validation.
+      #     validates_subdomain :subdomain, reserved: false
+      #   end
+      #
+      def validates_subdomain(*attr_names)
+        options = _merge_attributes(attr_names).merge(error_name: :subdomain)
+        validates_with SubdomainValidator, options
+      end
+    end
+  end
+end

data/lib/validators/validates_username.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class UsernameValidator < SubdomainValidator
+    end
+
+    module ClassMethods
+      def validates_username(*attr_names)
+        options = _merge_attributes(attr_names).merge(error_name: :username)
+        validates_with UsernameValidator, options
+      end
+    end
+  end
+end

data/lib/validators/version.rb

@@ -3,8 +3,8 @@
 module Validators
   module Version
     MAJOR = 3
-    MINOR = 0
-    PATCH = 5
+    MINOR = 3
+    PATCH = 0
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

data/test/support/models.rb

@@ -1,5 +1,17 @@
 # frozen_string_literal: true
 
+def build_model(&block)
+  Class.new do
+    include ActiveModel::Model
+
+    def self.name
+      "SomeModel"
+    end
+
+    instance_eval(&block)
+  end
+end
+
 class User < ActiveRecord::Base
   has_many :tasks
   has_many :categories

data/test/test_helper.rb

@@ -1,16 +1,9 @@
 # frozen_string_literal: true
 
-require "simplecov"
-require "simplecov-console"
-
-SimpleCov.minimum_coverage 100
-SimpleCov.minimum_coverage_by_file 100
-SimpleCov.refuse_coverage_drop
+$VERBOSE = nil
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
-  SimpleCov::Formatter::Console,
-  SimpleCov::Formatter::HTMLFormatter
-])
+require "simplecov"
+SimpleCov.start
 
 SimpleCov.start do
   add_filter "test/support"
@@ -24,18 +17,31 @@ require "active_support/all"
 require "minitest/utils"
 require "minitest/autorun"
 
+def build_email_with_filter(email)
+  mailbox, domain = email.split("@")
+  "#{mailbox}+#{SecureRandom.hex(3)}@#{domain}"
+end
+
+def build_email_with_dots(email)
+  mailbox, domain = email.split("@")
+  new_mailbox = mailbox.chars.map {|char| [char, "."] }.flatten[0..-2].join
+
+  "#{new_mailbox}@#{domain}"
+end
+
 Time.zone = "America/Sao_Paulo"
 TLDs = Validators::TLD.all.sample(10)
-DISPOSABLE_EMAILS = Validators::DisposableHostnames.all.sample(10)
+DISPOSABLE_DOMAINS = Validators::DisposableHostnames.all.sample(10)
+DISPOSABLE_EMAILS = Validators::DisposableEmails.all +
+                    Validators::DisposableEmails.all.sample(10).map {|email| build_email_with_filter(email) } +
+                    Validators::DisposableEmails.all.sample(10).map {|email| build_email_with_dots(email) } +
+                    Validators::DisposableEmails.all.sample(10).map {|email| build_email_with_filter(build_email_with_dots(email)) }
 
 Dir[File.join(__dir__, "support/**/*.rb")].sort.each {|f| require f }
 
 ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
 load "schema.rb"
 
-I18n.enforce_available_locales = false
-I18n.load_path << File.join(__dir__, "support/translations.yml")
-
 module Minitest
   class Test
     setup do

data/test/validators/disposable_email_test.rb

@@ -3,25 +3,27 @@
 require "test_helper"
 
 class DisposableEmailTest < Minitest::Test
-  DISPOSABLE_EMAILS.each do |domain|
-    test "rejects disposable e-mail (#{domain})" do
+  DISPOSABLE_DOMAINS.each do |domain|
+    test "rejects disposable domain (#{domain})" do
       User.validates_email_format_of :email
 
       user = User.new(email: "user@#{domain}")
       user.valid?
 
-      assert_includes user.errors[:email], I18n.t("activerecord.errors.messages.disposable_email")
+      assert_includes user.errors[:email],
+                      I18n.t("activerecord.errors.messages.disposable_domain")
     end
   end
 
-  DISPOSABLE_EMAILS.each do |domain|
+  DISPOSABLE_DOMAINS.each do |domain|
     test "rejects disposable e-mail with subdomain (custom.#{domain})" do
       User.validates_email_format_of :email
 
       user = User.new(email: "user@custom.#{domain}")
       user.valid?
 
-      assert_includes user.errors[:email], I18n.t("activerecord.errors.messages.disposable_email")
+      assert_includes user.errors[:email],
+                      I18n.t("activerecord.errors.messages.disposable_domain")
     end
   end
 
@@ -33,4 +35,16 @@ class DisposableEmailTest < Minitest::Test
 
     assert user.errors[:email].empty?
   end
+
+  DISPOSABLE_EMAILS.each do |email|
+    test "rejects disposable e-mail (#{email})" do
+      User.validates_email_format_of :email
+
+      user = User.new(email: email)
+      user.valid?
+
+      assert_includes user.errors[:email],
+                      I18n.t("activerecord.errors.messages.disposable_email")
+    end
+  end
 end