scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/lib/require_all.rb

@@ -0,0 +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.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

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/require_all.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name = "require_all"
+  s.version = "1.3.2"
+  s.authors = ["Jarmo Pertman", "Tony Arcieri"]
+  s.email = "jarmo.p@gmail.com"
+  s.summary = "A wonderfully simple way to load your code"
+
+  s.files = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.homepage = "http://github.com/jarmo/require_all"
+  s.license = "MIT" 
+
+  s.has_rdoc = true
+  s.rdoc_options = %w(--title require_all --main README.md --line-numbers)
+  s.extra_rdoc_files = ["LICENSE", "README.md", "CHANGES"]
+
+  s.add_development_dependency "rake",  "~>0.9"
+  s.add_development_dependency "rspec", "~>2.14"
+  s.add_development_dependency "simplecov", "~>0.7"
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/autoload_shared.rb

@@ -0,0 +1,74 @@
+shared_examples_for "#autoload_all syntactic sugar" do
+  before :each do
+    @file_list = [
+            "#{@base_dir}/module1/a.rb",
+            "#{@base_dir}/module2/longer_name.rb",
+            "#{@base_dir}/module2/module3/b.rb"
+    ]
+  end
+
+  it "accepts files with and without extensions" do
+    should_not be_loaded("Autoloaded::Module2::LongerName")
+    send(@method, @base_dir + '/module2/longer_name', :base_dir => @autoload_base_dir).should be_true
+    should be_loaded("Autoloaded::Module2::LongerName")
+
+    should_not be_loaded("Autoloaded::Module1::A")
+    send(@method, @base_dir + '/module1/a.rb', :base_dir => @autoload_base_dir).should be_true
+    should be_loaded("Autoloaded::Module1::A")
+  end
+
+  it "accepts lists of files" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B")
+    send(@method, @file_list, :base_dir => @autoload_base_dir).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B")
+  end
+
+  it "is totally cool with a splatted list of arguments" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B")
+    send(@method, *(@file_list << {:base_dir => @autoload_base_dir})).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B")
+  end
+
+  it "will load all .rb files under a directory without a trailing slash" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B")
+    send(@method, @base_dir, :base_dir => @autoload_base_dir).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B")
+  end
+
+  it "will load all .rb files under a directory with a trailing slash" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B")
+    send(@method, "#{@base_dir}/", :base_dir => @autoload_base_dir).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B")
+  end
+
+  it "will load all files specified by a glob" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B")
+    send(@method, "#{@base_dir}/**/*.rb", :base_dir => @autoload_base_dir).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B")
+  end
+
+  it "returns false if an empty input was given" do
+    send(@method, [])
+    send(@method, []).should be_false
+    send(@method).should be_false
+  end
+
+  it "raises LoadError if no file or directory found" do
+    lambda {send(@method, "not_found")}.should raise_error(LoadError)
+  end
+
+  it "raises LoadError if :base_dir doesn't exist" do
+    lambda {send(@method, @base_dir, :base_dir => @base_dir + "/non_existing_dir")}.
+            should raise_exception(LoadError)
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/autoload_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/autoload_shared.rb'
+
+describe "autoload_all" do
+
+  subject { self }
+  
+  it "provides require_all functionality by using 'autoload' instead of 'require'" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+    autoload_all File.dirname(__FILE__) + "/fixtures/autoloaded"
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+  end
+
+  it "doesn't autoload files with wrong module names" do
+    autoload_all File.dirname(__FILE__) + "/fixtures/autoloaded"
+    should_not be_loaded("Autoloaded::WrongModule::WithWrongModule", "WrongModule::WithWrongModule")
+  end
+
+  it "needs to specify base_dir for autoloading if loading something from under top-level module directory" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+    autoload_all File.dirname(__FILE__) + "/fixtures/autoloaded/module1"
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+
+    autoload_all File.dirname(__FILE__) + "/fixtures/autoloaded/module1",
+                 :base_dir => File.dirname(__FILE__) + "/fixtures/autoloaded"
+    should be_loaded("Autoloaded::Module1::A")
+    should_not be_loaded("Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+  end
+
+  before(:all) do
+    @base_dir = File.dirname(__FILE__) + '/fixtures/autoloaded'
+    @method = :autoload_all
+    @autoload_base_dir = @base_dir
+  end
+  it_should_behave_like "#autoload_all syntactic sugar"
+end
+
+describe "autoload_rel" do
+
+  subject { self }
+
+  it "provides autoload_all functionality relative to the current file" do
+    should_not be_loaded("Modules::Module1::First", "Modules::Module2::Second", "Modules::Zero")
+    require File.dirname(__FILE__) + '/fixtures/autoloaded_rel/modules/zero'
+    should be_loaded("Modules::Module1::First", "Modules::Module2::Second", "Modules::Zero")
+  end
+
+  it "needs to specify base_dir for autoloading if loading something from under top-level module directory" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+    autoload_rel "./fixtures/autoloaded/module1"
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+
+    autoload_rel "./fixtures/autoloaded/module1",
+                 :base_dir => File.dirname(__FILE__) + "/fixtures/autoloaded"
+    should be_loaded("Autoloaded::Module1::A")
+    should_not be_loaded("Autoloaded::Module2::LongerName", "Autoloaded::Module2::Module3::B")
+  end
+
+  before(:all) do
+    @base_dir = './fixtures/autoloaded'
+    @method = :autoload_rel
+    @autoload_base_dir = File.dirname(__FILE__) + "/fixtures/autoloaded"
+  end
+  it_should_behave_like "#autoload_all syntactic sugar"
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/autoloaded/module1/a.rb

@@ -0,0 +1,6 @@
+module Autoloaded
+  module Module1
+    class A
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/autoloaded/module2/longer_name.rb

@@ -0,0 +1,6 @@
+module Autoloaded
+  module Module2
+    class LongerName
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/autoloaded/module2/module3/b.rb

@@ -0,0 +1,8 @@
+module Autoloaded
+  module Module2
+    module Module3
+      class B
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/autoloaded/with_wrong_module.rb

@@ -0,0 +1,4 @@
+module WrongModule
+  class WithWrongModule
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/autoloaded_rel/modules/module1/first.rb

@@ -0,0 +1,6 @@
+module Modules
+  module Module1
+    class First
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/autoloaded_rel/modules/module2/second.rb

@@ -0,0 +1,6 @@
+module Modules
+  module Module2
+    class Second
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/autoloaded_rel/modules/zero.rb

@@ -0,0 +1,6 @@
+autoload_rel "../modules"
+
+module Modules
+  class Zero
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/relative/a.rb

@@ -0,0 +1,2 @@
+class RelativeA
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/relative/b/b.rb

@@ -0,0 +1,5 @@
+require_rel '../a'
+require_rel '../c'
+
+class RelativeB
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/relative/c/c.rb

@@ -0,0 +1,2 @@
+class RelativeC
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/relative/d/d.rb

@@ -0,0 +1,8 @@
+load_rel '../a'
+load_rel '../c'
+
+class RelativeD
+  def ok?
+    true
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/resolvable/a.rb

@@ -0,0 +1 @@
+class A < C; end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/resolvable/b.rb

@@ -0,0 +1 @@
+class B < A; end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/resolvable/c.rb

@@ -0,0 +1,5 @@
+class C
+  def cool?
+    true
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/resolvable/d.rb

@@ -0,0 +1 @@
+class D < C; end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/unresolvable/a.rb

@@ -0,0 +1 @@
+class A < C; end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/unresolvable/b.rb

@@ -0,0 +1 @@
+class B < A; end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/unresolvable/c.rb

@@ -0,0 +1 @@
+class C < Nonexistent; end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/fixtures/unresolvable/d.rb

@@ -0,0 +1 @@
+class D < C; end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/load_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/require_shared.rb'
+
+describe "load_all" do
+  
+  subject { self }
+
+  it "provides require_all functionality but using 'load' instead of 'require'" do
+    require_all File.dirname(__FILE__) + '/fixtures/resolvable'
+    C.new.should be_cool
+
+    class C
+      def cool?
+        false
+      end
+    end
+    C.new.should_not be_cool
+
+    load_all File.dirname(__FILE__) + '/fixtures/resolvable'
+    C.new.should be_cool
+  end
+
+  before(:all) do
+    @base_dir = File.dirname(__FILE__) + '/fixtures/autoloaded'
+    @method = :load_all
+  end
+  it_should_behave_like "#require_all syntactic sugar"
+end
+
+describe "load_rel" do
+
+  subject { self }
+
+  it "provides load_all functionality relative to the current file" do
+    require File.dirname(__FILE__) + '/fixtures/relative/d/d'
+
+    should be_loaded("RelativeA", "RelativeC", "RelativeD")
+    RelativeD.new.should be_ok
+
+    class RelativeD
+      def ok?
+        false
+      end
+    end
+    RelativeD.new.should_not be_ok
+
+    load File.dirname(__FILE__) + '/fixtures/relative/d/d.rb'
+    RelativeD.new.should be_ok
+  end
+
+  before(:all) do
+    @base_dir = './fixtures/autoloaded'
+    @method = :load_rel
+  end
+  it_should_behave_like "#require_all syntactic sugar"
+end

data/.bundle/gems/ruby/2.2.0/gems/require_all-1.3.2/spec/require_shared.rb

@@ -0,0 +1,68 @@
+shared_examples_for "#require_all syntactic sugar" do
+  before :each do
+    @file_list = [
+            "#{@base_dir}/module1/a.rb",
+            "#{@base_dir}/module2/longer_name.rb",
+            "#{@base_dir}/module2/module3/b.rb"
+    ]
+  end
+
+  it "accepts files with and without extensions" do
+    should_not be_loaded("Autoloaded::Module2::LongerName")
+    send(@method, @base_dir + '/module2/longer_name').should be_true
+    should be_loaded("Autoloaded::Module2::LongerName")
+
+    should_not be_loaded("Autoloaded::Module1::A")
+    send(@method, @base_dir + '/module1/a.rb').should be_true
+    should be_loaded("Autoloaded::Module1::A")
+  end
+
+  it "accepts lists of files" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B")
+    send(@method, @file_list).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B")
+  end
+
+  it "is totally cool with a splatted list of arguments" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B")
+    send(@method, *@file_list).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B")
+  end
+
+  it "will load all .rb files under a directory without a trailing slash" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B", "WrongModule::WithWrongModule")
+    send(@method, @base_dir).should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B", "WrongModule::WithWrongModule")
+  end
+
+  it "will load all .rb files under a directory with a trailing slash" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B", "WrongModule::WithWrongModule")
+    send(@method, "#{@base_dir}/").should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B", "WrongModule::WithWrongModule")
+  end
+
+  it "will load all files specified by a glob" do
+    should_not be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                         "Autoloaded::Module2::Module3::B", "WrongModule::WithWrongModule")
+    send(@method, "#{@base_dir}/**/*.rb").should be_true
+    should be_loaded("Autoloaded::Module1::A", "Autoloaded::Module2::LongerName",
+                     "Autoloaded::Module2::Module3::B", "WrongModule::WithWrongModule")
+  end
+
+  it "returns false if an empty input was given" do
+    send(@method, []).should be_false
+    send(@method).should be_false
+  end
+
+  it "throws LoadError if no file or directory found" do
+    lambda {send(@method, "not_found")}.should raise_error(LoadError)
+  end
+end