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.