ruby on rails - render_to_string - ¿Hay alguna forma de obtener una colección de todos los Modelos en su aplicación Rails?

routes in ruby on rails

Question

¿Hay alguna forma de obtener una colección de todos los Modelos en su aplicación Rails?

Básicamente, ¿puedo hacer lo siguiente de:

Models.each do |model|
puts model.class.name
end

Answer 1

Acabo de encontrar este, ya que necesito imprimir todos los modelos con sus atributos (basado en el comentario de @Aditya Sanghi):

ActiveRecord::Base.connection.tables.map{|x|x.classify.safe_constantize}.compact.each{ |model| print "/n/n"+model.name; model.new.attributes.each{|a,b| print "/n#{a}"}}

Answer 2

Aquí hay una solución que ha sido probada con una aplicación compleja de Rails (la que alimenta Square)

def all_models
# must eager load all the classes...
Dir.glob("#{RAILS_ROOT}/app/models/**/*.rb") do |model_path|
begin
require model_path
rescue
# ignore
end
end
# simply return them
ActiveRecord::Base.send(:subclasses)
end

Toma las mejores partes de las respuestas en este hilo y las combina en la solución más simple y completa. Este maneja los casos donde tus modelos están en subdirectorios, usa set_table_name, etc.

Answer 3

Asumiendo que todos los modelos están en la aplicación / modelos y que tienes grep & awk en tu servidor (la mayoría de los casos),

# extract lines that match specific string, and print 2nd word of each line
results = `grep -r "< ActiveRecord::Base" app/models/ | awk ''{print $2}''`
model_names = results.split("/n")

Es más rápido que Rails.application.eager_load! o recorriendo cada archivo con Dir .

EDITAR:

La desventaja de este método es que falla en los modelos que heredan indirectamente de ActiveRecord (por ejemplo, FictionalBook < Book ). La forma más segura es Rails.application.eager_load!; ActiveRecord::Base.descendants.map(&:name) Rails.application.eager_load!; ActiveRecord::Base.descendants.map(&:name) , aunque es un poco lento.

Answer 4

Busqué maneras de hacer esto y terminé eligiendo de esta manera:

in the controller:
@data_tables = ActiveRecord::Base.connection.tables
in the view:
<% @data_tables.each do |dt| %>
<br>
<%= dt %>
<% end %>
<br>

fuente: http://portfo.li/rails/348561-how-can-one-list-all-database-tables-from-one-project

Answer 5

Creo que la solución de @ hnovick es genial si no tienes modelos sin tablas. Esta solución funcionaría también en modo de desarrollo

Mi enfoque es sutilmente diferente -

ActiveRecord::Base.connection.tables.map{|x|x.classify.safe_constantize}.compact

se supone que clasifique para darle el nombre de la clase de una cadena correctamente . safe_constantize garantiza que puede convertirlo en una clase segura sin lanzar una excepción. Esto es necesario en caso de que tenga tablas de bases de datos que no sean modelos. compacto para eliminar cualquier nils en la enumeración.

Answer 6

En caso de que alguien se tropiece con este, tengo otra solución, no confiar en leer dir o extender la clase Class ...

ActiveRecord::Base.send :subclasses

Esto devolverá una matriz de clases. Entonces puedes hacer

ActiveRecord::Base.send(:subclasses).map(&:name)

Answer 7

En una línea: Dir[''app/models//*.rb''].map {|f| File.basename(f, ''.*'').camelize.constantize } Dir[''app/models//*.rb''].map {|f| File.basename(f, ''.*'').camelize.constantize }

Answer 8

En una sola línea:

 ActiveRecord::Base.subclasses.map(&:name)

Answer 9

Esto funcionó para mí. Un agradecimiento especial a todas las publicaciones anteriores. Esto debería devolver una colección de todos sus modelos.

models = []
Dir.glob("#{Rails.root}/app/models/**/*.rb") do |model_path|
temp = model_path.split(///models///)
models.push temp.last.gsub(//.rb$/, '''').camelize.constantize rescue nil
end

Answer 10

Esto funciona para Rails 3.2.18

Rails.application.eager_load!
def all_models
models = Dir["#{Rails.root}/app/models/**/*.rb"].map do |m|
m.chomp(''.rb'').camelize.split("::").last
end
end

Answer 11

Esto parece funcionar para mí:

 Dir.glob(RAILS_ROOT + ''/app/models/*.rb'').each { |file| require file }
@models = Object.subclasses_of(ActiveRecord::Base)

Los rieles solo cargan modelos cuando se usan, por lo que la línea Dir.glob "requiere" todos los archivos en el directorio de modelos.

Una vez que tenga los modelos en una matriz, puede hacer lo que estaba pensando (por ejemplo, en el código de vista):

<% @models.each do |v| %>
<li><%= h v.to_s %></li>
<% end %>

Answer 12

He intentado muchas de estas respuestas sin éxito en Rails 4 (wow cambiaron una cosa o dos por el amor de Dios) Decidí agregar la mía. Los que llamaron a ActiveRecord :: Base.connection y extrajeron los nombres de la tabla funcionaron pero no obtuvieron el resultado que quería porque he ocultado algunos modelos (en una carpeta dentro de la aplicación / modelos /) que no quería borrar:

def list_models
Dir.glob("#{Rails.root}/app/models/*.rb").map{|x| x.split("/").last.split(".").first.camelize}
end

Lo puse en un inicializador y puedo llamarlo desde cualquier lugar. Impide el uso innecesario del mouse.

Answer 13

La respuesta completa para Rails 3, 4 y 5 es:

Si cache_classes está desactivado (por defecto está desactivado en desarrollo, pero en producción):

Rails.application.eager_load!

Entonces:

ActiveRecord::Base.descendants

Esto asegura que todos los modelos en su aplicación, independientemente de dónde se encuentren, se carguen, y también se cargan las gemas que esté utilizando y que proporcionen modelos.

Esto también debería funcionar en las clases que heredan de ActiveRecord::Base , como ApplicationRecord en Rails 5, y devuelve solo ese subárbol de descendientes:

ApplicationRecord.descendants

Si desea obtener más información acerca de cómo se hace esto, consulte ActiveSupport::DescendantsTracker .

Answer 14

No puedo comentar todavía, pero creo que la respuesta sj26 debería ser la mejor respuesta. Solo una pista:

Rails.application.eager_load! unless Rails.configuration.cache_classes
ActiveRecord::Base.descendants

Answer 15

Para Rails5, los modelos ahora son subclases de ApplicationRecord por lo tanto, para obtener una lista de todos los modelos en su aplicación, haga lo siguiente:

ApplicationRecord.descendants.collect { |type| type.name }

O más corto:

ApplicationRecord.descendants.collect(&:name)

Si se encuentra en el modo de desarrollo, necesitará cargar modelos antes de:

Rails.application.eager_load!

Answer 16

Para evitar precargar todos los Rails, puede hacer esto:

Dir.glob("#{Rails.root}/app/models/**/*.rb").each {|f| require_dependency(f) }

require_dependency (f) es lo mismo que Rails.application.eager_load! usos. Esto debería evitar los errores de archivo ya requeridos.

Luego puede usar todo tipo de soluciones para enumerar modelos AR, como ActiveRecord::Base.descendants

Answer 17

Sí, hay muchas formas en que puede encontrar todos los nombres de modelo, pero lo que hice en mi gem es: model_info , le dará todos los modelos incluidos en las gemas.

array=[], @model_array=[]
Rails.application.eager_load!
array=ActiveRecord::Base.descendants.collect{|x| x.to_s if x.table_exists?}.compact
array.each do |x|
if x.split(''::'').last.split(''_'').first != "HABTM"
@model_array.push(x)
end
@model_array.delete(''ActiveRecord::SchemaMigration'')
end

entonces simplemente imprime esto

@model_array

Answer 18

Si solo desea los nombres de clase:

ActiveRecord::Base.descendants.map {|f| puts f}

Simplemente ejecútelo en la consola de Rails, nada más. ¡Buena suerte!

EDITAR: @ ​​sj26 es correcto, necesita ejecutar esto primero para poder llamar a los descendientes:

Rails.application.eager_load!

Answer 19

Solo estoy lanzando este ejemplo aquí si alguien lo encuentra útil. La solución se basa en esta respuesta https://.com/a/10712838/473040 .

Supongamos que tiene una columna public_uid que se utiliza como ID principal para el mundo exterior (puede encontrar razones por las que le gustaría hacer eso here )

Ahora supongamos que ha introducido este campo en muchos modelos existentes y ahora desea regenerar todos los registros que aún no están configurados. Puedes hacer eso así

# lib/tasks/data_integirity.rake
namespace :di do
namespace :public_uids do
desc "Data Integrity: genereate public_uid for any model record that doesn''t have value of public_uid"
task generate: :environment do
Rails.application.eager_load!
ActiveRecord::Base
.descendants
.select {|f| f.attribute_names.include?("public_uid") }
.each do |m|
m.where(public_uid: nil).each { |mi| puts "Generating public_uid for #{m}#id #{mi.id}"; mi.generate_public_uid; mi.save }
end
end
end
end

ahora puede ejecutar rake di:public_uids:generate

Answer 20

The Rails implementa los descendants del método, pero los modelos no necesariamente heredan de ActiveRecord::Base , por ejemplo, la clase que incluye el módulo ActiveModel::Model tendrá el mismo comportamiento que un modelo, simplemente no se vinculará a un mesa.

Complementando lo que dicen los colegas de arriba, el más mínimo esfuerzo haría esto:

Monkey Patch de la clase Class of the Ruby:

class Class
def extends? constant
ancestors.include?(constant) if constant != self
end
end

y los models métodos, incluidos los ancestros, como este:

El método Module.constants devuelve (superficialmente) una colección de symbols , en lugar de constantes, entonces, el método Array#select puede ser sustituido como este parche mono del Module :

class Module
def demodulize
splitted_trail = self.to_s.split("::")
constant = splitted_trail.last
const_get(constant) if defines?(constant)
end
private :demodulize
def defines? constant, verbose=false
splitted_trail = constant.split("::")
trail_name = splitted_trail.first
begin
trail = const_get(trail_name) if Object.send(:const_defined?, trail_name)
splitted_trail.slice(1, splitted_trail.length - 1).each do |constant_name|
trail = trail.send(:const_defined?, constant_name) ? trail.const_get(constant_name) : nil
end
true if trail
rescue Exception => e
$stderr.puts "Exception recovered when trying to check if the constant /"#{constant}/" is defined: #{e}" if verbose
end unless constant.empty?
end
def has_constants?
true if constants.any?
end
def nestings counted=[], &block
trail = self.to_s
collected = []
recursivityQueue = []
constants.each do |const_name|
const_name = const_name.to_s
const_for_try = "#{trail}::#{const_name}"
constant = const_for_try.constantize
begin
constant_sym = constant.to_s.to_sym
if constant && !counted.include?(constant_sym)
counted << constant_sym
if (constant.is_a?(Module) || constant.is_a?(Class))
value = block_given? ? block.call(constant) : constant
collected << value if value
recursivityQueue.push({
constant: constant,
counted: counted,
block: block
}) if constant.has_constants?
end
end
rescue Exception
end
end
recursivityQueue.each do |data|
collected.concat data[:constant].nestings(data[:counted], &data[:block])
end
collected
end
end

Monkey parche de String .

class String
def constantize
if Module.defines?(self)
Module.const_get self
else
demodulized = self.split("::").last
Module.const_get(demodulized) if Module.defines?(demodulized)
end
end
end

Y, finalmente, el método de los modelos

def models
# preload only models
application.config.eager_load_paths = model_eager_load_paths
application.eager_load!
models = Module.nestings do |const|
const if const.is_a?(Class) && const != ActiveRecord::SchemaMigration && (const.extends?(ActiveRecord::Base) || const.include?(ActiveModel::Model))
end
end
private
def application
::Rails.application
end
def model_eager_load_paths
eager_load_paths = application.config.eager_load_paths.collect do |eager_load_path|
model_paths = application.config.paths["app/models"].collect do |model_path|
eager_load_path if Regexp.new("(#{model_path})$").match(eager_load_path)
end
end.flatten.compact
end

Answer 21

puede verificar esto

@models = ActiveRecord::Base.connection.tables.collect{|t| t.underscore.singularize.camelize}

Answer 22

ActiveRecord::Base.connection.tables

Answer 23

EDITAR: Mire los comentarios y otras respuestas. ¡Hay respuestas más inteligentes que ésta! O intenta mejorar este como wiki de la comunidad.

Los modelos no se registran en un objeto maestro, entonces no, Rails no tiene la lista de modelos.

Pero aún podrías mirar el contenido del directorio de modelos de tu aplicación ...

Dir.foreach("#{RAILS_ROOT}/app/models") do |model_path|
# ...
end

EDITAR: Otra idea (salvaje) sería usar la reflexión de Ruby para buscar todas las clases que amplíen ActiveRecord :: Base. No sé cómo puedes enumerar todas las clases, aunque ...

EDITAR: solo por diversión, encontré una manera de enumerar todas las clases

Module.constants.select { |c| (eval c).is_a? Class }

EDITAR: finalmente logró enumerar todos los modelos sin mirar los directorios

Module.constants.select do |constant_name|
constant = eval constant_name
if not constant.nil? and constant.is_a? Class and constant.superclass == ActiveRecord::Base
constant
end
end

Si también quieres manejar la clase derivada, necesitarás probar toda la cadena de la superclase. Lo hice agregando un método a la clase Class:

class Class
def extend?(klass)
not superclass.nil? and ( superclass == klass or superclass.extend? klass )
end
end
def models
Module.constants.select do |constant_name|
constant = eval constant_name
if not constant.nil? and constant.is_a? Class and constant.extend? ActiveRecord::Base
constant
end
end
end

Answer 24

ActiveRecord::Base.connection.tables.map do |model|
model.capitalize.singularize.camelize
end

regresará

["Article", "MenuItem", "Post", "ZebraStripePerson"]

Información adicional Si desea llamar a un método en el nombre del objeto sin modelo: método desconocido de cadena o errores variables, use esto

model.classify.constantize.attribute_names

Answer 25

Module.constants.select { |c| (eval c).is_a?(Class) && (eval c) < ActiveRecord::Base }

Answer 26

def load_models_in_development
if Rails.env == "development"
load_models_for(Rails.root)
Rails.application.railties.engines.each do |r|
load_models_for(r.root)
end
end
end
def load_models_for(root)
Dir.glob("#{root}/app/models/**/*.rb") do |model_path|
begin
require model_path
rescue
# ignore
end
end
end