module RequireAll
Public Instance Methods
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
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
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
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
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
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
# 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