Qfyilyi

The whole answer for Rails 3, 4 and 5 is:

If cache_classes is off (by default it's off in development, but on in production):

Rails.application.eager_load!

Then:

ActiveRecord::Base.descendants

This makes sure all models in your application, regardless of where they are, are loaded, and any gems you are using which provide models are also loaded.

This should also work on classes that inherit from ActiveRecord::Base, like ApplicationRecord in Rails 5, and return only that subtree of descendants:

ApplicationRecord.descendants

If you'd like to know more about how this is done, check out ActiveSupport::DescendantsTracker.

Just in case anyone stumbles on this one, I've got another solution, not relying on dir reading or extending the Class class...

ActiveRecord::Base.send :subclasses

This will return an array of classes. So you can then do

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

ActiveRecord::Base.connection.tables.map do |model|

  model.capitalize.singularize.camelize

end

will return

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

Additional information If you want to call a method on the object name without model:string unknown method or variable errors use this

model.classify.constantize.attribute_names

I looked for ways to do this and ended up choosing this way:

in the controller:

    @data_tables = ActiveRecord::Base.connection.tables



in the view:

  <% @data_tables.each do |dt|  %>

  <br>

  <%= dt %>

  <% end %>

  <br>

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

I think @hnovick's solution is a cool one if you dont have table-less models. This solution would work in development mode as well

My approach is subtly different though -

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

classify is well supposed to give you the name of the class from a string properly. safe_constantize ensures that you can turn it into a class safely without throwing an exception. This is needed in case you have database tables which are not models. compact so that any nils in the enumeration are removed.

If you want just the Class names:

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

Just run it in Rails console, nothing more. Good luck!

EDIT: @sj26 is right, you need to run this first before you can call descendants:

Rails.application.eager_load!

For Rails5 models are now subclasses of ApplicationRecord so to get list of all models in your app you do:

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

Or shorter:

ApplicationRecord.descendants.collect(&:name)

If you are in dev mode, you will need to eager load models before:

Rails.application.eager_load!

This seems to work for me:

  Dir.glob(RAILS_ROOT + '/app/models/*.rb').each { |file| require file }

  @models = Object.subclasses_of(ActiveRecord::Base)

Rails only loads models when they are used, so the Dir.glob line "requires" all the files in the models directory.

Once you have the models in an array, you can do what you were thinking (e.g. in view code):

<% @models.each do |v| %>

  <li><%= h v.to_s %></li>

<% end %>

On one line: Dir['app/models/*.rb'].map {|f| File.basename(f, '.*').camelize.constantize }

ActiveRecord::Base.connection.tables

In just one line:

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

I can't comment yet, but I think sj26 answer should be the top answer. Just a hint:

Rails.application.eager_load! unless Rails.configuration.cache_classes

ActiveRecord::Base.descendants

This works for 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

To avoid pre-load all Rails, you can do this:

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

require_dependency(f) is the same that Rails.application.eager_load! uses. This should avoid already required file errors.

Then you can use all kind of solutions to list AR models, like ActiveRecord::Base.descendants

Yes there are many ways you can find all model names but what I did in my gem model_info is , it will give you all the models even included in the gems.

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

then simply print this

@model_array

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

Here's a solution that has been vetted with a complex Rails app (the one powering 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

It takes the best parts of the answers in this thread and combines them in the simplest and most thorough solution. This handle cases where your models are in subdirectories, use set_table_name etc.

Just came across this one, as I need to print all models with their attributes(built on @Aditya Sanghi's comment):

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

This worked for me. Special thanks to all the posts above. This should return a collection of all your models.

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

The Rails implements the method descendants, but models not necessarily ever inherits from ActiveRecord::Base, for example, the class that includes the module ActiveModel::Model will have the same behavior as a model, just doesn't will be linked to a table.

So complementing what says the colleagues above, the slightest effort would do this:

Monkey Patch of class Class of the Ruby:

class Class

  def extends? constant

    ancestors.include?(constant) if constant != self

  end

end

and the method models, including ancestors, as this:

The method Module.constants returns (superficially) a collection of symbols, instead of constants, so, the method Array#select can be substituted like this monkey patch of the 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 of 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

And, finally, the models method

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

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

I've tried so many of these answers unsuccessfully in Rails 4 (wow they changed a thing or two for god sakes) I decided to add my own. The ones that called ActiveRecord::Base.connection and pulled the table names worked but didn't get the result I wanted because I've hidden some models (in a folder inside of app/models/) that I didn't want to delete:

def list_models

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

end

I put that in an initializer and can call it from anywhere. Prevents unnecessary mouse-usage.

can check this

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

Assuming all models are in app/models and you have grep & awk on your server (majority of the cases),

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

It it faster than Rails.application.eager_load! or looping through each file with Dir.

EDIT:

The disadvantage of this method is that it misses models that indirectly inherit from ActiveRecord (e.g. FictionalBook < Book). The surest way is Rails.application.eager_load!; ActiveRecord::Base.descendants.map(&:name), even though it's kinda slow.

I'm just throwing this example here if anyone finds it useful. Solution is based on this answer https://stackoverflow.com/a/10712838/473040.

Let say you have a column public_uid that is used as a primary ID to outside world (you can findjreasons why you would want to do that here)

Now let say you've introduced this field on bunch of existing Models and now you want to regenerate all the records that are not yet set. You can do that like this

# 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

you can now run rake di:public_uids:generate

Dir.foreach("#{Rails.root.to_s}/app/models") do |model_path|

  next unless model_path.match(/.rb$/)

  model_class = model_path.gsub(/.rb$/, '').classify.constantize

  puts model_class

end

This will give to you all the model classes you have on your project.