libgems 0.0.1

data/LICENSE.txt

@@ -0,0 +1,51 @@
+RubyGems (and SlimGems) is copyrighted free software by Chad Fowler, Rich Kilmer,
+Jim Weirich and others.  You can redistribute it under the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.md

@@ -0,0 +1,87 @@
+# SlimGems
+
+* Website: http://slimgems.github.com/
+* Github: http://github.com/slimgems/slimgems
+* Get gems from: http://rubygems.org
+
+## Description
+
+SlimGems is a drop-in replacement for RubyGems, a package management framework 
+for Ruby. We forked the project at 1.3.7, which was a great stable release.
+
+SlimGems focuses on maintaining a sane and stable API. We believe that the
+project has been put through enough stress testing by the community to lock
+into the current API functionality for the forseeable future. We will also
+continue to improve the runtime performance over time; we can do this
+without changing the API.
+
+## Project Goals
+
+1. A fast package manager that "Just Works". We will attempt to make SlimGems
+   as fast as possible and believe it can be done without breaking the existing
+   API.
+   
+2. A consistent and stable API. Deprecations will not occur without ample
+   warning to library developers *before* a release. Deprecations will not 
+   necessarily mean removed methods or runtime warnings, and we will consult 
+   with the community if widely used APIs ever need to be removed.
+   
+3. Receptive and friendly project maintainers. We will listen to your bugs
+   and suggestions without deriding you. We believe the community deserves
+   a voice in matters that affect package management tools, and we respect 
+   that voice.
+
+4. Improved communication with the community about future plans. We believe
+   it's important to keep the community informed about major changes. We will
+   discuss our rationale for any changes that might cause problems for other
+   library developers.
+
+## What Do I Have to do Differently to Use SlimGems?
+
+Nothing. We maintain the same install paths, APIs and overall runtime environment
+that RubyGems had. The only difference is that we have no intention on changing
+this environment in future upgrades. You can upgrade safely knowing that the
+newer versions of SlimGems will still be compatible with all of your code.
+
+In short, yes, "require 'libgems'" still works.
+
+## Installing and Upgrading
+
+If you're on RubyGems, you can easily upgrade to SlimGems by typing:
+
+    $ gem install slimgems
+  
+You can do this from SlimGems too, but if you have SlimGems already, upgrading
+works better with:
+
+    $ gem update --system
+
+If you don't have any RubyGems or SlimGems install, there is still the pre-gem 
+approach to getting software, doing it manually:
+
+1. Download from: http://github.com/slimgems/slimgems
+2. Unpack into a directory and cd there
+3. Install with: ruby setup.rb  # you may need admin/root privilege
+
+For more details and other options, see:
+
+    ruby setup.rb --help
+
+## Uninstalling
+
+If SlimGems isn't for you, you can downgrade back to RubyGems by performing
+the following intuitive command:
+
+    $ gem uninstall slimgems
+
+Again, you might need to have administrator privileges (sudo) to run these
+commands.
+
+## Notes about this SlimGems Fork
+
+SlimGems is a RubyGems fork of RubyGems 1.3.7 and a limited set of backports
+from 1.5.2. SlimGems is maintained by Loren Segal and others. SlimGems will
+provide continual improvements with a stable API.
+
+You can download the original RubyGems project at 
+http://rubyforge.org/projects/rubygems

data/Rakefile

@@ -0,0 +1,113 @@
+# -*- ruby -*-
+
+$:.unshift 'lib'
+
+require 'libgems'
+require 'libgems/package_task'
+require 'rake/testtask'
+
+task :default => :test
+Rake::TestTask.new(:test) do |t|
+  t.options = '--seed=1'
+  t.ruby_opts = ['--disable-gems'] if RUBY_VERSION >= "1.9.1"
+  t.test_files = FileList['test/test_*.rb']
+end
+
+# These tasks expect to have the following directory structure:
+#
+#   git/git.rubini.us/code # Rubinius git HEAD checkout
+#   svn/ruby/trunk         # ruby subversion HEAD checkout
+#   svn/rubygems/trunk     # SlimGems subversion HEAD checkout
+#
+# If you don't have this directory structure, set RUBY_PATH and/or
+# RUBINIUS_PATH.
+
+def rsync_with dir
+  rsync_options = "-avP --exclude '*svn*' --exclude '*swp' --exclude '*rbc'" +
+    " --exclude '*.rej' --exclude '*.orig' --exclude 'lib/libgems/defaults/*'"
+  sh "rsync #{rsync_options} bin/gem             #{dir}/bin/gem"
+  sh "rsync #{rsync_options} lib/                #{dir}/lib"
+  sh "rsync #{rsync_options} test/               #{dir}/test/libgems"
+  sh "rsync #{rsync_options} util/gem_prelude.rb #{dir}/gem_prelude.rb"
+end
+
+def diff_with dir
+  diff_options = "-urpN --exclude '*svn*' --exclude '*swp' --exclude '*rbc'"
+  sh "diff #{diff_options} bin/gem             #{dir}/bin/gem;         true"
+  sh "diff #{diff_options} lib/ubygems.rb      #{dir}/lib/ubygems.rb;  true"
+  sh "diff #{diff_options} lib/libgems.rb     #{dir}/lib/libgems.rb; true"
+  sh "diff #{diff_options} lib/libgems        #{dir}/lib/libgems;    true"
+  sh "diff #{diff_options} lib/rbconfig        #{dir}/lib/rbconfig;    true"
+  sh "diff #{diff_options} test                #{dir}/test/libgems;   true"
+  sh "diff #{diff_options} util/gem_prelude.rb #{dir}/gem_prelude.rb;  true"
+end
+
+rubinius_dir = ENV['RUBINIUS_PATH'] || '../../../git/git.rubini.us/code'
+ruby_dir     = ENV['RUBY_PATH']     || '../../ruby/trunk'
+
+desc "Updates Ruby HEAD with the currently checked-out copy."
+task :update_ruby do
+  rsync_with ruby_dir
+end
+
+desc "Updates Rubinius HEAD with the currently checked-out copy."
+task :update_rubinius do
+  rsync_with rubinius_dir
+end
+
+desc "Diffs Ruby HEAD with the currently checked-out copy."
+task :diff_ruby do
+  diff_with ruby_dir
+end
+
+desc "Diffs Rubinius HEAD with the currently checked-out copy."
+task :diff_rubinius do
+  diff_with rubinius_dir
+end
+
+desc "Get coverage for a specific test."
+task "rcov:for", [:test] do |task, args|
+  mgem  = LibGems.source_index.find_name("minitest").first rescue nil
+  rgem  = LibGems.source_index.find_name(/rcov/).first
+  libs  = rgem.require_paths.map { |p| File.join rgem.full_gem_path, p }
+  rcov  = File.join rgem.full_gem_path, rgem.bindir, rgem.default_executable
+
+  if mgem
+    libs << mgem.require_paths.map { |p| File.join mgem.full_gem_path, p }
+  end
+
+  libs << "lib:test"
+
+  flags  = []
+  flags << "-I" << libs.flatten.join(":")
+
+  rflags  = []
+  rflags << "-i" << "lib/libgems"
+
+  ruby "#{flags.join ' '} #{rcov} #{rflags.join ' '} #{args[:test]}"
+end
+
+task :graph do
+  $: << File.expand_path("~/Work/p4/zss/src/graph/dev/lib")
+  require 'graph'
+  deps = Graph.new
+  deps.rotate
+
+  current = nil
+  `rake -P -s`.each_line do |line|
+    case line
+    when /^rake (.+)/
+      current = $1
+      deps[current] if current # force the node to exist, in case of a leaf
+    when /^\s+(.+)/
+      deps[current] << $1 if current
+    else
+      warn "unparsed: #{line.chomp}"
+    end
+  end
+
+
+  deps.boxes
+  deps.save "graph", nil
+end
+

data/lib/gauntlet_libgems.rb

@@ -0,0 +1,50 @@
+require 'libgems'
+require 'gauntlet'
+
+##
+# LibGemsGauntlet validates all current gems. Currently these packages are
+# borked:
+#
+# Asami-0.04           : No such file or directory - bin/Asami.rb
+# ObjectGraph-1.0.1    : No such file or directory - bin/objectgraph
+# evil-ruby-0.1.0      : authors must be Array of Strings
+# fresh_cookies-1.0.0  : authors must be Array of Strings
+# plugems_deploy-0.2.0 : authors must be Array of Strings
+# pmsrb-0.2.0          : authors must be Array of Strings
+# pqa-1.6              : authors must be Array of Strings
+# rant-0.5.7           : authors must be Array of Strings
+# rvsh-0.4.5           : No such file or directory - bin/rvsh
+# xen-0.1.2.1          : authors must be Array of Strings
+
+class LibGemsGauntlet < Gauntlet
+  def run(name)
+    warn name
+
+    spec = begin
+             LibGems::Specification.load 'gemspec'
+           rescue SyntaxError
+             LibGems::Specification.from_yaml File.read('gemspec')
+           end
+    spec.validate
+
+    self.data[name] = false
+    self.dirty = true
+  rescue SystemCallError, LibGems::InvalidSpecificationException => e
+    self.data[name] = e.message
+    self.dirty = true
+  end
+
+  def should_skip?(name)
+    self.data[name] == false
+  end
+
+  def report
+    self.data.sort.reject { |k,v| !v }.each do |k,v|
+      puts "%-21s: %s" % [k, v]
+    end
+  end
+end
+
+gauntlet = LibGemsGauntlet.new
+gauntlet.run_the_gauntlet ARGV.shift
+gauntlet.report

data/lib/libgems.rb

@@ -0,0 +1,1246 @@
+# -*- ruby -*-
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+
+require 'rubygems'
+require 'libgems/defaults'
+require 'thread'
+
+##
+# SlimGems is the Ruby standard for publishing and managing third party
+# libraries.
+#
+# For user documentation, see:
+#
+# * <tt>gem help</tt> and <tt>gem help [command]</tt>
+# * {SlimGems User Guide}[http://docs.rubygems.org/read/book/1]
+# * {Frequently Asked Questions}[http://docs.rubygems.org/read/book/3]
+#
+# For gem developer documentation see:
+#
+# * {Creating Gems}[http://docs.rubygems.org/read/chapter/5]
+# * LibGems::Specification
+# * LibGems::Version for version dependency notes
+#
+# Further SlimGems documentation can be found at:
+#
+# * {SlimGems API}[http://rubygems.rubyforge.org/rdoc] (also available from
+#   <tt>gem server</tt>)
+# * {SlimGems Bookshelf}[http://rubygem.org]
+#
+# == SlimGems Plugins
+#
+# As of #{LibGems::NAME} 1.3.2, SlimGems will load plugins installed in gems or
+# $LOAD_PATH.  Plugins must be named 'rubygems_plugin' (.rb, .so, etc) and
+# placed at the root of your gem's #require_path.  Plugins are discovered via
+# LibGems::find_files then loaded.  Take care when implementing a plugin as your
+# plugin file may be loaded multiple times if multiple versions of your gem
+# are installed.
+#
+# For an example plugin, see the graph gem which adds a `gem graph` command.
+#
+# == SlimGems Defaults, Packaging
+#
+# SlimGems defaults are stored in rubygems/defaults.rb.  If you're packaging
+# #{LibGems::NAME} or implementing Ruby you can change SlimGems' defaults.
+#
+# For SlimGems packagers, provide lib/libgems/operating_system.rb and
+# override any defaults from lib/libgems/defaults.rb.
+#
+# For Ruby implementers, provide lib/libgems/#{RUBY_ENGINE}.rb and override
+# any defaults from lib/libgems/defaults.rb.
+#
+# If you need SlimGems to perform extra work on install or uninstall, your
+# defaults override file can set pre and post install and uninstall hooks.
+# See LibGems::pre_install, LibGems::pre_uninstall, LibGems::post_install,
+# LibGems::post_uninstall.
+#
+# == Bugs
+#
+# You can submit bugs to the
+# {SlimGems bug tracker}[http://rubyforge.org/tracker/?atid=575&group_id=126]
+# on RubyForge
+#
+# == Credits
+#
+# SlimGems is currently maintained by Eric Hodel.
+#
+# SlimGems was originally developed at RubyConf 2003 by:
+#
+# * Rich Kilmer  -- rich(at)infoether.com
+# * Chad Fowler  -- chad(at)chadfowler.com
+# * David Black  -- dblack(at)wobblini.net
+# * Paul Brannan -- paul(at)atdesk.com
+# * Jim Weirch   -- jim(at)weirichhouse.org
+#
+# Contributors:
+#
+# * Gavin Sinclair     -- gsinclair(at)soyabean.com.au
+# * George Marrows     -- george.marrows(at)ntlworld.com
+# * Dick Davies        -- rasputnik(at)hellooperator.net
+# * Mauricio Fernandez -- batsman.geo(at)yahoo.com
+# * Simon Strandgaard  -- neoneye(at)adslhome.dk
+# * Dave Glasser       -- glasser(at)mit.edu
+# * Paul Duncan        -- pabs(at)pablotron.org
+# * Ville Aine         -- vaine(at)cs.helsinki.fi
+# * Eric Hodel         -- drbrain(at)segment7.net
+# * Daniel Berger      -- djberg96(at)gmail.com
+# * Phil Hagelberg     -- technomancy(at)gmail.com
+# * Ryan Davis         -- ryand-ruby(at)zenspider.com
+#
+# (If your name is missing, PLEASE let us know!)
+#
+# Thanks!
+#
+# -The SlimGems Team
+
+module LibGems
+  NAME = 'LibGems'
+  GEM_NAME = 'libgems'
+  VERSION = '0.0.1'
+  GEM_VERSION = '1.3.8'
+
+  ##
+  # Raised when SlimGems is unable to load or activate a gem.  Contains the
+  # name and version requirements of the gem that either conflicts with
+  # already activated gems or that SlimGems is otherwise unable to activate.
+
+  class LoadError < ::LoadError
+    # Name of gem
+    attr_accessor :name
+
+    # Version requirement of gem
+    attr_accessor :version_requirement
+  end
+
+  ##
+  # Configuration settings from ::RbConfig
+
+  ConfigMap = {} unless defined?(ConfigMap)
+
+  require 'rbconfig'
+
+  ConfigMap.merge!(
+    :EXEEXT            => RbConfig::CONFIG["EXEEXT"],
+    :RUBY_SO_NAME      => RbConfig::CONFIG["RUBY_SO_NAME"],
+    :arch              => RbConfig::CONFIG["arch"],
+    :bindir            => RbConfig::CONFIG["bindir"],
+    :datadir           => RbConfig::CONFIG["datadir"],
+    :libdir            => RbConfig::CONFIG["libdir"],
+    :ruby_install_name => RbConfig::CONFIG["ruby_install_name"],
+    :ruby_version      => RbConfig::CONFIG["ruby_version"],
+    :rubylibprefix     => RbConfig::CONFIG["rubylibprefix"],
+    :sitedir           => RbConfig::CONFIG["sitedir"],
+    :sitelibdir        => RbConfig::CONFIG["sitelibdir"],
+    :vendordir         => RbConfig::CONFIG["vendordir"] ,
+    :vendorlibdir      => RbConfig::CONFIG["vendorlibdir"]
+  )
+
+  ##
+  # Default directories in a gem repository
+
+  DIRECTORIES = %w[cache doc gems specifications] unless defined?(DIRECTORIES)
+
+  RubyGemsPackageVersion = GEM_VERSION
+  # :startdoc:
+
+  ##
+  # An Array of Regexps that match windows ruby platforms.
+
+  WIN_PATTERNS = [
+    /bccwin/i,
+    /cygwin/i,
+    /djgpp/i,
+    /mingw/i,
+    /mswin/i,
+    /wince/i,
+  ]
+
+  @@source_index = nil
+  @@win_platform = nil
+
+  @configuration = nil
+  @loaded_specs = {}
+  @loaded_stacks = {}
+  @platforms = []
+  @ruby = nil
+  @sources = []
+
+  @post_build_hooks     ||= []
+  @post_install_hooks   ||= []
+  @post_uninstall_hooks ||= []
+  @pre_uninstall_hooks  ||= []
+  @pre_install_hooks    ||= []
+
+  ##
+  # Specialized eval for gemspecs that sets Gem to LibGems
+
+  def self.gemspec_eval(str, *args)
+    eval(<<-end_eval, *args)
+      begin
+        libgems_original_gem = nil
+        if Object.const_defined?(:Gem)
+          libgems_original_gem = Object::Gem
+          Object.send(:remove_const, :Gem)
+        end
+        Object.const_set(:Gem, LibGems)
+        #{str}
+      ensure
+        Object.send(:remove_const, :Gem)
+        Object.const_set(:Gem, libgems_original_gem) if libgems_original_gem
+      end
+    end_eval
+  end
+
+  ##
+  # Run code with Gem = LibGems
+
+  def self.with_rubygems_compat
+    libgems_original_gem = nil
+    if Object.const_defined?(:Gem)
+      libgems_original_gem = Object::Gem
+      Object.send(:remove_const, :Gem)
+    end
+    Object.const_set(:Gem, LibGems)
+    yield
+  ensure
+    Object.send(:remove_const, :Gem)
+    Object.const_set(:Gem, libgems_original_gem) if libgems_original_gem
+  end
+
+  ##
+  # Activates an installed gem matching +gem+.  The gem must satisfy
+  # +version_requirements+.
+  #
+  # Returns true if the gem is activated, false if it is already
+  # loaded, or an exception otherwise.
+  #
+  # LibGems#activate adds the library paths in +gem+ to $LOAD_PATH.  Before a LibGems
+  # is activated its required Gems are activated.  If the version information
+  # is omitted, the highest version LibGems of the supplied name is loaded.  If a
+  # LibGems is not found that meets the version requirements or a required LibGems is
+  # not found, a LibGems::LoadError is raised.
+  #
+  # More information on version requirements can be found in the
+  # LibGems::Requirement and LibGems::Version documentation.
+
+  def self.activate(gem, *version_requirements)
+    if version_requirements.last.is_a?(Hash)
+      options = version_requirements.pop
+    else
+      options = {}
+    end
+
+    sources = options[:sources] || []
+
+    if version_requirements.empty? then
+      version_requirements = LibGems::Requirement.default
+    end
+
+    unless gem.respond_to?(:name) and
+           gem.respond_to?(:requirement) then
+      gem = LibGems::Dependency.new(gem, version_requirements)
+    end
+
+    matches = LibGems.source_index.find_name(gem.name, gem.requirement)
+    report_activate_error(gem) if matches.empty?
+
+    if @loaded_specs[gem.name] then
+      # This gem is already loaded.  If the currently loaded gem is not in the
+      # list of candidate gems, then we have a version conflict.
+      existing_spec = @loaded_specs[gem.name]
+
+      unless matches.any? { |spec| spec.version == existing_spec.version } then
+         sources_message = sources.map { |spec| spec.full_name }
+         stack_message = @loaded_stacks[gem.name].map { |spec| spec.full_name }
+
+         msg = "can't activate #{gem} for #{sources_message.inspect}, "
+         msg << "already activated #{existing_spec.full_name} for "
+         msg << "#{stack_message.inspect}"
+
+         e = LibGems::LoadError.new msg
+         e.name = gem.name
+         e.version_requirement = gem.requirement
+
+         raise e
+      end
+
+      return false
+    end
+
+    # new load
+    spec = matches.last
+    return false if spec.loaded?
+
+    spec.loaded = true
+    @loaded_specs[spec.name] = spec
+    @loaded_stacks[spec.name] = sources.dup
+
+    # Load dependent gems first
+    spec.runtime_dependencies.each do |dep_gem|
+      activate dep_gem, :sources => [spec, *sources]
+    end
+
+    # bin directory must come before library directories
+    spec.require_paths.unshift spec.bindir if spec.bindir
+
+    require_paths = spec.require_paths.map do |path|
+      File.join spec.full_gem_path, path
+    end
+
+    # gem directories must come after -I and ENV['RUBYLIB']
+    insert_index = load_path_insert_index
+
+    if insert_index then
+      # gem directories must come after -I and ENV['RUBYLIB']
+      $LOAD_PATH.insert(insert_index, *require_paths)
+    else
+      # we are probably testing in core, -I and RUBYLIB don't apply
+      $LOAD_PATH.unshift(*require_paths)
+    end
+
+    return true
+  end
+
+  ##
+  # An Array of all possible load paths for all versions of all gems in the
+  # LibGems installation.
+
+  def self.all_load_paths
+    result = []
+
+    LibGems.path.each do |gemdir|
+      each_load_path all_partials(gemdir) do |load_path|
+        result << load_path
+      end
+    end
+
+    result
+  end
+
+  ##
+  # Return all the partial paths in +gemdir+.
+
+  def self.all_partials(gemdir)
+    Dir[File.join(gemdir, 'gems/*')]
+  end
+
+  private_class_method :all_partials
+
+  ##
+  # See if a given gem is available.
+
+  def self.available?(gem, *requirements)
+    requirements = LibGems::Requirement.default if requirements.empty?
+
+    unless gem.respond_to?(:name) and
+           gem.respond_to?(:requirement) then
+      gem = LibGems::Dependency.new gem, requirements
+    end
+
+    !LibGems.source_index.search(gem).empty?
+  end
+
+  ##
+  # Find the full path to the executable for gem +name+.  If the +exec_name+
+  # is not given, the gem's default_executable is chosen, otherwise the
+  # specified executable's path is returned.  +version_requirements+ allows
+  # you to specify specific gem versions.
+
+  def self.bin_path(name, exec_name = nil, *version_requirements)
+    version_requirements = LibGems::Requirement.default if
+      version_requirements.empty?
+    specs = LibGems.source_index.find_name(name, version_requirements)
+
+    raise LibGems::GemNotFoundException,
+          "can't find gem #{name} (#{version_requirements})" if specs.empty?
+
+    specs = specs.find_all do |spec|
+      spec.executables.include?(exec_name)
+    end if exec_name
+
+    unless spec = specs.last
+      msg = "can't find gem #{name} (#{version_requirements}) with executable #{exec_name}"
+      raise LibGems::GemNotFoundException, msg
+    end
+
+    exec_name ||= spec.default_executable
+
+    unless exec_name
+      msg = "no default executable for #{spec.full_name} and none given"
+      raise LibGems::Exception, msg
+    end
+
+    File.join(spec.full_gem_path, spec.bindir, exec_name)
+  end
+
+  ##
+  # The mode needed to read a file as straight binary.
+
+  def self.binary_mode
+    'rb'
+  end
+
+  ##
+  # The path where gem executables are to be installed.
+
+  def self.bindir(install_dir=LibGems.dir)
+    return File.join(install_dir, 'bin') unless
+      install_dir.to_s == LibGems.default_dir
+    LibGems.default_bindir
+  end
+
+  ##
+  # Reset the +dir+ and +path+ values.  The next time +dir+ or +path+
+  # is requested, the values will be calculated from scratch.  This is
+  # mainly used by the unit tests to provide test isolation.
+
+  def self.clear_paths
+    @gem_home = nil
+    @gem_path = nil
+    @user_home = nil
+
+    @@source_index = nil
+
+    @searcher = nil
+  end
+
+  ##
+  # The path to standard location of the user's .gemrc file.
+
+  def self.config_file
+    File.join LibGems.user_home, '.gemrc'
+  end
+
+  ##
+  # The standard configuration object for gems.
+
+  def self.configuration
+    @configuration ||= LibGems::ConfigFile.new []
+  end
+
+  ##
+  # Use the given configuration object (which implements the ConfigFile
+  # protocol) as the standard configuration object.
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  ##
+  # The path the the data directory specified by the gem name.  If the
+  # package is not available as a gem, return nil.
+
+  def self.datadir(gem_name)
+    spec = @loaded_specs[gem_name]
+    return nil if spec.nil?
+    File.join(spec.full_gem_path, 'data', gem_name)
+  end
+
+  ##
+  # A Zlib::Deflate.deflate wrapper
+
+  def self.deflate(data)
+    require 'zlib'
+    Zlib::Deflate.deflate data
+  end
+
+  ##
+  # The path where gems are to be installed.
+
+  def self.dir
+    @gem_home ||= nil
+    set_home(ENV['LIBGEMS_HOME'] || ENV['GEM_HOME'] || LibGems.configuration.home || default_dir) unless @gem_home
+    @gem_home
+  end
+
+  ##
+  # Expand each partial gem path with each of the required paths specified
+  # in the LibGems spec.  Each expanded path is yielded.
+
+  def self.each_load_path(partials)
+    partials.each do |gp|
+      base = File.basename(gp)
+      specfn = File.join(dir, "specifications", base + ".gemspec")
+      if File.exist?(specfn)
+        spec = gemspec_eval(File.read(specfn))
+        spec.require_paths.each do |rp|
+          yield(File.join(gp, rp))
+        end
+      else
+        filename = File.join(gp, 'lib')
+        yield(filename) if File.exist?(filename)
+      end
+    end
+  end
+
+  private_class_method :each_load_path
+
+  ##
+  # Quietly ensure the named LibGems directory contains all the proper
+  # subdirectories.  If we can't create a directory due to a permission
+  # problem, then we will silently continue.
+
+  def self.ensure_gem_subdirectories(gemdir)
+    require 'fileutils'
+
+    LibGems::DIRECTORIES.each do |filename|
+      fn = File.join gemdir, filename
+      FileUtils.mkdir_p fn rescue nil unless File.exist? fn
+    end
+  end
+
+  ##
+  # Returns a list of paths matching +glob+ that can be used by a gem to pick
+  # up features from other gems.  For example:
+  #
+  #   LibGems.find_files('rdoc/discover').each do |path| load path end
+  #
+  # if +check_load_path+ is true (the default), then find_files also searches
+  # $LOAD_PATH for files as well as gems.
+  #
+  # Note that find_files will return all files even if they are from different
+  # versions of the same gem.
+
+  def self.find_files(glob, check_load_path=true)
+    files = []
+
+    if check_load_path
+      files = $LOAD_PATH.map { |load_path|
+        Dir["#{File.expand_path glob, load_path}#{LibGems.suffix_pattern}"]
+      }.flatten.select { |file| File.file? file.untaint }
+    end
+
+    specs = searcher.find_all glob
+
+    specs.each do |spec|
+      files.concat searcher.matching_files(spec, glob)
+    end
+
+    # $LOAD_PATH might contain duplicate entries or reference
+    # the spec dirs directly, so we prune.
+    files.uniq! if check_load_path
+
+    return files
+  end
+
+  ##
+  # Finds the user's home directory.
+  #--
+  # Some comments from the ruby-talk list regarding finding the home
+  # directory:
+  #
+  #   I have HOME, USERPROFILE and HOMEDRIVE + HOMEPATH. Ruby seems
+  #   to be depending on HOME in those code samples. I propose that
+  #   it should fallback to USERPROFILE and HOMEDRIVE + HOMEPATH (at
+  #   least on Win32).
+
+  def self.find_home
+    unless RUBY_VERSION > '1.9' then
+      ['HOME', 'USERPROFILE'].each do |homekey|
+        return File.expand_path(ENV[homekey]) if ENV[homekey]
+      end
+
+      if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
+        return File.expand_path("#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}")
+      end
+    end
+
+    File.expand_path "~"
+  rescue
+    if File::ALT_SEPARATOR then
+      drive = ENV['HOMEDRIVE'] || ENV['SystemDrive']
+      File.join(drive.to_s, '/')
+    else
+      "/"
+    end
+  end
+
+  private_class_method :find_home
+
+  ##
+  # Zlib::GzipReader wrapper that unzips +data+.
+
+  def self.gunzip(data)
+    require 'stringio'
+    require 'zlib'
+    data = StringIO.new data
+
+    Zlib::GzipReader.new(data).read
+  end
+
+  ##
+  # Zlib::GzipWriter wrapper that zips +data+.
+
+  def self.gzip(data)
+    require 'stringio'
+    require 'zlib'
+    zipped = StringIO.new
+
+    Zlib::GzipWriter.wrap zipped do |io| io.write data end
+
+    zipped.string
+  end
+
+  ##
+  # A Zlib::Inflate#inflate wrapper
+
+  def self.inflate(data)
+    require 'zlib'
+    Zlib::Inflate.inflate data
+  end
+
+  ##
+  # Get the default SlimGems API host. This is normally
+  # <tt>https://rubygems.org</tt>.
+
+  def self.host
+    @host ||= "https://rubygems.org"
+  end
+
+  ## Set the default SlimGems API host.
+
+  def self.host= host
+    @host = host
+  end
+
+  ##
+  # Return a list of all possible load paths for the latest version for all
+  # gems in the LibGems installation.
+
+  def self.latest_load_paths
+    result = []
+
+    LibGems.path.each do |gemdir|
+      each_load_path(latest_partials(gemdir)) do |load_path|
+        result << load_path
+      end
+    end
+
+    result
+  end
+
+  ##
+  # Return only the latest partial paths in the given +gemdir+.
+
+  def self.latest_partials(gemdir)
+    latest = {}
+    all_partials(gemdir).each do |gp|
+      base = File.basename(gp)
+      if base =~ /(.*)-((\d+\.)*\d+)/ then
+        name, version = $1, $2
+        ver = LibGems::Version.new(version)
+        if latest[name].nil? || ver > latest[name][0]
+          latest[name] = [ver, gp]
+        end
+      end
+    end
+    latest.collect { |k,v| v[1] }
+  end
+
+  private_class_method :latest_partials
+
+  ##
+  # The index to insert activated gem paths into the $LOAD_PATH.
+  #
+  # Defaults to the site lib directory unless gem_prelude.rb has loaded paths,
+  # then it inserts the activated gem's paths before the gem_prelude.rb paths
+  # so you can override the gem_prelude.rb default $LOAD_PATH paths.
+
+  def self.load_path_insert_index
+    index = $LOAD_PATH.index ConfigMap[:sitelibdir]
+  end
+
+  def self.remove_prelude_paths
+    LibGems::QuickLoader::GemLoadPaths.each do |path|
+      $LOAD_PATH.delete(path)
+    end
+  end
+
+  ##
+  # Loads YAML, preferring Psych
+
+  def self.load_yaml
+    require 'psych'
+  rescue ::LoadError
+  ensure
+    require 'yaml'
+  end
+
+  ##
+  # The file name and line number of the caller of the caller of this method.
+
+  def self.location_of_caller
+    caller[1] =~ /(.*?):(\d+).*?$/i
+    file = $1
+    lineno = $2.to_i
+
+    [file, lineno]
+  end
+
+  ##
+  # The version of the Marshal format for your Ruby.
+
+  def self.marshal_version
+    "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
+  end
+
+  ##
+  # Array of paths to search for Gems.
+
+  def self.path
+    @gem_path ||= nil
+
+    unless @gem_path then
+      paths = [ENV['LIBGEMS_PATH'] || ENV['GEM_PATH'] || LibGems.configuration.path || default_path]
+
+      if defined?(APPLE_GEM_HOME) and not ENV['GEM_PATH'] then
+        paths << APPLE_GEM_HOME
+      end
+
+      set_paths paths.compact.join(File::PATH_SEPARATOR)
+    end
+
+    @gem_path
+  end
+
+  ##
+  # Set array of platforms this SlimGems supports (primarily for testing).
+
+  def self.platforms=(platforms)
+    @platforms = platforms
+  end
+
+  ##
+  # Array of platforms this SlimGems supports.
+
+  def self.platforms
+    @platforms ||= []
+    if @platforms.empty?
+      @platforms = [LibGems::Platform::RUBY, LibGems::Platform.local]
+    end
+    @platforms
+  end
+
+  ##
+  # Adds a post-build hook that will be passed an LibGems::Installer instance
+  # when LibGems::Installer#install is called.  The hook is called after the gem
+  # has been extracted and extensions have been built but before the
+  # executables or gemspec has been written.  If the hook returns +false+ then
+  # the gem's files will be removed and the install will be aborted.
+
+  def self.post_build(&hook)
+    @post_build_hooks << hook
+  end
+
+  ##
+  # Adds a post-install hook that will be passed an LibGems::Installer instance
+  # when LibGems::Installer#install is called
+
+  def self.post_install(&hook)
+    @post_install_hooks << hook
+  end
+
+  ##
+  # Adds a post-uninstall hook that will be passed a LibGems::Uninstaller instance
+  # and the spec that was uninstalled when LibGems::Uninstaller#uninstall is
+  # called
+
+  def self.post_uninstall(&hook)
+    @post_uninstall_hooks << hook
+  end
+
+  ##
+  # Adds a pre-install hook that will be passed an LibGems::Installer instance
+  # when LibGems::Installer#install is called
+
+  def self.pre_install(&hook)
+    @pre_install_hooks << hook
+  end
+
+  ##
+  # Adds a pre-uninstall hook that will be passed an LibGems::Uninstaller instance
+  # and the spec that will be uninstalled when LibGems::Uninstaller#uninstall is
+  # called
+
+  def self.pre_uninstall(&hook)
+    @pre_uninstall_hooks << hook
+  end
+
+  ##
+  # The directory prefix this SlimGems was installed at.
+
+  def self.prefix
+    dir = File.dirname File.expand_path(__FILE__)
+    prefix = File.dirname dir
+
+    if prefix == File.expand_path(ConfigMap[:sitelibdir]) or
+       prefix == File.expand_path(ConfigMap[:libdir]) or
+       'lib' != File.basename(dir) then
+      nil
+    else
+      prefix
+    end
+  end
+
+  ##
+  # Promotes the load paths of the +gem_name+ over the load paths of
+  # +over_name+.  Useful for allowing one gem to override features in another
+  # using #find_files.
+
+  def self.promote_load_path(gem_name, over_name)
+    gem = LibGems.loaded_specs[gem_name]
+    over = LibGems.loaded_specs[over_name]
+
+    raise ArgumentError, "gem #{gem_name} is not activated" if gem.nil?
+    raise ArgumentError, "gem #{over_name} is not activated" if over.nil?
+
+    last_gem_path = File.join gem.full_gem_path, gem.require_paths.last
+
+    over_paths = over.require_paths.map do |path|
+      File.join over.full_gem_path, path
+    end
+
+    over_paths.each do |path|
+      $LOAD_PATH.delete path
+    end
+
+    gem = $LOAD_PATH.index(last_gem_path) + 1
+
+    $LOAD_PATH.insert(gem, *over_paths)
+  end
+
+  ##
+  # Refresh source_index from disk and clear searcher.
+
+  def self.refresh
+    source_index.refresh!
+
+    @searcher = nil
+  end
+
+  ##
+  # Safely read a file in binary mode on all platforms.
+
+  def self.read_binary(path)
+    File.open path, binary_mode do |f| f.read end
+  end
+
+  ##
+  # Report a load error during activation.  The message of load error
+  # depends on whether it was a version mismatch or if there are not gems of
+  # any version by the requested name.
+
+  def self.report_activate_error(gem)
+    matches = LibGems.source_index.find_name(gem.name)
+
+    if matches.empty? then
+      error = LibGems::LoadError.new(
+          "Could not find RubyGem #{gem.name} (#{gem.requirement})\n")
+    else
+      error = LibGems::LoadError.new(
+          "RubyGem version error: " +
+          "#{gem.name}(#{matches.first.version} not #{gem.requirement})\n")
+    end
+
+    error.name = gem.name
+    error.version_requirement = gem.requirement
+    raise error
+  end
+
+  private_class_method :report_activate_error
+
+  ##
+  # Full path to +libfile+ in +gemname+.  Searches for the latest gem unless
+  # +requirements+ is given.
+
+  def self.required_location(gemname, libfile, *requirements)
+    requirements = LibGems::Requirement.default if requirements.empty?
+
+    matches = LibGems.source_index.find_name gemname, requirements
+
+    return nil if matches.empty?
+
+    spec = matches.last
+    spec.require_paths.each do |path|
+      result = File.join spec.full_gem_path, path, libfile
+      return result if File.exist? result
+    end
+
+    nil
+  end
+
+  ##
+  # The path to the running Ruby interpreter.
+
+  def self.ruby
+    if @ruby.nil? then
+      @ruby = File.join(ConfigMap[:bindir],
+                        ConfigMap[:ruby_install_name])
+      @ruby << ConfigMap[:EXEEXT]
+
+      # escape string in case path to ruby executable contain spaces.
+      @ruby.sub!(/.*\s.*/m, '"\&"')
+    end
+
+    @ruby
+  end
+
+  ##
+  # A LibGems::Version for the currently running ruby.
+
+  def self.ruby_version
+    return @ruby_version if defined? @ruby_version
+    version = RUBY_VERSION.dup
+
+    if defined?(RUBY_PATCHLEVEL) && RUBY_PATCHLEVEL != -1 then
+      version << ".#{RUBY_PATCHLEVEL}"
+    elsif defined?(RUBY_REVISION) then
+      version << ".dev.#{RUBY_REVISION}"
+    end
+
+    @ruby_version = LibGems::Version.new version
+  end
+
+  ##
+  # The LibGemsPathSearcher object used to search for matching installed gems.
+
+  def self.searcher
+    @searcher ||= LibGems::GemPathSearcher.new
+  end
+
+  ##
+  # Set the LibGems home directory (as reported by LibGems.dir).
+
+  def self.set_home(home)
+    home = home.gsub File::ALT_SEPARATOR, File::SEPARATOR if File::ALT_SEPARATOR
+    @gem_home = home
+  end
+
+  private_class_method :set_home
+
+  ##
+  # Set the LibGems search path (as reported by LibGems.path).
+
+  def self.set_paths(gpaths)
+    if gpaths
+      @gem_path = gpaths.split(File::PATH_SEPARATOR)
+
+      if File::ALT_SEPARATOR then
+        @gem_path.map! do |path|
+          path.gsub File::ALT_SEPARATOR, File::SEPARATOR
+        end
+      end
+
+      @gem_path << LibGems.dir
+    else
+      # TODO: should this be LibGems.default_path instead?
+      @gem_path = [LibGems.dir]
+    end
+
+    @gem_path.uniq!
+  end
+
+  private_class_method :set_paths
+
+  ##
+  # Returns the LibGems::SourceIndex of specifications that are in the LibGems.path
+
+  def self.source_index
+    @@source_index ||= SourceIndex.from_installed_gems
+  end
+
+  ##
+  # Returns an Array of sources to fetch remote gems from.  If the sources
+  # list is empty, attempts to load the "sources" gem, then uses
+  # default_sources if it is not installed.
+
+  def self.sources
+    if !@sources || @sources.empty? then
+      @sources = default_sources
+    end
+
+    @sources
+  end
+
+  ##
+  # Need to be able to set the sources without calling
+  # LibGems.sources.replace since that would cause an infinite loop.
+
+  def self.sources=(new_sources)
+    @sources = new_sources
+  end
+
+  ##
+  # Glob pattern for require-able path suffixes.
+
+  def self.suffix_pattern
+    @suffix_pattern ||= "{#{suffixes.join(',')}}"
+  end
+
+  ##
+  # Suffixes for require-able paths.
+
+  def self.suffixes
+    ['', '.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar']
+  end
+
+  ##
+  # Prints the amount of time the supplied block takes to run using the debug
+  # UI output.
+
+  def self.time(msg, width = 0, display = LibGems.configuration.verbose)
+    now = Time.now
+
+    value = yield
+
+    elapsed = Time.now - now
+
+    ui.say "%2$*1$s: %3$3.3fs" % [-width, msg, elapsed] if display
+
+    value
+  end
+
+  ##
+  # Lazily loads DefaultUserInteraction and returns the default UI.
+
+  def self.ui
+    require 'libgems/user_interaction'
+
+    LibGems::DefaultUserInteraction.ui
+  end
+
+  ##
+  # Use the +home+ and +paths+ values for LibGems.dir and LibGems.path.  Used mainly
+  # by the unit tests to provide environment isolation.
+
+  def self.use_paths(home, paths=[])
+    clear_paths
+    set_home(home) if home
+    set_paths(paths.join(File::PATH_SEPARATOR)) if paths
+  end
+
+  ##
+  # The home directory for the user.
+
+  def self.user_home
+    @user_home ||= find_home
+  end
+
+  ##
+  # Is this a windows platform?
+
+  def self.win_platform?
+    if @@win_platform.nil? then
+      @@win_platform = !!WIN_PATTERNS.find { |r| RUBY_PLATFORM =~ r }
+    end
+
+    @@win_platform
+  end
+
+  ##
+  # Find all 'rubygems_plugin' files and load them
+
+  def self.load_plugin_files(plugins)
+    plugins.each do |plugin|
+
+      # Skip older versions of the LibGemsCutter plugin: Its commands are in
+      # SlimGems proper now.
+
+      next if plugin =~ /gemcutter-0\.[0-3]/
+
+      begin
+        load plugin
+      rescue ::Exception => e
+        details = "#{plugin.inspect}: #{e.message} (#{e.class})"
+        warn "Error loading #{LibGems::NAME} plugin #{details}"
+      end
+    end
+  end
+
+  ##
+  # Find all 'rubygems_plugin' files in installed gems and load them
+
+  def self.load_plugins
+    load_plugin_files(find_files('libgems_plugin', false) + find_files('rubygems_plugin', false))
+  end
+
+  ##
+  # Find all 'rubygems_plugin' files in $LOAD_PATH and load them
+
+  def self.load_env_plugins
+    path = "libgems_plugin"
+
+    files = []
+    $LOAD_PATH.each do |load_path|
+      globbed = Dir["#{File.expand_path path, load_path}#{LibGems.suffix_pattern}"]
+
+      globbed.each do |load_path_file|
+        files << load_path_file if File.file?(load_path_file.untaint)
+      end
+    end
+
+    load_plugin_files files
+  end
+
+  class << self
+
+    ##
+    # Hash of loaded LibGems::Specification keyed by name
+
+    attr_reader :loaded_specs
+
+    ##
+    # The list of hooks to be run before LibGems::Install#install finishes
+    # installation
+
+    attr_reader :post_build_hooks
+
+    ##
+    # The list of hooks to be run before LibGems::Install#install does any work
+
+    attr_reader :post_install_hooks
+
+    ##
+    # The list of hooks to be run before LibGems::Uninstall#uninstall does any
+    # work
+
+    attr_reader :post_uninstall_hooks
+
+    ##
+    # The list of hooks to be run after LibGems::Install#install is finished
+
+    attr_reader :pre_install_hooks
+
+    ##
+    # The list of hooks to be run after LibGems::Uninstall#uninstall is finished
+
+    attr_reader :pre_uninstall_hooks
+
+    # :stopdoc:
+
+    alias cache source_index # an alias for the old name
+
+    # :startdoc:
+
+  end
+
+  ##
+  # Location of Marshal quick gemspecs on remote repositories
+
+  MARSHAL_SPEC_DIR = "quick/Marshal.#{LibGems.marshal_version}/"
+
+  ##
+  # Location of legacy YAML quick gemspecs on remote repositories
+
+  YAML_SPEC_DIR = 'quick/'
+
+  root = ''
+  autoload :Version, 'libgems/version'
+  autoload :Requirement, 'libgems/requirement'
+  autoload :Dependency, 'libgems/dependency'
+  autoload :GemPathSearcher, 'libgems/gem_path_searcher'
+  autoload :SpecFetcher, 'libgems/spec_fetcher'
+  autoload :UserInteraction, 'libgems/user_interaction'
+  autoload :Specification, 'libgems/specification'
+  autoload :Cache, 'libgems/source_index'
+  autoload :SourceIndex, 'libgems/source_index'
+  autoload :Platform, 'libgems/platform'
+  autoload :Builder, 'libgems/builder'
+  autoload :ConfigFile, 'libgems/config_file'
+end
+
+module ::Kernel
+
+  ##
+  # Use Kernel#gem to activate a specific version of +gem_name+.
+  #
+  # +version_requirements+ is a list of version requirements that the
+  # specified gem must match, most commonly "= example.version.number".  See
+  # LibGems::Requirement for how to specify a version requirement.
+  #
+  # If you will be activating the latest version of a gem, there is no need to
+  # call Kernel#gem, Kernel#require will do the right thing for you.
+  #
+  # Kernel#gem returns true if the gem was activated, otherwise false.  If the
+  # gem could not be found, didn't match the version requirements, or a
+  # different version was already activated, an exception will be raised.
+  #
+  # Kernel#gem should be called *before* any require statements (otherwise
+  # SlimGems may load a conflicting library version).
+  #
+  # In older SlimGems versions, the environment variable GEM_SKIP could be
+  # used to skip activation of specified gems, for example to test out changes
+  # that haven't been installed yet.  Now SlimGems defers to -I and the
+  # RUBYLIB environment variable to skip activation of a gem.
+  #
+  # Example:
+  #
+  #   GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb
+
+  alias_method :original_gem, :gem
+
+  def gem(gem_name, *version_requirements) # :doc:
+    skip_list = (ENV['LIBGEMS_SKIP'] || ENV['GEM_SKIP'] || "").split(/:/)
+    raise LibGems::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name
+    LibGems.activate(gem_name, *version_requirements)
+  rescue LibGems::LoadError => e
+    begin
+      original_gem(gem_name, *version_requirements)
+    rescue Gem::LoadError
+      raise e
+    end
+  end
+
+  private :gem
+
+end
+
+##
+# Return the path to the data directory associated with the named package.  If
+# the package is loaded as a gem, return the gem specific data directory.
+# Otherwise return a path to the share area as define by
+# "#{ConfigMap[:datadir]}/#{package_name}".
+
+def RbConfig.datadir(package_name)
+  LibGems.datadir(package_name) ||
+    File.join(LibGems::ConfigMap[:datadir], package_name)
+end
+
+require 'libgems/exceptions'
+
+begin
+  ##
+  # Defaults the operating system (or packager) wants to provide for SlimGems.
+
+  require 'libgems/defaults/operating_system'
+rescue LoadError
+end
+
+if defined?(RUBY_ENGINE) then
+  begin
+    ##
+    # Defaults the ruby implementation wants to provide for SlimGems
+
+    require "libgems/defaults/#{RUBY_ENGINE}"
+  rescue LoadError
+  end
+end
+
+require 'libgems/config_file'
+
+class << LibGems
+  remove_method :try_activate if LibGems.respond_to?(:try_activate, true)
+
+  def try_activate(path)
+    spec = LibGems.searcher.find(path)
+    return false unless spec
+
+    LibGems.activate(spec.name, "= #{spec.version}")
+    return true
+  end
+end
+
+LibGems.clear_paths
+