¿Rails update_attributes sin guardar?

¿Hay una alternativa para update_attributes que no guarde el registro?

Entonces podría hacer 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 

Por cierto, sé que puedo @car.model = 'Sierra' , pero quiero actualizarlos todos en una línea.

Creo que lo que estás buscando es assign_attributes .

Básicamente es lo mismo que update_attributes, pero no guarda el 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 

Puede usar assign_attributes o attributes= (son lo mismo)

Actualizar la tabla de trucos de los métodos (para Rails 4):

  • update_attributes = assign_attributes + save
  • attributes= = alias de assign_attributes
  • update = alias de los update_attributes de update_attributes

Fuente:
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

Otra hoja de trucos:
http://www.davidverhasselt.com/set-attributes-in-activerecord/#cheat-sheet

Puedes usar el método de ‘atributos’:

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

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

attributes = (new_attributes, guard_protected_attributes = true) Le permite establecer todos los atributos a la vez pasando un hash con claves que coincidan con los nombres de los atributos (que de nuevo coinciden con los nombres de las columnas).

Si guard_protected_attributes es verdadero (el valor predeterminado), los atributos sensibles se pueden proteger de esta forma de asignación masiva mediante el uso de la macro attr_protected. O puede especificar alternativamente a qué atributos se puede acceder con la macro attr_accessible. Entonces todos los atributos no incluidos en eso no podrán ser asignados en masa.

 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 la asignación masiva de valores a un modelo de ActiveRecord sin guardar, use los attributes= assign_attributes o attributes= . Estos métodos están disponibles en Rails 3 y más nuevos. Sin embargo, hay pequeñas diferencias y errores relacionados con la versión a tener en cuenta.

Ambos métodos siguen este uso:

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

Tenga en cuenta que ninguno de los métodos realizará validaciones o ejecutar devoluciones de llamada; las devoluciones de llamada y la validación suceden cuando se llama a save .

Carriles 3

attributes= difiere ligeramente de assign_attributes en Rails 3. attributes= verificará que el argumento que se le pasa sea Hash, y devuelve inmediatamente si no lo es; assign_attributes no tiene dicha comprobación Hash. Consulte la documentación de la API de Asignación de atributos de ActiveRecord para attributes= .

El siguiente código inválido fallará silenciosamente simplemente volviendo sin establecer los atributos:

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

attributes= se comportará silenciosamente como si las asignaciones se hubieran realizado con éxito, cuando en realidad no lo eran.

Este código no válido generará una excepción cuando assign_attributes intente codificar las claves hash de la matriz circundante:

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

assign_attributes generará una excepción NoMethodError para stringify_keys , lo que indica que el primer argumento no es un Hash. La excepción en sí misma no es muy informativa sobre la causa real, pero el hecho de que ocurra una excepción es muy importante.

La única diferencia entre estos casos es el método utilizado para la asignación masiva: attributes= tiene éxito silenciosamente, y assign_attributes genera una excepción para informar que se ha producido un error.

Estos ejemplos pueden parecer ingeniosos, y lo son en cierto grado, pero este tipo de error puede ocurrir fácilmente al convertir datos de una API, o incluso simplemente usando una serie de transformación de datos y olvidando Hash[] los resultados del .map final . Mantenga un código 50 líneas arriba y 3 funciones eliminadas de su asignación de atributos, y tiene una receta para el fracaso.

La lección con Rails 3 es esta: siempre use assign_attributes lugar de attributes= .

Carriles 4

En Rails 4, attributes= es simplemente un alias para assign_attributes . Consulte la documentación de la API de Asignación de atributos de ActiveRecord para attributes= .

Con Rails 4, cualquiera de los métodos se puede usar indistintamente. Si no pasa un Hash como primer argumento, se obtendrá una excepción muy útil: ArgumentError: When assigning attributes, you must pass a hash as an argument.

Validaciones

Si tiene asignaciones previas al vuelo en preparación para un save , también podría estar interesado en validar antes de guardar. Puedes usar el valid? y invalid? métodos para esto Ambos devuelven valores booleanos. valid? devuelve verdadero si el modelo no guardado pasa todas las validaciones o falso si no lo hace. invalid? es simplemente el inverso de valid?

valid? se puede usar así:

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

Esto le dará la capacidad de manejar cualquier problema de validación antes de llamar a save .

    Intereting Posts