¿Cómo establecer valores predeterminados en Rails?

Estoy tratando de encontrar la mejor manera de establecer valores predeterminados para objetos en Rails.

Lo mejor que se me ocurre es establecer el valor predeterminado en el newmétodo en el controlador.

¿Alguien tiene alguna sugerencia si esto es aceptable o si hay una mejor manera de hacerlo?

"Correcto" es una palabra peligrosa en Ruby. Por lo general, hay más de una forma de hacer cualquier cosa. Si sabe que siempre querrá ese valor predeterminado para esa columna en esa tabla, configurarlos en un archivo de migración de base de datos es la forma más fácil:

class SetDefault < ActiveRecord::Migration
  def self.up
    change_column :people, :last_name, :type, :default => "Doe"
  end

  def self.down
    # You can't currently remove default values in Rails
    raise ActiveRecord::IrreversibleMigration, "Can't remove the default"
  end
end

Debido a que ActiveRecord detecta automáticamente las propiedades de su tabla y columna, esto hará que se establezca el mismo valor predeterminado en cualquier modelo que lo use en cualquier aplicación estándar de Rails.

Sin embargo, si solo desea establecer valores predeterminados en casos específicos, por ejemplo, es un modelo heredado que comparte una tabla con otros, entonces otra forma elegante es hacerlo directamente en su código Rails cuando se crea el objeto modelo:

class GenericPerson < Person
  def initialize(attributes=nil)
    attr_with_defaults = {:last_name => "Doe"}.merge(attributes)
    super(attr_with_defaults)
  end
end

Luego, cuando hagas una GenericPerson.new(), siempre se filtrará el atributo "Doe" a Person.new()menos que lo anules con otra cosa.

Basado en la respuesta de SFEley, aquí hay uno actualizado / fijo para las versiones más nuevas de Rails:

class SetDefault < ActiveRecord::Migration
  def change
    change_column :table_name, :column_name, :type, default: "Your value"
  end
end

En primer lugar, no puede sobrecargar, initialize(*args)ya que no se llama en todos los casos.

Su mejor opción es poner sus valores predeterminados en su migración:

add_column :accounts, :max_users, :integer, :default => 10

La segunda mejor opción es colocar valores predeterminados en su modelo, pero esto solo funcionará con atributos que inicialmente son nulos. Puede tener problemas como yo con las booleancolumnas:

def after_initialize
  if new_record?
    max_users ||= 10
  end
end

Necesita el new_record?para que los valores predeterminados no anulen los valores cargados desde la base de datos.

Es necesario ||=dejar de rieles anule los parámetros pasados al método initialize.

También puede probar change_column_defaulten sus migraciones (probado en Rails 3.2.8):

class SetDefault < ActiveRecord::Migration
  def up
    # Set default value
    change_column_default :people, :last_name, "Smith"
  end

  def down
    # Remove default
    change_column_default :people, :last_name, nil
  end
end

change_column_default Documentos de la API de Rails

Si se refiere a objetos ActiveRecord, tiene (más de) dos formas de hacerlo:

1. Utilice un: parámetro predeterminado en la base de datos

P.EJ

class AddSsl < ActiveRecord::Migration
  def self.up
    add_column :accounts, :ssl_enabled, :boolean, :default => true
  end

  def self.down
    remove_column :accounts, :ssl_enabled
  end
end

Más información aquí: http://api.rubyonrails.org/classes/ActiveRecord/Migration.html

2. Utilice una devolución de llamada

P.EJ before_validation_on_create

Más información aquí: http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html#M002147

En Ruby on Rails v3.2.8, usando la after_initializedevolución de llamada ActiveRecord, puede llamar a un método en su modelo que asignará los valores predeterminados para un nuevo objeto.

La devolución de llamada after_initialize se activa para cada objeto que un buscador encuentra y crea una instancia, y after_initialize también se activa después de crear una instancia de los nuevos objetos ( consulte las devoluciones de llamada de ActiveRecord ).

Entonces, en mi opinión, debería verse así:

class Foo < ActiveRecord::Base
  after_initialize :assign_defaults_on_new_Foo
  ...
  attr_accessible :bar
  ...
  private
  def assign_defaults_on_new_Foo
    # required to check an attribute for existence to weed out existing records
    self.bar = default_value unless self.attribute_whose_presence_has_been_validated
  end
end

Foo.bar = default_valuepara esta instancia, a menos que la instancia contenga attribute_whose_presence_has_been_validatedpreviamente un guardado / actualización. El default_valuese utilizará entonces en conjunción con su visión para hacer que el formulario utilizando el default_valuepara el baratributo.

En el mejor de los casos, esto es hacky ...

EDITAR - use 'new_record?' para comprobar si se crea una instancia desde una nueva llamada

En lugar de comprobar el valor de un atributo, utilice el new_record?método integrado con rieles. Entonces, el ejemplo anterior debería verse así:

class Foo < ActiveRecord::Base
  after_initialize :assign_defaults_on_new_Foo, if: 'new_record?'
  ...
  attr_accessible :bar
  ...
  private
  def assign_defaults_on_new_Foo
    self.bar = default_value
  end
end

Esto es mucho más limpio. Ah, la magia de Rails, es más inteligente que yo.

Para los campos booleanos en Rails 3.2.6 al menos, esto funcionará en su migración.

def change
  add_column :users, :eula_accepted, :boolean, default: false
end

Poner 1o 0por defecto no funcionará aquí, ya que es un campo booleano. Debe ser un valor trueo false.

En caso de que se trate de un modelo, puede utilizar la API de atributos en Rails 5+ http://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute

simplemente agregue una migración con un nombre de columna adecuado y luego en el modelo configúrelo con:

class StoreListing < ActiveRecord::Base
  attribute :country, :string, default: 'PT'
end

Genera una migración y uso change_column_default, es sucinto y reversible:

class SetDefaultAgeInPeople < ActiveRecord::Migration[5.2]
  def change
    change_column_default :people, :age, { from: nil, to: 0 }
  end
end

Si solo está configurando valores predeterminados para ciertos atributos de un modelo respaldado por una base de datos, consideraría usar valores de columna predeterminados de SQL: ¿puede aclarar qué tipos de valores predeterminados está utilizando?

Hay varios enfoques para manejarlo, este complemento parece una opción interesante.

La sugerencia de anular new / initialize probablemente esté incompleta. Rails (con frecuencia) llamará a allocate para los objetos ActiveRecord, y las llamadas a allocate no resultarán en llamadas a inicializar.

Si está hablando de objetos ActiveRecord, eche un vistazo a anular after_initialize.

Estas publicaciones de blog (no las mías) son útiles:

Valores predeterminados No se llaman los constructores predeterminados

[Editar: SFEley señala que Rails en realidad mira el valor predeterminado en la base de datos cuando crea una instancia de un nuevo objeto en la memoria; no me había dado cuenta de eso].

Necesitaba establecer un valor predeterminado como si estuviera especificado como valor de columna predeterminado en la base de datos. Entonces se comporta así

a = Item.new
a.published_at # => my default value

a = Item.new(:published_at => nil)
a.published_at # => nil

Debido a que se llama a la devolución de llamada after_initialize después de establecer atributos a partir de argumentos, no había forma de saber si el atributo es nil porque nunca se estableció o porque se estableció intencionalmente como nil. Así que tuve que hurgar un poco y vine con esta sencilla solución.

class Item < ActiveRecord::Base
  def self.column_defaults
    super.merge('published_at' => Time.now)
  end
end

Funciona muy bien para mi. (Rieles 3.2.x)

Una forma potencial potencialmente incluso mejor / más limpia que las respuestas propuestas es sobrescribir el descriptor de acceso, así:

def status
  self['name_of_var'] || 'desired_default_value'
end

Consulte "Sobrescritura de los descriptores de acceso predeterminados" en la documentación de ActiveRecord :: Base y más de StackOverflow sobre el uso de self .

Respondí una pregunta similar aquí ... una forma limpia de hacer esto es usando Rails attr_accessor_with_default

class SOF
  attr_accessor_with_default :is_awesome,true
end

sof = SOF.new
sof.is_awesome

=> true

ACTUALIZAR

attr_accessor_with_default ha quedado obsoleto en Rails 3.2 ... puedes hacer esto en su lugar con Ruby puro

class SOF
  attr_writer :is_awesome

  def is_awesome
    @is_awesome ||= true
  end
end

sof = SOF.new
sof.is_awesome

#=> true

Si estás hablando de objetos ActiveRecord, utilizo la gema 'atributos predeterminados'.

Documentación y descarga: https://github.com/bsm/attribute-defaults

Podrías usar la gema rails_default_value. p.ej:

class Foo < ActiveRecord::Base
  # ...
  default :bar => 'some default value'
  # ...
end

https://github.com/keithrowell/rails_default_value

Puede anular el constructor del modelo ActiveRecord.

Me gusta esto:

def initialize(*args)
  super(*args)
  self.attribute_that_needs_default_value ||= default_value
  self.attribute_that_needs_another_default_value ||= another_default_value
  #ad nauseum
end