libgems 0.0.1

data/lib/libgems/version_option.rb

@@ -0,0 +1,65 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'libgems'
+
+##
+# Mixin methods for --version and --platform LibGems::Command options.
+
+module LibGems::VersionOption
+
+  ##
+  # Add the --platform option to the option parser.
+
+  def add_platform_option(task = command, *wrap)
+    OptionParser.accept LibGems::Platform do |value|
+      if value == LibGems::Platform::RUBY then
+        value
+      else
+        LibGems::Platform.new value
+      end
+    end
+
+    add_option('--platform PLATFORM', LibGems::Platform,
+               "Specify the platform of gem to #{task}", *wrap) do
+                 |value, options|
+      unless options[:added_platform] then
+        LibGems.platforms = [LibGems::Platform::RUBY]
+        options[:added_platform] = true
+      end
+
+      LibGems.platforms << value unless LibGems.platforms.include? value
+    end
+  end
+
+  ##
+  # Add the --prerelease option to the option parser.
+
+  def add_prerelease_option(*wrap)
+    add_option("--[no-]prerelease",
+               "Allow prerelease versions of a gem", *wrap) do |value, options|
+      options[:prerelease] = value
+    end
+  end
+
+  ##
+  # Add the --version option to the option parser.
+
+  def add_version_option(task = command, *wrap)
+    OptionParser.accept LibGems::Requirement do |value|
+      LibGems::Requirement.new value
+    end
+
+    add_option('-v', '--version VERSION', LibGems::Requirement,
+               "Specify version of gem to #{task}", *wrap) do
+                 |value, options|
+      options[:version] = value
+      options[:prerelease] = true if value.prerelease?
+    end
+  end
+
+end
+

data/lib/rbconfig/datadir.rb

@@ -0,0 +1,20 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+module RbConfig
+
+  ##
+  # Return the path to the data directory associated with the given package
+  # name.  Normally this is just
+  # "#{RbConfig::CONFIG['datadir']}/#{package_name}", but may be modified by
+  # packages like SlimGems to handle versioned data directories.
+
+  def self.datadir(package_name)
+    File.join(CONFIG['datadir'], package_name)
+  end unless RbConfig.respond_to?(:datadir)
+
+end
+

data/test/bogussources.rb

@@ -0,0 +1,8 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'libgems'
+LibGems.use_paths("test/mock/gems")

data/test/data/gem-private_key.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAz0tTOtsJuHDKAEXrQx0f6DUEzBEUTSLR1fk0iEHsY9rDCQxm
+sw5Bf2UnVhdD03B4/XzIK+pat2CMQc37/vLIBuVgS7g/fzatGiM0m5rAHtycr0XU
+8Ek6zjx4iSv70OLjybY+/utHCEc838awGDMCFR21jYxgATPVwqAIyasvwbKh/Vhw
+uErFPqT9G8BKTHsaX+H+ADIRH001OmWkjB6EyjF05114kNMa0+2C7daV9hoBL3md
+hCt6zOGcapl/9LkGxhcNEUB/So16V1ZQldg9macGyWktyNTSfctlF+f8okAmicG3
+XIwaW8UTmjFCmvDs/h1R/uKpe2IOHz87n29d2QIDAQABAoIBAQCR6n/nyg+JmTtX
+/d+hGns/RTLfQpZ7xarXZ9gmoeD4WSE42VXhbIOGXXnXDAFecKl6Jb/xycGZm4if
+OZPM3rEWyZeDNWrc7WvkHiwF7GSYVMqmRg2iJqoSSla+mAtl+pBFiNfHMW6K0Tp0
+erOyFRW+L2+A9/MMZaRun6AP9URkn0jz2kwmMFf+6szmzVn6fPFzZDRI+hEeaDmi
+LBzSrfrddrIBX+xGEoBj6RmfnKBCSUVSSxOauYjd4mVjVYxvMH4SV1hXDUS5GPl5
+MbCiBb7bpNIg/8ljMoRrQiqk0XwwS7MaCqPtMhUtpSmC/zSjAfmoN7AOc/Xh69cQ
+OCMNZH9BAoGBAPBlsuuU6fg0gVTKDdR12jHx03uRRt8/nPxHnpJkZCIh9XKh1LtY
+bkumi9HZpp3mzDiaGg/rwfCwNckKx8NLhICLgkric6ClrKftxTu6C8tBAb5YDi6u
+74KYnV8lMY/unzBtIloPgM3uluS292POmrWZpKwhvHLD71MewzMor5HFAoGBANy/
+mwsBs8i3Gzk8Twjq8effhPpE7kpxhC7bhwmjX3q41EjQWDT8M6xb1P9dRSsCIebi
+kqP1yhl27dJpA8r5WqE/z89xhBvObAGRv41eXxOI0LaH2k5lJQrUeSC+51dy+BEB
+T3GXD4C5ezZHQ8Wz/oL73uikrfhD+AqOZT2YbMEFAoGBAJvWEWpOGm3f+4bvhI+Z
+5lxCG4oa3wqRvj58XvsfQRovUWGCLtlTtgwsZq8enLf3iaOXohV4Czzvva4Z4u1i
+4v5BcbEBo1scixRBOn5BWKvl9C9j/a2dkX3jWQD4p2xaj69gz8f6DNFyPTb+tNhq
+cjgO5YUASZ1MDrSfWIKteULRAoGAZkZv8x2KyofrmQ0UITGZerDYz4t4TA1kDMGx
+QwnqhtVzpXjCJWpkFotFmDsCfPaz9mErR8PtKvcrIL1/AF+fWe5Sve3+I1P0PpXk
+hf8fVdGhwbAXuRKrouTmagGI9b9Sp65PvHUcvasyJufFwqeuV8mScX87CzeSiHGI
+/ozMdnECgYEAq4+losrhe0DEmiC9zVPvwRXjbSixDsSJxHfOcqIsZqhUgBiZ4TJD
+SrkuukrMZib6BAD+PtCJS1TBbJyyvL3QecizhHSIh3ZnT0HnaRPatLEYmU65+3kE
+kTqL4ik92bJnnWowy677sydl1lzBJDVa9ZlTs7BFSd8y/0DZaUxGg2I=
+-----END RSA PRIVATE KEY-----

data/test/data/gem-public_cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMREwDwYDVQQDDAhydWJ5
+Z2VtczEXMBUGCgmSJomT8ixkARkWB2V4YW1wbGUxEzARBgoJkiaJk/IsZAEZFgNj
+b20wHhcNMDcwODAyMDMyNTQyWhcNMDgwODAxMDMyNTQyWjBBMREwDwYDVQQDDAhy
+dWJ5Z2VtczEXMBUGCgmSJomT8ixkARkWB2V4YW1wbGUxEzARBgoJkiaJk/IsZAEZ
+FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDPS1M62wm4cMoA
+RetDHR/oNQTMERRNItHV+TSIQexj2sMJDGazDkF/ZSdWF0PTcHj9fMgr6lq3YIxB
+zfv+8sgG5WBLuD9/Nq0aIzSbmsAe3JyvRdTwSTrOPHiJK/vQ4uPJtj7+60cIRzzf
+xrAYMwIVHbWNjGABM9XCoAjJqy/BsqH9WHC4SsU+pP0bwEpMexpf4f4AMhEfTTU6
+ZaSMHoTKMXTnXXiQ0xrT7YLt1pX2GgEveZ2EK3rM4ZxqmX/0uQbGFw0RQH9KjXpX
+VlCV2D2ZpwbJaS3I1NJ9y2UX5/yiQCaJwbdcjBpbxROaMUKa8Oz+HVH+4ql7Yg4f
+Pzufb13ZAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+BBRYTAoj4cn8CWZMHFnHGQgoO5jyFTANBgkqhkiG9w0BAQUFAAOCAQEATRrJC05l
+dOmx67Sy3bU+AVXkOr7B9nn2Myqo9uSIAncPoElN6aHr/Q8wOOjtok4r0JcHPe1e
+eotDCZUE1Jkl13Tpv26rOfOOUHtGlyAIAtpsUGOraaJkSut4WKLr1/KckyAAEtgP
+c13A0s0mEiWFRuYxIdEi54561pTT2qQBE/DUPGoYD5rUg9XYAlSovMMwG99Oca7L
+cI6vCymr1bzzddExoywBNOy0fbBT62I3ICBGbH5yOVVKVmlxeo2Zp10FCj0kDrnq
+OuMJSDr5I2XPYqoC+W4YSbwn55o2jGIUX1lOq2Hvj4tFgSxlnJZn0tUhBfR3gSOn
+IFnrqu8PlZsLFw==
+-----END CERTIFICATE-----

data/test/fake_certlib/openssl.rb

@@ -0,0 +1,7 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+raise LoadError, "no such file to load -- openssl"

data/test/gem_installer_test_case.rb

@@ -0,0 +1,97 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems/installer'
+
+class LibGems::Installer
+  attr_accessor :gem_dir
+
+  attr_writer :format
+  attr_writer :gem_home
+  attr_writer :env_shebang
+  attr_writer :ignore_dependencies
+  attr_writer :format_executable
+  attr_writer :security_policy
+  attr_writer :spec
+  attr_writer :wrappers
+end
+
+class LibGemsInstallerTestCase < RubyGemTestCase
+
+  def setup
+    super
+
+    @spec = quick_gem 'a'
+    @gem = File.join @tempdir, @spec.file_name
+
+    @installer = util_installer @spec, @gem, @gemhome
+
+    @user_spec = quick_gem 'b'
+    @user_gem = File.join @tempdir, @user_spec.file_name
+
+    @user_installer = util_installer @user_spec, @user_gem, LibGems.user_dir
+    @user_installer.gem_dir = File.join(LibGems.user_dir, 'gems',
+                                        @user_spec.full_name)
+  end
+
+  def util_gem_bindir(version = '2')
+    File.join util_gem_dir(version), "bin"
+  end
+
+  def util_gem_dir(version = '2')
+    File.join @gemhome, "gems", "a-#{version}" # HACK
+  end
+
+  def util_inst_bindir
+    File.join @gemhome, "bin"
+  end
+
+  def util_make_exec(version = '2', shebang = "#!/usr/bin/ruby")
+    @spec.executables = ["my_exec"]
+
+    FileUtils.mkdir_p util_gem_bindir(version)
+    exec_path = File.join util_gem_bindir(version), "my_exec"
+    File.open exec_path, 'w' do |f|
+      f.puts shebang
+    end
+  end
+
+  def util_setup_gem(ui = @ui) # HACK fix use_ui to make this automatic
+    @spec.files = File.join('lib', 'code.rb')
+    @spec.executables << 'executable'
+    @spec.extensions << File.join('ext', 'a', 'mkrf_conf.rb')
+
+    Dir.chdir @tempdir do
+      FileUtils.mkdir_p 'bin'
+      FileUtils.mkdir_p 'lib'
+      FileUtils.mkdir_p File.join('ext', 'a')
+      File.open File.join('bin', 'executable'), 'w' do |f| f.puts '1' end
+      File.open File.join('lib', 'code.rb'), 'w' do |f| f.puts '1' end
+      File.open File.join('ext', 'a', 'mkrf_conf.rb'), 'w' do |f|
+        f << <<-EOF
+          File.open 'Rakefile', 'w' do |rf| rf.puts "task :default" end
+        EOF
+      end
+
+      use_ui ui do
+        FileUtils.rm @gem
+        LibGems::Builder.new(@spec).build
+      end
+    end
+
+    @installer = LibGems::Installer.new @gem
+  end
+
+  def util_installer(spec, gem_path, gem_home)
+    util_build_gem spec
+    FileUtils.mv File.join(@gemhome, 'cache', spec.file_name),
+                 @tempdir
+
+    installer = LibGems::Installer.new gem_path
+    installer.gem_dir = util_gem_dir
+    installer.gem_home = gem_home
+    installer.spec = spec
+
+    installer
+  end
+
+end
+

data/test/gem_package_tar_test_case.rb

@@ -0,0 +1,132 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems/package'
+
+class TarTestCase < RubyGemTestCase
+
+  def ASCIIZ(str, length)
+    str + "\0" * (length - str.length)
+  end
+
+  def SP(s)
+    s + " "
+  end
+
+  def SP_Z(s)
+    s + " \0"
+  end
+
+  def Z(s)
+    s + "\0"
+  end
+
+  def assert_headers_equal(expected, actual)
+    expected = expected.to_s unless String === expected
+    actual = actual.to_s unless String === actual
+
+    fields = %w[
+      name 100
+      mode 8
+      uid 8
+      gid 8
+      size 12
+      mtime 12
+      checksum 8
+      typeflag 1
+      linkname 100
+      magic 6
+      version 2
+      uname 32
+      gname 32
+      devmajor 8
+      devminor 8
+      prefix 155
+    ]
+
+    offset = 0
+
+    until fields.empty? do
+      name = fields.shift
+      length = fields.shift.to_i
+
+      if name == "checksum" then
+        chksum_off = offset
+        offset += length
+        next
+      end
+
+      assert_equal expected[offset, length], actual[offset, length],
+                   "Field #{name} of the tar header differs."
+
+      offset += length
+    end
+
+    assert_equal expected[chksum_off, 8], actual[chksum_off, 8]
+  end
+
+  def calc_checksum(header)
+    sum = header.unpack("C*").inject{|s,a| s + a}
+    SP(Z(to_oct(sum, 6)))
+  end
+
+  def header(type, fname, dname, length, mode, checksum = nil)
+    checksum ||= " " * 8
+
+    arr = [                  # struct tarfile_entry_posix
+      ASCIIZ(fname, 100),    # char name[100];     ASCII + (Z unless filled)
+      Z(to_oct(mode, 7)),    # char mode[8];       0 padded, octal null
+      Z(to_oct(0, 7)),       # char uid[8];        ditto
+      Z(to_oct(0, 7)),       # char gid[8];        ditto
+      Z(to_oct(length, 11)), # char size[12];      0 padded, octal, null
+      Z(to_oct(0, 11)),      # char mtime[12];     0 padded, octal, null
+      checksum,              # char checksum[8];   0 padded, octal, null, space
+      type,                  # char typeflag[1];   file: "0"  dir: "5"
+      "\0" * 100,            # char linkname[100]; ASCII + (Z unless filled)
+      "ustar\0",             # char magic[6];      "ustar\0"
+      "00",                  # char version[2];    "00"
+      ASCIIZ("wheel", 32),   # char uname[32];     ASCIIZ
+      ASCIIZ("wheel", 32),   # char gname[32];     ASCIIZ
+      Z(to_oct(0, 7)),       # char devmajor[8];   0 padded, octal, null
+      Z(to_oct(0, 7)),       # char devminor[8];   0 padded, octal, null
+      ASCIIZ(dname, 155)     # char prefix[155];   ASCII + (Z unless filled)
+    ]
+
+    format = "C100C8C8C8C12C12C8CC100C6C2C32C32C8C8C155"
+    h = if RUBY_VERSION >= "1.9" then
+          arr.join
+        else
+          arr = arr.join("").split(//).map{|x| x[0]}
+          arr.pack format
+        end
+    ret = h + "\0" * (512 - h.size)
+    assert_equal(512, ret.size)
+    ret
+  end
+
+  def tar_dir_header(name, prefix, mode)
+    h = header("5", name, prefix, 0, mode)
+    checksum = calc_checksum(h)
+    header("5", name, prefix, 0, mode, checksum)
+  end
+
+  def tar_file_header(fname, dname, mode, length)
+    h = header("0", fname, dname, length, mode)
+    checksum = calc_checksum(h)
+    header("0", fname, dname, length, mode, checksum)
+  end
+
+  def to_oct(n, pad_size)
+    "%0#{pad_size}o" % n
+  end
+
+  def util_entry(tar)
+    io = TempIO.new tar
+    header = LibGems::Package::TarHeader.from io
+    entry = LibGems::Package::TarReader::Entry.new header, io
+  end
+
+  def util_dir_entry
+    util_entry tar_dir_header("foo", "bar", 0)
+  end
+
+end
+

data/test/gemutilities.rb

@@ -0,0 +1,605 @@
+at_exit { $SAFE = 1 }
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+if defined? LibGems::QuickLoader
+  LibGems::QuickLoader.load_full_rubygems_library
+else
+  require 'libgems'
+end
+require 'fileutils'
+require 'minitest/autorun'
+require 'tmpdir'
+require 'uri'
+require 'libgems/package'
+require 'libgems/test_utilities'
+require 'pp'
+require 'zlib'
+LibGems.load_yaml
+
+begin
+  gem 'rdoc'
+rescue LibGems::LoadError
+end
+
+require 'rdoc/rdoc'
+
+require File.join(File.expand_path(File.dirname(__FILE__)), 'mockgemui')
+
+module LibGems
+  def self.searcher=(searcher)
+    @searcher = searcher
+  end
+
+  def self.source_index=(si)
+    @@source_index = si
+  end
+
+  def self.win_platform=(val)
+    @@win_platform = val
+  end
+
+  module DefaultUserInteraction
+    @ui = MockGemUi.new
+  end
+end
+
+class RubyGemTestCase < MiniTest::Unit::TestCase
+
+  include LibGems::DefaultUserInteraction
+
+  undef_method :default_test if instance_methods.include? 'default_test' or
+                                instance_methods.include? :default_test
+
+  def setup
+    super
+
+    @ui = MockGemUi.new
+    tmpdir = nil
+    Dir.chdir Dir.tmpdir do tmpdir = Dir.pwd end # HACK OSX /private/tmp
+    @tempdir = File.join tmpdir, "test_rubygems_#{$$}"
+    @tempdir.untaint
+    @gemhome = File.join @tempdir, "gemhome"
+    @gemcache = File.join(@gemhome, "source_cache")
+    @usrcache = File.join(@gemhome, ".gem", "user_cache")
+    @latest_usrcache = File.join(@gemhome, ".gem", "latest_user_cache")
+    @userhome = File.join @tempdir, 'userhome'
+
+    LibGems.ensure_gem_subdirectories @gemhome
+
+    @orig_ruby = if ruby = ENV['RUBY'] then
+                   LibGems.class_eval { ruby, @ruby = @ruby, ruby }
+                   ruby
+                 end
+
+    LibGems.ensure_gem_subdirectories @gemhome
+
+    @orig_ENV_HOME = ENV['HOME']
+    ENV['HOME'] = @userhome
+    LibGems.instance_variable_set :@user_home, nil
+
+    FileUtils.mkdir_p @gemhome
+    FileUtils.mkdir_p @userhome
+
+    ENV['LIBGEMSCACHE'] = @usrcache
+    LibGems.use_paths(@gemhome)
+    LibGems.loaded_specs.clear
+
+    LibGems.configuration.verbose = true
+    LibGems.configuration.update_sources = true
+
+    @gem_repo = "http://gems.example.com/"
+    @uri = URI.parse @gem_repo
+    LibGems.sources.replace [@gem_repo]
+
+    LibGems::SpecFetcher.fetcher = nil
+
+    @orig_BASERUBY = LibGems::ConfigMap[:BASERUBY]
+    LibGems::ConfigMap[:BASERUBY] = LibGems::ConfigMap[:ruby_install_name]
+
+    @orig_arch = LibGems::ConfigMap[:arch]
+
+    if win_platform?
+      util_set_arch 'i386-mswin32'
+    else
+      util_set_arch 'i686-darwin8.10.1'
+    end
+
+    @marshal_version = "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
+
+    @private_key = File.expand_path File.join(File.dirname(__FILE__),
+                                              'private_key.pem')
+    @public_cert = File.expand_path File.join(File.dirname(__FILE__),
+                                              'public_cert.pem')
+
+    LibGems.post_install_hooks.clear
+    LibGems.post_uninstall_hooks.clear
+    LibGems.pre_install_hooks.clear
+    LibGems.pre_uninstall_hooks.clear
+
+    LibGems.post_install do |installer|
+      @post_install_hook_arg = installer
+    end
+
+    LibGems.post_uninstall do |uninstaller|
+      @post_uninstall_hook_arg = uninstaller
+    end
+
+    LibGems.pre_install do |installer|
+      @pre_install_hook_arg = installer
+    end
+
+    LibGems.pre_uninstall do |uninstaller|
+      @pre_uninstall_hook_arg = uninstaller
+    end
+
+    @orig_LOAD_PATH = $LOAD_PATH.dup
+  end
+
+  def teardown
+    $LOAD_PATH.replace @orig_LOAD_PATH
+
+    LibGems::ConfigMap[:BASERUBY] = @orig_BASERUBY
+    LibGems::ConfigMap[:arch] = @orig_arch
+
+    if defined? LibGems::RemoteFetcher then
+      LibGems::RemoteFetcher.fetcher = nil
+    end
+
+    FileUtils.rm_rf @tempdir
+
+    ENV.delete 'LIBGEMSCACHE'
+    ENV.delete 'LIBGEMS_HOME'
+    ENV.delete 'LIBGEMS_PATH'
+
+    LibGems.clear_paths
+
+    LibGems.class_eval { @ruby = ruby } if ruby = @orig_ruby
+
+    if @orig_ENV_HOME then
+      ENV['HOME'] = @orig_ENV_HOME
+    else
+      ENV.delete 'HOME'
+    end
+  end
+
+  def install_gem gem
+    require 'libgems/installer'
+
+    use_ui MockGemUi.new do
+      Dir.chdir @tempdir do
+        LibGems::Builder.new(gem).build
+      end
+    end
+
+    gem = File.join(@tempdir, gem.file_name).untaint
+    LibGems::Installer.new(gem, :wrappers => true).install
+  end
+
+  def uninstall_gem gem
+    require 'libgems/uninstaller'
+
+    uninstaller = LibGems::Uninstaller.new gem.name, :executables => true,
+                 :user_install => true
+    uninstaller.uninstall
+  end
+
+  def mu_pp(obj)
+    s = ''
+    s = PP.pp obj, s
+    s = s.force_encoding(Encoding.default_external) if defined? Encoding
+    s.chomp
+  end
+
+  def prep_cache_files(lc)
+    @usr_si ||= LibGems::SourceIndex.new
+    @usr_sice ||= LibGems::SourceInfoCacheEntry.new @usr_si, 0
+
+    @sys_si ||= LibGems::SourceIndex.new
+    @sys_sice ||= LibGems::SourceInfoCacheEntry.new @sys_si, 0
+
+    latest_si = LibGems::SourceIndex.new
+    latest_si.add_specs(*@sys_si.latest_specs)
+    latest_sys_sice = LibGems::SourceInfoCacheEntry.new latest_si, 0
+
+    latest_si = LibGems::SourceIndex.new
+    latest_si.add_specs(*@usr_si.latest_specs)
+    latest_usr_sice = LibGems::SourceInfoCacheEntry.new latest_si, 0
+
+    [ [lc.system_cache_file, @sys_sice],
+      [lc.latest_system_cache_file, latest_sys_sice],
+      [lc.user_cache_file, @usr_sice],
+      [lc.latest_user_cache_file, latest_usr_sice],
+    ].each do |filename, data|
+      FileUtils.mkdir_p File.dirname(filename).untaint
+
+      open filename.dup.untaint, 'wb' do |f|
+        f.write Marshal.dump({ @gem_repo => data })
+      end
+    end
+  end
+
+  def read_cache(path)
+    open path.dup.untaint, 'rb' do |io|
+      Marshal.load io.read
+    end
+  end
+
+  def read_binary(path)
+    LibGems.read_binary path
+  end
+
+  def write_file(path)
+    path = File.join(@gemhome, path)
+    dir = File.dirname path
+    FileUtils.mkdir_p dir
+
+    open path, 'wb' do |io|
+      yield io if block_given?
+    end
+
+    path
+  end
+
+  def quick_gem(gemname, version='2')
+    require 'libgems/specification'
+
+    spec = LibGems::Specification.new do |s|
+      s.platform = LibGems::Platform::RUBY
+      s.name = gemname
+      s.version = version
+      s.author = 'A User'
+      s.email = 'example@example.com'
+      s.homepage = 'http://example.com'
+      s.has_rdoc = true
+      s.summary = "this is a summary"
+      s.description = "This is a test description"
+
+      yield(s) if block_given?
+    end
+
+    path = File.join "specifications", spec.spec_name
+    written_path = write_file path do |io|
+      io.write(spec.to_ruby)
+    end
+
+    spec.loaded_from = written_path
+
+    LibGems.source_index.add_spec spec
+
+    return spec
+  end
+
+  def util_build_gem(spec)
+    dir = File.join(@gemhome, 'gems', spec.full_name)
+    FileUtils.mkdir_p dir
+
+    Dir.chdir dir do
+      spec.files.each do |file|
+        next if File.exist? file
+        FileUtils.mkdir_p File.dirname(file)
+        File.open file, 'w' do |fp| fp.puts "# #{file}" end
+      end
+
+      use_ui MockGemUi.new do
+        LibGems::Builder.new(spec).build
+      end
+
+      FileUtils.mv spec.file_name,
+                   File.join(@gemhome, 'cache', "#{spec.original_name}.gem")
+    end
+  end
+
+  def util_clear_gems
+    FileUtils.rm_r File.join(@gemhome, 'gems')
+    FileUtils.rm_r File.join(@gemhome, 'specifications')
+    LibGems.source_index.refresh!
+  end
+
+  def util_gem(name, version, deps = nil, &block)
+    if deps then # fuck you eric
+      block = proc do |s|
+        deps.each do |n, req|
+          s.add_dependency n, (req || '>= 0')
+        end
+      end
+    end
+
+    spec = quick_gem(name, version, &block)
+
+    util_build_gem spec
+
+    cache_file = File.join @tempdir, 'gems', "#{spec.original_name}.gem"
+    FileUtils.mv File.join(@gemhome, 'cache', "#{spec.original_name}.gem"),
+                 cache_file
+    FileUtils.rm File.join(@gemhome, 'specifications', spec.spec_name)
+
+    spec.loaded_from = nil
+    spec.loaded = false
+
+    [spec, cache_file]
+  end
+
+  def util_gzip(data)
+    out = StringIO.new
+
+    Zlib::GzipWriter.wrap out do |io|
+      io.write data
+    end
+
+    out.string
+  end
+
+  def util_make_gems(prerelease = false)
+    @a1 = quick_gem 'a', '1' do |s|
+      s.files = %w[lib/code.rb]
+      s.require_paths = %w[lib]
+      s.date = LibGems::Specification::TODAY - 86400
+      s.homepage = 'http://a.example.com'
+      s.email = %w[example@example.com example2@example.com]
+      s.authors = %w[Example Example2]
+      s.description = <<-DESC
+This line is really, really long.  So long, in fact, that it is more than eighty characters long!  The purpose of this line is for testing wrapping behavior because sometimes people don't wrap their text to eighty characters.  Without the wrapping, the text might not look good in the RSS feed.
+
+Also, a list:
+  * An entry that's actually kind of sort
+  * an entry that's really long, which will probably get wrapped funny.  That's ok, somebody wasn't thinking straight when they made it more than eighty characters.
+      DESC
+    end
+
+    init = proc do |s|
+      s.files = %w[lib/code.rb]
+      s.require_paths = %w[lib]
+    end
+
+    @a2 = quick_gem('a', '2', &init)
+    @a3a = quick_gem('a', '3.a', &init)
+    @a_evil9 = quick_gem('a_evil', '9', &init)
+    @b2 = quick_gem('b', '2', &init)
+    @c1_2   = quick_gem('c', '1.2',   &init)
+    @pl1     = quick_gem 'pl', '1' do |s| # l for legacy
+      s.files = %w[lib/code.rb]
+      s.require_paths = %w[lib]
+      s.platform = LibGems::Platform.new 'i386-linux'
+      s.instance_variable_set :@original_platform, 'i386-linux'
+    end
+
+    if prerelease
+      @a2_pre = quick_gem('a', '2.a', &init)
+      write_file File.join(*%W[gems #{@a2_pre.original_name} lib code.rb]) do
+      end
+      util_build_gem @a2_pre
+    end
+
+    write_file File.join(*%W[gems #{@a1.original_name} lib code.rb]) do end
+    write_file File.join(*%W[gems #{@a2.original_name} lib code.rb]) do end
+    write_file File.join(*%W[gems #{@a3a.original_name} lib code.rb]) do end
+    write_file File.join(*%W[gems #{@b2.original_name} lib code.rb]) do end
+    write_file File.join(*%W[gems #{@c1_2.original_name} lib code.rb]) do end
+    write_file File.join(*%W[gems #{@pl1.original_name} lib code.rb]) do end
+
+    [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2, @pl1].each do |spec|
+      util_build_gem spec
+    end
+
+    FileUtils.rm_r File.join(@gemhome, 'gems', @pl1.original_name)
+
+    LibGems.source_index = nil
+  end
+
+  ##
+  # Set the platform to +arch+
+
+  def util_set_arch(arch)
+    LibGems::ConfigMap[:arch] = arch
+    platform = LibGems::Platform.new arch
+
+    LibGems.instance_variable_set :@platforms, nil
+    LibGems::Platform.instance_variable_set :@local, nil
+
+    platform
+  end
+
+  def util_setup_fake_fetcher(prerelease = false)
+    require 'zlib'
+    require 'socket'
+    require 'libgems/remote_fetcher'
+
+    @fetcher = LibGems::FakeFetcher.new
+
+    util_make_gems(prerelease)
+
+    @all_gems = [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2].sort
+    @all_gem_names = @all_gems.map { |gem| gem.full_name }
+
+    gem_names = [@a1.full_name, @a2.full_name, @a3a.full_name, @b2.full_name]
+    @gem_names = gem_names.sort.join("\n")
+
+    @source_index = LibGems::SourceIndex.new
+    @source_index.add_spec @a1
+    @source_index.add_spec @a2
+    @source_index.add_spec @a3a
+    @source_index.add_spec @a_evil9
+    @source_index.add_spec @c1_2
+    @source_index.add_spec @a2_pre if prerelease
+
+    LibGems::RemoteFetcher.fetcher = @fetcher
+  end
+
+  def util_setup_spec_fetcher(*specs)
+    specs = Hash[*specs.map { |spec| [spec.full_name, spec] }.flatten]
+    si = LibGems::SourceIndex.new specs
+
+    spec_fetcher = LibGems::SpecFetcher.fetcher
+
+    spec_fetcher.specs[@uri] = []
+    si.gems.sort_by { |_, spec| spec }.each do |_, spec|
+      spec_tuple = [spec.name, spec.version, spec.original_platform]
+      spec_fetcher.specs[@uri] << spec_tuple
+    end
+
+    spec_fetcher.latest_specs[@uri] = []
+    si.latest_specs.sort.each do |spec|
+      spec_tuple = [spec.name, spec.version, spec.original_platform]
+      spec_fetcher.latest_specs[@uri] << spec_tuple
+    end
+
+    spec_fetcher.prerelease_specs[@uri] = []
+    si.prerelease_specs.sort.each do |spec|
+      spec_tuple = [spec.name, spec.version, spec.original_platform]
+      spec_fetcher.prerelease_specs[@uri] << spec_tuple
+    end
+
+    (si.gems.merge si.prerelease_gems).sort_by { |_,spec| spec }.each do |_, spec|
+      path = "#{@gem_repo}quick/Marshal.#{LibGems.marshal_version}/#{spec.original_name}.gemspec.rz"
+      data = Marshal.dump spec
+      data_deflate = Zlib::Deflate.deflate data
+      @fetcher.data[path] = data_deflate
+    end
+
+    si
+  end
+
+  def util_zip(data)
+    Zlib::Deflate.deflate data
+  end
+
+  def self.win_platform?
+    LibGems.win_platform?
+  end
+
+  def win_platform?
+    LibGems.win_platform?
+  end
+
+  # Returns whether or not we're on a version of Ruby built with VC++ (or
+  # Borland) versus Cygwin, Mingw, etc.
+  #
+  def self.vc_windows?
+    RUBY_PLATFORM.match('mswin')
+  end
+
+  # Returns whether or not we're on a version of Ruby built with VC++ (or
+  # Borland) versus Cygwin, Mingw, etc.
+  #
+  def vc_windows?
+    RUBY_PLATFORM.match('mswin')
+  end
+
+  # Returns the make command for the current platform. For versions of Ruby
+  # built on MS Windows with VC++ or Borland it will return 'nmake'. On all
+  # other platforms, including Cygwin, it will return 'make'.
+  #
+  def self.make_command
+    vc_windows? ? 'nmake' : 'make'
+  end
+
+  # Returns the make command for the current platform. For versions of Ruby
+  # built on MS Windows with VC++ or Borland it will return 'nmake'. On all
+  # other platforms, including Cygwin, it will return 'make'.
+  #
+  def make_command
+    vc_windows? ? 'nmake' : 'make'
+  end
+
+  # Returns whether or not the nmake command could be found.
+  #
+  def nmake_found?
+    system('nmake /? 1>NUL 2>&1')
+  end
+
+  # NOTE Allow tests to use a random (but controlled) port number instead of
+  # a hardcoded one. This helps CI tools when running parallels builds on
+  # the same builder slave.
+  def self.process_based_port
+    @@process_based_port ||= 8000 + $$ % 1000
+  end
+
+  def process_based_port
+    self.class.process_based_port
+  end
+
+  def build_rake_in
+    gem_ruby = LibGems.ruby
+    ruby = @@ruby
+    LibGems.module_eval {@ruby = ruby}
+    env_rake = ENV["rake"]
+    ENV["rake"] = @@rake
+    yield @@rake
+  ensure
+    LibGems.module_eval {@ruby = gem_ruby}
+    if env_rake
+      ENV["rake"] = env_rake
+    else
+      ENV.delete("rake")
+    end
+  end
+
+  def self.rubybin
+    if ruby = ENV["RUBY"]
+      return ruby
+    end
+    ruby = "ruby"
+    rubyexe = ruby+".exe"
+    3.times do
+      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
+        return File.expand_path(ruby)
+      end
+      if File.exist? rubyexe and File.executable? rubyexe
+        return File.expand_path(rubyexe)
+      end
+      ruby = File.join("..", ruby)
+    end
+    begin
+      require "rbconfig"
+      File.join(
+        RbConfig::CONFIG["bindir"],
+	RbConfig::CONFIG["ruby_install_name"] + RbConfig::CONFIG["EXEEXT"]
+      )
+    rescue LoadError
+      "ruby"
+    end
+  end
+
+  @@ruby = rubybin
+  env_rake = ENV['rake']
+  ruby19_rake = File.expand_path("../../../bin/rake", __FILE__)
+  @@rake = if env_rake then
+             ENV["rake"]
+           elsif File.exist? ruby19_rake then
+             @@ruby + " " + ruby19_rake
+           else
+             'rake'
+           end
+
+  ##
+  # Construct a new LibGems::Dependency.
+
+  def dep name, *requirements
+    LibGems::Dependency.new name, *requirements
+  end
+
+  ##
+  # Construct a new LibGems::Requirement.
+
+  def req *requirements
+    return requirements.first if LibGems::Requirement === requirements.first
+    LibGems::Requirement.create requirements
+  end
+
+  ##
+  # Construct a new LibGems::Specification.
+
+  def spec name, version, &block
+    LibGems::Specification.new name, v(version), &block
+  end
+
+  ##
+  # Construct a new LibGems::Version.
+
+  def v string
+    LibGems::Version.create string
+  end
+
+end
+