truck 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8475ef41616dc1d5e77921e3c1a4a1c2f49e4ee
+  data.tar.gz: 690aa4f1b04fcbb4df44fc03da487edf43c10171
+SHA512:
+  metadata.gz: 24820f2e0c852256e6f66316070067444de7a27d7819265219840b55a898b911a2979a756b887d10125047db779d4f2224b41f04b7291b0b8762950d5007f11d
+  data.tar.gz: 3925f6a1600e036edb2cdbda4621dc6aef8a937b79d03bfe37bf5ae37510cafdb4223c7bda5d877d45a3427f2a1ea0dc1694a7ed53dd2efa062171f306f83792

data/.gitignore

@@ -0,0 +1,26 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+tags
+.gems
+.ruby-version
+.rbenv-gemsets

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in truck.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nathan Ladd
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,81 @@
+# Truck
+
+Truck is an alternative autoloader that doesn't pollute the global namespace. Specifically, it does not load constants into `Object`; rather, it loads them into *Contexts* that you define. This has two main advantages:
+
+1. `reload!` is very fast; `Object.send(:remove_const, :MyContext)` does the trick
+2. You can have multiple autoloaders running in parallel contexts
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'truck'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install truck
+
+## Usage
+
+Unlike ActiveSupport's autoloader, truck requires a bit of setup for each context. An example:
+
+    Truck.define_context :MyContext, root: "/path/to/context/root"
+
+Also, after defining all your contexts, you'll want to boot everyone up:
+
+    Truck.boot!
+
+You'll want to define all your contexts, then fork/spawn threads, then have every sub process invoke `Truck.boot!` separately.
+
+There is no notion of autoload paths; if you want multiple autoload paths, you'd define multiple contexts. In this example, a top level module called `MyContext` would get defined. Suppose you had a class called `Foo` living in `/path/to/context/root/foo.rb`:
+
+```ruby
+# /path/to/context/root/foo.rb
+class Foo
+  def self.bar
+    Bar.hello_world
+  end
+end
+```
+
+```ruby
+# /path/to/context/root/bar.rb
+class Foo
+  def self.hello_world
+    "hello, world!"
+  end
+end
+```
+
+`Foo` can reference `Bar` without an explicit require. So how does the world outside of `MyContext` reference objects?
+
+    MyContext.resolve_const("Bar")
+
+This works with namespaced constant names, too:
+
+    MyContext.resolve_const("Foo::Bar::Baz")
+
+`MyContext` has some other interesting methods on it:
+
+    # Wipe the whole context and reload it (also aliased as reload!)
+    MyContext.reset!
+
+    # Kill the context
+    MyContext.shutdown!
+
+    # Eagerly load the entire context into memory (good for production)
+    MyContext.eager_load!
+
+These methods are also of course on `Truck` as well, and invoke the same operations on every context.
+
+## Contributing
+
+1. Fork it ( https://github.com/ntl/truck/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.libs << 'test'
+end
+
+desc "Update ctags"
+task :ctags do
+  `ctags -R --languages=Ruby --totals -f tags`
+end
+
+task default: 'test'

data/lib/truck.rb

@@ -0,0 +1,38 @@
+require_relative "truck/version"
+require_relative "truck/string_inflections"
+require_relative "truck/autoloader"
+require_relative "truck/context"
+require_relative "truck/const_resolver"
+
+module Truck
+  extend self
+
+  attr :contexts
+  @contexts = {}
+
+  def define_context(name, **params)
+    contexts[name] = Context.new(name, **params)
+  end
+
+  def boot!
+    contexts.each_value(&:boot!)
+  end
+
+  def reset!
+    each_booted_context &:reset!
+  end
+  alias_method :reload!, :reset!
+
+  def shutdown!
+    each_booted_context &:shutdown!
+  end
+
+  Error = Class.new StandardError
+
+  private
+
+  def each_booted_context(&block)
+    return to_enum(:each_booted_context) unless block_given?
+    contexts.each_value.select(&:booted?).each(&block)
+  end
+end

data/lib/truck/autoloader.rb

@@ -0,0 +1,131 @@
+module Truck
+  using Truck::StringInflections
+
+  class Autoloader
+    attr :base_nibbles, :context, :from, :dir_paths
+
+    def initialize(from)
+      @from = from
+      @context, @base_nibbles = fetch_context_and_base_nibbles
+      @dir_paths = [nil]
+    end
+
+    def <<(const_name)
+      raise_name_error!(const_name) unless context
+      @dir_paths = each_possible_const(const_name).reduce [] do |new_paths, possible_const|
+        resolved_const = context.resolve_const possible_const
+        throw :const, resolved_const if resolved_const
+        new_paths << possible_const if possible_namespace?(possible_const)
+        new_paths
+      end
+      raise_name_error!(const_name) if dir_paths.empty?
+    end
+
+    def each_possible_const(const_name)
+      return to_enum(:each_possible_const, const_name) unless block_given?
+      dir_paths.each do |dir_path|
+        base_nibbles.map { |e| yield constify(e, *dir_path, const_name) }
+        yield constify(*dir_path, const_name)
+      end
+    end
+
+    def possible_namespace?(possible_const)
+      context.root.join(possible_const.to_snake_case).directory?
+    end
+
+    def constify(*nibbles)
+      nibbles.compact.join '::'
+    end
+
+    def raise_name_error!(const_name = dir_paths.last)
+      message = "uninitialized constant #{const_name}"
+      message << " (in #{context.mod})" if context
+      raise NameError, message
+    end
+
+    # given "Foo::Bar::Baz", return ["Foo::Bar::Baz", "Foo::Bar", etc.]
+    def fetch_context_and_base_nibbles
+      each_base_nibble.to_a.reverse.reduce [] do |ary, (mod, const)|
+        owner = Truck.contexts.each_value.detect { |c| c.mod == mod }
+        return [owner, ary] if owner
+        ary.map! do |e| e.insert 0, '::'; e.insert 0, const; end
+        ary << const
+      end
+      nil
+    end
+
+    # given "Foo::Bar::Baz", return ["Foo", "Bar", "Baz"]
+    def each_base_nibble
+      return to_enum(:each_base_nibble) unless block_given?
+      from.name.split('::').reduce Object do |mod, const|
+        mod = mod.const_get const
+        yield [mod, const]
+        mod
+      end
+    end
+
+    module ThreadedState
+      def autoloaders
+        @autoloaders ||= {}
+      end
+
+      def current_autoloader
+        autoloaders[current_thread_id]
+      end
+
+      def set_current_autoloader(to:)
+        autoloaders[current_thread_id] = to
+      end
+
+      def current_thread_id
+        Thread.current.object_id
+      end
+    end
+    extend ThreadedState
+
+    module HandleConstMissing
+      def handle(*args)
+        found_const = catch :const do
+          handle! *args and return NullModule
+        end
+        throw :const, found_const
+      rescue NameError => name_error; raise name_error
+      ensure
+        set_current_autoloader(to: nil) if found_const or name_error
+      end
+
+      def handle!(const_name, from:)
+        autoloader = current_autoloader || new(from)
+        autoloader << String(const_name)
+        set_current_autoloader to: autoloader
+      end
+    end
+    extend HandleConstMissing
+
+    module NullModule
+      extend self
+
+      def method_missing(*)
+        Autoloader.current_autoloader.raise_name_error!
+      ensure
+        Autoloader.set_current_autoloader to: nil
+      end
+    end
+  end
+end
+
+class Module
+  def const_missing(const)
+    catch :const do
+      Truck::Autoloader.handle const, from: self
+    end
+  rescue NameError => name_error
+    if name_error.class == NameError
+      # Reraise the error to keep our junk out of the backtrace
+      raise NameError, name_error.message
+    else
+      # NoMethodError inherits from NameError
+      raise name_error
+    end
+  end
+end

data/lib/truck/const_resolver.rb

@@ -0,0 +1,91 @@
+module Truck
+  using StringInflections
+
+  class Context
+    class ConstResolver
+      attr :current_path, :autoload_paths, :context, :expanded_const
+
+      def initialize(context:, expanded_const:, autoload_paths: [''])
+        @autoload_paths = autoload_paths
+        @context        = context
+        @expanded_const = expanded_const
+      end
+
+      def autoload_paths=(paths)
+        autoload_paths.clear
+        autoload_paths.concat paths
+      end
+
+      def const_get
+        walk_const_parts.reduce context.mod do |mod, const_part|
+          return nil unless mod.const_defined?(const_part)
+          mod.const_get const_part
+        end
+      end
+
+      def each_autoload_path
+        autoload_paths.each do |autoload_path|
+          @current_path = context.root.join autoload_path
+          yield
+        end
+        @current_path = nil
+      end
+
+      def each_possible_rb_file
+        each_autoload_path do
+          base_path = current_path.join expanded_const.to_snake_case
+          each_rb_file_from_base_path base_path do |rb_file|
+            yield rb_file if File.exist?(rb_file)
+          end
+        end
+      end
+
+      def each_rb_file_from_base_path(base_path)
+        base_path.ascend do |path|
+          return if path == context.root
+          rb_file = path.sub_ext '.rb'
+          yield rb_file if rb_file.file?
+        end
+      end
+
+      def resolve
+        check_already_loaded or resolve!
+      end
+
+      def resolve!
+        each_possible_rb_file do |rb_file|
+          context.load_file rb_file
+          check_loaded rb_file
+        end
+        const_get
+      end
+
+      def walk_const_parts(const = expanded_const)
+        return to_enum(:walk_const_parts, const) if block_given?
+        const.split '::'
+      end
+
+      def check_already_loaded
+        walk_const_parts.reduce context.mod do |mod, const_part|
+          return nil unless mod.const_defined? const_part
+          mod.const_get const_part
+        end
+      end
+
+      def check_loaded(rb_file)
+        expected_const = expected_const_defined_in_rb_file rb_file
+        walk_const_parts(expected_const).reduce context.mod do |mod, const_part|
+          mod.const_defined?(const_part) or
+            raise AutoloadError.new(const: expected_const, rb_file: rb_file)
+          mod.const_get const_part
+        end
+      end
+
+      def expected_const_defined_in_rb_file(rb_file, autoload_path: current_path)
+        rel_path = rb_file.sub_ext('').relative_path_from(autoload_path).to_s
+        matcher = %r{\A(#{rel_path.to_camel_case})}i
+        expanded_const.match(matcher).captures.fetch 0
+      end
+    end
+  end
+end

data/lib/truck/context.rb

@@ -0,0 +1,84 @@
+module Truck
+  class Context
+    attr :mod, :name, :root
+
+    def initialize(name, parent: nil, root:)
+      @mod    = build_mod
+      @name   = name
+      @root   = Pathname(root) if root
+      @parent = parent
+    end
+
+    class << self
+      def owner(const)
+        owner, _ = Autoloader.owner_and_ascending_nibbles const
+        owner
+      end
+    end
+
+    def boot!
+      parent.const_set name, mod
+    end
+
+    def booted?
+      parent.const_defined? name
+    end
+
+    def eager_load!
+      Dir[root.join('**/*.rb')].each do |rb_file|
+        load_file rb_file
+      end
+    end
+
+    def load_file(rb_file)
+      mod.module_eval File.read(rb_file), rb_file.to_s
+    end
+
+    def parent
+      return Object unless @parent
+      Truck.contexts.fetch(@parent.to_sym).mod
+    end
+
+    def reset!
+      shutdown!
+      @mod = build_mod
+      boot!
+    end
+    alias_method :reload!, :reset!
+
+    def resolve_const(expanded_const)
+      build_const_resolver(expanded_const).resolve
+    end
+
+    def shutdown!
+      parent.send(:remove_const, name)
+    end
+
+    private
+
+    def build_const_resolver(expanded_const)
+      ConstResolver.new(
+        context: self,
+        expanded_const: String(expanded_const).dup.freeze,
+      )
+    end
+
+    def build_mod
+      Module.new
+    end
+
+  end
+
+  class AutoloadError < NameError
+    attr :const, :rb_file
+
+    def initialize(const:, rb_file:)
+      @const   = const
+      @rb_file = rb_file
+    end
+
+    def message
+      "Expected #{rb_file} to define #{const}"
+    end
+  end
+end

data/lib/truck/string_inflections.rb

@@ -0,0 +1,30 @@
+module Truck
+  module StringInflections
+    refine String do
+      def to_camel_case
+        str = "_#{self}"
+        str.gsub!(%r{_[a-z]}) { |snake| snake.slice(1).upcase }
+        str.gsub!('/', '::')
+        str
+      end
+
+      def to_snake_case
+        str = gsub '::', '/'
+        # Convert FOOBar => FooBar
+        str.gsub! %r{[[:upper:]]{2,}} do |uppercase|
+          bit = uppercase[0]
+          bit << uppercase[1...-1].downcase
+          bit << uppercase[-1]
+          bit
+        end
+        str.gsub! %r{[[:lower:]][[:upper:]]+[[:lower:]]} do |camel|
+          bit = camel[0]
+          bit << '_'
+          bit << camel[1..-1].downcase
+        end
+        str.downcase!
+        str
+      end
+    end
+  end
+end

data/lib/truck/version.rb

@@ -0,0 +1,3 @@
+module Truck
+  VERSION = "0.8.0"
+end

data/test/integration/autoloading_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+class AutoloadingTest < Minitest::Test
+  include FakesFilesystem
+  include TestsAutoloading
+
+  def test_simple_case
+    assert_equal 'hello from A::AA', Foo::A.references_aa
+  end
+
+  def test_negative_case
+    assert_raises NameError do
+      Foo::A.references_abracadabra
+    end
+  end
+
+  def test_deeply_nested_module_with_implicit_namespaces
+    assert_equal 'hello from C::CA::CAA::CAAA', Foo::A.references_caaa
+  end
+
+  def test_reference_from_within_constant
+    assert_equal 'hello from A', Foo::D.references_a
+    assert_equal 'hello from B::BA', Foo::D.new.references_b_ba
+  end
+
+  def test_invoking_method_inside_implicit_namespace_raises_error
+    exception = assert_raises NameError do
+      Foo::C.hello
+    end
+    assert_equal "uninitialized constant C (in Foo)", exception.message
+  end
+
+  def test_raises_name_error_if_no_context_found
+    exception = assert_raises NameError do
+      Abracadabra
+    end
+    assert_equal "uninitialized constant Abracadabra", exception.message
+  end
+end

data/test/support/fakes_filesystem.rb

@@ -0,0 +1,182 @@
+module FakesFilesystem
+  def before_setup
+    super
+    FakeFS::FileSystem.clear
+    FakeFS.activate!
+    World.build!
+    monkeypatch_assert!
+  end
+
+  def after_teardown
+    unmonkeypatch_assert!
+    FakeFS.deactivate!
+    super
+  end
+
+  private
+
+  def monkeypatch_assert!
+    Minitest::Assertions.module_eval do
+      alias_method :orig_diff, :diff
+      def diff(*args)
+        FakeFS.without { orig_diff *args }
+      end
+    end
+  end
+
+  def unmonkeypatch_assert!
+    Minitest::Assertions.module_eval do
+      undef_method :diff
+      alias_method :diff, :orig_diff
+    end
+  end
+
+  module World
+    extend self
+
+    def build!
+      Dir.mkdir '/foo'
+
+      File.write "/foo/a.rb", <<-FILE
+module A
+  def self.message
+    "hello from A"
+  end
+
+  def self.references_aa
+    AA.message
+  end
+
+  def self.references_abracadabra
+    Abracadabra.message
+  end
+
+  def self.references_caaa
+    C::CA::CAA::CAAA.message
+  end
+
+  module AB
+    def self.message
+      "hello from A::AB"
+    end
+
+    module ABA
+      def self.message
+        "hello from A::AB::ABA"
+      end
+
+      def self.references_abb
+        ABB.message
+      end
+    end
+  end
+end
+     FILE
+
+     Dir.mkdir "/foo/a"
+     File.write "/foo/a/aa.rb", <<-FILE
+module A
+  module AA
+    def self.message
+      "hello from A::AA"
+    end
+  end
+end
+      FILE
+
+      Dir.mkdir "/foo/a/ab"
+      File.write "/foo/a/ab/abb.rb", <<-FILE
+module A
+  module AB
+    module ABB
+      def self.message
+        "hello from A::AB::ABB"
+      end
+    end
+  end
+end
+      FILE
+
+      Dir.mkdir "/foo/b"
+      File.write "/foo/b/ba.rb", <<-FILE
+module B
+  module BA
+    def self.message
+      "hello from B::BA"
+    end
+  end
+end
+      FILE
+
+      Dir.mkdir "/foo/c"
+      Dir.mkdir "/foo/c/ca"
+      Dir.mkdir "/foo/c/ca/caa"
+      File.write "/foo/c/ca/caa/caaa.rb", <<-FILE
+module C
+  module CA
+    module CAA
+      module CAAA
+        def self.message
+          "hello from C::CA::CAA::CAAA"
+        end
+      end
+    end
+  end
+end
+      FILE
+
+      File.write "/foo/d.rb", <<-FILE
+class D
+  def self.references_a
+    A.message
+  end
+  def references_b_ba
+    B::BA.message
+  end
+end
+      FILE
+
+      Dir.mkdir "/bar"
+      File.write "/bar/a.rb", <<-FILE
+module A
+  def self.message
+    "hello from Bar::A"
+  end
+end
+      FILE
+
+      File.write "/bar/b.rb", <<-FILE
+module B
+  def self.message
+    "hello from Bar::B"
+  end
+end
+      FILE
+
+      Dir.mkdir "/my_app"
+      Dir.mkdir "/my_app/lib"
+      File.write "/my_app/lib/a.rb", <<-FILE
+module A
+  def self.message
+    "hello from MyApp::A"
+  end
+
+  def self.references_b_ba
+    B::BA.message
+  end
+end
+      FILE
+
+      Dir.mkdir "/my_app/lib/b"
+      File.write "/my_app/lib/b/ba.rb", <<-FILE
+module B
+  module BA
+    def self.message
+      "hello from MyApp::B::BA"
+    end
+  end
+end
+      FILE
+    end
+  end
+end

data/test/support/tests_autoloading.rb

@@ -0,0 +1,13 @@
+module TestsAutoloading
+  def setup
+    @foo = Truck.define_context :Foo, root: "/foo"
+    @bar = Truck.define_context :Bar, root: '/bar', parent: :Foo
+    Truck.boot!
+    assert_nil Truck::Autoloader.current_autoloader
+  end
+
+  def teardown
+    assert_nil Truck::Autoloader.current_autoloader,
+      "Each test in this file must clean up after itself"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,35 @@
+require "bundler"
+Bundler.setup
+
+require "minitest/autorun"
+require "minitest/reporters"
+
+require "fakefs/safe"
+require "ostruct"
+require "pathname"
+require "stringio"
+
+Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+
+require_relative "../lib/truck"
+
+$LOAD_PATH << "test/support"
+
+Minitest::Test.class_eval do
+  autoload :FakesFilesystem, "fakes_filesystem"
+  autoload :TestsAutoloading, "tests_autoloading"
+
+  def after_teardown
+    Truck.shutdown!
+  end
+end
+
+class Binding
+  def method_missing(sym, *)
+    return super unless sym == :pry
+    FakeFS.without do
+      require 'pry'
+      pry
+    end
+  end
+end

data/test/unit/autoloader_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class AutoloaderTest < Minitest::Test
+  include FakesFilesystem
+  include TestsAutoloading
+
+  def test_throws_constant_when_found
+    const = assert_catches :const do
+      Truck::Autoloader.handle :A, from: Foo
+    end
+    assert_equal 'Foo::A', const.name
+  end
+
+  def test_raises_error_when_const_not_found
+    exception = assert_raises NameError do
+      Truck::Autoloader.handle :Abracadabra, from: Foo
+    end
+    assert_equal 'uninitialized constant Abracadabra (in Foo)', exception.message
+  end
+
+  def test_simple_implicit_namespace_case
+    Truck::Autoloader.handle :B, from: Foo
+    const = assert_catches :const do
+      Truck::Autoloader.handle :BA, from: Foo
+    end
+    assert_equal 'Foo::B::BA', const.name
+    assert_nil Truck::Autoloader.current_autoloader
+  end
+
+  def test_cleanup_after_implicit_namespace
+    Truck::Autoloader.handle :B, from: Foo
+    assert_raises NameError do
+      Truck::Autoloader.handle :Abracadabra, from: Foo
+    end
+    assert_nil Truck::Autoloader.current_autoloader
+  end
+
+  def test_deeply_nested_module_with_implicit_namespaces
+    %i(C CA CAA).each do |implicit_namespace|
+      Truck::Autoloader.handle implicit_namespace, from: Foo
+    end
+    const = assert_catches :const do
+      Truck::Autoloader.handle :CAAA, from: Foo
+    end
+    assert_equal 'Foo::C::CA::CAA::CAAA', const.name
+  end
+
+  def test_shallowly_nested_module_with_implicit_namespaces
+    @foo.resolve_const 'A::AB::ABA'
+
+    const = assert_catches :const do
+      Truck::Autoloader.handle :ABB, from: Foo::A::AB::ABA
+    end
+    assert_equal 'Foo::A::AB::ABB', const.name
+  end
+
+  private
+
+  def assert_catches(thrown)
+    val = catch thrown do
+      yield
+      :not_found
+    end
+    refute_equal :not_found, val, "Expected block to throw #{thrown.inspect}"
+    val
+  end
+
+end

data/test/unit/context_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+class ContextTest < Minitest::Test
+  include FakesFilesystem
+
+  def setup
+    @context = Truck.define_context :Foo, root: "/foo"
+    @context.boot!
+  end
+
+  def test_resolving_constant
+    mod = @context.resolve_const(:A)
+    assert_autoloaded_module 'A', mod
+  end
+
+  def test_resolving_deep_constant
+    mod = @context.resolve_const('A::AA')
+    assert_autoloaded_module 'A::AA', mod
+  end
+
+  def test_resolving_inner_constant
+    mod = @context.resolve_const('A::AB::ABA')
+    assert_autoloaded_module 'A::AB::ABA', mod
+  end
+
+  def test_parent_namespace_defined_in_child
+    mod = @context.resolve_const('B::BA')
+    assert_autoloaded_module 'B::BA', mod
+  end
+
+  def test_returns_nil_if_constant_isnt_defined
+    assert_nil @context.resolve_const(:Abracadabra)
+  end
+
+  def test_returns_constant_that_has_already_been_resolved
+    @context.resolve_const(:A)
+    File.write '/foo/a.rb', "raise 'should not load this file'"
+    @context.resolve_const(:A)
+  end
+
+  def test_raises_error_if_corresponding_file_did_not_define_constant
+    File.write "/foo/abracadabra.rb", ""
+
+    exception = assert_raises(Truck::AutoloadError) do
+      @context.resolve_const(:Abracadabra)
+    end
+
+    expected_message = %r{Expected /foo/abracadabra\.rb to define Abracadabra}
+    assert_match expected_message, exception.message
+  end
+
+  def test_nesting_context
+    nested_context = Truck.define_context :Bar, root: "/bar", parent: 'Foo'
+    nested_context.boot!
+
+    mod = nested_context.resolve_const('A')
+    assert_autoloaded_module 'Bar::A', mod
+  end
+
+  def test_eager_load
+    refute Foo.const_defined?(:A)
+    @context.eager_load!
+    assert Foo.const_defined?(:A)
+  end
+
+  def test_reload_drops_constant_references
+    @context.eager_load!
+    assert Foo.const_defined?(:A)
+    @context.reload!
+    refute Foo.const_defined?(:A)
+  end
+
+  def test_shutdown_removes_const
+    assert @context.booted?
+    @context.shutdown!
+    refute @context.booted?
+  end
+
+  private
+
+  def assert_autoloaded_module(expected_name, mod)
+    assert_kind_of Module, mod
+    assert_equal "Foo::#{expected_name}", mod.name
+    assert_equal "hello from #{expected_name}", mod.message
+  end
+end

data/truck.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'truck/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "truck"
+  spec.version       = Truck::VERSION
+  spec.authors       = ["ntl"]
+  spec.email         = ["nathanladd+github@gmail.com"]
+  spec.summary       = %q{Truck is an alternative autoloader that doesn't pollute the global namespace. Specifically, it does not load constants into `Object`; rather, it loads them into *Contexts* that you define.}
+  spec.description   = %q{Truck is an alternative autoloader that doesn't pollute the global namespace.}
+  spec.homepage      = "https://github.com/ntl/truck"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "fakefs", "~> 0.5"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters", "~> 1.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: truck
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- ntl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Truck is an alternative autoloader that doesn't pollute the global namespace.
+email:
+- nathanladd+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/truck.rb
+- lib/truck/autoloader.rb
+- lib/truck/const_resolver.rb
+- lib/truck/context.rb
+- lib/truck/string_inflections.rb
+- lib/truck/version.rb
+- test/integration/autoloading_test.rb
+- test/support/fakes_filesystem.rb
+- test/support/tests_autoloading.rb
+- test/test_helper.rb
+- test/unit/autoloader_test.rb
+- test/unit/context_test.rb
+- truck.gemspec
+homepage: https://github.com/ntl/truck
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Truck is an alternative autoloader that doesn't pollute the global namespace.
+  Specifically, it does not load constants into `Object`; rather, it loads them into
+  *Contexts* that you define.
+test_files:
+- test/integration/autoloading_test.rb
+- test/support/fakes_filesystem.rb
+- test/support/tests_autoloading.rb
+- test/test_helper.rb
+- test/unit/autoloader_test.rb
+- test/unit/context_test.rb