Come impostare i valori predefiniti in Rails?

Sto cercando di trovare il modo migliore per impostare i valori predefiniti per gli oggetti in Rails.

La cosa migliore a cui riesco a pensare è impostare il valore predefinito nel newmetodo nel controller.

Qualcuno ha qualche input se questo è accettabile o se c'è un modo migliore per farlo?

"Corretto" è una parola pericolosa in Ruby. Di solito c'è più di un modo per fare qualsiasi cosa. Se sai che vorrai sempre quel valore predefinito per quella colonna su quella tabella, impostarli in un file di migrazione DB è il modo più semplice:

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

Poiché ActiveRecord rileva automaticamente le proprietà della tabella e della colonna, questo farà sì che lo stesso valore predefinito venga impostato in qualsiasi modello che lo utilizzi in qualsiasi app Rails standard.

Tuttavia, se desideri impostare valori predefiniti solo in casi specifici, ad esempio è un modello ereditato che condivide una tabella con altri, un altro modo elegante è farlo direttamente nel codice Rails quando viene creato l'oggetto del modello:

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

Quindi, quando si esegue un GenericPerson.new(), verrà sempre trasmesso l'attributo "Doe" fino a, a Person.new()meno che non lo si sostituisca con qualcos'altro.

Sulla base della risposta di SFEley, eccone uno aggiornato / corretto per le versioni più recenti di Rails:

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

Prima di tutto non puoi sovraccaricare initialize(*args) perché non viene chiamato in tutti i casi.

La tua migliore opzione è inserire le tue impostazioni predefinite nella migrazione:

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

La seconda opzione migliore è inserire i valori predefiniti nel modello, ma funzionerà solo con attributi inizialmente nulli. Potresti avere problemi come ho fatto con le booleancolonne:

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

Hai bisogno di new_record? modo che i valori predefiniti non sovrascrivano i valori caricati dal database.

Devi ||=impedire a Rails di sovrascrivere i parametri passati al metodo initialize.

Puoi anche provare change_column_defaultnelle tue migrazioni (testato in 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 Rails API docs

Se ti riferisci a oggetti ActiveRecord, hai (più di) due modi per farlo:

1. Utilizzare un: parametro predefinito nel DB

PER ESEMPIO

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

Maggiori informazioni qui: http://api.rubyonrails.org/classes/ActiveRecord/Migration.html

2. Utilizzare una richiamata

PER ESEMPIO before_validation_on_create

Maggiori informazioni qui: http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html#M002147

In Ruby on Rails v3.2.8, utilizzando il after_initializecallback ActiveRecord, puoi chiamare un metodo nel tuo modello che assegnerà i valori predefiniti per un nuovo oggetto.

Il callback after_initialize viene attivato per ogni oggetto che viene trovato e istanziato da un finder, con after_initialize che viene attivato anche dopo che sono stati istanziati nuovi oggetti ( vedere Callback ActiveRecord ).

Quindi, IMO dovrebbe assomigliare a qualcosa di simile:

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_valueper questa istanza a meno che l'istanza non contenga un attribute_whose_presence_has_been_validatedprecedente salvataggio / aggiornamento. Il default_valueverrà quindi utilizzato in congiunzione con il fine di rendere il modulo che utilizza la default_valueper l' barattributo.

Nella migliore delle ipotesi questo è hacky ...

MODIFICA - usa "new_record?" per verificare se si sta creando un'istanza da una nuova chiamata

Invece di controllare il valore di un attributo, usa il new_record?metodo integrato con rails. Quindi, l'esempio sopra dovrebbe essere simile a:

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

Questo è molto più pulito. Ah, la magia di Rails - è più intelligente di me.

Almeno per i campi booleani in Rails 3.2.6, questo funzionerà nella migrazione.

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

Mettere un 1o 0per un valore predefinito non funzionerà qui, poiché è un campo booleano. Deve essere un valore trueo false.

Se hai a che fare con un modello, puoi utilizzare l'API di Attriutes in Rails 5+ http://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute

basta aggiungere una migrazione con un nome di colonna appropriato e quindi nel modello impostarla con:

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

Genera una migrazione e usa change_column_default, è succinto e reversibile:

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

Se stai solo impostando i valori predefiniti per determinati attributi di un modello supportato da database, prenderei in considerazione l'utilizzo di valori di colonna predefiniti sql: puoi chiarire quali tipi di valori predefiniti stai utilizzando?

Esistono diversi approcci per gestirlo, questo plugin sembra un'opzione interessante.

Il suggerimento di sovrascrivere new / initialize è probabilmente incompleto. Rails chiamerà (frequentemente) allocate per oggetti ActiveRecord e le chiamate per allocare non risulteranno in chiamate da inizializzare.

Se stai parlando di oggetti ActiveRecord, dai un'occhiata a override after_initialize.

Questi post del blog (non il mio) sono utili:

Valori predefiniti Costruttori predefiniti non chiamati

[Modifica: SFEley sottolinea che Rails in realtà guarda il valore predefinito nel database quando istanzia un nuovo oggetto in memoria - non me ne ero reso conto.]

Avevo bisogno di impostare un valore predefinito proprio come se fosse stato specificato come valore di colonna predefinito in DB. Quindi si comporta in questo modo

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

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

Poiché il callback after_initialize viene chiamato dopo aver impostato gli attributi dagli argomenti, non c'era modo di sapere se l'attributo è nil perché non è mai stato impostato o perché è stato impostato intenzionalmente come nil. Quindi ho dovuto dare un'occhiata un po 'e sono arrivato con questa semplice soluzione.

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

Funziona alla grande per me. (Rotaie 3.2.x)

Un modo potenzialmente migliore / più pulito rispetto alle risposte proposte è quello di sovrascrivere l'accessor, in questo modo:

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

Vedere "Sovrascrittura delle funzioni di accesso predefinite" nella documentazione di ActiveRecord :: Base e altro da StackOverflow sull'utilizzo di self .

ho risposto a una domanda simile qui .. un modo pulito per farlo è usare Rails attr_accessor_with_default

class SOF
  attr_accessor_with_default :is_awesome,true
end

sof = SOF.new
sof.is_awesome

=> true

AGGIORNARE

attr_accessor_with_default è stato deprecato in Rails 3.2 .. potresti farlo invece con Ruby puro

class SOF
  attr_writer :is_awesome

  def is_awesome
    @is_awesome ||= true
  end
end

sof = SOF.new
sof.is_awesome

#=> true

Se stai parlando di oggetti ActiveRecord, io uso la gemma "attribute-defaults".

Documentazione e download: https://github.com/bsm/attribute-defaults

Potresti usare la gemma rails_default_value. per esempio:

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

https://github.com/keithrowell/rails_default_value

È possibile sostituire il costruttore per il modello ActiveRecord.

Come questo:

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