Tipos de Validações no Active Record

As validações do Active Record são uma parte crucial no desenvolvimento de aplicações web utilizando o framework Ruby on Rails. O Active Record é a camada de modelo do Rails, responsável por representar e interagir com os dados do banco de dados. As validações são usadas para garantir que os dados inseridos no banco de dados estejam em conformidade com as regras definidas pela aplicação.

Existem várias tipos de validações disponíveis no Active Record, cada uma destinada a validar um aspecto específico dos dados. Vamos explorar algumas das validações mais comuns e suas opções:

Presence Validation (Validação de Presença): Esta validação garante que um determinado campo não esteja vazio. É muito útil para campos obrigatórios em formulários. Por exemplo:
```
ruby
class User < ApplicationRecord
  validates :username, presence: true
end
```
Neste exemplo, o campo username deve estar preenchido para que o registro seja considerado válido.
Length Validation (Validação de Tamanho): Esta validação permite definir limites para o tamanho de um campo de texto. Pode ser usado para garantir que um campo de texto não seja muito longo ou muito curto. Por exemplo:
```
ruby
class Post < ApplicationRecord
  validates :content, length: { maximum: 1000 }
end
```
Aqui, o campo content não pode ter mais de 1000 caracteres.
Numericality Validation (Validação de Numericalidade): Esta validação verifica se um campo é numérico. Pode ser útil para campos que devem conter apenas números. Por exemplo:
```
ruby
class Product < ApplicationRecord
  validates :price, numericality: true
end
```
Neste caso, o campo price deve conter apenas valores numéricos.
Format Validation (Validação de Formato): Esta validação permite validar um campo com base em uma expressão regular. É útil para garantir que um campo esteja no formato correto, como um endereço de e-mail. Por exemplo:
```
ruby
class Email < ApplicationRecord
  validates :address, format: { with: /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i }
end
```
Aqui, address deve corresponder a um padrão de endereço de e-mail válido.
Uniqueness Validation (Validação de Unicidade): Esta validação garante que o valor de um campo seja único entre todos os registros no banco de dados. É comumente usado para campos como endereço de e-mail ou nome de usuário. Por exemplo:
```
ruby
class Account < ApplicationRecord
  validates :email, uniqueness: true
end
```
Neste caso, cada endereço de e-mail na tabela accounts deve ser único.
Custom Validation (Validação Personalizada): Além das validações predefinidas, você também pode definir suas próprias validações personalizadas. Isso é útil quando você precisa de uma lógica de validação mais complexa que não é coberta pelas validações padrão. Por exemplo:
```
ruby
class Order < ApplicationRecord
  validate :must_be_friends

  def must_be_friends
    errors.add(:base, "You must be friends to create an order") unless user.friends.include?(friend)
  end
end
```
Neste exemplo, must_be_friends é uma validação personalizada que verifica se dois usuários são amigos antes de permitir a criação de um pedido.

Além das opções mencionadas acima, as validações do Active Record oferecem uma variedade de outras opções para personalizar o comportamento das validações. Por exemplo, você pode fornecer mensagens de erro personalizadas, condicionalmente aplicar validações e agrupar várias validações em uma única chamada. Ao utilizar essas opções em conjunto com os tipos de validação mencionados, você pode criar regras robustas para garantir a integridade dos dados em sua aplicação Rails.

“Mais Informações”

Claro, vou expandir um pouco mais sobre as validações do Active Record, fornecendo mais detalhes sobre algumas das opções adicionais disponíveis e exemplos adicionais de uso.

Mensagens de Erro Personalizadas:
Ao definir uma validação, você pode fornecer uma mensagem de erro personalizada que será exibida quando a validação falhar. Isso é útil para orientar os usuários sobre o que está errado com os dados que eles forneceram. Por exemplo:
```
ruby
class Product < ApplicationRecord
  validates :price, numericality: { message: "deve ser um número válido" }
end
```
Aqui, se o campo price não conter um valor numérico, a mensagem de erro “deve ser um número válido” será exibida.
Validações Condicionalmente Aplicadas:
Você pode condicionar a aplicação de uma validação com base em determinadas condições. Isso é útil quando você deseja aplicar uma validação apenas em certas circunstâncias. Por exemplo:
```
ruby
class Order < ApplicationRecord
  validates :payment_status, presence: true, if: :paid_with_credit_card?

  def paid_with_credit_card?
    payment_method == 'credit_card'
  end
end
```
Neste exemplo, a validação de presença para payment_status será aplicada apenas se o método de pagamento for um cartão de crédito.
Validações em Lote (Batch Validations):
Às vezes, é conveniente agrupar várias validações em uma única chamada para melhorar a legibilidade do código. Você pode fazer isso usando o método validates com vários atributos. Por exemplo:
```
ruby
class User < ApplicationRecord
  validates :username, :email, presence: true
end
```
Aqui, tanto o campo username quanto o campo email são validados para garantir que não estejam vazios.
Opções Adicionais:
Além das opções mencionadas acima, existem outras opções que você pode utilizar para personalizar ainda mais o comportamento das validações. Algumas dessas opções incluem allow_nil, allow_blank, on, strict, entre outras. Por exemplo:
```
ruby
class Person < ApplicationRecord
  validates :name, presence: true, allow_blank: false
end
```
Neste exemplo, mesmo que name esteja presente, ele não pode estar em branco de acordo com a opção allow_blank.

Em resumo, as validações do Active Record oferecem uma maneira poderosa e flexível de garantir a integridade dos dados em suas aplicações Rails. Ao utilizar uma combinação das opções de validação mencionadas acima, você pode criar regras de validação abrangentes que garantem que seus dados estejam sempre em um estado válido. Essas validações são essenciais para manter a consistência e a precisão dos dados em sua aplicação, ajudando a evitar problemas como dados corrompidos ou inválidos.