Comment définir les valeurs par défaut dans Rails?

J'essaie de trouver le meilleur moyen de définir des valeurs par défaut pour les objets dans Rails.

Le mieux que je puisse penser est de définir la valeur par défaut dans la newméthode dans le contrôleur.

Quelqu'un a-t-il quelque chose à dire si cela est acceptable ou s'il existe une meilleure façon de le faire?

«Correct» est un mot dangereux en Ruby. Il y a généralement plus d'une façon de faire quoi que ce soit. Si vous savez que vous voudrez toujours cette valeur par défaut pour cette colonne sur cette table, les définir dans un fichier de migration de base de données est le moyen le plus simple:

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

Étant donné qu'ActiveRecord détecte automatiquement les propriétés de votre table et de votre colonne, la même valeur par défaut sera définie dans tout modèle l'utilisant dans n'importe quelle application Rails standard.

Cependant, si vous ne voulez que des valeurs par défaut définies dans des cas spécifiques - par exemple, c'est un modèle hérité qui partage une table avec d'autres - alors une autre manière élégante est de le faire directement dans votre code Rails lorsque l'objet de modèle est créé:

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

Ensuite, lorsque vous faites un GenericPerson.new(), il va toujours ruisseler l'attribut "Doe" jusqu'à Person.new()moins que vous ne le remplaciez par autre chose.

Sur la base de la réponse de SFEley, en voici une mise à jour / corrigée pour les nouvelles versions de Rails:

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

Tout d'abord, vous ne pouvez pas surcharger initialize(*args)car il n'est pas appelé dans tous les cas.

Votre meilleure option est de mettre vos valeurs par défaut dans votre migration:

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

Le deuxième mieux est de placer des valeurs par défaut dans votre modèle, mais cela ne fonctionnera qu'avec des attributs initialement nuls. Vous pouvez avoir des problèmes comme je l'ai fait avec les booleancolonnes:

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

Vous en avez besoin new_record?pour que les valeurs par défaut ne remplacent pas les valeurs chargées à partir de la base de données.

Vous devez ||=empêcher Rails de remplacer les paramètres passés dans la méthode d'initialisation.

Vous pouvez également essayer change_column_defaultdans vos migrations (testé dans 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

Documentation sur l'API change_column_default Rails

Si vous faites référence à des objets ActiveRecord, vous avez (plus de) deux façons de procéder:

1. Utilisez un: paramètre par défaut dans le DB

PAR EXEMPLE

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

Plus d'informations ici: http://api.rubyonrails.org/classes/ActiveRecord/Migration.html

2. Utilisez un rappel

PAR EXEMPLE before_validation_on_create

Plus d'informations ici: http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html#M002147

Dans Ruby on Rails v3.2.8, en utilisant le after_initializerappel ActiveRecord, vous pouvez appeler une méthode dans votre modèle qui attribuera les valeurs par défaut pour un nouvel objet.

Le rappel after_initialize est déclenché pour chaque objet trouvé et instancié par un chercheur, after_initialize étant également déclenché après l'instanciation de nouveaux objets ( voir Rappels ActiveRecord ).

Donc, IMO, cela devrait ressembler à quelque chose comme:

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_valuepour cette instance, sauf si l'instance contient une attribute_whose_presence_has_been_validatedsauvegarde / mise à jour précédemment en cours. Le default_valuesera ensuite utilisé avec votre vue pour rendre le formulaire en utilisant default_valuepour l' barattribut.

Au mieux, c'est du piratage ...

EDIT - utilisez 'new_record?' pour vérifier si l'instanciation à partir d'un nouvel appel

Au lieu de vérifier une valeur d'attribut, utilisez la new_record?méthode intégrée avec des rails. Ainsi, l'exemple ci-dessus devrait ressembler à:

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

C'est beaucoup plus propre. Ah, la magie de Rails - c'est plus intelligent que moi.

Pour les champs booléens dans Rails 3.2.6 au moins, cela fonctionnera dans votre migration.

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

Mettre un 1ou 0pour une valeur par défaut ne fonctionnera pas ici, car il s'agit d'un champ booléen. Ce doit être une valeur trueou false.

Dans le cas où vous avez affaire à un modèle, vous pouvez utiliser l'API Attriutes dans Rails 5+ http://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute

ajoutez simplement une migration avec un nom de colonne approprié, puis dans le modèle, définissez-la avec:

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

Générer une migration et une utilisation change_column_default, c'est succinct et réversible:

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

Si vous définissez simplement des valeurs par défaut pour certains attributs d'un modèle basé sur une base de données, j'envisagerais d'utiliser les valeurs de colonne par défaut SQL - pouvez-vous clarifier les types de valeurs par défaut que vous utilisez?

Il existe un certain nombre d'approches pour le gérer, ce plugin ressemble à une option intéressante.

La suggestion de remplacer new / initialize est probablement incomplète. Rails appellera (fréquemment) allocate pour les objets ActiveRecord, et les appels à allouer n'entraîneront pas d'appels à initialiser.

Si vous parlez d'objets ActiveRecord, jetez un œil à la substitution de after_initialize.

Ces articles de blog (pas les miens) sont utiles:

Valeurs par défaut Constructeurs par défaut non appelés

[Edit: SFEley souligne que Rails regarde réellement la valeur par défaut dans la base de données quand il instancie un nouvel objet en mémoire - je ne l'avais pas réalisé.]

J'avais besoin de définir une valeur par défaut comme si elle était spécifiée comme valeur de colonne par défaut dans DB. Donc ça se comporte comme ça

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

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

Comme le rappel after_initialize est appelé après avoir défini des attributs à partir d'arguments, il n'y avait aucun moyen de savoir si l'attribut est nul car il n'a jamais été défini ou parce qu'il a été intentionnellement défini comme nul. J'ai donc dû fouiller un peu à l'intérieur et suis venu avec cette solution simple.

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

Fonctionne très bien pour moi. (Rails 3.2.x)

Un moyen potentiel potentiellement encore meilleur / plus propre que les réponses proposées est d'écraser l'accesseur, comme ceci:

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

Voir «Écraser les accesseurs par défaut» dans la documentation ActiveRecord :: Base et plus de StackOverflow sur l'utilisation de self .

J'ai répondu à une question similaire ici .. une façon simple de le faire est d'utiliser Rails attr_accessor_with_default

class SOF
  attr_accessor_with_default :is_awesome,true
end

sof = SOF.new
sof.is_awesome

=> true

METTRE À JOUR

attr_accessor_with_default est obsolète dans Rails 3.2 .. vous pouvez le faire à la place avec du Ruby pur

class SOF
  attr_writer :is_awesome

  def is_awesome
    @is_awesome ||= true
  end
end

sof = SOF.new
sof.is_awesome

#=> true

Si vous parlez d'objets ActiveRecord, j'utilise la gemme «attributs par défaut».

Documentation et téléchargement: https://github.com/bsm/attribute-defaults

Vous pouvez utiliser la gemme rails_default_value. par exemple:

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

https://github.com/keithrowell/rails_default_value

Vous pouvez remplacer le constructeur du modèle ActiveRecord.

Comme ça:

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