Gem

 
               # File rubygems.rb, line 233
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
            

 
               # File rubygems.rb, line 256
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 rubygems.rb, line 280
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
            

 
               # File rubygems.rb, line 296
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
            

 
               # File rubygems.rb, line 325
def self.binary_mode
  'rb'
end
            

 
               # File rubygems.rb, line 332
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
            

 
               # File rubygems.rb, line 720
def self.cache_dir(custom_dir=false)
  File.join(custom_dir || Gem.dir, "cache")
end
            

 
               # File rubygems.rb, line 730
def self.cache_gem(filename, user_dir=false)
  cache_dir(user_dir).add(filename)
end
            

 
               # File rubygems.rb, line 344
def self.clear_paths
  @@source_index = nil
  @paths         = nil
  @user_home     = nil
  @searcher      = nil
  Gem::Specification.reset
end
            

 
               # File rubygems.rb, line 355
def self.config_file
  @config_file ||= File.join Gem.user_home, '.gemrc'
end
            

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

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

 
               # File rubygems.rb, line 378
  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
            

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

 
               # File rubygems/defaults.rb, line 21
def self.default_dir
  path = if defined? RUBY_FRAMEWORK_VERSION then
           [
             File.dirname(ConfigMap[:sitedir]),
             'Gems',
             ConfigMap[:ruby_version]
           ]
         elsif ConfigMap[:rubylibprefix] then
           [
            ConfigMap[:rubylibprefix],
            'gems',
            ConfigMap[:ruby_version]
           ]
         else
           [
             ConfigMap[:libdir],
             ruby_engine,
             'gems',
             ConfigMap[:ruby_version]
           ]
         end

  @default_dir ||= File.join(*path)
end
            

 
               # File rubygems/defaults.rb, line 74
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 rubygems/defaults.rb, line 63
def self.default_path
  if File.exist? Gem.user_home then
    [user_dir, default_dir]
  else
    [default_dir]
  end
end
            

 
               # File rubygems/defaults.rb, line 49
def self.default_rubygems_dirs
  nil # default to standard layout
end
            

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

 
               # File rubygems/defaults.rb, line 99
def self.default_system_source_cache_dir
  File.join(Gem.dir, 'source_cache')
end
            

 
               # File rubygems/defaults.rb, line 106
def self.default_user_source_cache_dir
  #
  # NOTE Probably an argument for moving this to per-ruby supported dirs like
  # user_dir
  #
  File.join(Gem.user_home, '.gem', 'source_cache')
end
            

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

 
               # File rubygems.rb, line 408
def self.dir
  # TODO: raise "no"
  paths.home
end
            

 
               # File rubygems.rb, line 446
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
            

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

 
               # File rubygems.rb, line 473
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
            

 
               # File rubygems.rb, line 536
def self.gunzip(data)
  # TODO: move to utils
  require 'stringio'
  require 'zlib'
  data = StringIO.new data

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

 
               # File rubygems.rb, line 548
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
            

 
               # File rubygems.rb, line 572
def self.host
  # TODO: move to utils
  @host ||= "https://rubygems.org"
end
            

 
               # File rubygems.rb, line 579
def self.host= host
  # TODO: move to utils
  @host = host
end
            

 
               # File rubygems.rb, line 562
def self.inflate(data)
  # TODO: move to utils
  require 'zlib'
  Zlib::Inflate.inflate data
end
            

 
               # File rubygems.rb, line 588
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 rubygems.rb, line 949
def self.latest_rubygems_version
  latest_version_for "rubygems-update"
end
            

 
               # File rubygems.rb, line 930
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
            

 
               # File rubygems.rb, line 944
def self.latest_version_for name
  spec = latest_spec_for name
  spec and spec.version
end
            

 
               # File rubygems.rb, line 1113
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
            

 
               # File rubygems.rb, line 628
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
            

 
               # File rubygems.rb, line 1086
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
            

 
               # File rubygems.rb, line 1106
def self.load_plugins
  load_plugin_files find_files('rubygems_plugin', false)
end
            

 
               # File rubygems.rb, line 649
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
            

 
               # File rubygems.rb, line 1009
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
            

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

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

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

 
               # File rubygems.rb, line 413
def self.path
  # TODO: raise "no"
  paths.path
end
            

 
               # File rubygems.rb, line 393
def self.paths
  @paths ||= Gem::PathSupport.new
end
            

 
               # File rubygems.rb, line 397
def self.paths=(env)
  clear_paths
  @paths = Gem::PathSupport.new env
  Gem::Specification.dirs = @paths.path # FIX: home is at end
end
            

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

 
               # File rubygems.rb, line 737
def self.platforms=(platforms)
  @platforms = platforms
end
            

 
               # File rubygems.rb, line 759
def self.post_build(&hook)
  @post_build_hooks << hook
end
            

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

 
               # File rubygems.rb, line 775
def self.post_reset(&hook)
  @post_reset_hooks << hook
end
            

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

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

 
               # File rubygems.rb, line 801
def self.pre_reset(&hook)
  @pre_reset_hooks << hook
end
            

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

 
               # File rubygems.rb, line 819
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
            

 
               # File rubygems.rb, line 834
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
            

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

 
               # File rubygems.rb, line 859
def self.refresh
  Gem::Specification.reset
  @source_index = nil
  @searcher = nil
end
            

 
               # File rubygems.rb, line 900
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
            

 
               # File rubygems.rb, line 919
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
            

 
               # File rubygems/test_case.rb, line 60
def self.ruby= ruby
  @ruby = ruby
end
            

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

 
               # File rubygems.rb, line 956
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 rubygems.rb, line 972
def self.searcher
  @searcher ||= Gem::GemPathSearcher.new
end
            

 
               # File rubygems/test_case.rb, line 34
def self.searcher=(searcher)
  @searcher = searcher
end
            

 
               # File rubygems.rb, line 979
def self.source_index
  @@source_index ||= Gem::Deprecate.skip_during do
    SourceIndex.new Gem::Specification.dirs
  end
end
            

 
               # File rubygems/test_case.rb, line 42
def self.source_index=(si)
  raise "This method is not supported"
  Gem::Specification.reset if si # HACK
  @@source_index = si
end
            

 
               # File rubygems.rb, line 990
def self.sources
  @sources ||= default_sources
end
            

 
               # File rubygems.rb, line 998
def self.sources= new_sources
  @sources = new_sources
end
            

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

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

 
               # File rubygems.rb, line 1018
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
            

 
               # File rubygems.rb, line 1033
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 rubygems.rb, line 199
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
            

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

  Gem::DefaultUserInteraction.ui
end
            

 
               # File rubygems.rb, line 248
def self.unresolved_deps
  @unresolved_deps ||= Hash.new { |h, n| h[n] = Gem::Dependency.new n }
end
            

 
               # File rubygems.rb, line 1058
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
            

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

 
               # File rubygems.rb, line 1068
def self.user_home
  @user_home ||= find_home
end
            

 
               # File rubygems/test_case.rb, line 52
def self.win_platform=(val)
  @@win_platform = val
end
            

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

  @@win_platform
end