Gibt es eine Möglichkeit, eine Sammlung aller Modelle in Ihrer Rails App zu erhalten?

Die ganze Antwort für Schienen 3, 4 und 5:

Wenn cache_classes ausgeschaltet ist (standardmäßig ist es ausgeschaltet in der Entwicklung, aber in der Produktion):

Rails.application.eager_load!

Dann:

ActiveRecord::Base.descendants

Dies stellt sicher, dass alle Modelle in Ihrer Anwendung, unabhängig davon, wo Sie sind, sind geladen, und alle Edelsteine, die Sie verwenden, die Modelle sind auch geladen.

Diese sollte auch auf Klassen, die Erben von ActiveRecord::Base wie ApplicationRecord im Schienen 5 und wieder nur, dass die Teilstruktur der Nachkommen:

ApplicationRecord.descendants

Wenn Sie wissen möchten, mehr über wie dies geschieht, überprüfen Sie heraus ActiveSupport::DescendantsTracker.

InformationsquelleAutor der Antwort sj26

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

zurück

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

Zusätzliche Informationen Wenn Sie möchten, rufen Sie eine Methode auf dem Objekt-Namen ohne Modell:string unbekannten Methode oder variable Fehler verwenden Sie diese

model.classify.constantize.attribute_names

InformationsquelleAutor der Antwort lightyrs

Ich denke, @hnovick die Lösung ist eine Coole, wenn man keinen Tisch-weniger Modelle. Diese Lösung würde die Arbeit im development-Modus als auch

Mein Ansatz ist etwas anders, obwohl -

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

klassifizieren ist gut soll geben Sie den Namen der Klasse aus einem string richtig. safe_constantize sorgt dafür, dass Sie es drehen kann, in einer Klasse sicher, ohne eine Ausnahme zu werfen. Dies ist erforderlich, im Falle Sie haben Datenbank-Tabellen, die sind nicht Modelle. kompakt, so dass jede nils in der Aufzählung entfernt werden.

InformationsquelleAutor der Antwort Aditya Sanghi

Dies scheint für mich arbeiten:

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

Schienen nur eine Menge von Modellen, wenn Sie verwendet werden, so Dir.glob-line "muss" alle Dateien im models-Verzeichnis.

Sobald Sie die Modelle in einer Reihe, Sie können tun, was Sie waren zu denken (z.B. in anzeigen-code):

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

InformationsquelleAutor der Antwort bhousel

In einer Zeile: Dir['app/models/\*.rb'].map {|f| File.basename(f, '.*').camelize.constantize }

InformationsquelleAutor der Antwort vjt

ActiveRecord::Base.connection.tables

InformationsquelleAutor der Antwort Lumbee

Dies funktioniert für Schienen 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

InformationsquelleAutor der Antwort ryan0

Zu vermeiden, pre-load alle Schienen, können Sie dies tun:

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

require_dependency(f) ist die gleiche, die Rails.application.eager_load! verwendet. Dies sollte vermeiden, die bereits erforderliche Datei Fehler.

Dann können Sie alle Arten von Lösungen zur Liste der AR-Modelle, wie ActiveRecord::Base.descendants

InformationsquelleAutor der Antwort John Owen Chile

Kam gerade über diese, wie ich brauche, um alle Drucker-Modelle mit Ihren Parametern(gebaut auf @Aditya Sanghi Kommentar):

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

InformationsquelleAutor der Antwort gouravtiwari21

Den Rails implementiert die Methode descendants, aber Modelle nicht unbedingt immer erbt von ActiveRecord::Base zum Beispiel, der Klasse, beinhaltet das Modul ActiveModel::Model wird das gleiche Verhalten wie ein Modell, einfach nicht wird mit einer Tabelle verknüpft.

Also ergänzen, was sagt die Kollegen oben, die geringste Mühe dies zu tun wäre:

Monkey Patch der Klasse Class des Ruby:

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

und die Methode models, einschließlich der Vorfahren, als diese:

Die Methode Module.constants gibt (oberflächlich) eine Sammlung von symbols anstelle von Konstanten, also, die Methode Array#select ausgetauscht werden können, wie dieses monkey patch der 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 patch von 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

Und, schließlich, die Modelle Methode

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

InformationsquelleAutor der Antwort rplaurindo

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

InformationsquelleAutor der Antwort Abdul

können dies überprüfen,

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

InformationsquelleAutor der Antwort Arvind

Ich bin einfach nur werfen in diesem Beispiel hier, wenn jemand findet es nützlich. Die Lösung basiert auf diese Antwort https://stackoverflow.com/a/10712838/473040.

Lassen Sie sagen, Sie haben eine Spalte public_uid verwendet wird als eine primär-ID, um sich mit der Außenwelt (Sie können findjreasons, warum Sie würde wollen, dass hier)

Lassen Sie uns jetzt sagen Sie eingeführt haben, dieses Feld auf Haufen von bestehenden Modellen und jetzt wollen Sie regenerieren, werden alle Datensätze, die noch nicht eingestellt sind. Sie können tun, wie diese

# 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

nun können Sie rake di:public_uids:generate

InformationsquelleAutor der Antwort equivalent8