Existe uma alternativa para update_attributes que não salva o registro?

Então eu poderia fazer algo como:

@car = Car.new(:make => 'GMC')
#other processing
@car.update_attributes(:model => 'Sierra', :year => "2012", :looks => "Super Sexy, wanna make love to it")
#other processing
@car.save

BTW, eu sei que posso @car.model = 'Sierra', mas quero atualizá-los todos em uma linha.

Eu acredito que você está procurando assign_attributes.

É basicamente o mesmo que update_attributes, mas não salva o registro:

class User < ActiveRecord::Base
  attr_accessible :name
  attr_accessible :name, :is_admin, :as => :admin
end

user = User.new
user.assign_attributes({ :name => 'Josh', :is_admin => true }) # Raises an ActiveModel::MassAssignmentSecurity::Error
user.assign_attributes({ :name => 'Bob'})
user.name        # => "Bob"
user.is_admin?   # => false
user.new_record? # => true

Você pode usar assign_attributesou attributes=(eles são iguais)

Folha de dicas dos métodos de atualização (para Rails 6):

• update= assign_attributes+save
• attributes= = apelido de assign_attributes
• update_attributes = obsoleto, apelido de update

Fonte:
https://github.com/rails/rails/blob/master/activerecord/lib/active_record/persistence.rb
https://github.com/rails/rails/blob/master/activerecord/lib/active_record/attribute_assignment .rb

Outra folha de dicas:
http://www.davidverhasselt.com/set-attributes-in-activerecord/#cheat-sheet

Você pode usar o método 'attribute':

@car.attributes = {:model => 'Sierra', :years => '1990', :looks => 'Sexy'}

Fonte: http://api.rubyonrails.org/classes/ActiveRecord/Base.html

attribute = (new_attributes, guard_protected_attributes = true) Permite definir todos os atributos de uma só vez passando um hash com chaves correspondentes aos nomes dos atributos (que novamente correspondem aos nomes das colunas).

Se guard_protected_attributes for true (o padrão), os atributos sensíveis poderão ser protegidos dessa forma de atribuição em massa usando a macro attr_protected. Ou, como alternativa, você pode especificar quais atributos podem ser acessados ​​com a macro attr_accessible. Em seguida, todos os atributos não incluídos nos que não serão permitidos serão atribuídos em massa.

class User < ActiveRecord::Base
  attr_protected :is_admin
end

user = User.new
user.attributes = { :username => 'Phusion', :is_admin => true }
user.username   # => "Phusion"
user.is_admin?  # => false

user.send(:attributes=, { :username => 'Phusion', :is_admin => true }, false)
user.is_admin?  # => true

Para atribuição em massa de valores a um modelo ActiveRecord sem salvar, use os métodos assign_attributesou attributes=. Esses métodos estão disponíveis no Rails 3 e mais recentes. No entanto, existem pequenas diferenças e dicas relacionadas à versão a serem observadas.

Ambos os métodos seguem esse uso:

@user.assign_attributes{ model: "Sierra", year: "2012", looks: "Sexy" }

@user.attributes = { model: "Sierra", year: "2012", looks: "Sexy" }

Observe que nenhum dos métodos realizará validações ou executará retornos de chamada; retornos de chamada e validação acontecerão quando savefor chamado.

Trilhos 3

attributes=difere um pouco do assign_attributesRails 3. attributes=irá verificar se o argumento passado para ele é um Hash e retorna imediatamente se não for; assign_attributesnão tem essa verificação de hash. Consulte a documentação da API ActiveRecord Attribute Assignment paraattributes= .

O seguinte código inválido falhará silenciosamente retornando sem definir os atributos:

@user.attributes = [ { model: "Sierra" }, { year: "2012" }, { looks: "Sexy" } ]

attributes= comportará silenciosamente como se as designações tivessem sido feitas com sucesso, quando na verdade não eram.

Este código inválido gerará uma exceção ao assign_attributestentar especificar as chaves hash da matriz anexa:

@user.assign_attributes([ { model: "Sierra" }, { year: "2012" }, { looks: "Sexy" } ])

assign_attributesirá gerar uma NoMethodErrorexceção para stringify_keys, indicando que o primeiro argumento não é um Hash. A exceção em si não é muito informativa sobre a causa real, mas o fato de ocorrer uma exceção é muito importante.

A única diferença entre esses casos é o método usado para atribuição em massa: attributes=silenciosamente é bem-sucedido e assign_attributesgera uma exceção para informar que ocorreu um erro.

Esses exemplos podem parecer inventados, e são até certo ponto, mas esse tipo de erro pode ocorrer facilmente ao converter dados de uma API, ou mesmo usando uma série de transformação de dados e esquecendo Hash[]os resultados da final .map. Mantenha algum código de 50 linhas acima e 3 funções removidas da atribuição de atributo, e você terá uma receita para a falha.

A lição do Rails 3 é esta: sempre use em assign_attributesvez de attributes=.

Trilhos 4

No Rails 4, attributes=é simplesmente um apelido para assign_attributes. Consulte a documentação da API ActiveRecord Attribute Assignment paraattributes= .

Com o Rails 4, qualquer um dos métodos pode ser usado de forma intercambiável. A falha em passar um Hash como o primeiro argumento resultará em uma exceção muito útil:ArgumentError: When assigning attributes, you must pass a hash as an argument.

Validações

Se você estiver executando tarefas de pré-vôo em preparação para a save, também poderá estar interessado em validar antes de salvar. Você pode usar os métodos valid?e invalid?para isso. Ambos retornam valores booleanos. valid?retorna true se o modelo não salvo passa em todas as validações ou false se não passa. invalid?é simplesmente o inverso devalid?

valid? pode ser usado assim:

@user.assign_attributes{ model: "Sierra", year: "2012", looks: "Sexy" }.valid?

Isso permitirá que você lide com qualquer problema de validação antes de ligar save.