534 palavras

Form objects com ActiveModel::Attributes

, em Rails

Nesta página
  1. Convertendo na mão
  2. Deixando o Rails converter
  3. Duas pegadinhas
  4. Um tipo seu
  5. Antes de procurar uma gem
  6. Referências

Os parâmetros de um formulário chegam no controller como strings:

{ "name" => "Buzz Aldrin", "age" => "92", "birthday" => "1930-01-20", "newsletter" => "1" }

Num model do ActiveRecord você nem percebe, porque o Rails converte cada valor pelo tipo da coluna. Mas nem todo formulário é uma tabela: uma busca com filtros, um cadastro que cria dois registros, um formulário de contato. Nesses casos o objeto é seu, e as strings também.

Convertendo na mão

O primeiro impulso é um PORO que converte no initialize:

class PersonForm
  attr_reader :name, :age, :birthday, :newsletter

  def initialize(params = {})
    @name = params[:name]
    @age = params[:age].to_i
    @birthday = Date.parse(params[:birthday])
    @newsletter = params[:newsletter] == "1"
  end
end

Funciona, mas cada campo novo é mais uma linha de conversão, e cada uma tem os seus casos de borda. O Date.parse(nil) quebra, e o checkbox pode chegar como "1", "true" ou "on". Logo vêm os valores padrão e as validações, e o initialize vira o lugar mais complicado da classe.

Deixando o Rails converter

O ActiveRecord faz essa conversão com o ActiveModel::Attributes, e você pode usar o mesmo módulo em qualquer classe:

class PersonForm
  include ActiveModel::Model
  include ActiveModel::Attributes

  attribute :name, :string
  attribute :age, :integer
  attribute :birthday, :date
  attribute :favorite_color, :string, default: "red"
  attribute :newsletter, :boolean, default: false

  validates :name, presence: true
  validates :age, numericality: { greater_than: 0 }, allow_nil: true
end

form = PersonForm.new(name: "Buzz Aldrin", age: "92", birthday: "1930-01-20", newsletter: "1")

form.age            # => 92
form.birthday       # => #<Date: 1930-01-20>
form.newsletter     # => true
form.favorite_color # => "red"

Cada atributo declara o seu tipo, e a conversão é a mesma que o Rails usa nas colunas do banco. O :boolean entende "1", "true" e "on", e o :date aceita nil sem quebrar.

O ActiveModel::Model traz o resto: validações, errors e o que o form_with precisa. Então a view trata esse objeto como trata um model:

<%= form_with model: @form, url: people_path do |f| %>
  <%= f.text_field :name %>
  <%= f.date_field :birthday %>
<% end %>

E o controller fica no padrão de sempre:

def create
  @form = PersonForm.new(person_params)

  if @form.valid?
    # cria os registros
    redirect_to root_path
  else
    render :new, status: :unprocessable_entity
  end
end

Duas pegadinhas

Um texto que não é número vira zero. O tipo :integer converte "abc" em 0 sem reclamar. A validação de numericality vê o 0, e a mensagem sai como “must be greater than 0”, não “is not a number”. Se a mensagem importa para quem preenche o formulário, valide antes da conversão.

Atributo desconhecido levanta erro. Passar uma chave que a classe não declara gera ActiveModel::UnknownAttributeError. Com os params filtrados pelo permit, isso não acontece.

Um tipo seu

Se nenhum tipo pronto serve, você cria um. Este tira os espaços das pontas de qualquer texto:

class StrippedString < ActiveModel::Type::String
  def cast(value) = super&.strip
end

ActiveModel::Type.register(:stripped_string, StrippedString)

class PersonForm
  # ...
  attribute :name, :stripped_string
end

PersonForm.new(name: "  Buzz  ").name
# => "Buzz"

Antes de procurar uma gem

Existem gems de form objects e de tipos. Mas o ActiveModel::Attributes já vem no Rails, usa o mesmo sistema de tipos que os seus models e não traz conceito novo para o time aprender. Para a maioria dos formulários, ele é suficiente.

Referências