ActiveRecord::Base, Senza Tavolo
-
06-09-2019 - |
Domanda
Questo è venuto un po ' fa ( guide di attributi del modello senza corrispondente colonna nel db ) ma sembra che i Binari plugin menzionato non è mantenuto ( http://agilewebdevelopment.com/plugins/activerecord_base_without_table ).Non c'è modo di fare questo con ActiveRecord, come è?
Se non c'è un modo per ottenere ActiveRecord regole di convalida, senza l'utilizzo di ActiveRecord?
ActiveRecord vuole la tabella esiste, naturalmente.
Soluzione
Questo è un approccio che ho usato in passato:
Nel app / modelli / tableless.rb
class Tableless < ActiveRecord::Base
def self.columns
@columns ||= [];
end
def self.column(name, sql_type = nil, default = nil, null = true)
columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default,
sql_type.to_s, null)
end
# Override the save method to prevent exceptions.
def save(validate = true)
validate ? valid? : true
end
end
Nel app / modelli / foo.rb
class Foo < Tableless
column :bar, :string
validates_presence_of :bar
end
Nel script / console
Loading development environment (Rails 2.2.2)
>> foo = Foo.new
=> #<Foo bar: nil>
>> foo.valid?
=> false
>> foo.errors
=> #<ActiveRecord::Errors:0x235b270 @errors={"bar"=>["can't be blank"]}, @base=#<Foo bar: nil>>
Altri suggerimenti
Le convalide sono semplicemente un modulo all'interno di ActiveRecord. Hai provato a mescolare li nella vostra non-ActiveRecord modello?
class MyModel
include ActiveRecord::Validations
# ...
end
ho dato le risposte più e meglio dal momento che questo è uno dei primi risultati in Google per la ricerca di "rotaie 3.1 modelli senza tabelle"
Ho implementa la stessa cosa senza usare ActiveRecord :: Base, mentre tra cui l'ActiveRecord :: convalide
Lo scopo principale era quello di far funzionare tutto in Formtastic, e al di sotto ho incluso un pagamento del campione che non andranno da nessuna parte salvato, ma ha ancora la capacità di essere convalidati utilizzando le convalide che tutti noi conosciamo e amiamo.
class Payment
include ActiveModel::Validations
attr_accessor :cc_number, :payment_type, :exp_mm, :exp_yy, :card_security, :first_name, :last_name, :address_1, :address_2, :city, :state, :zip_code, :home_telephone, :email, :new_record
validates_presence_of :cc_number, :payment_type, :exp_mm, :exp_yy, :card_security, :first_name, :last_name, :address_1, :address_2, :city, :state
def initialize(options = {})
if options.blank?
new_record = true
else
new_record = false
end
options.each do |key, value|
method_object = self.method((key + "=").to_sym)
method_object.call(value)
end
end
def new_record?
return new_record
end
def to_key
end
def persisted?
return false
end
end
Spero che questo aiuta qualcuno come ho passato un paio d'ore cercando di capire questo fuori oggi.
UPDATE: Per Rails 3 questo può essere fatto molto facile. In Rails 3+ è possibile utilizzare il nuovo modulo ActiveModel
ed i suoi moduli. Questo dovrebbe funzionare ora:
class Tableless
include ActiveModel::Validations
attr_accessor :name
validates_presence_of :name
end
Per ulteriori informazioni, è possibile controllare il Railscast (o letto su AsciiCasts ) sul tema, così come questo post sul blog da Yehuda Katz .
RISPOSTA OLD segue:
Potrebbe essere necessario aggiungere questo alla soluzione, proposta da John Topley nel commento precedente:
class Tableless
class << self
def table_name
self.name.tableize
end
end
end
class Foo < Tableless; end
Foo.table_name # will return "foos"
Questo fornisce un nome di tabella "falso", se ne avrete bisogno. Senza questo metodo, Foo::table_name
valuterà a "tablelesses".
Ho trovato questo link, che funziona a meraviglia.
http://codetunes.com/2008/07/ 20 / tableless-modelli-in-rails /
Proprio un'aggiunta alla risposta accettata:
Fai la tua sottoclassi ereditano le colonne genitore con:
class FakeAR < ActiveRecord::Base
def self.inherited(subclass)
subclass.instance_variable_set("@columns", columns)
super
end
def self.columns
@columns ||= []
end
def self.column(name, sql_type = nil, default = nil, null = true)
columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
end
# Overrides save to prevent exceptions.
def save(validate = true)
validate ? valid? : true
end
end
Questo è un modulo di ricerca che presenta un oggetto chiamato criteri che ha nidificato periodo oggetto inizio e fine attributi.
L'azione del controller è molto semplice ma carica di valori da oggetti nidificati sul modulo e ri-rende gli stessi valori con i messaggi di errore, se necessario.
Funziona su Rails 3.1.
Modello:
class Criteria < ActiveRecord::Base
class << self
def column_defaults
{}
end
def column_names
[]
end
end # of class methods
attr_reader :period
def initialize values
values ||= {}
@period = Period.new values[:period] || {}
super values
end
def period_attributes
@period
end
def period_attributes= new_values
@period.attributes = new_values
end
end
Nel controller:
def search
@criteria = Criteria.new params[:criteria]
end
Nel helper:
def criteria_index_path ct, options = {}
url_for :action => :search
end
Nella vista:
<%= form_for @criteria do |form| %>
<%= form.fields_for :period do |prf| %>
<%= prf.text_field :beginning_as_text %>
<%= prf.text_field :end_as_text %>
<% end %>
<%= form.submit "Search" %>
<% end %>
Produce l'HTML:
<form action="/admin/search" id="new_criteria" method="post">
<input id="criteria_period_attributes_beginning_as_text" name="criteria[period_attributes][beginning_as_text]" type="text">
<input id="criteria_period_attributes_end_as_text" name="criteria[period_attributes][end_as_text]" type="text">
Nota:L'attributo action forniti dall'aiuto e gli attributi annidati formato di denominazione che la rende così semplice per il controller per caricare tutti i valori in una sola volta
il activerecord-tableless gioiello . E 'un gioiello per creare modelli ActiveRecord tableless, quindi ha il supporto per le convalide, le associazioni, i tipi. Supporta attivo Record 2.3, 3.0, 3.2
Il modo consigliato di farlo in Rails 3.x (usando ActiveModel) non ha il supporto per le associazioni, né i tipi.