AnonymousFox

//opt/alt/ruby19/lib64/ruby/1.9.1/rubygems.rb

# -*- ruby -*-
#--
# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
# All rights reserved.
# See LICENSE.txt for permissions.
#++

module Gem
  QUICKLOADER_SUCKAGE = RUBY_VERSION =~ /^1\.9\.1/

# Only MRI 1.9.2 has the custom prelude.
  GEM_PRELUDE_SUCKAGE = RUBY_VERSION =~ /^1\.9\.2/ && RUBY_ENGINE == "ruby"
end

if Gem::GEM_PRELUDE_SUCKAGE and defined?(Gem::QuickLoader) then
  Gem::QuickLoader.remove

$LOADED_FEATURES.delete Gem::QuickLoader.path_to_full_rubygems_library

if $LOADED_FEATURES.any? do |path| path.end_with? '/rubygems.rb' end then
    # TODO path does not exist here
    raise LoadError, "another rubygems is already loaded from #{path}"
  end

class << Gem
    remove_method :try_activate if Gem.respond_to?(:try_activate, true)
  end
end

require 'rubygems/defaults'
require 'rbconfig'
require "rubygems/deprecate"

##
# RubyGems 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>
# * {RubyGems 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]
# * Gem::Specification
# * Gem::Version for version dependency notes
#
# Further RubyGems documentation can be found at:
#
# * {RubyGems API}[http://rubygems.rubyforge.org/rdoc] (also available from
#   <tt>gem server</tt>)
# * {RubyGems Bookshelf}[http://rubygem.org]
#
# == RubyGems Plugins
#
# As of RubyGems 1.3.2, RubyGems 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
# Gem::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.
#
# == RubyGems Defaults, Packaging
#
# RubyGems defaults are stored in rubygems/defaults.rb.  If you're packaging
# RubyGems or implementing Ruby you can change RubyGems' defaults.
#
# For RubyGems packagers, provide lib/rubygems/operating_system.rb and
# override any defaults from lib/rubygems/defaults.rb.
#
# For Ruby implementers, provide lib/rubygems/#{RUBY_ENGINE}.rb and override
# any defaults from lib/rubygems/defaults.rb.
#
# If you need RubyGems to perform extra work on install or uninstall, your
# defaults override file can set pre and post install and uninstall hooks.
# See Gem::pre_install, Gem::pre_uninstall, Gem::post_install,
# Gem::post_uninstall.
#
# == Bugs
#
# You can submit bugs to the
# {RubyGems bug tracker}[http://rubyforge.org/tracker/?atid=575&group_id=126]
# on RubyForge
#
# == Credits
#
# RubyGems is currently maintained by Eric Hodel.
#
# RubyGems 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
# * Evan Phoenix       -- evan@phx.io
#
# (If your name is missing, PLEASE let us know!)
#
# Thanks!
#
# -The RubyGems Team

module Gem
  VERSION = '1.8.23.2'

##
  # Raised when RubyGems 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 RubyGems is otherwise unable to activate.

class LoadError < ::LoadError
    # Name of gem
    attr_accessor :name

# Version requirement of gem
    attr_accessor :requirement
  end

# :stopdoc:

RubyGemsVersion = VERSION

RbConfigPriorities = %w[
    EXEEXT RUBY_SO_NAME arch bindir datadir libdir ruby_install_name
    ruby_version rubylibprefix sitedir sitelibdir vendordir vendorlibdir
  ]

unless defined?(ConfigMap)
    ##
    # Configuration settings from ::RbConfig
    ConfigMap = Hash.new do |cm, key|
      cm[key] = RbConfig::CONFIG[key.to_s]
    end
  else
    RbConfigPriorities.each do |key|
      ConfigMap[key.to_sym] = RbConfig::CONFIG[key]
    end
  end

RubyGemsPackageVersion = VERSION

RUBYGEMS_DIR = File.dirname File.expand_path(__FILE__)

# :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 = {}
  @platforms = []
  @ruby = nil
  @sources = nil

@post_build_hooks     ||= []
  @post_install_hooks   ||= []
  @post_uninstall_hooks ||= []
  @pre_uninstall_hooks  ||= []
  @pre_install_hooks    ||= []
  @pre_reset_hooks      ||= []
  @post_reset_hooks     ||= []

##
  # Try to activate a gem containing +path+. Returns true if
  # activation succeeded or wasn't needed because it was already
  # activated. Returns false if it can't find the path in a gem.

def self.try_activate path
    # TODO: deprecate when 1.9.3 comes out.
    # finds the _latest_ version... regardless of loaded specs and their deps

# TODO: use find_all and bork if ambiguous

spec = Gem::Specification.find_by_path path
    return false unless spec

begin
      spec.activate
    rescue Gem::LoadError # this could fail due to gem dep collisions, go lax
      Gem::Specification.find_by_name(spec.name).activate
    end

return true
  end

##
  # Activates an installed gem matching +dep+.  The gem must satisfy
  # +requirements+.
  #
  # Returns true if the gem is activated, false if it is already
  # loaded, or an exception otherwise.
  #
  # Gem#activate adds the library paths in +dep+ to $LOAD_PATH.  Before a Gem
  # is activated its required Gems are activated.  If the version information
  # is omitted, the highest version Gem of the supplied name is loaded.  If a
  # Gem is not found that meets the version requirements or a required Gem is
  # not found, a Gem::LoadError is raised.
  #
  # More information on version requirements can be found in the
  # Gem::Requirement and Gem::Version documentation.

def self.activate(dep, *requirements)
    raise ArgumentError, "Deprecated use of Gem.activate(dep)" if
      Gem::Dependency === dep

Gem::Specification.find_by_name(dep, *requirements).activate
  end

def self.activate_dep dep, *requirements # :nodoc:
    dep.to_spec.activate
  end

def self.activate_spec spec # :nodoc:
    spec.activate
  end

def self.unresolved_deps
    @unresolved_deps ||= Hash.new { |h, n| h[n] = Gem::Dependency.new n }
  end

##
  # An Array of all possible load paths for all versions of all gems in the
  # Gem installation.

def self.all_load_paths
    result = []

Gem.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?(dep, *requirements)
    requirements = Gem::Requirement.default if requirements.empty?

unless dep.respond_to?(:name) and dep.respond_to?(:requirement) then
      dep = Gem::Dependency.new dep, requirements
    end

not dep.matching_specs(true).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.  +requirements+ allows
  # you to specify specific gem versions.

def self.bin_path(name, exec_name = nil, *requirements)
    # TODO: fails test_self_bin_path_bin_file_gone_in_latest
    # Gem::Specification.find_by_name(name, *requirements).bin_file exec_name

raise ArgumentError, "you must supply exec_name" unless exec_name

requirements = Gem::Requirement.default if
      requirements.empty?

specs = Gem::Dependency.new(name, requirements).matching_specs(true)

raise Gem::GemNotFoundException,
          "can't find gem #{name} (#{requirements})" if specs.empty?

specs = specs.find_all { |spec|
      spec.executables.include? exec_name
    } if exec_name

unless spec = specs.last
      msg = "can't find gem #{name} (#{requirements}) with executable #{exec_name}"
      raise Gem::GemNotFoundException, msg
    end

spec.bin_file 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=Gem.dir)
    # TODO: move to Gem::Dirs
    return File.join install_dir, 'bin' unless
      install_dir.to_s == Gem.default_dir.to_s
    Gem.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
    @@source_index = nil
    @paths         = nil
    @user_home     = nil
    @searcher      = nil
    Gem::Specification.reset
  end

##
  # The path to standard location of the user's .gemrc file.

def self.config_file
    @config_file ||= File.join Gem.user_home, '.gemrc'
  end

##
  # The standard configuration object for gems.

def self.configuration
    @configuration ||= Gem::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)
# TODO: deprecate
    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

def self.paths
    @paths ||= Gem::PathSupport.new
  end

def self.paths=(env)
    clear_paths
    @paths = Gem::PathSupport.new env
    Gem::Specification.dirs = @paths.path # FIX: home is at end
  end

##
  # The path where gems are to be installed.
  #--
  # FIXME deprecate these once everything else has been done -ebh

def self.dir
    # TODO: raise "no"
    paths.home
  end

def self.path
    # TODO: raise "no"
    paths.path
  end

##
  # Expand each partial gem path with each of the required paths specified
  # in the Gem 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.exists? specfn
        spec = 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.exists? filename
      end
    end
  end

private_class_method :each_load_path

##
  # Quietly ensure the named Gem 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 dir = Gem.dir
    old_umask = File.umask
    File.umask old_umask | 002

require 'fileutils'

%w[cache doc gems specifications].each do |name|
      subdir = File.join dir, name
      next if File.exist? subdir
      FileUtils.mkdir_p subdir rescue nil # in case of perms issues -- lame
    end
  ensure
    File.umask old_umask
  end

##
  # Returns a list of paths matching +glob+ that can be used by a gem to pick
  # up features from other gems.  For example:
  #
  #   Gem.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}#{Gem.suffix_pattern}"]
      }.flatten.select { |file| File.file? file.untaint }
    end

files.concat Gem::Specification.map { |spec|
      spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
    }.flatten

# $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).
  #++
  #--
  #
  # FIXME move to pathsupport
  #
  #++

def self.find_home
    windows = File::ALT_SEPARATOR
    if not windows or RUBY_VERSION >= '1.9' then
      File.expand_path "~"
    else
      ['HOME', 'USERPROFILE'].each do |key|
        return File.expand_path ENV[key] if ENV[key]
      end

if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
        File.expand_path "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}"
      end
    end
  rescue
    if windows then
      File.expand_path File.join(ENV['HOMEDRIVE'] || ENV['SystemDrive'], '/')
    else
      File.expand_path "/"
    end
  end

private_class_method :find_home

##
  # Zlib::GzipReader wrapper that unzips +data+.

def self.gunzip(data)
    # TODO: move to utils
    require 'stringio'
    require 'zlib'
    data = StringIO.new data

Zlib::GzipReader.new(data).read
  end

##
  # Zlib::GzipWriter wrapper that zips +data+.

def self.gzip(data)
    # TODO: move to utils
    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)
    # TODO: move to utils
    require 'zlib'
    Zlib::Inflate.inflate data
  end

##
  # Get the default RubyGems API host. This is normally
  # <tt>https://rubygems.org</tt>.

def self.host
    # TODO: move to utils
    @host ||= "https://rubygems.org"
  end

## Set the default RubyGems API host.

def self.host= host
    # TODO: move to utils
    @host = host
  end

##
  # Return a list of all possible load paths for the latest version for all
  # gems in the Gem installation.

def self.latest_load_paths
    result = []

Gem.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.to_s =~ /(.*)-((\d+\.)*\d+)/ then
        name, version = $1, $2
        ver = Gem::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]

if QUICKLOADER_SUCKAGE then
      $LOAD_PATH.each_with_index do |path, i|
        if path.instance_variables.include?(:@gem_prelude_index) or
            path.instance_variables.include?('@gem_prelude_index') then
          index = i
          break
        end
      end
    end

index
  end

@yaml_loaded = false

##
  # Loads YAML, preferring Psych

def self.load_yaml
    return if @yaml_loaded

test_syck = ENV['TEST_SYCK']

unless test_syck
      begin
        gem 'psych', '~> 1.2', '>= 1.2.1'
      rescue Gem::LoadError
        # It's OK if the user does not have the psych gem installed.  We will
        # attempt to require the stdlib version
      end

begin
        # Try requiring the gem version *or* stdlib version of psych.
        require 'psych'
      rescue ::LoadError
        # If we can't load psych, thats fine, go on.
      else
        # If 'yaml' has already been required, then we have to
        # be sure to switch it over to the newly loaded psych.
        if defined?(YAML::ENGINE) && YAML::ENGINE.yamler != "psych"
          YAML::ENGINE.yamler = "psych"
        end

require 'rubygems/psych_additions'
        require 'rubygems/psych_tree'
      end
    end

require 'yaml'

# If we're supposed to be using syck, then we may have to force
    # activate it via the YAML::ENGINE API.
    if test_syck and defined?(YAML::ENGINE)
      YAML::ENGINE.yamler = "syck" unless YAML::ENGINE.syck?
    end

# Now that we're sure some kind of yaml library is loaded, pull
    # in our hack to deal with Syck's DefaultKey ugliness.
    require 'rubygems/syck_hack'

@yaml_loaded = true
  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

# TODO: it is ALWAYS joined! STUPID!
    [file, lineno]
  end

##
  # The version of the Marshal format for your Ruby.

def self.marshal_version
    "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
  end

##
  # Get the appropriate cache path.
  #
  # Pass a string to use a different base path, or nil/false (default) for
  # Gem.dir.
  #

def self.cache_dir(custom_dir=false)
    File.join(custom_dir || Gem.dir, "cache")
  end

##
  # Given a gem path, find the gem in cache.
  #
  # Pass a string as the second argument to use a different base path, or
  # nil/false (default) for Gem.dir.

def self.cache_gem(filename, user_dir=false)
    cache_dir(user_dir).add(filename)
  end

##
  # Set array of platforms this RubyGems supports (primarily for testing).

def self.platforms=(platforms)
    @platforms = platforms
  end

##
  # Array of platforms this RubyGems supports.

def self.platforms
    @platforms ||= []
    if @platforms.empty?
      @platforms = [Gem::Platform::RUBY, Gem::Platform.local]
    end
    @platforms
  end

##
  # Adds a post-build hook that will be passed an Gem::Installer instance
  # when Gem::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 Gem::Installer instance
  # when Gem::Installer#install is called

def self.post_install(&hook)
    @post_install_hooks << hook
  end

##
  # Adds a hook that will get run after Gem::Specification.reset is
  # run.

def self.post_reset(&hook)
    @post_reset_hooks << hook
  end

##
  # Adds a post-uninstall hook that will be passed a Gem::Uninstaller instance
  # and the spec that was uninstalled when Gem::Uninstaller#uninstall is
  # called

def self.post_uninstall(&hook)
    @post_uninstall_hooks << hook
  end

##
  # Adds a pre-install hook that will be passed an Gem::Installer instance
  # when Gem::Installer#install is called.  If the hook returns +false+ then
  # the install will be aborted.

def self.pre_install(&hook)
    @pre_install_hooks << hook
  end

##
  # Adds a hook that will get run before Gem::Specification.reset is
  # run.

def self.pre_reset(&hook)
    @pre_reset_hooks << hook
  end

##
  # Adds a pre-uninstall hook that will be passed an Gem::Uninstaller instance
  # and the spec that will be uninstalled when Gem::Uninstaller#uninstall is
  # called

def self.pre_uninstall(&hook)
    @pre_uninstall_hooks << hook
  end

##
  # The directory prefix this RubyGems was installed at. If your
  # prefix is in a standard location (ie, rubygems is installed where
  # you'd expect it to be), then prefix returns nil.

def self.prefix
    prefix = File.dirname RUBYGEMS_DIR

if prefix != File.expand_path(ConfigMap[:sitelibdir]) and
       prefix != File.expand_path(ConfigMap[:libdir]) and
       'lib' == File.basename(RUBYGEMS_DIR) then
      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 = Gem.loaded_specs[gem_name]
    over = Gem.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 = Gem::Path.path(gem.full_gem_path).add(gem.require_paths.last)

over_paths = over.require_paths.map do |path|
      Gem::Path.path(over.full_gem_path).add(path).to_s
    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
    Gem::Specification.reset
    @source_index = nil
    @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 = Gem::Specification.find_by_name(gem.name)

if matches.empty? then
      error = Gem::LoadError.new(
          "Could not find RubyGem #{gem.name} (#{gem.requirement})\n")
    else
      error = Gem::LoadError.new(
          "RubyGem version error: " +
          "#{gem.name}(#{matches.first.version} not #{gem.requirement})\n")
    end

error.name = gem.name
    error.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 = Gem::Requirement.default if requirements.empty?

matches = Gem::Specification.find_all_by_name gemname, *requirements

return nil if matches.empty?

spec = matches.last
    spec.require_paths.each do |path|
      result = Gem::Path.path(spec.full_gem_path).add(path, libfile)
      return result if result.exist?
    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]}#{ConfigMap[:EXEEXT]}")

@ruby = "\"#{@ruby}\"" if @ruby =~ /\s/
    end

@ruby
  end

def self.latest_spec_for name
    dependency  = Gem::Dependency.new name
    fetcher     = Gem::SpecFetcher.fetcher
    spec_tuples = fetcher.find_matching dependency

match = spec_tuples.select { |(n, _, p), _|
      n == name and Gem::Platform.match p
    }.sort_by { |(_, version, _), _|
      version
    }.last

match and fetcher.fetch_spec(*match)
  end

def self.latest_version_for name
    spec = latest_spec_for name
    spec and spec.version
  end

def self.latest_rubygems_version
    latest_version_for "rubygems-update"
  end

##
  # A Gem::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 = Gem::Version.new version
  end

##
  # The GemPathSearcher object used to search for matching installed gems.

def self.searcher
    @searcher ||= Gem::GemPathSearcher.new
  end

##
  # Returns the Gem::SourceIndex of specifications that are in the Gem.path

def self.source_index
    @@source_index ||= Gem::Deprecate.skip_during do
      SourceIndex.new Gem::Specification.dirs
    end
  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
    @sources ||= default_sources
  end

##
  # Need to be able to set the sources without calling
  # Gem.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

def self.loaded_path? path
    # TODO: ruby needs a feature to let us query what's loaded in 1.8 and 1.9
    re = /(^|\/)#{Regexp.escape path}#{Regexp.union(*Gem.suffixes)}$/
    $LOADED_FEATURES.any? { |s| s =~ re }
  end

##
  # Suffixes for require-able paths.

def self.suffixes
    @suffixes ||= ['',
                   '.rb',
                   *%w(DLEXT DLEXT2).map { |key|
                     val = RbConfig::CONFIG[key]
                     next unless val and not val.empty?
                     ".#{val}"
                   }
                  ].compact.uniq
  end

##
  # Prints the amount of time the supplied block takes to run using the debug
  # UI output.

def self.time(msg, width = 0, display = Gem.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 'rubygems/user_interaction'

Gem::DefaultUserInteraction.ui
  end

##
  # Use the +home+ and +paths+ values for Gem.dir and Gem.path.  Used mainly
  # by the unit tests to provide environment isolation.

def self.use_paths(home, *paths)
    paths = nil if paths == [nil]
    paths = paths.first if Array === Array(paths).first
    self.paths = { "GEM_HOME" => home, "GEM_PATH" => paths }
    # TODO: self.paths = home, 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

##
  # Load +plugins+ as ruby files

def self.load_plugin_files(plugins)
    plugins.each do |plugin|

# Skip older versions of the GemCutter plugin: Its commands are in
      # RubyGems 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 RubyGems 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('rubygems_plugin', false)
  end

##
  # Find all 'rubygems_plugin' files in $LOAD_PATH and load them

def self.load_env_plugins
    path = "rubygems_plugin"

files = []
    $LOAD_PATH.each do |load_path|
      globbed = Dir["#{File.expand_path path, load_path}#{Gem.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 Gem::Specification keyed by name

attr_reader :loaded_specs

##
    # The list of hooks to be run before Gem::Install#install finishes
    # installation

attr_reader :post_build_hooks

##
    # The list of hooks to be run before Gem::Install#install does any work

attr_reader :post_install_hooks

##
    # The list of hooks to be run after Gem::Specification.reset is run.

attr_reader :post_reset_hooks

##
    # The list of hooks to be run before Gem::Uninstall#uninstall does any
    # work

attr_reader :post_uninstall_hooks

##
    # The list of hooks to be run after Gem::Install#install is finished

attr_reader :pre_install_hooks

##
    # The list of hooks to be run before Gem::Specification.reset is run.

attr_reader :pre_reset_hooks

##
    # The list of hooks to be run after Gem::Uninstall#uninstall is finished

attr_reader :pre_uninstall_hooks
  end

def self.cache # :nodoc:
    source_index
  end

##
  # Location of Marshal quick gemspecs on remote repositories

MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/"

autoload :Version,         'rubygems/version'
  autoload :Requirement,     'rubygems/requirement'
  autoload :Dependency,      'rubygems/dependency'
  autoload :DependencyList,  'rubygems/dependency_list'
  autoload :GemPathSearcher, 'rubygems/gem_path_searcher'
  autoload :SpecFetcher,     'rubygems/spec_fetcher'
  autoload :Specification,   'rubygems/specification'
  autoload :Cache,           'rubygems/source_index'
  autoload :SourceIndex,     'rubygems/source_index'
  autoload :PathSupport,     'rubygems/path_support'
  autoload :Platform,        'rubygems/platform'
  autoload :Builder,         'rubygems/builder'
  autoload :ConfigFile,      'rubygems/config_file'
end

module Kernel

remove_method :gem if 'method' == defined? gem # from gem_prelude.rb on 1.9

##
  # Use Kernel#gem to activate a specific version of +gem_name+.
  #
  # +requirements+ is a list of version requirements that the
  # specified gem must match, most commonly "= example.version.number".  See
  # Gem::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
  # RubyGems may load a conflicting library version).
  #
  # In older RubyGems 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 RubyGems 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

def gem(gem_name, *requirements) # :doc:
    skip_list = (ENV['GEM_SKIP'] || "").split(/:/)
    raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name
    spec = Gem::Dependency.new(gem_name, *requirements).to_spec
    spec.activate if spec
  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) # :nodoc:
  warn "#{Gem.location_of_caller.join ':'}:Warning: " \
    "RbConfig.datadir is deprecated and will be removed on or after " \
    "August 2011.  " \
    "Use Gem::datadir."

require 'rbconfig/datadir'

Gem.datadir(package_name) || File.join(Gem::ConfigMap[:datadir], package_name)
end

require 'rubygems/exceptions'

gem_preluded = Gem::GEM_PRELUDE_SUCKAGE and defined? Gem
unless gem_preluded then # TODO: remove guard after 1.9.2 dropped
  begin
    ##
    # Defaults the operating system (or packager) wants to provide for RubyGems.

require 'rubygems/defaults/operating_system'
  rescue LoadError
  end

if defined?(RUBY_ENGINE) then
    begin
      ##
      # Defaults the ruby implementation wants to provide for RubyGems

require "rubygems/defaults/#{RUBY_ENGINE}"
    rescue LoadError
    end
  end
end

##
# Enables the require hook for RubyGems.

require 'rubygems/custom_require'

module Gem
  class << self
    extend Gem::Deprecate
    deprecate :activate_dep,          "Specification#activate", 2011,  6
    deprecate :activate_spec,         "Specification#activate", 2011,  6
    deprecate :cache,                 "Gem::source_index",      2011,  8
    deprecate :activate,              "Specification#activate", 2011, 10
    deprecate :all_load_paths,        :none,                    2011, 10
    deprecate :all_partials,          :none,                    2011, 10
    deprecate :latest_load_paths,     :none,                    2011, 10
    deprecate :promote_load_path,     :none,                    2011, 10
    deprecate :available?,       "Specification::find_by_name", 2011, 11
    deprecate :cache_dir,           "Specification#cache_dir",  2011, 11
    deprecate :cache_gem,           "Specification#cache_file", 2011, 11
    deprecate :default_system_source_cache_dir, :none,          2011, 11
    deprecate :default_user_source_cache_dir,   :none,          2011, 11
    deprecate :report_activate_error, :none,                    2011, 11
    deprecate :required_location,     :none,                    2011, 11
    deprecate :searcher,              "Specification",          2011, 11
    deprecate :source_index,          "Specification",          2011, 11
  end
end