Activerecord :: Base Ohne Tabelle

Question

Das kam vor etwas nach oben ( Schienen Modellattribut ohne Spalte in db entspricht), aber es sieht aus wie die Rails-Plugin erwähnt ist nicht aufrechterhalten ( http://agilewebdevelopment.com/plugins/activerecord_base_without_table ). Gibt es keine Möglichkeit, dies mit Active zu tun wie?

Wenn nicht, gibt es eine Möglichkeit, Activevalidierungsregeln zu erhalten, ohne Active mit?

Active will die Tabelle existiert, natürlich.

Answer 1

Dies ist ein Ansatz, den ich in der Vergangenheit verwendet habe:

app / models / 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

app / models / foo.rb

class Foo < Tableless
  column :bar, :string  
  validates_presence_of :bar
end

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

Validierungen sind einfach ein Modul innerhalb von Active. Haben Sie versucht, sie in Ihr nicht-Active Modell Mischen?

class MyModel
  include ActiveRecord::Validations

  # ...
end

Answer 3

Ich stelle dar, die mehr Antworten, da dies die bessere der ersten Ergebnisse in Google ist bei der Suche nach „Schienen 3.1 Modelle ohne Tabellen“

Ich habe implementiert die gleiche Sache ohne Active mit :: Base unter Einbeziehung der Active :: Validierungen

Das Hauptziel war alles in formtastic Arbeit zu bekommen, und unten ich eine Probe Zahlung aufgenommen haben, die nicht überall gespeichert werden erhalten, aber hat immer noch die Möglichkeit, die Validierungen werden validiert mit Hilfe wir alle kennen und lieben.

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

Ich hoffe, das hilft jemand wie ich ein paar Stunden verbracht haben versucht, dies heute zu verstehen.

Answer 4

UPDATE: Für Rails 3 dies sehr einfach durchgeführt werden kann. In Rails 3 + können Sie den neuen ActiveModel Modul und seine Submodule verwenden. Dies sollte funktionieren jetzt:

class Tableless
  include ActiveModel::Validations

  attr_accessor :name

  validates_presence_of :name
end

Für weitere Informationen, können Sie Besuche die Railscast (oder lesen sie es auf AsciiCasts ) zum Thema sowie das Blog-Eintrag von Yehuda Katz .

ALTE ANTWORT FOLGT:

Unter Umständen müssen Sie diese zur Lösung hinzuzufügen, die von John Topley im vorherigen Kommentar vorgeschlagen:

class Tableless

  class << self
    def table_name
      self.name.tableize
    end
  end

end

class Foo < Tableless; end
Foo.table_name # will return "foos"

Damit erhalten Sie einen „falschen“ Tabellenname, wenn man einen braucht. Ohne diese Methode wird Foo::table_name bewerten zu „tablelesses“.

Answer 5

Ich fand diesen Link, die BEAUTIFULLY funktioniert.

http://codetunes.com/2008/07/ 20 / tableless-Modelle-in-Schienen /

Answer 6

Nur eine Ergänzung der akzeptierten Antwort:

Machen Sie Ihre Unterklassen die übergeordneten Spalten mit erben:

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

Dies ist ein Suchformular, das ein Objekt präsentiert genannt Kriterien , der ein verschachtelter hat Periode Objekt mit Anfang und Ende Attribute.

Die Aktion in der Steuerung ist wirklich einfach noch lädt es Werte von verschachtelten Objekten auf dem Formular und wieder macht die gleichen Werte mit Fehlermeldungen, falls erforderlich.

Works on Rails 3.1.

Das Modell:

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

In der Steuerung:

def search
  @criteria = Criteria.new params[:criteria]
end

In den Helfern:

def criteria_index_path ct, options = {}
  url_for :action => :search
end

In der Ansicht:

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

Erzeugt die 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">

Hinweis : Das action-Attribut durch den Helfer und die verschachtelten Attribute Namensformat zur Verfügung gestellt, die es so einfach für die Steuerung macht auf einmal alle Werte laden

Answer 8

Es gibt das active-tableless gem . Es ist ein Juwel tableless Active Modelle zu erstellen, so hat es die Unterstützung für Validierungen, Verbände, Typen. Es unterstützt Active Record 2.3, 3.0, 3.2

Es wird empfohlen, es in Rails 3.x (mit ActiveModel) zu tun hat, keine Unterstützung für Verbände noch Typen.