Como definir valores padrão no Rails?

Estou tentando encontrar a melhor maneira de definir valores padrão para objetos no Rails.

O melhor que posso pensar é definir o valor padrão no newmétodo do controlador.

Alguém tem alguma opinião se isso é aceitável ou se existe uma maneira melhor de fazer isso?

"Correto" é uma palavra perigosa em Ruby. Geralmente, há mais de uma maneira de fazer qualquer coisa. Se você sabe que sempre desejará esse valor padrão para aquela coluna na tabela, configurá-los em um arquivo de migração de banco de dados é a maneira mais 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

Como o ActiveRecord descobre automaticamente suas propriedades de tabela e coluna, isso fará com que o mesmo padrão seja definido em qualquer modelo que o use em qualquer aplicativo Rails padrão.

No entanto, se você deseja apenas valores padrão definidos em casos específicos - digamos, é um modelo herdado que compartilha uma tabela com alguns outros - então outra maneira elegante é fazer isso diretamente em seu código Rails quando o objeto de modelo é criado:

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

Então, quando você fizer um GenericPerson.new(), o atributo "Doe" será sempre adicionado a, a Person.new()menos que você o substitua por outra coisa.

Com base na resposta do SFEley, aqui está um atualizado / corrigido para as versões mais recentes do Rails:

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

Em primeiro lugar, você não pode sobrecarregar, initialize(*args)pois não é chamado em todos os casos.

Sua melhor opção é colocar seus padrões em sua migração:

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

A segunda melhor opção é colocar padrões em seu modelo, mas isso só funcionará com atributos que inicialmente são nulos. Você pode ter problemas como eu tive com as booleancolunas:

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

Você precisa do new_record?para que os padrões não substituam os valores carregados do banco de dados.

Você precisa ||=impedir o Rails de sobrescrever os parâmetros passados ​​no método de inicialização.

Você também pode tentar change_column_defaultem suas migrações (testado no 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 API do Rails docs

Se estiver se referindo a objetos ActiveRecord, você tem (mais de) duas maneiras de fazer isso:

1. Use um: parâmetro padrão no banco de dados

POR EXEMPLO

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

Mais informações aqui: http://api.rubyonrails.org/classes/ActiveRecord/Migration.html

2. Use um retorno de chamada

POR EXEMPLO before_validation_on_create

Mais informações aqui: http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html#M002147

No Ruby on Rails v3.2.8, usando o after_initializeretorno de chamada ActiveRecord, você pode chamar um método em seu modelo que atribuirá os valores padrão para um novo objeto.

after_initialize callback é disparado para cada objeto que é encontrado e instanciado por um localizador, com after_initialize sendo disparado depois que novos objetos são instanciados também ( veja ActiveRecord Callbacks ).

Então, IMO, deve ser algo como:

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 instância, a menos que a instância contenha attribute_whose_presence_has_been_validatedanteriormente em salvar / atualizar. O default_valueserá então usado em conjunto com sua visualização para renderizar o formulário usando o default_valuepara o baratributo.

Na melhor das hipóteses, isso é hacky ...

EDITAR - usar 'new_record?' para verificar se instanciando de uma nova chamada

Em vez de verificar um valor de atributo, use o new_record?método integrado com trilhos. Portanto, o exemplo acima deve ser semelhante 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

Isso é muito mais limpo. Ah, a magia do Rails - é mais inteligente do que eu.

Para campos booleanos no Rails 3.2.6 pelo menos, isso funcionará em sua migração.

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

Colocar um 1ou 0para um padrão não funcionará aqui, pois é um campo booleano. Deve ser um valor trueou false.

Caso esteja lidando com um modelo, você pode usar a API de atributos no Rails 5+ http://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute

basta adicionar uma migração com um nome de coluna adequado e, em seguida, no modelo configurá-la com:

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

Gerar uma migração e usar change_column_default, é sucinto e reversível:

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

Se você estiver apenas definindo padrões para certos atributos de um modelo de banco de dados, consideraria usar valores de coluna padrão sql - você pode esclarecer quais tipos de padrões você está usando?

Existem várias abordagens para lidar com isso, este plugin parece uma opção interessante.

A sugestão para substituir new / initialize está provavelmente incompleta. O Rails (freqüentemente) chamará alocação para objetos ActiveRecord, e chamadas para alocar não resultarão em chamadas para inicializar.

Se você estiver falando sobre objetos ActiveRecord, dê uma olhada em substituir after_initialize.

Estas postagens do blog (não as minhas) são úteis:

Valores padrão Construtores padrão não chamados

[Edit: SFEley aponta que Rails realmente olha para o padrão no banco de dados quando instancia um novo objeto na memória - eu não tinha percebido isso.]

Eu precisava definir um padrão como se fosse especificado como valor de coluna padrão no banco de dados. Então se comporta assim

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

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

Como o retorno de chamada after_initialize é chamado depois de definir atributos de argumentos, não havia como saber se o atributo é nulo porque nunca foi definido ou porque foi intencionalmente definido como nulo. Então eu tive que fuçar um pouco e vim com esta solução simples.

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

Funciona muito bem para mim. (Rails 3.2.x)

Uma forma potencial ainda melhor / mais limpa do que as respostas propostas é sobrescrever o acessador, assim:

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

Consulte "Sobrescrevendo acessadores padrão" na documentação ActiveRecord :: Base e mais de StackOverflow sobre como usar self .

Eu respondi a uma pergunta semelhante aqui .. uma maneira limpa de fazer isso é usando Rails attr_accessor_with_default

class SOF
  attr_accessor_with_default :is_awesome,true
end

sof = SOF.new
sof.is_awesome

=> true

ATUALIZAR

attr_accessor_with_default tornou-se obsoleto no Rails 3.2 .. você poderia fazer isso ao invés com Ruby puro

class SOF
  attr_writer :is_awesome

  def is_awesome
    @is_awesome ||= true
  end
end

sof = SOF.new
sof.is_awesome

#=> true

Se você está falando sobre objetos ActiveRecord, eu uso a gem 'attribute-defaults'.

Documentação e download: https://github.com/bsm/attribute-defaults

Você pode usar a gema rails_default_value. por exemplo:

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

https://github.com/keithrowell/rails_default_value

Você pode substituir o construtor do modelo ActiveRecord.

Como isso:

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