module RequireAll

Public Instance Methods

autoload_all(*paths) click to toggle source

Performs Kernel#autoload on all of the files rather than requiring immediately.

Note that all Ruby files inside of the specified directories should have same module name as the directory itself and file names should reflect the class/module names. For example if there is a my_file.rb in directories dir1/dir2/ then there should be a declaration like this in my_file.rb:

 module Dir1
   module Dir2
     class MyFile
       ...
     end
   end
end

If the filename and namespaces won't match then my_file.rb will be loaded into wrong module! Better to fix these files.

Set $DEBUG=true to see how files will be autoloaded if experiencing any problems.

If trying to perform autoload on some individual file or some inner module, then you'd have to always specify :base_dir option to specify where top-level namespace resides. Otherwise it's impossible to know the namespace of the loaded files.

For example loading only my_file.rb from dir1/dir2 with autoload_all:

autoload_all File.dirname(__FILE__) + '/dir1/dir2/my_file',
             :base_dir => File.dirname(__FILE__) + '/dir1'

WARNING: All modules will be created even if files themselves aren't loaded yet, meaning that all the code which depends of the modules being loaded or not will not work, like usages of define? and it's friends.

Also, normal caveats of using Kernel#autoload apply - you have to remember that before applying any monkey-patches to code using autoload, you'll have to reference the full constant to load the code before applying your patch!

    # File lib/require_all.rb
210 def autoload_all(*paths)
211   paths.flatten!
212   return false if paths.empty?
213   require "pathname"
214 
215   options = {:method => :autoload}
216   options.merge!(paths.pop) if paths.last.is_a?(Hash)
217 
218   paths.each do |path|
219     require_all path, {:base_dir => path}.merge(options)
220   end
221 end
autoload_rel(*paths) click to toggle source

Performs autoloading relatively from the caller instead of using current working directory

    # File lib/require_all.rb
224 def autoload_rel(*paths)
225   paths.flatten!
226   return false if paths.empty?
227   require "pathname"
228 
229   options = {:method => :autoload}
230   options.merge!(paths.pop) if paths.last.is_a?(Hash)
231 
232   source_directory = File.dirname caller.first.sub(/:\d+$/, '')
233   paths.each do |path|
234     file_path = Pathname.new(source_directory).join(path).to_s
235     require_all file_path, {:method => :autoload,
236                             :base_dir => source_directory}.merge(options)
237   end
238 end
load_all(*paths) click to toggle source

Loads all files like require_all instead of requiring

    # File lib/require_all.rb
158 def load_all(*paths)
159   require_all paths, :method => :load
160 end
load_rel(*paths) click to toggle source

Loads all files by using relative paths of the caller rather than the current working directory

    # File lib/require_all.rb
164 def load_rel(*paths)
165   paths.flatten!
166   return false if paths.empty?
167 
168   source_directory = File.dirname caller.first.sub(/:\d+$/, '')
169   paths.each do |path|
170     require_all File.join(source_directory, path), :method => :load
171   end
172 end
require_all(*args) click to toggle source

A wonderfully simple way to load your code.

The easiest way to use require_all is to just point it at a directory containing a bunch of .rb files. These files can be nested under subdirectories as well:

require_all 'lib'

This will find all the .rb files under the lib directory and load them. The proper order to load them in will be determined automatically.

If the dependencies between the matched files are unresolvable, it will throw the first unresolvable NameError.

You can also give it a glob, which will enumerate all the matching files:

require_all 'lib   /*.rb'

It will also accept an array of files:

require_all Dir.glob("blah/   *.rb").reject { |f| stupid_file(f) }

Or if you want, just list the files directly as arguments:

require_all 'lib/a.rb', 'lib/b.rb', 'lib/c.rb', 'lib/d.rb'
    # File lib/require_all.rb
 34 def require_all(*args)
 35   # Handle passing an array as an argument
 36   args.flatten!
 37 
 38   options = {:method => :require}
 39   options.merge!(args.pop) if args.last.is_a?(Hash)
 40 
 41   if args.empty?
 42     puts "no files were loaded due to an empty Array" if $DEBUG
 43     return false
 44   end
 45 
 46   if args.size > 1
 47     # Expand files below directories
 48     files = args.map do |path|
 49       if File.directory? path
 50         Dir[File.join(path, '**', '*.rb')]
 51       else
 52         path
 53       end
 54     end.flatten
 55   else
 56     arg = args.first
 57     begin
 58       # Try assuming we're doing plain ol' require compat
 59       stat = File.stat(arg)
 60 
 61       if stat.file?
 62         files = [arg]
 63       elsif stat.directory?
 64         files = Dir.glob File.join(arg, '**', '*.rb')
 65       else
 66         raise ArgumentError, "#{arg} isn't a file or directory"
 67       end
 68     rescue SystemCallError
 69       # If the stat failed, maybe we have a glob!
 70       files = Dir.glob arg
 71 
 72       # Maybe it's an .rb file and the .rb was omitted
 73       if File.file?(arg + '.rb')
 74         file = arg + '.rb'
 75         options[:method] != :autoload ? Kernel.send(options[:method], file) : __autoload(file, file, options)
 76         return true
 77       end
 78 
 79       # If we ain't got no files, the glob failed
 80       raise LoadError, "no such file to load -- #{arg}" if files.empty?
 81     end
 82   end
 83 
 84    return if files.empty?
 85 
 86   if options[:method] == :autoload
 87     files.map! { |file_| [file_, File.expand_path(file_)] }
 88     files.each do |file_, full_path|
 89       __autoload(file_, full_path, options)
 90     end
 91 
 92     return true
 93   end
 94 
 95   files.map! { |file_| File.expand_path file_ }
 96   files.sort!
 97 
 98   begin
 99     failed = []
100     first_name_error = nil
101 
102     # Attempt to load each file, rescuing which ones raise NameError for
103     # undefined constants.  Keep trying to successively reload files that
104     # previously caused NameErrors until they've all been loaded or no new
105     # files can be loaded, indicating unresolvable dependencies.
106     files.each do |file_|
107       begin
108         Kernel.send(options[:method], file_)
109       rescue NameError => ex
110         failed << file_
111         first_name_error ||= ex
112       rescue ArgumentError => ex
113         # Work around ActiveSuport freaking out... *sigh*
114         #
115         # ActiveSupport sometimes throws these exceptions and I really
116         # have no idea why.  Code loading will work successfully if these
117         # exceptions are swallowed, although I've run into strange
118         # nondeterministic behaviors with constants mysteriously vanishing.
119         # I've gone spelunking through dependencies.rb looking for what
120         # exactly is going on, but all I ended up doing was making my eyes
121         # bleed.
122         #
123         # FIXME: If you can understand ActiveSupport's dependencies.rb
124         # better than I do I would *love* to find a better solution
125         raise unless ex.message["is not missing constant"]
126 
127         STDERR.puts "Warning: require_all swallowed ActiveSupport 'is not missing constant' error"
128         STDERR.puts ex.backtrace[0..9]
129       end
130     end
131 
132     # If this pass didn't resolve any NameErrors, we've hit an unresolvable
133     # dependency, so raise one of the exceptions we encountered.
134     if failed.size == files.size
135       raise first_name_error
136     else
137       files = failed
138     end
139   end until failed.empty?
140 
141   true
142 end
require_rel(*paths) click to toggle source

Works like require_all, but paths are relative to the caller rather than the current working directory

    # File lib/require_all.rb
146 def require_rel(*paths)
147   # Handle passing an array as an argument
148   paths.flatten!
149   return false if paths.empty?
150 
151   source_directory = File.dirname caller.first.sub(/:\d+$/, '')
152   paths.each do |path|
153     require_all File.join(source_directory, path)
154   end
155 end

Private Instance Methods

__autoload(file, full_path, options) click to toggle source
    # File lib/require_all.rb
242 def __autoload(file, full_path, options)
243   last_module = "Object" # default constant where namespaces are created into
244   begin
245     base_dir = Pathname.new(options[:base_dir]).realpath
246   rescue Errno::ENOENT
247     raise LoadError, ":base_dir doesn't exist at #{options[:base_dir]}"
248   end
249   Pathname.new(file).realpath.descend do |entry|
250     # skip until *entry* is same as desired directory
251     # or anything inside of it avoiding to create modules
252     # from the top-level directories
253     next if (entry <=> base_dir) < 0
254 
255     # get the module into which a new module is created or
256     # autoload performed
257     mod = Object.class_eval(last_module)
258 
259     without_ext = entry.basename(entry.extname).to_s
260     const = without_ext.split("_").map {|word| word.capitalize}.join
261 
262     if entry.directory?
263       mod.class_eval "module #{const} end"
264       last_module += "::#{const}"
265     else
266       mod.class_eval do
267         puts "autoloading #{mod}::#{const} from #{full_path}" if $DEBUG
268         autoload const, full_path
269       end
270     end
271   end
272 end