roll 0.8.0 → 1.1.0

data/lib/roll/ledger.rb

@@ -0,0 +1,299 @@
+module Roll
+  require 'roll/original'
+  require 'roll/environment'
+  require 'roll/library'
+
+  # = Ledger class
+  #
+  class Ledger
+
+    include Enumerable
+
+    #
+    def initialize
+      @index = Hash.new{|h,k| h[k] = []}
+
+      @environment = Environment.new
+
+      @environment.each do |name, paths|
+        paths.each do |path|
+          unless File.directory?(path)
+            warn "roll: invalid path for #{name} -- #{path}"
+            next
+          end
+          lib = Library.new(path, name)
+          @index[name] << lib if lib.active?
+        end
+      end
+
+      @load_stack   = []
+      @load_monitor = Hash.new{ |h,k| h[k]=[] }
+    end
+
+    #
+    def enironment
+      @environment
+    end
+
+    #
+    def [](name)
+      @index[name]
+    end
+
+    #
+    def []=(name, value)
+      @index[name] = value
+    end
+
+    #
+    def include?(name)
+      @index.include?(name)
+    end
+
+    #
+    def names
+      @index.keys
+    end
+
+    #
+    def each(&block)
+      @index.each(&block)
+    end
+
+    #
+    def size
+      @index.size
+    end
+
+    #
+    def load_stack
+      @load_stack
+    end
+
+    # NOTE: Not used yet.
+    def load_monitor
+      @load_monitor
+    end
+
+    #--
+    # TODO: Should Ruby's underlying require be tried first,
+    # then fallback to Rolls. Or vice-versa?
+    #++
+ 
+    #
+    def require(path)
+      #begin
+      #  original_require(path)
+      #rescue LoadError => load_error
+      #  lib, file = *match(path)
+      #  if lib && file
+      #    constrain(lib)
+      #    lib.require_absolute(file)
+      #  else
+      #    raise clean_backtrace(load_error)
+      #  end
+      #end
+      lib, file = *match(path)
+      if lib && file
+        constrain(lib)
+        lib.require_absolute(file)
+      else
+        begin
+          original_require(path)
+        rescue LoadError => load_error
+          raise clean_backtrace(load_error)
+        end
+      end
+
+    end
+
+    #
+    def load(path, wrap=nil)
+      lib, file = *match(path, false)
+      if lib && file
+        constrain(lib)
+        lib.load_absolute(file, wrap)
+      else
+        begin
+          original_load(path, wrap)
+        rescue LoadError => load_error
+          raise clean_backtrace(load_error)
+        end
+      end
+    end
+
+    # Use acquire to use Roll-style loading. This first
+    # looks for a specific library via ':'. If ':' is 
+    # not present it then tries the current library.
+    # Failing that it fallsback to Ruby itself.
+    #
+    #   acquire('facets:string/margin')
+    #
+    # To "load" the library, rather than "require" it set
+    # the +:load+ option to true.
+    #
+    #   acquire('facets:string/margin', :load=>true)
+    #
+    def acquire(file, opts={})
+      if file.index(':') # a specific library
+        name, file = file.split(':')
+        lib = Library.open(name)
+      else # try the current library
+        cur = load_stack.last
+        if cur && cur.include?(file)
+          lib = cur
+        elsif !file.index('/') # is this a library name?
+          if cur = Library.instance(file)
+            lib  = cur
+            file = lib.default # default file to load
+          end
+        end
+      end
+      if opts[:load]
+        lib ? lib.load(file) : original_load(file)
+      else
+        lib ? lib.require(file) : original_require(file)
+      end
+    end
+
+    #
+    def constrain(lib)
+      cmp = self[lib.name]
+      if Array === cmp
+        self[lib.name] = lib
+      else
+        if lib.version != cmp.version
+          raise VersionError
+        end
+      end
+    end
+
+  private
+
+    # Find require matches.
+    def match(path, suffix=true)
+      path = path.to_s
+
+      return nil if /^\// =~ path  # absolute path
+
+      if path.index(':') # a specified library
+        name, path = path.split(':')
+        lib  = Library.open(name)
+        if lib.active?
+          file = lib.find(path, suffix)
+          return lib, file
+        end
+      end
+
+      matches = []
+
+      # try the load stack first
+      load_stack.reverse_each do |lib|
+        if file = lib.find(path, suffix)
+          return [lib, file] unless $VERBOSE
+          matches << [lib, file]
+        end
+      end
+
+      # TODO: Perhaps the selected and unselected should be kept in separate lists?
+      unselected, selected = *@index.partition{ |name, libs| Array === libs }
+
+      selected.each do |(name, lib)|
+        if file = lib.find(path, suffix)
+          #matches << [lib, file]
+          #return matches.first unless $VERBOSE
+          return [lib, file] unless $VERBOSE
+          matches << [lib, file]
+        end
+      end
+
+      unselected.each do |(name, libs)|
+        pos = []
+        libs.each do |lib|
+          if file = lib.find(path, suffix)
+            pos << [lib, file]
+          end
+        end
+        unless pos.empty?
+          latest = pos.sort{ |a,b| b[0].version <=> a[0].version }.first
+          return latest unless $VERBOSE
+          matches << latest
+          #return matches.first unless $VERBOSE
+        end
+      end
+
+      matches.uniq!
+
+      if matches.size > 1
+        warn_multiples(path, matches)
+      end
+
+      matches.first
+    end
+
+    #
+    def warn_multiples(path, matches)
+      warn "multiple matches for same request -- #{path}"
+      matches.each do |lib, file|
+        warn "  #{file}"
+      end
+    end
+
+    #
+    def clean_backtrace(error)
+      if $DEBUG
+        error
+      else
+        bt = error.backtrace
+        bt = bt.reject{ |e| /roll/ =~ e }
+        error.set_backtrace(bt)
+        error
+      end
+    end
+
+  end#class Ledger
+
+  #--
+  # Ledger augments the Library metaclass.
+  #++
+  class << Library
+
+    #
+    def ledger
+      @ledger ||= Ledger.new
+    end
+
+    # Current environment
+    def environment
+      ledger.environment
+    end
+
+    # List of library names.
+    def list
+      ledger.names
+    end
+
+    #
+    def require(path)
+      ledger.require(path)
+    end
+
+    #
+    def load(path, wrap=nil)
+      ledger.load(path, wrap)
+    end
+
+    #
+    def load_stack
+      ledger.load_stack
+    end
+
+    # NOTE: Not used yet.
+    def load_monitor
+      ledger.load_monitor
+    end
+
+  end
+
+end#module Roll
+

data/lib/roll/library.rb

@@ -1,635 +1,318 @@
-# TITLE:
-#
-#   library.rb
-#
-# LICENSE:
-#
-#   Copyright (c)2007 Thomas Sawyer, Ruby License
-#
-# TODO:
-#
-#   - Commented out #import for now. Facets' module_require and module_load
-#     are probably better. Implement those for Rolls instead. (Yes?)
-#   - Maybe add autopackage install system?
-#   - What about remotes? What about version tiers when remote requiring?
-
-require 'rbconfig'
-require 'fileutils'
-require 'roll/package'
+#require 'rbconfig'
 require 'roll/version'
-#require 'roll/sign'
-
-# We need to hold a copy of the original $LOAD_PATH
-# for specified "ruby: ..." loads.
-
-$RUBY_PATH = $LOAD_PATH.dup
-
-# Locations of rolls-ready libraries.
-# # We could use the site_ruby locations instead, but that creates an odd sort of overlap in
-# # the load paths, and would also promote putting the information file in the lib/ dir. So
-# # I think it's better to use a separate location. (After all site_ruby may just fade away.)
-# $LOAD_SITE = $LOAD_PATH - Config::CONFIG.values_at('rubylibdir', 'archdir') - ['.']
-
-rolldir = 'ruby_library'
-sitedir = ::Config::CONFIG['sitedir']
-version = ::Config::CONFIG['ruby_version']
+require 'roll/metadata'
+require 'roll/errors'
 
-$LOAD_SITE = [File.join(File.dirname(sitedir), rolldir, version)] + ENV['ROLL_PATH'].to_s.split(':')
-
-# = Library Class
-#
-# The Library class serves as an objecified location in Ruby's load paths.
-#
-# The Library qua class also serves as the library manager, storing a ledger of
-# available libraries.
-#
-# A library is roll-ready when it supplies a {name}-{verison}.roll file in either its
-# base directory or in the base's meta/ directory. The roll file name is specifically
-# designed to make library lookup fast. There is no need for Rolls to open the roll
-# file until an actual version is used. It also gives the most flexability in repository
-# layout. Rolls searches up to three subdirs deep looking for roll files. This is
-# suitable to non-versioned libs, versioned libs, non-versioned subprojects and subprojects,
-# including typical Subversion repository layouts.
-
-class Library
-
-  # Dynamic link extension.
-  def self.dlext
-    @dlext ||= '.' + ::Config::CONFIG['DLEXT']
-  end
-
-  # Location of rolls-ready libs.
-  def self.load_site
-    $LOAD_SITE
-  end
+module Roll
 
+  # = Library class
   #
-  def self.load_path
-    $LOAD_PATH
-  end
+  class Library
 
-  #
-  def self.ruby_path
-    $RUBY_PATH
-  end
-
-  # Name of library.
-  attr_reader :name
-
-  # Version of library. This is a VersionNumber object.
-  attr_reader :version
+    # Dynamic link extension.
+    #DLEXT = '.' + ::Config::CONFIG['DLEXT']
 
-  # Path to library.
-  attr_reader :location
+    #
+    #SUFFIXES = ['', '.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar']
+    SUFFIXES = ['', '.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar']
 
-  # New libray.
-  def initialize(location, identity=nil) #name, version, location=nil)
-    @location = location
-
-    if identity
-      @name      = identity[:name]
-      @version   = identity[:version]
-      @load_path = identity[:load_path] || identity[:load_paths]
-    else
-      identify(location)
-    end
+    #
+    SUFFIX_PATTERN = "{#{SUFFIXES.join(',')}}"
 
-    raise unless @name
-    raise unless @version
+    # Get an instance of a library by name, or name and version.
+    # Libraries are singleton, so once loaded the same object is
+    # always returned.
 
-    @identity = identity
+    def self.instance(name, constraint=nil)
+      name = name.to_s
+      #raise "no library -- #{name}" unless ledger.include?(name)
+      return nil unless ledger.include?(name)
 
-    # TODO Version number needs to be more flexiable in handling non-numeric tuples.
-    @version = VersionNumber.new(@version) unless VersionNumber === @version
-  end
+      library = ledger[name]
 
-  # Identify a library based on it's location.
-  def identify(location)
-    file = File.join(location,'{,meta/}*.roll')
-    if file = Dir.glob(file).first
-      @name, @version = file.chomp('.roll').split('-')
-    end
-  end
-
-  # Inspection.
-  def inspect
-    if version
-      "#<Library #{name}/#{version}>"
-    else
-      "#<Library #{name}>"
+      if Library===library
+        if constraint # TODO: it's okay if constraint fits current
+          raise VersionConflict, "previously selected version -- #{ledger[name].version}"
+        else
+          library
+        end
+      else # library is an array of versions
+        if constraint
+          compare = Version.constraint_lambda(constraint)
+          library = library.select(&compare).max
+        else
+          library = library.max
+        end
+        unless library
+          raise VersionError, "no library version -- #{name} #{constraint}"
+        end
+        #ledger[name] = library
+        #library.activate
+        return library
+      end
     end
-  end
 
-  def roll_file
-    find = "{,meta/}*.roll"  # "{,meta/}#{name}-#{version}.roll"
-    file = Dir.glob(File.join(location, find), File::FNM_CASEFOLD).first
-  end
+    # A shortcut for #instance.
 
-  # Read roll file.
-  def load_roll
-    return unless location  # NEED TO DO THIS BETTER. THIS IS HERE FOR THE ONE 'ruby' CASE.
-    raise LoadError unless File.directory?(location)
-    glob = File.join(location, "{,meta/}*.roll")  # "{,meta/}#{name}-#{version}.roll"
-    file = Dir.glob(glob, File::FNM_CASEFOLD).first
-    if file
-      @roll_file = file
-      @roll = Roll::Package.open(file, :name=>name, :version=>version.to_s)
-    else
-      raise "THIS SHOULD NOT POSSIBLE!"
-      #@roll = false #Roll::Package.new # THIS IN NO LONGER POSSIBLE
+    def self.[](name, constraint=nil)
+      instance(name, constraint)
     end
-    #use #?
-    return @roll
-  end
-
-  # Does this library have an roll file?
-  #def rolled?
-  #  roll ? true : false
-  #end
-
-  # Does this library have a remote source?
-
-  #def remote?
-  #  rolled? and source and pubkey
-  #end
-
-  # Meta information about the libray.
-  def roll
-    @roll = load_roll if @roll.nil?  # If it's false, we don't have one.
-    @roll
-  end
-  alias_method :info, :roll
 
-  # Compare by version.
-  def <=>(other)
-    version <=> other.verison
-  end
+    # Same as #instance but will raise and error if the library is
+    # not found. This can also take a block to yield on the library.
 
-  # List of subdirectories that are searched when loading libs.
-  # In general this should include all the libs internal load paths,
-  # so long as there will be no name conflicts between directories.
-  def lib_path
-    return unless roll # NEED TO DO THIS BETTER. THIS IS HERE FOR THE ONE 'ruby' CASE.
-    return @load_path if @load_path
-    if roll.load_path
-      @load_path = roll.load_path.collect{ |path| File.join(location, path) }
-    else
-      @load_path = ['lib']  # ["lib/#{name}"]
-    end
-  end
-  alias_method :load_path,  :lib_path
-  alias_method :load_paths, :lib_path
-
-  # List of subdirectories that are searched for binaries.
-  #++
-  # TODO I think it would be better just to make this a fix
-  # convention that bin/ is always the place to put these.
-  # (Unlike lib/ which needs to be more flexable.)
-  #--
-  def bin_path
-    return @bin_path if @bin_path
-    return [] unless location  # NEED TO DO THIS BETTER.
-    if roll.bin_path
-      @bin_path = roll.bin_path.collect{ |path| File.join(location, path) }
-    else
-      if File.directory?(File.join(location, 'bin'))
-        @bin_path = [File.join(location, 'bin')]
-      else
-        @bin_path = []
+    def self.open(name, constraint=nil) #:yield:
+      lib = instance(name, constraint)
+      unless lib
+        raise LoadError, "no library -- #{name}"
       end
+      yield(lib) if block_given?
+      lib
     end
-    return @bin_path
-  end
 
-  # Return the path to the data directory associated with the given
-  # package name. Normally this is just
-  # "#{Config::CONFIG['datadir']}/#{package_name}", but may be
-  # modified by packages like RubyGems and Rolls to handle
-  # versioned data directories.
-  def datadir(versionless=false)
-    if version and not versionless
-      File.join(Config::CONFIG['datadir'], name, version)
-    else
-      File.join(Config::CONFIG['datadir'], name)
+    #
+    def initialize(location, name=nil)
+      @location = location
+      @name     = name
     end
-  end
-
-  # Return the path to the configuration directory.
-  #--
-  # Can or should configuration directories be versioned?
-  #++
-  def confdir
-    File.join(location, 'data')
-    #if version
-    #  File.join(Config::CONFIG['confdir'], name, version)
-    #else
-    #  File.join(Config::CONFIG['datadir'], name)
-    #end
-  end
-
-  # Require find.
-  def require_find(file)
-    file = roll.index_file if (file.nil? or file.empty?)
-    glob = File.join('{' + load_path.join(',') + '}', file + "{.rb,#{Library.dlext},}")
-    Dir.glob(glob).first
-  end
-
-  # Load find.
-  def load_find(file)
-    file = roll.index_file if (file.nil? or file.empty?)
-    glob = File.join('{' + load_path.join(',') + '}', file)
-    Dir.glob(glob).first
-  end
 
-  # Library specific #require.
-  def require(file)
-    if path = require_find(file)
-      Kernel.require(path)
-    else
-      raise LoadError, "no such file to load -- #{name}:#{file}"
+    #
+    def location
+      @location
     end
-  end
 
-  # Library specific load.
-  def load(file, wrap=nil)
-    if path = load_find(file)
-      Kernel.load(path, wrap)
-    else
-      raise LoadError, "no such file to load -- #{name}:#{file}"
+    #
+    def name
+      @name ||= metadata.name
     end
-  end
 
-  # Library specific autoload.
-  def autoload(base, file)
-    if path = require_find(file)
-      Kernel.autoload(base, file)
-    else
-      raise LoadError, "no such file to autoload -- #{name}:#{file}"
+    #
+    def version
+      @version ||= metadata.version
     end
-  end
 
-  # Require into module.
-  def module_require(mod, file)
-    if path = require_find(file)
-      mod.module_require(path)  # FIXME
-    else
-      raise LoadError, "no such file to load -- #{name}:#{file}"
+    #
+    def active?
+      @active ||= metadata.active
     end
-  end
 
-  # Load into module.
-  def module_load(mod, file)
-    if path = load_find(file)
-      mod.module_load(path)  # FIXME
-    else
-      raise LoadError, "no such file to load -- #{name}:#{file}"
+    #
+    def loadpath
+      @loadpath ||= metadata.loadpath
     end
-  end
 
-  # Library specific autoload for module.
-  def module_autoload(mod, base, file)
-    if path = require_find(file)
-      mod.autoload_without_roll(base, file)
-    else
-      raise LoadError, "no such file to autoload -- #{name}:#{file}"
+    #
+    def requires
+      @requires ||= metadata.requires
     end
-  end
 
-  # Put the libs load paths into the global lookup.
-  #--
-  # TODO Maybe call 'import' instead?
-  #++
-  def utilize
-    lib_path.each do |path|
-      Library.load_path.unshift(path)
+    #
+    def released
+      @released ||= metadata.released
     end
-    Library.load_path.uniq!
-    self
-  end
-
-  # Class instance variable @ledger stores the library references.
 
-  @ledger = {}
-
-  class << self
-
-    # Scan the site locations for libraries.
-    def scan
-      # First we add Ruby core and standard libraries.
-      @ledger['ruby'] = Library.new(nil, :name=>'ruby', :version=>VERSION, :load_path=>Library.ruby_path)
-
-      scan_working() if $DEBUG
-
-      projs1 = Dir.glob( '{' + $LOAD_SITE.join(',') + '}/*{/meta,}/*.roll', File::FNM_CASEFOLD )
-      projs2 = Dir.glob( '{' + $LOAD_SITE.join(',') + '}/*/*{/meta,}/*.roll', File::FNM_CASEFOLD )
-      projs3 = Dir.glob( '{' + $LOAD_SITE.join(',') + '}/*/*/*{/meta,}/*.roll', File::FNM_CASEFOLD )
-
-      projs = projs1 + projs2 + projs3
-
-      #dirs = projs.collect do |prj|
-      #  metafile = File.basename(prj)
-      #  dir = File.dirname(prj)
-      #  dir = File.dirname(dir) if dir =~ /meta$/
-      #  dir
-      #end
-
-      projs.uniq!
-
-      #dirs -= $LOAD_SITE
+    #
+    def verify
+      requires.each do |(name, constraint)|
+        Library.open(name, constraint)
+      end
+    end
 
-      projs.each do |proj|
-        name, ver = *File.basename(proj).chomp('.roll').split('-')
-        dir = File.dirname(proj)
-        dir = File.dirname(dir) if File.basename(dir) == 'meta'
+    # Find first matching +file+.
 
-        name = name.downcase
+    #def find(file, suffix=true)
+    #  case File.extname(file)
+    #  when *SUFFIXES
+    #    find = File.join(lookup_glob, file)
+    #  else
+    #    find = File.join(lookup_glob, file + SUFFIX_PATTERN) #'{' + ".rb,#{DLEXT}" + '}')
+    #  end
+    #  Dir[find].first
+    #end
 
-        #if versions.empty?
-        #  @ledger[name] ||= Library.new(dir, :name=>name, :version=>'0') #Version.new('0', dir)
-        #else
-          @ledger[name] ||= []
-          @ledger[name] << Library.new(dir, :name=>name, :version=>ver)
-        #end
+    # Standard loadpath search.
+    #
+    def find(file, suffix=true)
+      if suffix
+        SUFFIXES.each do |ext|
+          loadpath.each do |lpath|
+            f = File.join(location, lpath, file + ext)
+            return f if File.file?(f)
+          end
+        end
+      else
+        loadpath.each do |lpath|
+          f = File.join(location, lpath, file)
+          return f if File.file?(f)
+        end
       end
+      nil
     end
 
-    # Scan current working location to see if there's
-    # a library. This will ascend from the current
-    # working directy to one level below root looking
-    # for a lib/ directory.
-    #--
-    # TODO CHANGE TO LOOK FRO INDEX FILE.
-    #++
-    def scan_working
-      paths = Dir.pwd.split('/')
-      (paths.size-1).downto(1) do |n|
-        dir = File.join( *(paths.slice(0..n) << 'lib') )
-        if File.directory? dir
-          $LOAD_SITE.unshift dir
+    # Does this library have a matching +file+? If so, the full-path
+    # of the file is returned.
+    #
+    # Unlike #find, this also matches within the library directory
+    # itself, eg. <tt>lib/foo/*</tt>. It is used by #aquire.
+    #
+    def include?(file, suffix=true)
+      if suffix
+        SUFFIXES.each do |ext|
+          loadpath.each do |lpath|
+            f = File.join(location, lpath, name, file + ext)
+            return f if File.file?(f)
+            f = File.join(location, lpath, file + ext)
+            return f if File.file?(f)
+          end
+        end
+      else
+        loadpath.each do |lpath|
+          f = File.join(location, lpath, name, file)
+          return f if File.file?(f)
+          f = File.join(location, lpath, file)
+          return f if File.file?(f)
         end
       end
+      nil
     end
 
-    # Return a list of library names.
-    def list
-      @ledger.keys
-    end
+    #def include?(file)
+    #  case File.extname(file)
+    #  when *SUFFIXES
+    #    find = File.join(lookup_glob, "{#{name}/,}" + file)
+    #  else
+    #    find = File.join(lookup_glob, "{#{name}/,}" + file + SUFFIX_PATTERN) #'{' + ".rb,#{DLEXT}" + '}')
+    #   end
+    #  Dir[find].first
+    #end
 
-    # Libraries are Singleton pattern.
-    def instance(name, constraint=nil)
-      name = name.to_s
-      #raise "no library -- #{name}" unless @ledger.include?( name )
-      return nil unless @ledger.include?(name)
-      case lib = @ledger[name]
-      when Library
-        return lib unless constraint
-        raise VersionConflict, "previously selected library version" # -- #{lib.version}"
-      #when Version
-      #  @ledger[name] = new(lib.location, :name=>name, :version=>lib) #new(name, lib, lib.location)
-      when Array
-        if constraint
-          compare = VersionNumber.constrant_lambda(constraint)
-          version = lib.select(&compare).max
-        else
-          version = lib.max
-        end
-        unless version
-          raise VersionError, "no library version -- #{name} #{constraint}"
-        end
-        @ledger[name] = version #new(version.location, :name=>name, :version=>version) #new(name, version, version.location)
+    #
+    def require(file)
+      if path = include?(file)
+        require_absolute(path)
       else
-        raise "this should never happen"
+        load_error = LoadError.new("no such file to require -- #{name}:#{file}")
+        raise clean_backtrace(load_error)
       end
-      @ledger[name].roll  # Make sure the roll file is loaded.
-      @ledger[name]
     end
 
-    # A shortcut for #instance.
-    alias_method :[], :instance
-
-    # Same as #instance but will raise and error if the library is not found.
-    def open(name, constraint=nil, &yld)
-      lib = instance(name, constraint)
-      unless lib
-        raise LoadError, "no library -- #{name}"
+    # NOT SURE ABOUT USING THIS
+    def require_absolute(file)
+      #Library.load_monitor[file] << caller if $LOAD_MONITOR
+      Library.load_stack << self
+      begin
+        success = original_require(file)
+      #rescue LoadError => load_error
+      #  raise clean_backtrace(load_error)
+      ensure
+        Library.load_stack.pop
       end
-      yield(lib) if yld
-      lib
+      success
     end
 
-  end
-
-  # VersionError is raised when a requested version cannot be found.
-  class VersionError < ::RangeError  # :nodoc:
-  end
+    #
+    def load(file, wrap=nil)
+      if path = include?(file, false)
+        load_absolute(path, wrap)
+      else
+        load_error = LoadError.new("no such file to load -- #{name}:#{file}")
+        clean_backtrace(load_error)
+      end
+    end
 
-  # VersionConflict is raised when selecting another version
-  # of a library when a previous version has already been selected.
-  class VersionConflict < ::LoadError  # :nodoc:
-  end
-end
+    #
+    def load_absolute(file, wrap=nil)
+      #Library.load_monitor[file] << caller if $LOAD_MONITOR
+      Library.load_stack << self
+      begin
+        success = original_load(file, wrap)
+      #rescue LoadError => load_error
+      #  raise clean_backtrace(load_error)
+      ensure
+        Library.load_stack.pop
+      end
+      success
+    end
 
+    # Inspection.
+    def inspect
+      if @version
+        %[#<Library #{name}/#{@version} @location="#{location}">]
+      else
+        %[#<Library #{name} @location="#{location}">]
+      end
+    end
 
-module ::Config
-  # Return the path to the data directory associated with the given
-  # package name. Normally this is just
-  # "#{Config::CONFIG['datadir']}/#{package_name}", but may be
-  # modified by packages like RubyGems and Rolls to handle
-  # versioned data directories.
-  def self.datadir(name, versionless=false)
-    if lib = Library.instance( name )
-      lib.datadir( versionless )
-    else
-      File.join(CONFIG['datadir'], name)
+    def to_s
+      inspect
     end
-  end
 
-  # Return the path to the configuration directory.
-  def self.confdir(name)
-    if lib = Library.instance( name )
-      lib.confdir
-    else
-      File.join(CONFIG['datadir'], name)
+    # Compare by version.
+    def <=>(other)
+      version <=> other.version
     end
-  end
-end
 
+#    # List of subdirectories that are searched when loading.
+#    #--
+#    # This defualts to ['lib/{name}', 'lib']. The first entry is
+#    # usually proper location; the latter is added for default
+#    # compatability with the traditional require system.
+#    #++
+#    def libdir
+#      loadpath.map{ |path| File.join(location, path) }
+#    end
+#
+#    # Does the library have any lib directories?
+#    def libdir?
+#      lib.any?{ |d| File.directory?(d) }
+#    end
 
-module ::Kernel
+    # Location of executable. This is alwasy bin/. This is a fixed
+    # convention, unlike lib/ which needs to be more flexable.
+    def bindir  ; File.join(location, 'bin') ; end
 
-  # Activate a library.
-  def library(name, constraint=nil)
-    Library.open(name, constraint)
-  end
-  module_function :library
-
-  # Use library. This activates a library, and adds
-  # it's load_path to the global $LOAD_PATH.
-  #--
-  # Maybe call #import instead ?
-  #++
-  def use(name, constraint=nil)
-    Library.open(name, constraint).utilize
-  end
+    # Is there a <tt>bin/</tt> location?
+    def bindir? ; File.exist?(bindir) ; end
 
+    # Location of library system configuration files.
+    # This is alwasy the <tt>etc/</tt> directory.
+    def confdir ; File.join(location, 'etc') ; end
 
-  def self.parse_load_parameters(file)
-    if must = file.index(':')
-      name, path = file.split(':')
-    else
-      name, *rest = file.split('/')
-      path = File.join(*rest)
-    end
-    name = nil if name == ''
-    lib = name ? Library.instance(name) : nil
-    raise LoadError, "no library found -- #{file}" if must && !lib
-    return lib, path
-  end
+    # Is there a <tt>etc/</tt> location?metadata.name
+    def confdir? ; File.exist?(confdir) ; end
 
-  # Rolls requires a modification to #require and #load.
-  # So that it is not neccessary to make the library() call
-  # if you just want the latest version.
-  #
-  # This would be a bit simpler if we mandated the
-  # use of the ':' notation when specifying the library
-  # name. Use of the ':' is robust. But we cannot do this
-  # w/o loosing backward-compatability. Using '/' in its
-  # place has the potential for pathname clashing, albeit
-  # the likelihood is small. There are two ways to bypass
-  # the problem if it arises. Use 'ruby:{path}' if the
-  # conflicting lib is a ruby core or standard library.
-  # Use ':{path}' to bypass Roll system altogether.
-
-#   # Require script.
-#   def require(file)
-#     if file.index(':')
-#       name, file = file.split(':')
-#       if name == ''
-#         Kernel.require(file)
-#       #if lib == 'ruby'
-#       #  Ruby.require(file)
-#       elsif lib = Library.instance(name)
-#         lib.require(file)
-#       else
-#         raise LoadError, "no library found -- #{name}"
-#       end
-#     else
-#       name, *rest = file.split('/')
-#       if lib = Library.instance(name)
-#         lib.require(File.join(*rest))
-#       else
-#         Kernel.require(file)
-#       end
-#     end
-#   end
-
-  # Require script.
-  def require(file)
-    lib, path = *Kernel.parse_load_parameters(file)
-    if lib
-      lib.require(path)
-    else
-      Kernel.require(file)
-    end
-  end
+    # Location of library shared data directory.
+    # This is always the <tt>data/</tt> directory.
+    def datadir ; File.join(location, 'data') ; end
 
-#   # Load script.
-#   def load(file, wrap=nil)
-#     if file.index(':')
-#       name, file = file.split(':')
-#       if name == ''
-#         Kernel.require(file)
-#       #if lib == 'ruby'
-#       #  Ruby.load(file, safe)
-#       elsif lib = Library.instance(name)
-#         lib.load(file, wrap)
-#       else
-#         raise LoadError, "no library found -- #{name}"
-#       end
-#     else
-#       name, *rest = file.split('/')
-#       if lib = Library.instance(name)
-#         lib.load(File.join(*rest))
-#       else
-#         Kernel.load(file, wrap)
-#       end
-#     end
-#   end
-
-  # Require script.
-  def load(file, wrap=false)
-    lib, path = *Kernel.parse_load_parameters(file)
-    if lib
-      lib.load(path, wrap)
-    else
-      Kernel.load(file, wrap)
-    end
-  end
+    # Is there a <tt>data/</tt> location?
+    def datadir? ; File.exist?(datadir) ; end
 
-#   #
-#   def autoload(base, file)
-#     if file.index(':')
-#       name, file = file.split(':')
-#       if name == ''
-#         Kernel.autoload(base, file)
-#       elsif lib = Library.instance(name)
-#         lib.autoload(base, file)
-#       else
-#         raise LoadError, "no library found -- #{name}"
-#       end
-#     else
-#       name, *rest = file.split('/')
-#       if lib = Library.instance(name)
-#         lib.autoload(base, File.join(*rest))
-#       else
-#         Kernel.autoload(base, file)
-#       end
-#     end
-#   end
-
-=begin
-  # Autoload script.
-  def autoload(base, file)
-    lib, path = *Kernel.parse_load_parameters(file)
-    if lib
-      lib.autoload(base, path)
-    else
-      Kernel.autoload(base, file)
+    # Access to secondary metadata.
+    def metadata
+      @metadata ||= Metadata.new(location)
     end
-  end
-=end
 
-end
-
-# TODO
-class ::Module
+  private
 
-=begin
-  alias_method :autoload_without_roll, :autoload
+    #
+    #def lookup_glob
+    #  @lookup_glob ||= File.join(location, '{' + loadpath.join(',') + '}')
+    #end
 
-  #
-  def autoload(base, file)
-    lib, path = *Kernel.parse_load_parameters(file)
-    if lib
-      lib.module_autoload(self, base, path)
-    else
-      autoload_without_roll(base, file)
+    #
+    def clean_backtrace(error)
+      if $DEBUG
+        error
+      else
+        bt = error.backtrace
+        bt = bt.reject{ |e| /roll/ =~ e } if bt
+        error.set_backtrace(bt)
+        error
+      end
     end
-  end
-=end
-
-  # TODO
 
-  # Adds importing to Module class called against +self+ as default.
-
-  # def module_require()
-  # end
-
-  # def module_load()
-  # end
+  end
 
 end
 
-# Prime the library ledger.
-Library.scan
-