require_all 1.1.0 → 1.2.0

data/CHANGES

@@ -1,13 +1,20 @@
-1.1.0:
-
-* Add require_rel (require_all relative to the current file)
-* Fix bug in auto-appending .rb ala require
-
-1.0.1:
-
-* Allow require_all to take a directory name as an argument
-
-1.0.0:
-
-* Initial release (was originally load_glob, converted to require_all which is
-  a lot cooler, seriously trust me)
+1.2.0:
+
+* Add load_all, and load_rel which behave similarly to require_all/require_rel except that Kernel#load is used
+* Add autoload_all and autoload_rel (see README and/or specs for examples of usage)
+* Minor bug fixes
+* Improved specs
+
+1.1.0:
+
+* Add require_rel (require_all relative to the current file)
+* Fix bug in auto-appending .rb ala require
+
+1.0.1:
+
+* Allow require_all to take a directory name as an argument
+
+1.0.0:
+
+* Initial release (was originally load_glob, converted to require_all which is
+  a lot cooler, seriously trust me)

data/LICENSE

@@ -1,58 +1,58 @@
-Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
-You can redistribute it and/or modify it under either the terms of the GPL
-(see COPYING.txt file), or the conditions below:
-
-  1. You may make and give away verbatim copies of the source form of the
-     software without restriction, provided that you duplicate all of the
-     original copyright notices and associated disclaimers.
-
-  2. You may modify your copy of the software in any way, provided that
-     you do at least ONE of the following:
-
-       a) place your modifications in the Public Domain or otherwise
-          make them Freely Available, such as by posting said
-	  modifications to Usenet or an equivalent medium, or by allowing
-	  the author to include your modifications in the software.
-
-       b) use the modified software only within your corporation or
-          organization.
-
-       c) rename any non-standard executables so the names do not conflict
-	  with standard executables, which must also be provided.
-
-       d) make other distribution arrangements with the author.
-
-  3. You may distribute the software in object code or executable
-     form, provided that you do at least ONE of the following:
-
-       a) distribute the executables and library files of the software,
-	  together with instructions (in the manual page or equivalent)
-	  on where to get the original distribution.
-
-       b) accompany the distribution with the machine-readable source of
-	  the software.
-
-       c) give non-standard executables non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  4. You may modify and include the part of the software into any other
-     software (possibly commercial).  But some files in the distribution
-     are not written by the author, so that they are not under this terms.
-
-     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
-     files under the ./missing directory.  See each file for the copying
-     condition.
-
-  5. The scripts and library files supplied as input to or produced as 
-     output from the software do not automatically fall under the
-     copyright of the software, but belong to whomever generated them, 
-     and may be sold commercially, and may be aggregated with this
-     software.
-
-  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-     PURPOSE.
-
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README.textile

@@ -1,83 +1,129 @@
-h1. require_all
-
-A wonderfully simple way to load your code.
-
-Tired of futzing around with require statements everywhere, littering your code
-with <code>require File.dirname(__FILE__)</code> crap?  What if you could just 
-point something at a big directory full of code and have everything just 
-automagically load regardless of the dependency structure?  
-
-Wouldn't that be nice?  Well, now you can!
-
- <code>require 'require_all'</code>
-
-You can use require_all in a multitude of different ways.
-
-The easiest way to use require_all is to just point it at a directory
-containing a bunch of .rb files:
-
- <code>require_all 'lib'</code>
-
-This will find all the .rb files under the lib directory (including all 
-subdirectories as well) and load them.
-
-The proper order to in which to load them is 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: 
-
- <code>require_all 'lib/**/*.rb'</code>
-
-It will also accept an array of files:
-
- <code>require_all Dir.glob("blah/**/*.rb").reject { |f| stupid_file? f }</code>
- 
-Or if you want, just list the files directly as arguments:
-
- <code>require_all 'lib/a.rb', 'lib/b.rb', 'lib/c.rb', 'lib/d.rb'</code>
-
-Still have the require File.dirname(__FILE__) blues?  The require_all gem also
-provides a require_rel statement which requires files to relative to the 
-current file.  So you can replace statements like:
-
- <code>require File.dirname(__FILE__) + '/foobar'</code>
-
-with just a simple require_rel:
-
- <code>require_rel 'foobar'</code>
- 
-Even better, require_rel still has the full power of require_all, so you can
-use require_rel to load entire directories of code too.  If "foobar" is a
-directory this will load all the .rb files found under that directory with
-automagic dependency handling.
- 
-It's just that easy!  Code loading shouldn't be hard.
-
-h2. Methodology
-
-I didn't invent the approach this gem uses.  It was shamelessly stolen from
-Merb (which apparently stole it from elsewhere).  Here's how it works:  
-
-# Enumerate the files to be loaded
-# Try to load all of the files.  If we encounter a NameError loading a 
-  particular file, store that file in a "try to load it later" list.
-# If all the files loaded, great, we're done!  If not, go through the
-  "try to load it later" list again rescuing NameErrors the same way.
-# If we walk the whole "try to load it later" list and it doesn't shrink
-  at all, we've encountered an unresolvable dependency.  In this case,
-  require_all will rethrow the first NameError it encountered.
-
-h2. Questions? Comments? Concerns?
-
-You can reach the author on github or freenode: "tarcieri"
-
-Or by email: "tony@medioh.com":mailto:tony@medioh.com
-
-Got issues with require_all to report?  Post 'em here:
-
-"Github Tracker":http://github.com/tarcieri/require_all/issues
-
-h2. License
-
-MIT (see the LICENSE file for details)
+h1. require_all
+
+A wonderfully simple way to load your code.
+
+Tired of futzing around with require statements everywhere, littering your code
+with <code>require File.dirname(__FILE__)</code> crap?  What if you could just 
+point something at a big directory full of code and have everything just 
+automagically load regardless of the dependency structure?  
+
+Wouldn't that be nice?  Well, now you can!
+
+ <code>require 'require_all'</code>
+
+You can use require_all in a multitude of different ways.
+
+The easiest way to use require_all is to just point it at a directory
+containing a bunch of .rb files:
+
+ <code>require_all 'lib'</code>
+
+This will find all the .rb files under the lib directory (including all 
+subdirectories as well) and load them.
+
+The proper order to in which to load them is 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: 
+
+ <code>require_all 'lib/**/*.rb'</code>
+
+It will also accept an array of files:
+
+ <code>require_all Dir.glob("blah/**/*.rb").reject { |f| stupid_file? f }</code>
+ 
+Or if you want, just list the files directly as arguments:
+
+ <code>require_all 'lib/a.rb', 'lib/b.rb', 'lib/c.rb', 'lib/d.rb'</code>
+
+Still have the require File.dirname(__FILE__) blues?  The require_all gem also
+provides a require_rel statement which requires files to relative to the 
+current file.  So you can replace statements like:
+
+ <code>require File.dirname(__FILE__) + '/foobar'</code>
+
+with just a simple require_rel:
+
+ <code>require_rel 'foobar'</code>
+ 
+Even better, require_rel still has the full power of require_all, so you can
+use require_rel to load entire directories of code too.  If "foobar" is a
+directory this will load all the .rb files found under that directory with
+automagic dependency handling.
+
+Also load_all and load_rel methods exist to use Kernel#load instead of Kernel#require!
+ 
+It's just that easy!  Code loading shouldn't be hard.
+
+h2. autoload_all
+
+There's also a methods for performing autoloading - what a bargain!
+Similar syntax is used as for require and load methods although some things have to be
+kept in mind:
+
+* Directory and file names have to reflect namespaces and/or constant names - e.g.
+  a file called my_file.rb in directories dir1/dir2 has to be defined like this:
+ <pre>
+ <code>
+  module Dir1
+    module Dir2
+      class MyFile
+      end
+    end
+  end
+ </code>
+ </pre>
+
+ in a loader.rb, which is in a parent directory for dir1:
+  <code>autoload_all File.dirname(__FILE__) + "/dir1"</code>
+
+* A :base_dir option has to be specified if loading directories or files from some other location
+  than top-level directory.
+
+  in dir1/other_file.rb:
+ <pre>
+ <code>
+  autoload_all File.dirname(__FILE__) + "/dir2/my_file.rb",
+               :base_dir => File.dirname(__FILE__) + "/../dir1" # top-level namespace starts from dir1
+ </code>
+ </pre>
+
+* All namespaces will be created dynamically by autoload_all - this means that defined?(Dir1) will
+  return "constant" even if my_file.rb is not loaded!
+
+Of course there's also an autoload_rel method:
+ <code>autoload_rel "dir2/my_file.rb", :base_dir => File.dirname(__FILE__) + "/../dir1"</code>
+
+If having some problems with autoload_all or autoload_rel then set $DEBUG to true to see how files
+are mapped to their respective modules and classes.
+
+h2. Methodology
+
+I didn't invent the approach this gem uses.  It was shamelessly stolen from
+Merb (which apparently stole it from elsewhere).  Here's how it works:  
+
+# Enumerate the files to be loaded
+# Try to load all of the files.  If we encounter a NameError loading a 
+  particular file, store that file in a "try to load it later" list.
+# If all the files loaded, great, we're done!  If not, go through the
+  "try to load it later" list again rescuing NameErrors the same way.
+# If we walk the whole "try to load it later" list and it doesn't shrink
+  at all, we've encountered an unresolvable dependency.  In this case,
+  require_all will rethrow the first NameError it encountered.
+
+h2. Questions? Comments? Concerns?
+
+You can reach the author on github or freenode: "jarm0"
+
+Or by email: "jarmo.p@gmail.com":mailto:jarmo.p@gmail.com
+
+Got issues with require_all to report? Post 'em here:
+
+"Github Tracker":http://github.com/jarmo/require_all/issues
+
+h2. License
+
+require_all was done originally by Tony Arcieri who asked me to maintain the gem.
+
+MIT (see the LICENSE file for details)

data/Rakefile

@@ -1,12 +1,12 @@
-require 'rake'
-require 'rake/clean'
-
-Dir['tasks/**/*.rake'].each { |task| load task }
-
-task :default => :spec
-
-task :clean do
-  %w[pkg coverage].each do |dir|
-    rm_rf dir
-  end
+require 'rake'
+require 'rake/clean'
+
+Dir['tasks/**/*.rake'].each { |task| load task }
+
+task :default => :spec
+
+task :clean do
+  %w[pkg coverage].each do |dir|
+    rm_rf dir
+  end
 end

data/lib/require_all.rb

@@ -1,125 +1,277 @@
-#--
-# Copyright (C)2009 Tony Arcieri
-# You can redistribute this under the terms of the MIT license
-# See file LICENSE for details
-#++
-
-module RequireAll
-  # 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'
-  #
-  def require_all(*args)
-    # Handle passing an array as an argument
-    args = args.flatten
-    
-    if args.size > 1
-      # If we got a list, those be are files!
-      files = args
-    else
-      arg = args.first
-      begin
-        # Try assuming we're doing plain ol' require compat
-        stat = File.stat(arg)
-        
-        if stat.file?
-          files = [arg]
-        elsif stat.directory?
-          files = Dir.glob File.join(arg, '**', '*.rb')
-        else
-          raise ArgumentError, "#{arg} isn't a file or directory"
-        end
-      rescue Errno::ENOENT
-        # If the stat failed, maybe we have a glob!
-        files = Dir.glob arg
-        
-        # Maybe it's an .rb file and the .rb was omitted
-        if File.file?(arg + '.rb')
-          require(arg + '.rb')
-          return true
-        end
-        
-        # If we ain't got no files, the glob failed
-        raise LoadError, "no such file to load -- #{arg}" if files.empty?
-      end
-    end
-    
-    files.map! { |file| File.expand_path file }
-            
-    begin
-      failed = []
-      first_name_error = nil
-      
-      # Attempt to load each file, rescuing which ones raise NameError for
-      # undefined constants.  Keep trying to successively reload files that 
-      # previously caused NameErrors until they've all been loaded or no new
-      # files can be loaded, indicating unresolvable dependencies.
-      files.each do |file|
-        begin
-          require file
-        rescue NameError => ex
-          failed << file
-          first_name_error ||= ex
-        rescue ArgumentError => ex
-          # Work around ActiveSuport freaking out... *sigh*
-          #
-          # ActiveSupport sometimes throws these exceptions and I really
-          # have no idea why.  Code loading will work successfully if these
-          # exceptions are swallowed, although I've run into strange 
-          # nondeterministic behaviors with constants mysteriously vanishing.
-          # I've gone spelunking through dependencies.rb looking for what 
-          # exactly is going on, but all I ended up doing was making my eyes 
-          # bleed.
-          #
-          # FIXME: If you can understand ActiveSupport's dependencies.rb 
-          # better than I do I would *love* to find a better solution
-          raise unless ex.message["is not missing constant"]
-          
-          STDERR.puts "Warning: require_all swallowed ActiveSupport 'is not missing constant' error"
-          STDERR.puts ex.backtrace[0..9]
-        end
-      end
-      
-      # If this pass didn't resolve any NameErrors, we've hit an unresolvable
-      # dependency, so raise one of the exceptions we encountered.
-      if failed.size == files.size
-        raise first_name_error
-      else
-        files = failed
-      end
-    end until failed.empty?
-    
-    true
-  end
-  
-  # Works like require_all, but paths are relative to the caller rather than 
-  # the current working directory
-  def require_rel(path)
-    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
-    require_all File.join(source_directory, path)
-  end
-end
-
-include RequireAll
+#--
+# Copyright (C)2009 Tony Arcieri
+# You can redistribute this under the terms of the MIT license
+# See file LICENSE for details
+#++
+
+module RequireAll
+  # 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'
+  #
+  def require_all(*args)
+    # Handle passing an array as an argument
+    args.flatten!
+
+    options = {:method => :require}
+    options.merge!(args.pop) if args.last.is_a?(Hash)
+
+    if args.empty?
+      puts "no files were loaded due to an empty Array" if $DEBUG
+      return false
+    end
+
+    if args.size > 1
+      # Expand files below directories
+      files = args.map do |path|
+        if File.directory? path
+          Dir[File.join(path, '**', '*.rb')]
+        else
+          path
+        end
+      end.flatten
+    else
+      arg = args.first
+      begin
+        # Try assuming we're doing plain ol' require compat
+        stat = File.stat(arg)
+
+        if stat.file?
+          files = [arg]
+        elsif stat.directory?
+          files = Dir.glob File.join(arg, '**', '*.rb')
+        else
+          raise ArgumentError, "#{arg} isn't a file or directory"
+        end
+      rescue SystemCallError
+        # If the stat failed, maybe we have a glob!
+        files = Dir.glob arg
+
+        # Maybe it's an .rb file and the .rb was omitted
+        if File.file?(arg + '.rb')
+          file = arg + '.rb'
+          options[:method] != :autoload ? Kernel.send(options[:method], file) : __autoload(file, file, options)
+          return true
+        end
+
+        # If we ain't got no files, the glob failed
+        raise LoadError, "no such file to load -- #{arg}" if files.empty?
+      end
+    end
+
+    # If there's nothing to load, you're doing it wrong!
+    raise LoadError, "no files to load" if files.empty?
+
+    if options[:method] == :autoload
+      files.map! { |file| [file, File.expand_path(file)] }
+      files.each do |file, full_path|
+        __autoload(file, full_path, options)
+      end
+
+      return true
+    end
+
+    files.map! { |file| File.expand_path file }
+    files.sort!
+
+    begin
+      failed = []
+      first_name_error = nil
+
+      # Attempt to load each file, rescuing which ones raise NameError for
+      # undefined constants.  Keep trying to successively reload files that 
+      # previously caused NameErrors until they've all been loaded or no new
+      # files can be loaded, indicating unresolvable dependencies.
+      files.each do |file|
+        begin
+          Kernel.send(options[:method], file)
+        rescue NameError => ex
+          failed << file
+          first_name_error ||= ex
+        rescue ArgumentError => ex
+          # Work around ActiveSuport freaking out... *sigh*
+          #
+          # ActiveSupport sometimes throws these exceptions and I really
+          # have no idea why.  Code loading will work successfully if these
+          # exceptions are swallowed, although I've run into strange 
+          # nondeterministic behaviors with constants mysteriously vanishing.
+          # I've gone spelunking through dependencies.rb looking for what 
+          # exactly is going on, but all I ended up doing was making my eyes 
+          # bleed.
+          #
+          # FIXME: If you can understand ActiveSupport's dependencies.rb 
+          # better than I do I would *love* to find a better solution
+          raise unless ex.message["is not missing constant"]
+
+          STDERR.puts "Warning: require_all swallowed ActiveSupport 'is not missing constant' error"
+          STDERR.puts ex.backtrace[0..9]
+        end
+      end
+
+      # If this pass didn't resolve any NameErrors, we've hit an unresolvable
+      # dependency, so raise one of the exceptions we encountered.
+      if failed.size == files.size
+        raise first_name_error
+      else
+        files = failed
+      end
+    end until failed.empty?
+
+    true
+  end
+
+  # Works like require_all, but paths are relative to the caller rather than 
+  # the current working directory
+  def require_rel(*paths)
+    # Handle passing an array as an argument
+    paths.flatten!
+    return false if paths.empty?
+
+    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
+    paths.each do |path|
+      require_all File.join(source_directory, path)
+    end
+  end
+
+  # Loads all files like require_all instead of requiring
+  def load_all(*paths)
+    require_all paths, :method => :load
+  end
+
+  # Loads all files by using relative paths of the caller rather than
+  # the current working directory
+  def load_rel(*paths)
+    paths.flatten!
+    return false if paths.empty?
+
+    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
+    paths.each do |path|
+      require_all File.join(source_directory, path), :method => :load
+    end
+  end
+
+  # 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!
+
+  def autoload_all(*paths)
+    paths.flatten!
+    return false if paths.empty?
+    require "pathname"
+
+    options = {:method => :autoload}
+    options.merge!(paths.pop) if paths.last.is_a?(Hash)
+
+    paths.each do |path|
+      require_all path, {:base_dir => path}.merge(options)
+    end
+  end
+
+  # Performs autoloading relatively from the caller instead of using current working directory
+  def autoload_rel(*paths)
+    paths.flatten!
+    return false if paths.empty?
+    require "pathname"
+
+    options = {:method => :autoload}
+    options.merge!(paths.pop) if paths.last.is_a?(Hash)
+
+    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
+    paths.each do |path|
+      file_path = Pathname.new(source_directory).join(path).to_s
+      require_all file_path, {:method => :autoload,
+                              :base_dir => source_directory}.merge(options)
+    end
+  end
+
+  private
+
+  def __autoload(file, full_path, options)
+    last_module = "Object" # default constant where namespaces are created into
+    begin
+      base_dir = Pathname.new(options[:base_dir]).realpath
+    rescue Errno::ENOENT
+      raise LoadError, ":base_dir doesn't exist at #{options[:base_dir]}"
+    end
+    Pathname.new(file).realpath.descend do |entry|
+      # skip until *entry* is same as desired directory
+      # or anything inside of it avoiding to create modules
+      # from the top-level directories
+      next if (entry <=> base_dir) < 0
+
+      # get the module into which a new module is created or
+      # autoload performed
+      mod = Object.class_eval(last_module)
+
+      without_ext = entry.basename(entry.extname).to_s
+      const = without_ext.split("_").map {|word| word.capitalize}.join
+
+      if entry.directory?
+        mod.class_eval "module #{const} end"
+        last_module += "::#{const}"
+      else
+        mod.class_eval do
+          puts "autoloading #{mod}::#{const} from #{full_path}" if $DEBUG
+          autoload const, full_path
+        end
+      end
+    end
+  end
+
+end
+
+include RequireAll