br_validators 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46a5c5d1d504c919923fbc23bb01ee2f4c82eeccbf752f8130740baa97ae35e6
-  data.tar.gz: 8d7dc883a24f170123e0df911397e4981af249941ae48d04d0476ff1d97029c0
+  metadata.gz: 7c36775e47d48c4dadc9fae27db78abb372bacdd85cf58ac586d3c005ddc29ae
+  data.tar.gz: 5b0a94be147182c7773dd201194041810b06cc4c0a6e784392dee72233dc4797
 SHA512:
-  metadata.gz: 66f54a26023c513533a5f1928a7875232d645f44161b0d6457da9cff3579aa666444d5ff09cad07058144c4113f41d89e75c05543433cf62a811fe7f387a1ceb
-  data.tar.gz: '08a8f1547c74bf7062abb1a7dda42c69e55e7a9f6578f6473871d19155b36e463644a4d03458aed3b972c8fbce1d90b1da74151ec3fb539c0a7c3cc8ab294bc5'
+  metadata.gz: b88cefcb1d52ba0f54b77f6a808b9f962449f4fbc636c3491e9502c48747e1dd205e23887bcc126c7661bc48096beabc13ccab9d75695ec1b0bb033f091ceec1
+  data.tar.gz: c04d5712613468e91dfe37ad9669634c5ec6991a4e2c36e9eaff43b8b3d21958612cac46cfd93bc8b6eccffbec885511132a601ec91c878bb9c7931542764a8e

data/CHANGELOG.md

@@ -3,6 +3,29 @@
 As mudanças de cada versão ficam aqui. O projeto segue o
 [versionamento semântico](https://semver.org/lang/pt-BR/).
 
+## [0.3.1] - 2026-10-31
+
+### Corrigido
+
+- `Consulta.banco` e `Consulta.ddd` aceitam número e texto em qualquer encoding:
+  `Consulta.banco("341".encode("UTF-16LE"))` levantava `Encoding::CompatibilityError`.
+
+### Mudado
+
+- Mais rápido, com os mesmos resultados (conferido em 72 mil entradas contra a 0.3.0):
+  `format`, `uf`, `ddd`, `segmento` e `modelo` tiram a máscara uma vez só, e as contas
+  de dígito verificador não criam uma lista por caractere. `CPF.format` ficou cerca de
+  3 vezes mais rápido; a chave de acesso e o boleto, cerca de 2 vezes.
+- A conta de módulo 11 com pesos de 2 a 9, que estava repetida no CNPJ, no RENAVAM, na
+  chave de acesso e no boleto, ficou num lugar só (`digitos.rb`, interno da gem).
+
+### Outros
+
+- Página de teste com visual novo, de documento: fonte datilografada, a trama dos papéis
+  de segurança no topo, o formulário como uma ficha e o resultado como um carimbo. O
+  campo mostra o modelo do formato, o resultado aparece na tela no celular e a página
+  tem imagem para quando o link é compartilhado.
+
 ## [0.3.0] - 2026-10-31
 
 ### Novo

data/README.md

@@ -189,8 +189,11 @@ pode abrir direto num documento: `?documento=placa`, `?documento=boleto`... A p
 mostra o resultado, explica por que um número é inválido e monta o trecho de código
 Ruby que faz o mesmo.
 
-A página (`public/`) é HTML e JavaScript puro e chama uma função Ruby da Vercel
-(`api/validar.rb`) que usa a própria gem, então as regras ficam num lugar só:
+A página (`public/`) é HTML, CSS e JavaScript puro, sem build, e chama uma função Ruby
+da Vercel (`api/validar.rb`) que usa a própria gem, então as regras ficam num lugar só.
+O visual imita um documento brasileiro; a fonte datilografada é a
+[Courier Prime](https://github.com/quoteunquoteapps/CourierPrime) (licença OFL, em
+`public/fontes`).
 
 ```
 GET /api/validar?documento=cnpj&valor=12.ABC.345/01DE-35

data/lib/br_validators/boleto.rb

@@ -30,11 +30,7 @@ module BrValidators
 
     # :cobranca, :arrecadacao ou nil se a linha for inválida.
     def self.type(value)
-      line = strip(value)
-      return :cobranca if line.match?(/\A\d{47}\z/) && valid_cobranca?(line)
-      return :arrecadacao if line.match?(/\A8\d{47}\z/) && valid_arrecadacao?(line)
-
-      nil
+      type_stripped(strip(value))
     end
 
     def self.valid?(value)
@@ -46,12 +42,19 @@ module BrValidators
     #   arrecadação: "82670000001-9 00000000000-0 00000000000-0 00000000000-0"
     def self.format(value)
       line = strip(value)
-      case type(line)
+      case type_stripped(line)
       when :cobranca then format_cobranca(line)
       when :arrecadacao then line.scan(/\d{12}/).map { |block| "#{block[0, 11]}-#{block[11]}" }.join(" ")
       end
     end
 
+    # A regra, com a linha já sem máscara.
+    def self.type_stripped(line)
+      return :cobranca if line.match?(/\A\d{47}\z/) && valid_cobranca?(line)
+
+      :arrecadacao if line.match?(/\A8\d{47}\z/) && valid_arrecadacao?(line)
+    end
+
     def self.format_cobranca(line)
       "#{line[0, 5]}.#{line[5, 5]} #{line[10, 5]}.#{line[15, 6]} " \
         "#{line[21, 5]}.#{line[26, 6]} #{line[32]} #{line[33, 14]}"
@@ -102,33 +105,30 @@ module BrValidators
 
     # Pesos 2, 1, 2, 1... da direita para a esquerda; produtos com dois algarismos
     # entram somados (12 vira 1 + 2). O dígito é o que falta para a próxima dezena.
+    # getbyte - 48 é o valor do dígito (explicado em digitos.rb).
     def self.mod10(digits)
-      sum = digits.reverse.chars.each_with_index.sum do |digit, index|
-        product = digit.to_i * (index.even? ? 2 : 1)
+      last = digits.size - 1
+      sum = (0..last).sum do |index|
+        product = (digits.getbyte(last - index) - 48) * (index.even? ? 2 : 1)
         (product / 10) + (product % 10)
       end
       (10 - (sum % 10)) % 10
     end
 
-    # Pesos 2 a 9, da direita para a esquerda, voltando ao 2 depois do 9.
-    def self.mod11_sum(digits)
-      digits.reverse.chars.each_with_index.sum { |digit, index| digit.to_i * ((index % 8) + 2) }
-    end
-
-    # Na cobrança, quando a conta dá 0, 10 ou 11, o dígito vira 1 (nunca é 0).
+    # Na cobrança, a soma é a do módulo 11 com pesos de 2 a 9 (Digitos, em
+    # digitos.rb), mas quando a conta dá 0, 10 ou 11 o dígito vira 1 (nunca é 0).
     def self.mod11_cobranca(digits)
-      digit = 11 - (mod11_sum(digits) % 11)
+      digit = 11 - (Digitos.soma_modulo11(digits) % 11)
       [0, 10, 11].include?(digit) ? 1 : digit
     end
 
-    # Na arrecadação, resto 0 ou 1 vira dígito 0.
+    # Na arrecadação, é o módulo 11 comum: resto 0 ou 1 vira dígito 0.
     def self.mod11_arrecadacao(digits)
-      rest = mod11_sum(digits) % 11
-      rest < 2 ? 0 : 11 - rest
+      Digitos.modulo11(digits)
     end
 
-    private_class_method :format_cobranca, :valid_cobranca?, :cobranca_barcode, :valid_arrecadacao?,
-                         :arrecadacao_check, :check_digit_ok?, :without, :mod10, :mod11_sum,
+    private_class_method :type_stripped, :format_cobranca, :valid_cobranca?, :cobranca_barcode,
+                         :valid_arrecadacao?, :arrecadacao_check, :check_digit_ok?, :without, :mod10,
                          :mod11_cobranca, :mod11_arrecadacao
   end
 end

data/lib/br_validators/cep.rb

@@ -24,16 +24,21 @@ module BrValidators
     # 8 dígitos. "00000-000" é o CEP que sistemas usam como "não informado";
     # nenhuma região dos Correios começa com 00000.
     def self.valid?(value)
-      cep = strip(value)
-      cep.match?(/\A\d{8}\z/) && cep != "00000000"
+      valid_stripped?(strip(value))
     end
 
     # Devolve "01001-000", ou nil se o CEP for inválido.
     def self.format(value)
-      return nil unless valid?(value)
-
       cep = strip(value)
+      return nil unless valid_stripped?(cep)
+
       "#{cep[0, 5]}-#{cep[5, 3]}"
     end
+
+    def self.valid_stripped?(cep)
+      cep.match?(/\A\d{8}\z/) && cep != "00000000"
+    end
+
+    private_class_method :valid_stripped?
   end
 end

data/lib/br_validators/chave_acesso.rb

@@ -48,31 +48,32 @@ module BrValidators
     end
 
     def self.valid?(value)
-      chave = strip(value)
-      return false unless chave.match?(PATTERN)
-      return false unless UFS_IBGE.include?(chave[0, 2]) && chave[4, 2].between?("01", "12")
-
-      chave[43] == check_digit(chave[0, 43])
+      valid_stripped?(strip(value))
     end
 
     # Devolve a chave em 11 grupos de 4 ("3526 1011 2223 ..."), ou nil se for inválida.
     def self.format(value)
-      return nil unless valid?(value)
+      chave = strip(value)
+      return nil unless valid_stripped?(chave)
 
-      strip(value).scan(/.{4}/).join(" ")
+      chave.scan(/.{4}/).join(" ")
     end
 
     # O código do modelo ("55" para NF-e, "65" para NFC-e...), ou nil se for inválida.
     def self.modelo(value)
-      valid?(value) ? strip(value)[20, 2] : nil
+      chave = strip(value)
+      valid_stripped?(chave) ? chave[20, 2] : nil
     end
 
-    def self.check_digit(chars)
-      sum = chars.reverse.chars.each_with_index.sum { |char, index| (char.ord - 48) * ((index % 8) + 2) }
-      rest = sum % 11
-      (rest < 2 ? 0 : 11 - rest).to_s
+    # A regra, com a chave já sem máscara. O dígito é o módulo 11 com pesos de 2 a 9
+    # (Digitos, em digitos.rb), com as letras do CNPJ valendo ASCII menos 48.
+    def self.valid_stripped?(chave)
+      return false unless chave.match?(PATTERN)
+      return false unless UFS_IBGE.include?(chave[0, 2]) && chave[4, 2].between?("01", "12")
+
+      chave[43] == Digitos.modulo11(chave[0, 43]).to_s
     end
 
-    private_class_method :check_digit
+    private_class_method :valid_stripped?
   end
 end

data/lib/br_validators/cnpj.rb

@@ -33,7 +33,19 @@ module BrValidators
     end
 
     def self.valid?(value)
+      valid_stripped?(strip(value))
+    end
+
+    # Devolve "12.ABC.345/01DE-35", ou nil se o CNPJ for inválido.
+    def self.format(value)
       cnpj = strip(value)
+      return nil unless valid_stripped?(cnpj)
+
+      "#{cnpj[0, 2]}.#{cnpj[2, 3]}.#{cnpj[5, 3]}/#{cnpj[8, 4]}-#{cnpj[12, 2]}"
+    end
+
+    # A regra, com o CNPJ já sem máscara e em maiúsculas.
+    def self.valid_stripped?(cnpj)
       return false unless cnpj.match?(PATTERN)
 
       # 00.000.000/0000-00 e parecidos passam na conta, mas não existem.
@@ -42,29 +54,14 @@ module BrValidators
       cnpj[12, 2] == check_digits(cnpj[0, 12])
     end
 
-    # Devolve "12.ABC.345/01DE-35", ou nil se o CNPJ for inválido.
-    def self.format(value)
-      return nil unless valid?(value)
-
-      cnpj = strip(value)
-      "#{cnpj[0, 2]}.#{cnpj[2, 3]}.#{cnpj[5, 3]}/#{cnpj[8, 4]}-#{cnpj[12, 2]}"
-    end
-
+    # Cada dígito é o módulo 11 com pesos de 2 a 9 (Digitos, em digitos.rb) dos
+    # caracteres anteriores; o segundo conta também o primeiro.
     def self.check_digits(base)
-      first = check_digit(base)
-      second = check_digit("#{base}#{first}")
+      first = Digitos.modulo11(base)
+      second = Digitos.modulo11("#{base}#{first}")
       "#{first}#{second}"
     end
 
-    def self.check_digit(chars)
-      # Pesos 2, 3, ..., 9, 2, 3... a partir do último caractere.
-      sum = chars.reverse.chars.each_with_index.sum do |char, index|
-        (char.ord - 48) * ((index % 8) + 2)
-      end
-      rest = sum % 11
-      (rest < 2 ? 0 : 11 - rest).to_s
-    end
-
-    private_class_method :check_digits, :check_digit
+    private_class_method :valid_stripped?, :check_digits
   end
 end

data/lib/br_validators/cns.rb

@@ -28,7 +28,20 @@ module BrValidators
     end
 
     def self.valid?(value)
+      valid_stripped?(strip(value))
+    end
+
+    # Devolve o CNS em grupos de 3, 4, 4 e 4 dígitos, como aparece impresso no
+    # cartão ("123 4567 8901 0000"), ou nil se for inválido.
+    def self.format(value)
       cns = strip(value)
+      return nil unless valid_stripped?(cns)
+
+      "#{cns[0, 3]} #{cns[3, 4]} #{cns[7, 4]} #{cns[11, 4]}"
+    end
+
+    # A regra, com o CNS já sem máscara.
+    def self.valid_stripped?(cns)
       return false unless cns.match?(/\A\d{15}\z/)
 
       case cns[0]
@@ -38,15 +51,6 @@ module BrValidators
       end
     end
 
-    # Devolve o CNS em grupos de 3, 4, 4 e 4 dígitos, como aparece impresso no
-    # cartão ("123 4567 8901 0000"), ou nil se for inválido.
-    def self.format(value)
-      return nil unless valid?(value)
-
-      cns = strip(value)
-      "#{cns[0, 3]} #{cns[3, 4]} #{cns[7, 4]} #{cns[11, 4]}"
-    end
-
     # Monta o CNS esperado para um PIS, como na rotina do Ministério da Saúde.
     def self.from_pis(pis)
       sum = weighted_sum(pis)
@@ -59,11 +63,12 @@ module BrValidators
       "#{pis}001#{digit}"
     end
 
-    # Pesos começando em 15 e diminuindo de 1 em 1 a cada dígito.
+    # Pesos começando em 15 e diminuindo de 1 em 1 a cada dígito. getbyte - 48 é o
+    # valor do dígito (explicado em digitos.rb).
     def self.weighted_sum(digits)
-      digits.chars.each_with_index.sum { |digit, index| digit.to_i * (15 - index) }
+      (0...digits.size).sum { |index| (digits.getbyte(index) - 48) * (15 - index) }
     end
 
-    private_class_method :from_pis, :weighted_sum
+    private_class_method :valid_stripped?, :from_pis, :weighted_sum
   end
 end

data/lib/br_validators/consulta.rb

@@ -61,7 +61,8 @@ module BrValidators
 
     # Banco pelo código de compensação ("001", "237", 341): code, name, fullName e ispb.
     def self.banco(codigo)
-      codigo = codigo.to_s.strip
+      # BrValidators.texto: aceita número e texto em qualquer encoding (UTF-16 dava erro).
+      codigo = BrValidators.texto(codigo).strip
       return nil unless codigo.match?(/\A\d{1,3}\z/)
 
       buscar("/banks/v1/#{codigo.to_i}")
@@ -69,7 +70,7 @@ module BrValidators
 
     # UF e cidades de um DDD: state e cities.
     def self.ddd(valor)
-      ddd = valor.to_s.strip
+      ddd = BrValidators.texto(valor).strip
       return nil unless Telefone::DDDS.include?(ddd)
 
       buscar("/ddd/v1/#{ddd}")

data/lib/br_validators/cpf.rb

@@ -24,24 +24,28 @@ module BrValidators
     end
 
     def self.valid?(value)
-      digits = strip(value)
-      return false unless digits.match?(/\A\d{11}\z/)
-
-      # 111.111.111-11, 222.222.222-22... passam na conta, mas não são CPFs reais.
-      return false if digits.squeeze.size == 1
-
-      digits[9, 2] == check_digits(digits[0, 9])
+      valid_stripped?(strip(value))
     end
 
     # Devolve "123.456.789-09", ou nil se o CPF for inválido
     # (formatar um número errado esconderia o erro de quem chamou).
     def self.format(value)
-      return nil unless valid?(value)
-
       digits = strip(value)
+      return nil unless valid_stripped?(digits)
+
       "#{digits[0, 3]}.#{digits[3, 3]}.#{digits[6, 3]}-#{digits[9, 2]}"
     end
 
+    # A regra, com o CPF já sem máscara.
+    def self.valid_stripped?(digits)
+      return false unless digits.match?(/\A\d{11}\z/)
+
+      # 111.111.111-11, 222.222.222-22... passam na conta, mas não são CPFs reais.
+      return false if digits.squeeze.size == 1
+
+      digits[9, 2] == check_digits(digits[0, 9])
+    end
+
     def self.check_digits(base)
       first = check_digit(base)
       second = check_digit("#{base}#{first}")
@@ -49,14 +53,15 @@ module BrValidators
     end
 
     # Pesos decrescentes até 2, começando por (tamanho + 1): 10..2 para 9 dígitos,
-    # 11..2 para 10 dígitos.
+    # 11..2 para 10 dígitos. getbyte devolve o código ASCII do dígito; menos 48 dá
+    # o valor dele ("0" é 48), sem criar uma string por dígito.
     def self.check_digit(digits)
-      weights = (2..(digits.size + 1)).to_a.reverse
-      sum = digits.chars.zip(weights).sum { |digit, weight| digit.to_i * weight }
+      first_weight = digits.size + 1
+      sum = (0...digits.size).sum { |index| (digits.getbyte(index) - 48) * (first_weight - index) }
       rest = sum % 11
       (rest < 2 ? 0 : 11 - rest).to_s
     end
 
-    private_class_method :check_digits, :check_digit
+    private_class_method :valid_stripped?, :check_digits, :check_digit
   end
 end

data/lib/br_validators/digitos.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BrValidators
+  # Contas de dígito verificador usadas por mais de um documento. É interno da gem
+  # (private_constant no fim): quem usa a gem não precisa dele.
+  #
+  # O valor de cada caractere é o código ASCII dele menos 48: "0" vale 0, "9" vale
+  # 9 e "A" vale 17, como manda a regra do CNPJ alfanumérico. Para dígitos, dá o
+  # mesmo que to_i, sem criar uma string por caractere (getbyte devolve o código).
+  module Digitos
+    # Soma do "módulo 11 com pesos de 2 a 9": da direita para a esquerda, cada
+    # caractere é multiplicado por 2, 3, ..., 9, e o peso volta ao 2 depois do 9.
+    # Usada no CNPJ, no RENAVAM, na chave de acesso e no boleto.
+    def self.soma_modulo11(texto)
+      ultimo = texto.size - 1
+      (0..ultimo).sum { |posicao| (texto.getbyte(ultimo - posicao) - 48) * ((posicao % 8) + 2) }
+    end
+
+    # O dígito mais comum do módulo 11: resto 0 ou 1 vira 0; senão, 11 menos o resto.
+    def self.modulo11(texto)
+      resto = soma_modulo11(texto) % 11
+      resto < 2 ? 0 : 11 - resto
+    end
+  end
+
+  private_constant :Digitos
+end

data/lib/br_validators/documentos.rb

@@ -2,6 +2,7 @@
 
 require_relative "version"
 require_relative "texto"
+require_relative "digitos"
 require_relative "cpf"
 require_relative "cnpj"
 require_relative "cns"
@@ -27,6 +28,10 @@ require_relative "chave_acesso"
 # Alguns têm métodos a mais: type (Pix, Boleto, Telefone, Placa), uf (TituloEleitor),
 # segmento (ProcessoCNJ), modelo (ChaveAcesso), ddd (Telefone), mercosul e antiga (Placa).
 #
+# Dentro de cada módulo, os métodos públicos tiram a máscara uma vez só e passam
+# o texto limpo para um método privado com a regra (valid_stripped? ou
+# type_stripped). Assim format, uf, modelo... não refazem o mesmo trabalho.
+#
 # Este arquivo carrega só os documentos, sem os validadores do Rails. Serve para o
 # app que já tem um CpfValidator (ou outro com o mesmo nome) e quer continuar com o
 # dele: no Gemfile, gem "br_validators", require: "br_validators/documentos".

data/lib/br_validators/placa.rb

@@ -28,11 +28,7 @@ module BrValidators
 
     # :antiga, :mercosul ou nil se a placa for inválida.
     def self.type(value)
-      placa = strip(value)
-      return :antiga if placa.match?(ANTIGA)
-      return :mercosul if placa.match?(MERCOSUL)
-
-      nil
+      type_stripped(strip(value))
     end
 
     def self.valid?(value)
@@ -42,7 +38,7 @@ module BrValidators
     # Devolve "ABC-1234" (antiga) ou "ABC1D23" (Mercosul), ou nil se for inválida.
     def self.format(value)
       placa = strip(value)
-      case type(placa)
+      case type_stripped(placa)
       when :antiga then "#{placa[0, 3]}-#{placa[3, 4]}"
       when :mercosul then placa
       end
@@ -52,7 +48,7 @@ module BrValidators
     #   mercosul("ABC-1234") # => "ABC1C34"
     def self.mercosul(value)
       placa = strip(value)
-      case type(placa)
+      case type_stripped(placa)
       when :antiga then placa[0, 4] + ("A".ord + placa[4].to_i).chr + placa[5, 2]
       when :mercosul then placa
       end
@@ -64,10 +60,21 @@ module BrValidators
     #   antiga("ABC1C34") # => "ABC1234"
     def self.antiga(value)
       placa = strip(value)
-      return placa if type(placa) == :antiga
-      return nil unless type(placa) == :mercosul && placa[4].between?("A", "J")
+      case type_stripped(placa)
+      when :antiga then placa
+      when :mercosul
+        # Só as letras de A a J na quinta posição vieram da conversão.
+        placa[0, 4] + (placa[4].ord - "A".ord).to_s + placa[5, 2] if placa[4].between?("A", "J")
+      end
+    end
+
+    # A regra, com a placa já sem máscara e em maiúsculas.
+    def self.type_stripped(placa)
+      return :antiga if placa.match?(ANTIGA)
 
-      placa[0, 4] + (placa[4].ord - "A".ord).to_s + placa[5, 2]
+      :mercosul if placa.match?(MERCOSUL)
     end
+
+    private_class_method :type_stripped
   end
 end

data/lib/br_validators/processo_cnj.rb

@@ -38,26 +38,33 @@ module BrValidators
     end
 
     def self.valid?(value)
-      numero = strip(value)
-      return false unless numero.match?(/\A\d{20}\z/)
-      return false unless SEGMENTOS.key?(numero[13])
-
-      # NNNNNNN + AAAA J TR OOOO + DD
-      (numero[0, 7] + numero[9, 11] + numero[7, 2]).to_i % 97 == 1
+      valid_stripped?(strip(value))
     end
 
     # Devolve "0000123-45.2024.8.26.0100", ou nil se o número for inválido.
     def self.format(value)
-      return nil unless valid?(value)
-
       numero = strip(value)
+      return nil unless valid_stripped?(numero)
+
       "#{numero[0, 7]}-#{numero[7, 2]}.#{numero[9, 4]}.#{numero[13]}.#{numero[14, 2]}.#{numero[16, 4]}"
     end
 
     # O nome do segmento do Judiciário ("Justiça do Trabalho"), ou nil se o número
     # for inválido.
     def self.segmento(value)
-      valid?(value) ? SEGMENTOS[strip(value)[13]] : nil
+      numero = strip(value)
+      valid_stripped?(numero) ? SEGMENTOS[numero[13]] : nil
     end
+
+    # A regra, com o número já sem máscara.
+    def self.valid_stripped?(numero)
+      return false unless numero.match?(/\A\d{20}\z/)
+      return false unless SEGMENTOS.key?(numero[13])
+
+      # NNNNNNN + AAAA J TR OOOO + DD
+      (numero[0, 7] + numero[9, 11] + numero[7, 2]).to_i % 97 == 1
+    end
+
+    private_class_method :valid_stripped?
   end
 end

data/lib/br_validators/renavam.rb

@@ -23,26 +23,26 @@ module BrValidators
     end
 
     def self.valid?(value)
-      renavam = strip(value)
-      return false unless renavam.match?(/\A\d{11}\z/)
-
-      # 00000000000, 11111111111... não são códigos reais.
-      return false if renavam.squeeze.size == 1
-
-      renavam[10] == check_digit(renavam[0, 10])
+      valid_stripped?(strip(value))
     end
 
     # O RENAVAM não tem máscara: devolve os 11 dígitos, ou nil se for inválido.
     def self.format(value)
-      valid?(value) ? strip(value) : nil
+      renavam = strip(value)
+      valid_stripped?(renavam) ? renavam : nil
     end
 
-    def self.check_digit(digits)
-      sum = digits.reverse.chars.each_with_index.sum { |digit, index| digit.to_i * ((index % 8) + 2) }
-      rest = sum % 11
-      (rest < 2 ? 0 : 11 - rest).to_s
+    # A regra, com o RENAVAM já sem máscara. O dígito é o módulo 11 com pesos de
+    # 2 a 9 (Digitos, em digitos.rb).
+    def self.valid_stripped?(renavam)
+      return false unless renavam.match?(/\A\d{11}\z/)
+
+      # 00000000000, 11111111111... não são códigos reais.
+      return false if renavam.squeeze.size == 1
+
+      renavam[10] == Digitos.modulo11(renavam[0, 10]).to_s
     end
 
-    private_class_method :check_digit
+    private_class_method :valid_stripped?
   end
 end

data/lib/br_validators/telefone.rb

@@ -47,14 +47,7 @@ module BrValidators
 
     # :celular, :fixo ou nil se o número for inválido.
     def self.type(value)
-      numero = nacional(value)
-      return nil unless numero && DDDS.include?(numero[0, 2])
-
-      assinante = numero[2..]
-      return :celular if assinante.match?(CELULAR)
-      return :fixo if assinante.match?(FIXO)
-
-      nil
+      type_nacional(nacional(value))
     end
 
     def self.valid?(value)
@@ -63,15 +56,26 @@ module BrValidators
 
     # Devolve "(11) 98765-4321" ou "(11) 3456-7890", ou nil se for inválido.
     def self.format(value)
-      return nil unless valid?(value)
-
       numero = nacional(value)
+      return nil unless type_nacional(numero)
+
       "(#{numero[0, 2]}) #{numero[2...-4]}-#{numero[-4..]}"
     end
 
     # O DDD ("11"), ou nil se o número for inválido.
     def self.ddd(value)
-      valid?(value) ? nacional(value)[0, 2] : nil
+      numero = nacional(value)
+      type_nacional(numero) ? numero[0, 2] : nil
+    end
+
+    # A regra, com o número já como devolvido por nacional (ou nil).
+    def self.type_nacional(numero)
+      return nil unless numero && DDDS.include?(numero[0, 2])
+
+      assinante = numero[2..]
+      return :celular if assinante.match?(CELULAR)
+
+      :fixo if assinante.match?(FIXO)
     end
 
     # O número só com DDD e assinante (10 ou 11 dígitos), sem o código do país
@@ -88,6 +92,6 @@ module BrValidators
       digits.size.between?(10, 11) ? digits : nil
     end
 
-    private_class_method :nacional
+    private_class_method :type_nacional, :nacional
   end
 end

data/lib/br_validators/titulo_eleitor.rb

@@ -36,32 +36,39 @@ module BrValidators
     end
 
     def self.valid?(value)
-      titulo = strip(value)
-      return false unless titulo.match?(/\A\d{12}\z/)
-
-      uf = titulo[8, 2]
-      return false unless UFS.key?(uf)
-
-      first = check_digit(weighted_sum(titulo[0, 8], 2..9), uf)
-      second = check_digit(weighted_sum("#{uf}#{first}", 7..9), uf)
-      titulo[10, 2] == "#{first}#{second}"
+      valid_stripped?(strip(value))
     end
 
     # Devolve "1023 8501 0671", ou nil se o título for inválido.
     def self.format(value)
-      return nil unless valid?(value)
-
       titulo = strip(value)
+      return nil unless valid_stripped?(titulo)
+
       "#{titulo[0, 4]} #{titulo[4, 4]} #{titulo[8, 4]}"
     end
 
     # A sigla da UF onde o título foi emitido ("SP", "ZZ" para o exterior), ou nil.
     def self.uf(value)
-      valid?(value) ? UFS[strip(value)[8, 2]] : nil
+      titulo = strip(value)
+      valid_stripped?(titulo) ? UFS[titulo[8, 2]] : nil
+    end
+
+    # A regra, com o título já sem máscara.
+    def self.valid_stripped?(titulo)
+      return false unless titulo.match?(/\A\d{12}\z/)
+
+      uf = titulo[8, 2]
+      return false unless UFS.key?(uf)
+
+      first = check_digit(weighted_sum(titulo[0, 8], 2), uf)
+      second = check_digit(weighted_sum("#{uf}#{first}", 7), uf)
+      titulo[10, 2] == "#{first}#{second}"
     end
 
-    def self.weighted_sum(digits, weights)
-      digits.chars.zip(weights.to_a).sum { |digit, weight| digit.to_i * weight }
+    # Pesos crescentes da esquerda para a direita, a partir de first_weight (2 no
+    # primeiro dígito, 7 no segundo). getbyte - 48 é o valor do dígito (digitos.rb).
+    def self.weighted_sum(digits, first_weight)
+      (0...digits.size).sum { |index| (digits.getbyte(index) - 48) * (first_weight + index) }
     end
 
     # codigo_uf: "01" (SP) e "02" (MG) têm a regra especial do resto 0.
@@ -72,6 +79,6 @@ module BrValidators
       rest == 10 ? 0 : rest
     end
 
-    private_class_method :weighted_sum, :check_digit
+    private_class_method :valid_stripped?, :weighted_sum, :check_digit
   end
 end

data/lib/br_validators/version.rb

@@ -2,5 +2,5 @@
 
 # Versão da gem, lida também pelo gemspec.
 module BrValidators
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: br_validators
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Pedro Pedrassolli
@@ -31,6 +31,7 @@ files:
 - lib/br_validators/cns.rb
 - lib/br_validators/consulta.rb
 - lib/br_validators/cpf.rb
+- lib/br_validators/digitos.rb
 - lib/br_validators/documentos.rb
 - lib/br_validators/locale/en.yml
 - lib/br_validators/locale/pt-BR.yml