Gem

# File lib/rubygems.rb, line 242
  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 = Gem::Requirement.default
    end

    unless gem.respond_to?(:name) and
           gem.respond_to?(:version_requirements) then
      gem = Gem::Dependency.new(gem, version_requirements)
    end

    matches = Gem.source_index.find_name(gem.name, gem.version_requirements)
    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 = Gem::LoadError.new msg
         e.name = gem.name
         e.version_requirement = gem.version_requirements

         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

    sitelibdir = ConfigMap[:sitelibdir]

    # 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

# File lib/rubygems.rb, line 326
  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

# File lib/rubygems.rb, line 350
  def self.available?(gem, *requirements)
    requirements = Gem::Requirement.default if requirements.empty?

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

    !Gem.source_index.search(gem).empty?
  end

# File lib/rubygems.rb, line 367
  def self.bin_path(name, exec_name = nil, *version_requirements)
    version_requirements = Gem::Requirement.default if
      version_requirements.empty?
    spec = Gem.source_index.find_name(name, version_requirements).last

    raise Gem::GemNotFoundException,
          "can't find gem #{name} (#{version_requirements})" unless spec

    exec_name ||= spec.default_executable

    unless exec_name
      msg = "no default executable for #{spec.full_name}"
      raise Gem::Exception, msg
    end

    unless spec.executables.include? exec_name
      msg = "can't find executable #{exec_name} for #{spec.full_name}"
      raise Gem::Exception, msg
    end

    File.join(spec.full_gem_path, spec.bindir, exec_name)
  end

# File lib/rubygems.rb, line 393
  def self.binary_mode
    @binary_mode ||= RUBY_VERSION > '1.9' ? 'rb:ascii-8bit' : 'rb'
  end

# File lib/rubygems.rb, line 400
  def self.bindir(install_dir=Gem.dir)
    return File.join(install_dir, 'bin') unless
      install_dir.to_s == Gem.default_dir
    Gem.default_bindir
  end

# File lib/rubygems.rb, line 411
  def self.clear_paths
    @gem_home = nil
    @gem_path = nil
    @user_home = nil

    @@source_index = nil

    MUTEX.synchronize do
      @searcher = nil
    end
  end

# File lib/rubygems.rb, line 426
  def self.config_file
    File.join Gem.user_home, '.gemrc'
  end

# File lib/rubygems.rb, line 433
  def self.configuration
    @configuration ||= Gem::ConfigFile.new []
  end

# File lib/rubygems.rb, line 441
  def self.configuration=(config)
    @configuration = config
  end

# File lib/rubygems.rb, line 449
  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

# File lib/rubygems/defaults.rb, line 69
  def self.default_bindir
    if defined? RUBY_FRAMEWORK_VERSION then # mac framework support
      '/usr/bin'
    else # generic install
      ConfigMap[:bindir]
    end
  end

# File lib/rubygems/defaults.rb, line 19
  def self.default_dir
    if defined? RUBY_FRAMEWORK_VERSION then
      File.join File.dirname(ConfigMap[:sitedir]), 'Gems',
                ConfigMap[:ruby_version]
    # 1.9.2dev reverted to 1.8 style path
    elsif RUBY_VERSION > '1.9' and RUBY_VERSION < '1.9.2' then
      File.join(ConfigMap[:libdir], ConfigMap[:ruby_install_name], 'gems',
                ConfigMap[:ruby_version])
    else
      File.join(ConfigMap[:libdir], ruby_engine, 'gems',
                ConfigMap[:ruby_version])
    end
  end

# File lib/rubygems/defaults.rb, line 55
  def self.default_exec_format
    exec_format = ConfigMap[:ruby_install_name].sub('ruby', '%s') rescue '%s'

    unless exec_format =~ /%s/ then
      raise Gem::Exception,
        "[BUG] invalid exec_format #{exec_format.inspect}, no %s"
    end

    exec_format
  end

# File lib/rubygems/defaults.rb, line 44
  def self.default_path
    if File.exist?(Gem.user_home)
      [user_dir, default_dir]
    else
      [default_dir]
    end
  end

# File lib/rubygems/defaults.rb, line 11
  def self.default_sources
    %w[http://gems.rubyforge.org/]
  end

# File lib/rubygems/defaults.rb, line 80
  def self.default_system_source_cache_dir
    File.join Gem.dir, 'source_cache'
  end

# File lib/rubygems/defaults.rb, line 87
  def self.default_user_source_cache_dir
    File.join Gem.user_home, '.gem', 'source_cache'
  end

# File lib/rubygems.rb, line 458
  def self.deflate(data)
    require 'zlib'
    Zlib::Deflate.deflate data
  end

# File lib/rubygems.rb, line 466
  def self.dir
    @gem_home ||= nil
    set_home(ENV['GEM_HOME'] || Gem.configuration.home || default_dir) unless @gem_home
    @gem_home
  end

# File lib/rubygems.rb, line 499
  def self.ensure_gem_subdirectories(gemdir)
    require 'fileutils'

    Gem::DIRECTORIES.each do |filename|
      fn = File.join gemdir, filename
      FileUtils.mkdir_p fn rescue nil unless File.exist? fn
    end
  end

# File lib/rubygems/gem_openssl.rb, line 31
    def ensure_ssl_available
      unless ssl_available?
        fail Gem::Exception, "SSL is not installed on this system"
      end
    end

# File lib/rubygems.rb, line 519
  def self.find_files(path)
    load_path_files = $LOAD_PATH.map do |load_path|
      files = Dir["#{File.expand_path path, load_path}#{Gem.suffix_pattern}"]

      files.select do |load_path_file|
        File.file? load_path_file.untaint
      end
    end.flatten

    specs = searcher.find_all path

    specs_files = specs.map do |spec|
      searcher.matching_files spec, path
    end.flatten

    (load_path_files + specs_files).flatten.uniq
  end

# File lib/rubygems.rb, line 573
  def self.gunzip(data)
    require 'stringio'
    require 'zlib'
    data = StringIO.new data

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

# File lib/rubygems.rb, line 584
  def self.gzip(data)
    require 'stringio'
    require 'zlib'
    zipped = StringIO.new

    Zlib::GzipWriter.wrap zipped do |io| io.write data end

    zipped.string
  end

# File lib/rubygems.rb, line 597
  def self.inflate(data)
    require 'zlib'
    Zlib::Inflate.inflate data
  end

# File lib/rubygems.rb, line 606
  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

# File lib/rubygems.rb, line 645
  def self.load_path_insert_index
    index = $LOAD_PATH.index ConfigMap[:sitelibdir]

    $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

    index
  end

# File lib/rubygems.rb, line 662
  def self.location_of_caller
    caller[1] =~ /(.*?):(\d+).*?$/i
    file = $1
    lineno = $2.to_i

    [file, lineno]
  end

# File lib/rubygems.rb, line 673
  def self.marshal_version
    "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
  end

# File lib/rubygems.rb, line 680
  def self.path
    @gem_path ||= nil

    unless @gem_path then
      paths = [ENV['GEM_PATH'] || Gem.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

# File lib/rubygems.rb, line 706
  def self.platforms
    @platforms ||= []
    if @platforms.empty?
      @platforms = [Gem::Platform::RUBY, Gem::Platform.local]
    end
    @platforms
  end

# File lib/rubygems.rb, line 699
  def self.platforms=(platforms)
    @platforms = platforms
  end

# File lib/rubygems.rb, line 718
  def self.post_install(&hook)
    @post_install_hooks << hook
  end

# File lib/rubygems.rb, line 727
  def self.post_uninstall(&hook)
    @post_uninstall_hooks << hook
  end

# File lib/rubygems.rb, line 735
  def self.pre_install(&hook)
    @pre_install_hooks << hook
  end

# File lib/rubygems.rb, line 744
  def self.pre_uninstall(&hook)
    @pre_uninstall_hooks << hook
  end

# File lib/rubygems.rb, line 751
  def self.prefix
    prefix = File.dirname File.expand_path(__FILE__)

    if File.dirname(prefix) == File.expand_path(ConfigMap[:sitelibdir]) or
       File.dirname(prefix) == File.expand_path(ConfigMap[:libdir]) or
       'lib' != File.basename(prefix) then
      nil
    else
      File.dirname prefix
    end
  end

# File lib/rubygems.rb, line 768
  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 = 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

# File lib/rubygems.rb, line 804
  def self.read_binary(path)
    File.open path, binary_mode do |f| f.read end
  end

# File lib/rubygems.rb, line 793
  def self.refresh
    source_index.refresh!

    MUTEX.synchronize do
      @searcher = nil
    end
  end

# File lib/rubygems.rb, line 836
  def self.required_location(gemname, libfile, *requirements)
    requirements = Gem::Requirement.default if requirements.empty?

    matches = Gem.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

# File lib/rubygems.rb, line 855
  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

# File lib/rubygems/defaults.rb, line 94
  def self.ruby_engine
    if defined? RUBY_ENGINE then
      RUBY_ENGINE
    else
      'ruby'
    end
  end

# File lib/rubygems.rb, line 871
  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

# File lib/rubygems.rb, line 887
  def self.searcher
    MUTEX.synchronize do
      @searcher ||= Gem::GemPathSearcher.new
    end
  end

# File lib/rubygems.rb, line 943
  def self.source_index
    @@source_index ||= SourceIndex.from_installed_gems
  end

# File lib/rubygems.rb, line 952
  def self.sources
    if @sources.empty? then
      begin
        gem 'sources', '> 0.0.1'
        require 'sources'
      rescue LoadError
        @sources = default_sources
      end
    end

    @sources
  end

# File lib/rubygems.rb, line 969
  def self.sources=(new_sources)
    @sources = new_sources
  end

# File lib/rubygems/gem_openssl.rb, line 19
    def ssl_available?
      @ssl_available
    end

# File lib/rubygems.rb, line 976
  def self.suffix_pattern
    @suffix_pattern ||= "{#{suffixes.join(',')}}"
  end

# File lib/rubygems.rb, line 983
  def self.suffixes
    ['', '.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar']
  end

# File lib/rubygems.rb, line 991
  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

# File lib/rubygems.rb, line 1006
  def self.ui
    require 'rubygems/user_interaction'

    Gem::DefaultUserInteraction.ui
  end

# File lib/rubygems.rb, line 1016
  def self.use_paths(home, paths=[])
    clear_paths
    set_home(home) if home
    set_paths(paths.join(File::PATH_SEPARATOR)) if paths
  end

# File lib/rubygems/defaults.rb, line 36
  def self.user_dir
    File.join(Gem.user_home, '.gem', ruby_engine,
              ConfigMap[:ruby_version])
  end

# File lib/rubygems.rb, line 1025
  def self.user_home
    @user_home ||= find_home
  end

# File lib/rubygems.rb, line 1032
  def self.win_platform?
    if @@win_platform.nil? then
      @@win_platform = !!WIN_PATTERNS.find { |r| RUBY_PLATFORM =~ r }
    end

    @@win_platform
  end

# File lib/rubygems.rb, line 341
  def self.all_partials(gemdir)
    Dir[File.join(gemdir, 'gems/*')]
  end

# File lib/rubygems.rb, line 476
  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 = 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

# File lib/rubygems.rb, line 548
  def self.find_home
    ['HOME', 'USERPROFILE'].each do |homekey|
      return ENV[homekey] if ENV[homekey]
    end

    if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
      return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}"
    end

    begin
      File.expand_path("~")
    rescue
      if File::ALT_SEPARATOR then
          "C:/"
      else
          "/"
      end
    end
  end

# File lib/rubygems.rb, line 621
  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 = 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

# File lib/rubygems.rb, line 813
  def self.report_activate_error(gem)
    matches = Gem.source_index.find_name(gem.name)

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

    error.name = gem.name
    error.version_requirement = gem.version_requirements
    raise error
  end

# File lib/rubygems.rb, line 896
  def self.set_home(home)
    home = home.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
    @gem_home = home
    ensure_gem_subdirectories(@gem_home)
  end

# File lib/rubygems.rb, line 907
  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 << Gem.dir
    else
      # TODO: should this be Gem.default_path instead?
      @gem_path = [Gem.dir]
    end

    @gem_path.uniq!
    @gem_path.each do |path|
      if 0 == File.expand_path(path).index(Gem.user_home)
        next unless File.directory? Gem.user_home
        unless win_platform? then
          # only create by matching user
          if Etc.getpwuid.nil? || Etc.getpwuid.uid != File::Stat.new(Gem.user_home).uid
            next
          end
        end
      end
      ensure_gem_subdirectories path
    end
  end