ActiveRecord::Base, Senza Tavolo

Question

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.

Answer 1

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>>

Answer 2

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

Answer 3

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.

Answer 4

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".

Answer 5

Ho trovato questo link, che funziona a meraviglia.

http://codetunes.com/2008/07/ 20 / tableless-modelli-in-rails /

Answer 6

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

Answer 7

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

Answer 8

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.