truck 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8475ef41616dc1d5e77921e3c1a4a1c2f49e4ee
-  data.tar.gz: 690aa4f1b04fcbb4df44fc03da487edf43c10171
+  metadata.gz: b9163ddda9ad94d4bdb3142fde6704ac24c8fe2e
+  data.tar.gz: 377e00cc27d4b0f6ea8ef1b0d3386c7ca7e9cc43
 SHA512:
-  metadata.gz: 24820f2e0c852256e6f66316070067444de7a27d7819265219840b55a898b911a2979a756b887d10125047db779d4f2224b41f04b7291b0b8762950d5007f11d
-  data.tar.gz: 3925f6a1600e036edb2cdbda4621dc6aef8a937b79d03bfe37bf5ae37510cafdb4223c7bda5d877d45a3427f2a1ea0dc1694a7ed53dd2efa062171f306f83792
+  metadata.gz: a55de745877a006ec2722fb2c68741b6b41eb4f673122a42f6d457a42d2a6a8a4bca5640d487ef58c52ca22003a0745859c75e821611cde4ef7f7e22d0894611
+  data.tar.gz: fd4ff258f9782f0ef11f665d0125fbac6ada1ef10f54286f87cfd39aa64d3b383a1e28cf99afd160f92bc21174991fbed12ddfd8bcbbf258a3a4503723851475

data/README.md

@@ -1,9 +1,11 @@
 # 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:
+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 three 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
+3. Eliminates the need for `fork()` based preloaders like `zeus` and `spring`. Instead, load your gems, define your contexts, and safely `reload!` them between each test run.
+
 
 ## Installation
 
@@ -23,15 +25,21 @@ Or install it yourself as:
 
 Unlike ActiveSupport's autoloader, truck requires a bit of setup for each context. An example:
 
-    Truck.define_context :MyContext, root: "/path/to/context/root"
+```ruby
+Truck.define_context :MyContext, root: "/path/to/context/root"
+```
 
 Also, after defining all your contexts, you'll want to boot everyone up:
 
-    Truck.boot!
+```ruby
+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`:
+### Referencing constants
+
+Suppose you had a class called `Foo` living in `/path/to/context/root/foo.rb`:
 
 ```ruby
 # /path/to/context/root/foo.rb
@@ -53,25 +61,49 @@ end
 
 `Foo` can reference `Bar` without an explicit require. So how does the world outside of `MyContext` reference objects?
 
-    MyContext.resolve_const("Bar")
+```ruby
+MyContext.resolve_const("Bar")
+```
 
 This works with namespaced constant names, too:
 
-    MyContext.resolve_const("Foo::Bar::Baz")
+```ruby
+MyContext.resolve_const("Foo::Bar::Baz")
+```
+
+### Other
 
 `MyContext` has some other interesting methods on it:
 
-    # Wipe the whole context and reload it (also aliased as reload!)
-    MyContext.reset!
+```ruby
+# Wipe the whole context and reload it (also aliased as reload!)
+MyContext.reset!
 
-    # Kill the context
-    MyContext.shutdown!
+# Kill the context
+MyContext.shutdown!
 
-    # Eagerly load the entire context into memory (good for production)
-    MyContext.eager_load!
+# 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.
 
+### Autoload Paths
+
+By default, the `root` you pass to the `Context` is your autoload paths. You can alternatively supply a list of autoload paths relative to `root`:
+
+```ruby
+Truck.define_context(
+  :MyContext,
+  root: "/path/to/context/root",
+  autoload_paths: %w(app/models app/controllers lib)
+)
+```
+
+### Compatibiilty
+
+Currently, truck has been tested against 2.1.1. It uses refinements internally. The plan is to support recent rubinius releases as well.
+
 ## Contributing
 
 1. Fork it ( https://github.com/ntl/truck/fork )

data/lib/truck.rb

@@ -36,3 +36,7 @@ module Truck
     contexts.each_value.select(&:booted?).each(&block)
   end
 end
+
+# Load this last so that when truck itself has unresolvable constants, we throw
+# up vanilla ruby NameErrors.
+require_relative "truck/core_ext"

data/lib/truck/autoloader.rb

@@ -113,19 +113,3 @@ module Truck
     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

@@ -3,32 +3,23 @@ module Truck
 
   class Context
     class ConstResolver
-      attr :current_path, :autoload_paths, :context, :expanded_const
+      attr :current_path, :context, :expanded_const
 
-      def initialize(context:, expanded_const:, autoload_paths: [''])
-        @autoload_paths = autoload_paths
+      def initialize(context:, expanded_const:)
         @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
+      def resolve
+        check_already_loaded or resolve!
       end
 
-      def each_autoload_path
-        autoload_paths.each do |autoload_path|
-          @current_path = context.root.join autoload_path
-          yield
+      def resolve!
+        each_possible_rb_file do |rb_file|
+          context.load_file rb_file
+          check_loaded rb_file
         end
-        @current_path = nil
+        const_get
       end
 
       def each_possible_rb_file
@@ -40,6 +31,14 @@ module Truck
         end
       end
 
+      def each_autoload_path
+        context.autoload_paths.each do |autoload_path|
+          @current_path = autoload_path
+          yield
+        end
+        @current_path = nil
+      end
+
       def each_rb_file_from_base_path(base_path)
         base_path.ascend do |path|
           return if path == context.root
@@ -48,16 +47,11 @@ module Truck
         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
+      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
-        const_get
       end
 
       def walk_const_parts(const = expanded_const)

data/lib/truck/context.rb

@@ -1,12 +1,13 @@
 module Truck
   class Context
-    attr :mod, :name, :root
+    attr :autoload_paths, :mod, :name, :root
 
-    def initialize(name, parent: nil, root:)
+    def initialize(name, parent: nil, root:, autoload_paths: ['.'])
       @mod    = build_mod
       @name   = name
       @root   = Pathname(root) if root
       @parent = parent
+      @autoload_paths = expand_autoload_paths autoload_paths
     end
 
     class << self
@@ -67,6 +68,10 @@ module Truck
       Module.new
     end
 
+    def expand_autoload_paths(paths)
+      paths.map do |path| root.join path; end
+    end
+
   end
 
   class AutoloadError < NameError

data/lib/truck/core_ext.rb

@@ -0,0 +1,15 @@
+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/version.rb

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

data/test/integration/autoloading_test.rb

@@ -36,4 +36,8 @@ class AutoloadingTest < Minitest::Test
     end
     assert_equal "uninitialized constant Abracadabra", exception.message
   end
+
+  def test_explicit_autoload_paths
+    assert_equal 'hello from Bar::Z', MultipleAutoloadPaths::A.references_z
+  end
 end

data/test/support/fakes_filesystem.rb

@@ -55,6 +55,10 @@ module A
     C::CA::CAA::CAAA.message
   end
 
+  def self.references_z
+    Z.message
+  end
+
   module AB
     def self.message
       "hello from A::AB"
@@ -153,6 +157,14 @@ module B
 end
       FILE
 
+      File.write "/bar/z.rb", <<-FILE
+module Z
+  def self.message
+    "hello from Bar::Z"
+  end
+end
+      FILE
+
       Dir.mkdir "/my_app"
       Dir.mkdir "/my_app/lib"
       File.write "/my_app/lib/a.rb", <<-FILE

data/test/support/tests_autoloading.rb

@@ -2,6 +2,7 @@ module TestsAutoloading
   def setup
     @foo = Truck.define_context :Foo, root: "/foo"
     @bar = Truck.define_context :Bar, root: '/bar', parent: :Foo
+    @multi = Truck.define_context :MultipleAutoloadPaths, root: "/", autoload_paths: %w(foo bar)
     Truck.boot!
     assert_nil Truck::Autoloader.current_autoloader
   end

data/test/unit/context_test.rb

@@ -76,6 +76,23 @@ class ContextTest < Minitest::Test
     refute @context.booted?
   end
 
+  def test_autoload_path_defaults_to_root
+    assert_equal %w(/foo), Truck.contexts.fetch(:Foo).autoload_paths.map(&:to_s)
+  end
+
+  def test_explicit_autoload_paths
+    context = Truck.define_context :MultipleAutoloadPaths, root: "/", autoload_paths: %w(foo bar)
+    context.boot!
+
+    mod = context.resolve_const('A')
+    assert_kind_of Module, mod
+    assert_equal 'MultipleAutoloadPaths::A', mod.name
+
+    mod = context.resolve_const('B::BA')
+    assert_kind_of Module, mod
+    assert_equal 'MultipleAutoloadPaths::B::BA', mod.name
+  end
+
   private
 
   def assert_autoloaded_module(expected_name, mod)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: truck
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - ntl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-05 00:00:00.000000000 Z
+date: 2014-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,6 +96,7 @@ files:
 - lib/truck/autoloader.rb
 - lib/truck/const_resolver.rb
 - lib/truck/context.rb
+- lib/truck/core_ext.rb
 - lib/truck/string_inflections.rb
 - lib/truck/version.rb
 - test/integration/autoloading_test.rb