Best way to require all files from a directory in ruby?

Question

What's the best way to require all files from a directory in ruby ?

Answer 1

How about:

Dir["/path/to/directory/*.rb"].each {|file| require file }

Answer 2

If it's a directory relative to the file that does the requiring (e.g. you want to load all files in the lib directory):

Dir[File.dirname(__FILE__) + '/lib/*.rb'].each {|file| require file }

Edit: Based on comments below, an updated version:

Dir[File.join(__dir__, 'lib', '*.rb')].each { |file| require file }

Answer 3

Try the require_all gem:

1. http://github.com/jarmo/require_all
2. https://rubygems.org/gems/require_all

It lets you simply:

require_all 'path/to/directory'

Answer 4

Dir[File.dirname(__FILE__) + '/../lib/*.rb'].each do |file| 
  require File.basename(file, File.extname(file))
end

If you don't strip the extension then you may end up requiring the same file twice (ruby won't realize that "foo" and "foo.rb" are the same file). Requiring the same file twice can lead to spurious warnings (e.g. "warning: already initialized constant").

Answer 5

Dir.glob(File.join('path', '**', '*.rb'), &method(:require))

or alternatively, if you want to scope the files to load to specific folders:

Dir.glob(File.join('path', '{folder1,folder2}', '**', '*.rb'), &method(:require))

explanation:

Dir.glob takes a block as argument.

method(:require) will return the require method.

&method(:require) will convert the method to a bloc.

Answer 6

The best way is to add the directory to the load path and then require the basename of each file. This is because you want to avoid accidentally requiring the same file twice -- often not the intended behavior. Whether a file will be loaded or not is dependent on whether require has seen the path passed to it before. For example, this simple irb session shows that you can mistakenly require and load the same file twice.

$ irb
irb(main):001:0> require 'test'
=> true
irb(main):002:0> require './test'
=> true
irb(main):003:0> require './test.rb'
=> false
irb(main):004:0> require 'test'
=> false

Note that the first two lines return true meaning the same file was loaded both times. When paths are used, even if the paths point to the same location, require doesn't know that the file was already required.

Here instead, we add a directory to the load path and then require the basename of each *.rb file within.

dir = "/path/to/directory"
$LOAD_PATH.unshift(dir)
Dir[File.join(dir, "*.rb")].each {|file| require File.basename(file) }

If you don't care about the file being required more than once, or your intention is just to load the contents of the file, perhaps load should be used instead of require. Use load in this case, because it better expresses what you're trying to accomplish. For example:

Dir["/path/to/directory/*.rb"].each {|file| load file }

Answer 7

Instead of concatenating paths like in some answers, I use File.expand_path:

Dir[File.expand_path('importers/*.rb', File.dirname(__FILE__))].each do |file|
  require file
end

Update:

Instead of using File.dirname you could do the following:

Dir[File.expand_path('../importers/*.rb', __FILE__)].each do |file|
  require file
end

Where .. strips the filename of __FILE__.

Answer 8

Dir[File.join(__dir__, "/app/**/*.rb")].each do |file|
  require file
end

This will work recursively on your local machine and a remote (Like Heroku) which does not use relative paths.

Answer 9

In Rails, you can do:

Dir[Rails.root.join('lib', 'ext', '*.rb')].each { |file| require file }

Update: Corrected with suggestion of @Jiggneshh Gohel to remove slashes.

Answer 10

I'm a few years late to the party, but I kind of like this one-line solution I used to get rails to include everything in app/workers/concerns:

Dir[ Rails.root.join *%w(app workers concerns *) ].each{ |f| require f }

Answer 11

For Ruby older than 3.0, Rubocop warns against the accepted answer because load order is not deterministic for all OSes. Linux sorts upper and lower case differently than Mac or Windows. The following does what the OP requested for all versions of Ruby:

Dir['/path/to/directory/*.rb'].sort.each { |file| require file }

The following recurses through all subdirectories for all versions of Ruby:

Dir['/path/to/directory/**/*.rb'].sort.each { |file| require file }

Ruby 3.0 and later sort files consistently, so the following is all that is needed if you know that older Ruby versions will never be used:

Dir['/path/to/directory/*.rb'].each { |file| require file }

The following recurses through all subdirectories for Ruby 3.0 and later:

Dir['/path/to/directory/**/*.rb'].each { |file| require file }

Answer 12

All these answers are great. To add, if you want to do this automagically, you can use Zeitwerk, which is what Rails uses to load files.

require 'zeitwerk'
loader = Zeitwerk::Loader.new
loader.push_dir('main/src/dir')
loader.setup

Then everything has access to everything

Answer 13

And what about: require_relative *Dir['relative path']?