loadable 1.2.0

data/lib/loadable/loaders/vendor_loader.rb

@@ -0,0 +1,109 @@
+# TODO: Support `:from` option.
+
+require 'loadable/mixin'
+
+module Loadable
+
+  # Add vendored projects to load path. For example:
+  #
+  #   Loadable.vendor(project_root_directoy, 'vendor')
+  #
+  # Then any projects in the vendor directory will be accessible
+  # via require and load. This method looks for a .gemspec or .ruby
+  # file in the project to determine it's proper load paths, baring
+  # either of these it falls back to using `lib/`.
+
+  class VendorLoader
+
+    include Loadable
+
+    #
+    def initialize(*directory)
+      raise ArgumentError if directory.empty?
+
+      @_yaml_loaded ||= !(require 'yaml').nil?
+
+      settings  = (Hash === directory.last ? directory.pop : {})
+      directory = File.expand_path(File.join(*directory))
+
+      @load_path = []
+
+      if settings[:direct]
+        @load_path.concat(Dir.glob(directory))
+      else
+        Dir.glob(directory).each do |dir|
+          next unless File.directory?(dir)
+          build_loadpath(dir)
+        end
+      end
+
+      if @load_path.empty?
+        # TODO: if load_path empty should we fallback to direct path ?
+      end
+    end
+
+    # Load script from vendored locations.
+    #
+    def call(fname, options={})
+      @load_path.each do |path|
+        file = lookup(path, fname, options)
+        return super(file, options) if file
+      end
+      raise_load_error(fname)
+    end
+
+    # Iterate over each loadable file in vendored locations.
+    #
+    def each(options={}, &block)
+      @load_path.uniq.each do |path|
+        path = File.expand_path(path)
+        traverse(path, &block)
+      end
+    end
+
+  private
+
+    # Build up load_path given a directory to check. Looks for a `.ruby`
+    # or `.gemspec` file to get project's local load paths, otherwise if
+    # looks for a `lib` directory.
+    #
+    def build_loadpath(dir)
+      if dotruby_file = Dir.glob(File.join(dir, '.ruby')).first
+        @load_path.concat(loadpath_dotruby(dotruby_file, dir))
+
+      elsif defined?(::Gem) && gemspec = Dir.glob(File.join(dir, '{*,}.gemspec')).first
+        @load_path.concat(loadpath_gemspec(gemspec_file, dir))
+
+      elsif path = Dir.glob(File.join(dir, 'lib')).first
+        @load_path << path
+
+      else
+        # TODO: is this an error, just ignore, or add dir directly ?
+      end
+
+      return @load_path
+    end
+
+    # Build the load_path given a '.ruby` file.
+    #
+    def loadpath_dotruby(dotruby_file, dir)
+      data = YAML.load(dotruby_file)
+      path = data['load_path'] || ['lib']
+      path.map do |lp|
+        File.join(dir, lp)
+      end
+    end
+
+    # Build the load_path given a '.gemspec` file.
+    #
+    def loadpath_gemspec(gemspec_file, dir)
+      # TODO: handle YAML gemspecs
+      spec = Gem::Specification.load(gemspec_file)
+      spec.require_paths.map do |rp|
+        File.join(dir, rp)
+      end
+    end
+
+  end
+
+end

data/lib/loadable/mixin.rb

@@ -0,0 +1,100 @@
+# Loadable is used in two ways.
+
+# First, it can be used as a mixin for loaders (also called load wedges). Loaders
+# are used to safely inject new import logic into Ruby's require/load system.
+#
+# Secondly, Loadable's class methods are used to override Ruby's built-in
+# require and load Kernel methods.
+#
+# Active load wedges are stored in `$LOADERS` global variable.
+#
+# IMPORTANT: This must be loaded before `loadable/kernel.rb`.
+
+module Loadable
+
+  # TODO: Some extensions are platform specific --only add the ones needed
+  # for the current platform.
+
+  # Script extensions recognized by Ruby (MRI and variants).
+  RB_EXTS = ['.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar'] #, '']
+
+  alias :require :require
+  alias :load    :load
+
+  #
+  def call(fname, options={})
+    if options[:load]
+      load(fname, options[:wrap])
+    else
+      require(fname)
+    end
+  end
+
+  # A load wedge should provide a means for iterating over all requirable
+  # files that its `#call` method could load.
+  #
+  # If a load wedge is "esoteric", in that it doesn't actually load
+  # a file, then it's `#each` method can iterate over a list of suitable
+  # symbolic identifiers, or if otherwise necessary nothing at all. But
+  # be sure to document this prominantly!!!
+  #
+  def each(options={}, &block)
+  end
+
+  # Name of wedge. By default it is simply the class name.
+  def name
+    self.class.name
+  end
+
+private
+
+  # Given a base-path, and a path relative to it determine if a matching
+  # file exists. Unless +:load+ option is +true+, this will check for each
+  # viable Ruby suffix. If a match is found the full path to the file
+  # is returned, otherwise +nil+.
+
+  def lookup(base_path, relative_path, options={})
+    exts = default_file_extensions
+    if options[:load] or exts.include?(File.extname(relative_path))
+      abspath = File.join(base_path, relative_path)
+      File.exist?(abspath) ? abspath : nil
+    else
+      exts.each do |ext|
+        abspath = File.join(base_path, relative_path + ext)
+        return abspath if File.exist?(abspath)
+      end
+      nil
+    end
+  end
+
+  # This helper method provides a fast way to traverse a directory
+  # recursively iteratating over each file.
+
+  def traverse(dir, base=dir, &block)
+    return unless File.directory?(dir)
+    Dir.new(dir).each do |file|
+      next if file == '.' or file == '..'
+      path = File.join(dir, file)
+      if File.directory?(path)
+        traverse(path, base, &block)
+      else
+        block.call(path.sub(base+'/',''))
+      end
+    end
+  end
+
+  # This method is used by `#lookup` to handle defualt file extensions.
+  # By default it returns the value of the `RB_EXTS` constant.
+
+  def default_file_extensions
+    RB_EXTS
+  end
+
+  # Raise LoadError with an error message patterned after Ruby's standard 
+  # error message when a script can't be required or loaded.
+
+  def raise_load_error(fname)
+    raise LoadError, "no such file to load -- #{fname}"
+  end
+
+end

data/lib/loadable/system.rb

@@ -0,0 +1,11 @@
+require 'loadable/version'
+require 'loadable/mixin'
+require 'loadable/domain'
+require 'loadable/loaders/original_loader'
+require 'loadable/loaders/ruby_loader'
+require 'loadable/loaders/gem_loader'
+require 'loadable/loaders/vendor_loader'
+require 'loadable/kernel'
+
+Loadable.register(Loadable::OriginalLoader.new)
+

data/lib/loadable/version.rb

@@ -0,0 +1,20 @@
+module RbConfig
+
+  class LoadWedge
+
+    #
+    def self.metadata
+      @metadata ||= (
+        require 'yaml'
+        YAML.load_file(File.dirname(__FILE__) + '/load_wedge.yml')
+      )
+    end
+
+    #
+    def self.method_missing(name)
+      metadata[name.to_s.downcase] || super(name)
+    end
+
+  end
+
+end

data/lib/loadable.rb

@@ -0,0 +1,5 @@
+require 'loadable/system'
+
+Loadable.register(Loadable::RubyLoader.new)
+Loadable.register(Loadable::GemLoader.new)
+

data/spec/fixture/abbrev.rb

@@ -0,0 +1,3 @@
+# This is a dummy abbrev.rb script to test
+# is Ruby's standard abbrev.rb can be loaded.
+$NO_ABBREV = true

data/spec/fixture/ansi.rb

@@ -0,0 +1,3 @@
+# This is a dummy ansi.rb script to test
+# if ansi.rb from the ANSI gem can be loaded.
+$NO_ANSI = true

data/spec/fixture/subpro/.ruby

@@ -0,0 +1,5 @@
+---
+name: subpro
+version: 0.0.0
+load_path: [lib]
+

data/spec/fixture/subpro/lib/subpro.rb

@@ -0,0 +1 @@
+$SUBPRO = true

data/spec/gem_loader_spec.rb

@@ -0,0 +1,49 @@
+require 'helper'
+require 'loadable'
+
+# TODO: techincally these tests need to be isolated in separate processes
+# to truly work right, but we won't overly fret about it presently b/c
+# MiniTest randomizes execution order, so they will get fully tested
+# over the course a handful of runs.
+
+describe "GemLoader" do
+
+  # setup alternate loadpath
+  dir = File.expand_path(File.dirname(__FILE__) + '/fixture')
+
+  before do
+    $LOAD_PATH.unshift(dir)
+  end
+
+  after do
+    $LOAD_PATH.delete(dir)
+  end
+
+  it "should load local library when neither `:gem` or `:from` option is supplied" do
+    require 'ansi'
+    assert $NO_ANSI, "Local `ansi.rb' library not loaded."
+  end
+
+  it "should load the gem when `:from` option is supplied" do
+    require 'ansi', :gem=>'ansi'
+    assert ANSI, "Ruby `ansi.rb' library not loaded."
+  end
+
+  it "should load from the gem when the `:gem` option is supplied" do
+    require 'ansi', :from=>'ansi'
+    assert ANSI, "Ruby `ansi.rb' library not loaded."
+  end
+
+  # This isn't a 100% thurough.
+  it "should iterate over current gems files" do
+    loader = Loadable::GemLoader.new
+
+    list = []
+    loader.each(:gem=>'ansi'){ |f| list << f }
+
+    assert list.include?('ansi.rb')
+    assert list.include?('ansi/code.rb')
+  end
+
+end
+

data/spec/helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitap'
+
+MiniTest::Unit.runner = MiniTest::TapY.new
+

data/spec/ruby_loader_spec.rb

@@ -0,0 +1,38 @@
+require 'helper'
+require 'loadable'
+
+describe "RubyLoader" do
+
+  # setup alternate loadpath
+  dir = File.expand_path(File.dirname(__FILE__) + '/fixture')
+
+  before do
+    $LOAD_PATH.unshift(dir)
+  end
+
+  after do
+    $LOAD_PATH.delete(dir)
+  end
+
+  it "should load local library without the ruby prefix" do
+    require 'abbrev'
+    assert $NO_ABBREV, "Local `abbrev.rb' library not loaded."
+  end
+
+  it "should load the standard ruby library with the `:from` ruby option" do
+    require 'abbrev', :from=>'ruby'
+    assert Abbrev, "Ruby `abbrev.rb' library not loaded."
+  end
+
+  it "should iterate over standard ruby libs" do
+    loader = Loadable::RubyLoader.new
+
+    list = []
+    loader.each{ |f| list << f }
+
+    assert list.include?('abbrev.rb')
+    assert list.include?('ostruct.rb')
+  end
+
+end
+

data/spec/vendor_loader_spec.rb

@@ -0,0 +1,30 @@
+require 'helper'
+require 'loadable'
+
+describe "VendorLoader" do
+
+  dir = File.dirname(__FILE__) + '/fixture'
+
+  it "should be able to vendor a directory directly" do
+    loader = Loadable::VendorLoader.new(dir, :direct=>true)
+    list = []
+    loader.each{ |f| list << f }
+    list.must_include('abbrev.rb')
+    list.must_include('ansi.rb')
+  end
+
+  it "should be able to vendor subprojects" do
+    loader = Loadable::VendorLoader.new(dir, '*')
+    list = []
+    loader.each{ |f| list << f }
+    list.must_include('subpro.rb')
+  end
+
+  it "should vendor using the Loadable class method" do
+    Loadable.vendor(dir, '*')
+    require 'subpro'
+    assert $SUBPRO, "Vendored project not loaded."
+  end
+
+end
+

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: loadable
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &21512620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21512620
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &21517660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21517660
+- !ruby/object:Gem::Dependency
+  name: minitap
+  requirement: &21751300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21751300
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &21755040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21755040
+description: Loadable modifieds Ruby's load/require system to handle "load wedges",
+  which work much like routes in web frameworks, but in this case determine which
+  files get loaded.
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- HISTORY.rdoc
+- COPYING.rdoc
+- INFRACTIONS.rdoc
+- README.md
+files:
+- .yardopts
+- .ruby
+- lib/loadable/class_require.rb
+- lib/loadable/core_ext/rubygems.rb
+- lib/loadable/domain.rb
+- lib/loadable/kernel.rb
+- lib/loadable/loaders/gem_loader.rb
+- lib/loadable/loaders/original_loader.rb
+- lib/loadable/loaders/roll_loader.rb
+- lib/loadable/loaders/ruby_loader.rb
+- lib/loadable/loaders/vendor_loader.rb
+- lib/loadable/mixin.rb
+- lib/loadable/system.rb
+- lib/loadable/version.rb
+- lib/loadable.rb
+- spec/fixture/abbrev.rb
+- spec/fixture/ansi.rb
+- spec/fixture/subpro/.ruby
+- spec/fixture/subpro/lib/subpro.rb
+- spec/gem_loader_spec.rb
+- spec/helper.rb
+- spec/ruby_loader_spec.rb
+- spec/vendor_loader_spec.rb
+- HISTORY.rdoc
+- README.md
+- COPYING.rdoc
+- INFRACTIONS.rdoc
+homepage: http://rubyworks.github.com/loadable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Safely Customize Ruby's Load System
+test_files:
+- spec/gem_loader_spec.rb
+- spec/vendor_loader_spec.rb
+- spec/ruby_loader_spec.rb