ActiveRecord :: Base Sin tabla

Question

Esto me ocurrió hace un poco (los atributos de los carriles href="https://stackoverflow.com/questions/399490"> correspondiente), pero parece que el plugin de Rails es mencionado no se mantiene ( http://agilewebdevelopment.com/plugins/activerecord_base_without_table ). ¿No hay manera de hacer esto con ActiveRecord como es?

Si no, ¿hay alguna manera de obtener las reglas de validación de ActiveRecord sin usar ActiveRecord?

ActiveRecord quiere la mesa de existir, por supuesto.

Answer 1

Este es un método que he utilizado en el pasado:

En app / modelos / 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

En app / modelos / foo.rb

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

script / consola

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

Las validaciones son simplemente un módulo dentro de ActiveRecord. ¿Los ha intentado mezclar en su modelo no ActiveRecord?

class MyModel
  include ActiveRecord::Validations

  # ...
end

Answer 3

Me imagino las respuestas más el mejor ya que este es uno de los primeros resultados en Google al buscar por "carriles 3.1 modelos sin tablas"

He implementa la misma cosa sin usar ActiveRecord :: Base, mientras incluyendo el ActiveRecord :: validaciones

El objetivo principal era conseguir que todo funcione en Formtastic, y por debajo he incluido un pago de ejemplo que no se salvó en cualquier lugar, pero aún tiene la capacidad de ser validado utilizando las validaciones que todos sabemos y el amor.

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

Espero que esto ayude a alguien como yo he pasado un par de horas tratando de resolver esto hoy.

Answer 4

ACTUALIZACIÓN: En Rails 3 esto se puede hacer muy fácil. En Rails 3+ se puede utilizar el nuevo módulo ActiveModel y sus submódulos. Esto debería funcionar ahora:

class Tableless
  include ActiveModel::Validations

  attr_accessor :name

  validates_presence_of :name
end

Para obtener más información, puedes leer el Railscast (o leer sobre él en AsciiCasts ) sobre el tema, así como este entrada de blog por Yehuda Katz .

RESPUESTA OLD sigue:

Es posible que necesite añadir esto a la solución, propuesta por John Topley en el comentario anterior:

class Tableless

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

end

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

Esto le proporciona un nombre de tabla "falso", si lo necesita. Sin este método, Foo::table_name evaluará a "tablelesses".

Answer 5

He encontrado este enlace, que funciona de maravilla.

http://codetunes.com/2008/07/ 20 / sin tablas-modelos-in-rieles /

Answer 6

Sólo una adición a la respuesta aceptada:

Haga que sus subclases heredan las columnas de padres 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

Este es un formulario de búsqueda que presenta un objeto llamado criterios que tiene un anidado periodo objeto con comenzando y final atributos.

La acción en el controlador es muy simple, sin embargo, las cargas de valores de objetos anidados en el formulario y re-renders los mismos valores con mensajes de error si es necesario.

Trabajos sobre rieles 3.1.

El modelo:

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

En el controlador:

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

En el helper:

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

En la 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 el código 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: : El atributo de acción proporcionada por el ayudante y los atributos anidados formato de nombre que hace que sea tan sencillo para el controlador para cargar todos los valores a la vez

Answer 8

Hay la activerecord-joya sin tablas . Es una joya para crear modelos ActiveRecord sin tablas, por lo que cuenta con el apoyo para las validaciones, asociaciones, tipos. Es compatible con Active Record 2.3, 3.0, 3.2

La forma recomendada de hacerlo en los carriles 3.x (usando ActiveModel) no tiene soporte para las asociaciones ni tipos.