Jak ustawić domyślne wartości w Railsach?

Próbuję znaleźć najlepszy sposób na ustawienie wartości domyślnych dla obiektów w Railsach.

Najlepsze, co przychodzi mi do głowy, to ustawienie wartości domyślnej w newmetodzie w kontrolerze.

Czy ktoś ma jakiś wkład, jeśli jest to dopuszczalne lub czy istnieje lepszy sposób na zrobienie tego?

„Prawidłowo” to niebezpieczne słowo w języku Ruby. Zwykle jest więcej niż jeden sposób na zrobienie czegokolwiek. Jeśli wiesz, że zawsze będziesz potrzebować tej domyślnej wartości dla tej kolumny w tej tabeli, ustawienie ich w pliku migracji bazy danych jest najłatwiejszym sposobem:

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

Ponieważ ActiveRecord automatycznie wykrywa właściwości tabeli i kolumny, spowoduje to ustawienie tego samego domyślnego w każdym modelu używającym go w dowolnej standardowej aplikacji Railsowej.

Jeśli jednak chcesz ustawić wartości domyślne tylko w określonych przypadkach - powiedzmy, że jest to model dziedziczony, który dzieli tabelę z innymi - to innym eleganckim sposobem jest zrobienie tego bezpośrednio w kodzie Railsów, gdy tworzony jest obiekt modelu:

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

Następnie, gdy zrobisz a GenericPerson.new(), zawsze przepłynie atrybut „Doe” do, Person.new()chyba że zastąpisz go czymś innym.

W oparciu o odpowiedź SFEley, tutaj jest zaktualizowany / poprawiony dla nowszych wersji Railsów:

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

Przede wszystkim nie możesz przeciążać, initialize(*args)ponieważ nie jest to wywoływane we wszystkich przypadkach.

Najlepszą opcją jest dodanie ustawień domyślnych do migracji:

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

Drugą najlepszą metodą jest umieszczenie w modelu wartości domyślnych, ale zadziała to tylko z atrybutami, które początkowo są zerowe. Możesz mieć problemy, tak jak ja z booleankolumnami:

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

Potrzebujesz, new_record?aby wartości domyślne nie zastępowały wartości załadowanych z bazy danych.

Musisz ||=powstrzymać Railsy przed nadpisywaniem parametrów przekazanych do metody initialize.

Możesz także spróbować change_column_defaultswoich migracji (testowane w Railsach 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 Dokumentacja Rails API

Jeśli odnosisz się do obiektów ActiveRecord, masz na to (więcej niż) dwa sposoby:

1. Użyj: default parametru w DB

NA PRZYKŁAD

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

Więcej informacji tutaj: http://api.rubyonrails.org/classes/ActiveRecord/Migration.html

2. Użyj oddzwaniania

NA PRZYKŁAD before_validation_on_create

Więcej informacji tutaj: http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html#M002147

W Ruby on Rails v3.2.8, używając after_initializewywołania zwrotnego ActiveRecord, możesz wywołać metodę w swoim modelu, która przypisze domyślne wartości dla nowego obiektu.

Funkcja zwrotna after_initialize jest wyzwalana dla każdego obiektu, który został znaleziony i utworzony przez wyszukiwarkę, przy czym funkcja after_initialize jest wyzwalana również po utworzeniu instancji nowych obiektów ( zobacz Wywołania zwrotne ActiveRecord ).

Więc IMO powinno wyglądać mniej więcej tak:

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_valuew tym przypadku, chyba że instancja zawiera attribute_whose_presence_has_been_validatedpoprzednio zapisaną / aktualizację. default_valueZostaną następnie wykorzystane w połączeniu z widoku do renderowania formularz używając default_valuedo baratrybutu.

W najlepszym razie jest to hacky ...

EDYCJA - użyj „new_record?” aby sprawdzić, czy tworzona jest instancja z nowego połączenia

Zamiast sprawdzać wartość atrybutu, użyj new_record?wbudowanej metody z railsami. Tak więc powyższy przykład powinien wyglądać następująco:

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

To jest dużo czystsze. Ach, magia Railsów - jest mądrzejsza ode mnie.

Przynajmniej dla pól boolowskich w Railsach 3.2.6 będzie to działać podczas migracji.

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

Wstawienie 1lub 0jako wartości domyślnej nie zadziała tutaj, ponieważ jest to pole logiczne. Musi to być wartość a truelub false.

Jeśli masz do czynienia z modelem, możesz użyć API Attriutes w Railsach 5+ http://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute

wystarczy dodać migrację z odpowiednią nazwą kolumny, a następnie w modelu ustawić ją za pomocą:

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

Wygeneruj migrację i użyj change_column_default, jest zwięzły i odwracalny:

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

Jeśli ustawiasz tylko wartości domyślne dla niektórych atrybutów modelu opartego na bazie danych, rozważyłbym użycie domyślnych wartości kolumn sql - czy możesz wyjaśnić, jakich typów domyślnych używasz?

Istnieje wiele podejść do tego, ta wtyczka wygląda na interesującą opcję.

Propozycja zastąpienia nowego / inicjalizacji jest prawdopodobnie niekompletna. Railsy będą (często) wywoływać alokację dla obiektów ActiveRecord, a wywołania alokacji nie spowodują wywołań inicjalizacji.

Jeśli mówisz o obiektach ActiveRecord, przyjrzyj się zastępowaniu after_initialize.

Te posty na blogu (nie moje) są przydatne:

Wartości domyślne Nie wywołano konstruktorów domyślnych

[Edycja: SFEley wskazuje, że Railsy faktycznie patrzą na domyślne w bazie danych, gdy tworzy instancję nowego obiektu w pamięci - nie zdawałem sobie z tego sprawy.]

Musiałem ustawić wartość domyślną, tak jakby została określona jako domyślna wartość kolumny w DB. Więc zachowuje się tak

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

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

Ponieważ wywołanie zwrotne after_initialize jest wywoływane po ustawieniu atrybutów z argumentów, nie było możliwości sprawdzenia, czy atrybut jest zerowy, ponieważ nigdy nie został ustawiony lub został celowo ustawiony na zero. Musiałem więc trochę zagrzebać się w środku i przyszedłem z tym prostym rozwiązaniem.

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

U mnie działa świetnie. (Rails 3.2.x)

Potencjalnie jeszcze lepszym / czystszym potencjalnym sposobem niż proponowane odpowiedzi jest nadpisanie akcesora, na przykład:

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

Zobacz „Nadpisywanie domyślnych metod dostępu ” w dokumentacji ActiveRecord :: Base i nie tylko ze StackOverflow na temat używania self .

I odpowiedział na podobne pytanie tutaj .. czysty sposób, aby to zrobić przy użyciu Rails attr_accessor_with_default

class SOF
  attr_accessor_with_default :is_awesome,true
end

sof = SOF.new
sof.is_awesome

=> true

AKTUALIZACJA

attr_accessor_with_default został uznany za przestarzały w Railsach 3.2 .. zamiast tego możesz to zrobić za pomocą czystego Rubiego

class SOF
  attr_writer :is_awesome

  def is_awesome
    @is_awesome ||= true
  end
end

sof = SOF.new
sof.is_awesome

#=> true

Jeśli mówisz o obiektach ActiveRecord, używam klejnotu „atrybut-domyślne”.

Dokumentacja i pobieranie: https://github.com/bsm/attribute-defaults

Możesz użyć klejnotu rails_default_value. na przykład:

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

https://github.com/keithrowell/rails_default_value

Możesz nadpisać konstruktora dla modelu ActiveRecord.

Lubię to:

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