Validar CPF facilmente em Kotlin
Tags: kotlin
Published: 2020-08-26 23:14:09

### NL;NL
Desenvolvi a biblioteca [SimpleCPFValidator](https://github.com/LeoColman/SimpleCpfValidator) para facilitar validações de CPF em Kotlin.

# Olá, Kotliners!

Todo novo cadastro de usuário em todo aplicativo segue sempre o mesmo padrão. Pedimos nome, data de nascimento e **CPF** de nossos queridos usuários quase que rotineiramente.

Quem já brincou de validar CPF sabe que é uma chatice contar todos os números, fazer valer com o digito verificador e zás e zás...

## A validação

As regras de validação em si são bem simples, e estão facilmente disponibilizadas pela web, além das [normas oficiais da receita](http://normas.receita.fazenda.gov.br/sijut2consulta/link.action?visao=anotado&idAto=1893).

1. CPFs com números repetidos (111.111.111-11, 222.222.222-22, ... 999.999.999-99) não são válidos
2. O CPF 000.000.001-91 é válido apenas para representar pessoas sem CPF
3. O cálculo maluco de digito verificador

Esta última regra é mais chata de entender. Este [artigo do Só Matemática](https://www.somatematica.com.br/faq/cpf.php) explica bem como funciona, mas se tiver interesse, leia:

```
O número do CPF é escrito na forma ABCDEFGHI/JK

O J e o K são o 1̣° e 2° dígitos verificadores

Para obter J multiplicamos A, B, C, D, E, F, G, H e I 
pelas constantes correspondentes:
| A   | B  | C  | D  | E  | F  | G  | H  | I  |
| 10x | 9x | 8x | 7x | 6x | 5x | 4x | 3x | 2x |
O resultado de 10A + 9B + ... + 2I é então dividido por 11, e
o valor que RESTAR da divisão será utilizado. Se o resto for
0 ou 1, J = 0. Caso contrário, J = 11 - resto

Para obter K. seguimos a mesma regra, porém com J no final 
da tabela, e começaremos a conta a partir de 11:
| A   | B   | C  | D  | E  | F  | G  | H  | I  | J  |
| 11x | 10x | 9x | 8x | 7x | 6x | 5x | 4x | 3x | 2x |
O resultado de 11A + ... + 2J é então dividido 
por 11, e a regra do resto será a mesma que o J.
```

### É fácil, não?

As regras são simples, não são? Fáceis de entender do ponto de vista matemático e do ponto de vista de código. Então **Por que é sempre tão chato implementar isso?** Ou copiamos códigos de outros projetos, ou escrevemos um espaguete para seguir essas regras. Testar é complicado, e no final fica uma gororoba.

Essa gororoba precisa de manutenção, no entanto, e estará amarrada no nosso projeto pra sempre. Não queremos isso!

# A maneira fácil

Em Kotlin temos a tendência de **evitar boilerplates**, e não carregar nosso código de tanta coisa.

Com isso em mente, desenvolvi a biblioteca open source [SimpleCPFValidator](https://github.com/LeoColman/SimpleCpfValidator). Ela colocará em seu projeto alguns utilitários para validação de CPF.

Busquei as regras originais para validação, e desenvolvi funções de extensão em cima disso:

```kotlin
val userCpf = userCpf.text
if(userCpf.isCpf()) {
    // Is CPF!
}
```
E simples assim, seu código conhece as regras de validação de CPF!

Por padrão, os caracteres `.` e `-` são retirados da String (permitindo o formato `123.456.789-11`, por exemplo), mas isso pode ser modificado através do parâmetro `charactersToIgnore`:

```kotlin
"123.456.789/11".isCpf(charactersToIgnore = listOf('.', '/'))
```

Para utilizar essa lib em seu projeto,coloque em seu build.gradle:

```
implementation("br.com.colman.simplecpfvalidator:simple-cpf-validator:{version}")
```