Есть ли способ получить коллекцию всех моделей в вашем приложении Rails?

Question

Есть ли способ получить коллекцию всех моделей в вашем приложении Rails?

В принципе, я могу сделать, подобного: -

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

Answer 1

EDIT: Посмотрите на комментарии и другие ответы. Есть более умные ответы, чем этот! Или попробуйте улучшить это как сообщество wiki.

Модели не регистрируются на главном объекте, поэтому нет, у Rails нет списка моделей.

Но вы могли бы еще посмотреть в содержании каталога моделей вашего приложения ...

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

EDIT: Еще одна идея (дикий) будет использовать Ruby, отражение искать для каждого класса, который простирается ActiveRecord ::База. Не знаю, как вы можете перечислить все классы, хотя ...

EDIT: Просто для удовольствия, я нашел способ перечислить все классы

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

EDIT: Наконец удалось перечисляя все модели, не глядя в каталогах

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 

Если вы хотите обрабатывать производный класс слишком, то вам нужно будет проверить всю цепочку суперкласса. Я сделал это, добавив метод класса 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 2

Это, кажется, работает для меня:

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

Rails загружает только модели, когда они используются, поэтому Dir.glob линия «требует msgstr "все файлы в каталоге моделей.

После того, как у вас есть модели в массиве, вы можете делать то, что вы думаете (например, вид кода):

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

Answer 3

Только в случае, если кто-нибудь натыкается на этом, у меня есть другое решение, не полагаясь на показания дирижера или расширяя класс класса ...

ActiveRecord::Base.send :subclasses 

Это вернет массив классов.Таким образом, вы можете сделать

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

Answer 4

На одной строке: Dir['app/models/\*.rb'].map {|f| File.basename(f, '.*').camelize.constantize }

Answer 5

Я искал способы, чтобы сделать это, и в конечном итоге выбрали этот путь:

in the controller: 
    @data_tables = ActiveRecord::Base.connection.tables 

in the view: 
    <% @data_tables.each do |dt| %> 
    <br> 
    <%= dt %> 
    <% end %> 
    <br> 

Источник: http://portfo.li/rails/348561-how-can-one-list-all-database-tables-from-one-project

Answer 6

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

вернет

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

Дополнительная информация Если вы хотите вызвать метод с именем объекта без модели: строка неизвестный метод или переменная ошибки используют этот

model.classify.constantize.attribute_names 

Answer 7

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

Answer 8

ActiveRecord::Base.connection.tables

Answer 9

Я думаю, @ hnovick-х решение является классным, если у вас нет моделей без таблиц. Это решение будет работать в режиме разработки, а

Мой подход немного отличается, хотя -

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

Классифицировать хорошо должен дать вам имя класса из строки правильно. safe_constantize гарантирует, что вы можете безопасно превратить его в класс без исключения исключения. Это необходимо, если у вас есть таблицы базы данных, которые не являются моделями. компактный, так что любые нули в перечислении удаляются.

Answer 10

Весь ответ на Rails 3, 4 и 5:

Если cache_classes выключен (по умолчанию он выключен в разработке, но в производстве):

Rails.application.eager_load! 

Тогда:

ActiveRecord::Base.descendants 

Это гарантирует, что все модели в вашем приложении, независимо от того, где они находятся, загружаются, а также любые драгоценные камни, которые вы используете, которые предоставляют модели, также загружаются.

Это также должно работать на классы, которые наследуют от ActiveRecord::Base, как ApplicationRecord в Rails 5, и вернуть только то, что поддерево потомков:

ApplicationRecord.descendants 

Если вы хотите узнать больше о том, как это сделано, проверьте ActiveSupport::DescendantsTracker.

Answer 11

только в одной строке:

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

Answer 12

Я хотел бы прокомментировать ответ sj26, который является тот, который я предпочитаю, как я работаю в среде разработки, но я не могу из-за моей молодой репутации , Я понял, что он имел в виду, но, возможно, есть небольшая ошибка: насколько я знаю в среде разработки cache_classes отключен (false), поэтому вам нужно вручную загружать приложение для доступа ко всем моделям.

Answer 13

может проверить этот

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

Answer 14

Вот решение, которое было проверено с комплексным приложением Rails (один питанием 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 

Он принимает лучшие части ответов в этой теме и сочетает их в самом простом и тщательном решении. Эта ручка случаи, когда ваши модели находятся в подкаталогах, используйте set_table_name и т.д.

Answer 15

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 

Answer 16

Просто наткнулся на этом, как мне нужно, чтобы напечатать все модели с их атрибутами (построенных на комментарии @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 17

Я еще не могу прокомментировать, но я думаю, что sj26 answer должен быть лучшим ответом. Подсказка:

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

Answer 18

Это сработало для меня. Особая благодарность всем вышеперечисленным сообщениям. Это должно вернуть коллекцию всех ваших моделей.

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 19

Я пробовал многие из этих ответов безуспешно в Rails 4 (ничего себе они изменили одну или две вещи для бога пользы), я решил добавить мой собственный. Те, которые вызвали ActiveRecord :: Base.connection и вытащили имена таблиц, работали, но не получили результат, который я хотел, потому что я спрятал некоторые модели (в папке внутри приложения/models /), которую я не хотел delete:

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

Я положил это в инициализатор и могу назвать его из любого места. Предотвращает ненужное использование мыши.

Answer 20

Если вы хотите только имена классов:

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

Просто запустить его в Rails консоли, ничего больше. Удачи!

EDIT: @ sj26 правильно, вам нужно запустить это первым, прежде чем вы можете называть потомков:

Rails.application.eager_load! 

Answer 21

Это работает для 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 22

предполагая, что все модели в приложении/модели и у вас есть Grep & AWK на сервере (большинство случаев),

# 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") 

Это он быстрее, чем Rails.application.eager_load! или перебирает каждый файл с Dir.

EDIT:

Недостатком этого метода является то, что он пропускает модели, которые косвенно наследуются от ActiveRecord (например FictionalBook < Book). Самый верный способ - Rails.application.eager_load!; ActiveRecord::Base.descendants.map(&:name), хотя он медленный.

Answer 23

Для Rails5 моделей are now subclasses из ApplicationRecord так, чтобы получить список всех моделей в вашем приложении вы делаете:

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

Или короче:

ApplicationRecord.descendants.collect(&:name) 

Если вы находитесь в режиме разработчика, вы необходимо будет поддерживать модели нагрузки до:

Rails.application.eager_load! 

Answer 24

Я просто бросаю этот пример здесь, если кто-то считает его полезным. Решение основано на этом ответе https://stackoverflow.com/a/10712838/473040.

Пусть у вас есть столбец public_uid, который используется в качестве основного идентификатора внешнего мира (вы можете findjreasons почему вы хотели бы сделать это here)

Теперь говорят, что вы ввели в этом поле на кучу существующих моделей, и теперь вы хотите восстановить все записи, которые еще не установлены. Вы можете сделать это, как этот

# 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 

вы можете запустить rake di:public_uids:generate

Answer 25

Rails реализует метод descendants, но модели не обязательно когда-нибудь наследует от ActiveRecord::Base, например, класс, который включает в себя модуль ActiveModel::Model будет иметь то же поведение, что и модель, просто не связано с таблицей.

Так дополняя то, что говорит, что выше его коллеги, малейшее усилие будет сделать это:

обезьяна патч класса Class рубина:

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

и метод models, в том числе предков, как это:

Метод Module.constants возвращает (по существу) коллекцию symbols, вместо констант, поэтому метод Array#select может быть заменен заций, как эта обезьяна пятачок 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 

обезьяна патч 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 

И, наконец, метод модели

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 26

Чтобы избежать предварительной нагрузки все Rails, вы можете сделать это:

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

require_dependency (е) то же самое, что Rails.application.eager_load! использует. Это должно избежать уже требуемых ошибок файла.

Затем вы можете использовать все виды решений в список моделей AR, как ActiveRecord::Base.descendants

Answer 27

Да, есть много способов, вы можете найти все имена моделей, но то, что я сделал в моем драгоценном камне model_info, оно даст вам все модели даже включены в драгоценные камни.

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 

затем просто распечатать эту

@model_array