File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby19/lib64/ruby/1.9.1

opt / alt / ruby19 / lib64 / ruby / 1.9.1 /

?? ..
?? English.rb(5.59 KB)
?? abbrev.rb(2.57 KB)
?? base64.rb(2.63 KB)
?? benchmark.rb(18 KB)
?? cgi
?? cgi.rb(9.3 KB)
?? cmath.rb(7.22 KB)
?? complex.rb(380 B)
?? csv.rb(82.66 KB)
?? date
?? date.rb(946 B)
?? debug.rb(23.23 KB)
?? delegate.rb(9.74 KB)
?? digest
?? digest.rb(2.24 KB)
?? dl
?? dl.rb(176 B)
?? drb
?? drb.rb(19 B)
?? e2mmap.rb(3.8 KB)
?? erb.rb(25.72 KB)
?? expect.rb(1.33 KB)
?? fiddle
?? fiddle.rb(928 B)
?? fileutils.rb(45.32 KB)
?? find.rb(2.03 KB)
?? forwardable.rb(7.64 KB)
?? getoptlong.rb(15.38 KB)
?? gserver.rb(8.83 KB)
?? ipaddr.rb(24.92 KB)
?? irb
?? irb.rb(8.34 KB)
?? json
?? json.rb(1.74 KB)
?? kconv.rb(5.74 KB)
?? logger.rb(20.85 KB)
?? mathn.rb(6.52 KB)
?? matrix
?? matrix.rb(47.65 KB)
?? mkmf.rb(68.9 KB)
?? monitor.rb(6.94 KB)
?? mutex_m.rb(1.61 KB)
?? net
?? observer.rb(5.69 KB)
?? open-uri.rb(25.84 KB)
?? open3.rb(20.64 KB)
?? openssl
?? openssl.rb(547 B)
?? optparse
?? optparse.rb(51.13 KB)
?? ostruct.rb(6.49 KB)
?? pathname.rb(14.21 KB)
?? pp.rb(13.31 KB)
?? prettyprint.rb(9.63 KB)
?? prime.rb(13.98 KB)
?? profile.rb(205 B)
?? profiler.rb(1.59 KB)
?? pstore.rb(15.81 KB)
?? psych
?? psych.rb(9.82 KB)
?? racc
?? rake
?? rake.rb(2.02 KB)
?? rational.rb(308 B)
?? rbconfig
?? rdoc
?? rdoc.rb(4.29 KB)
?? resolv-replace.rb(1.74 KB)
?? resolv.rb(59.91 KB)
?? rexml
?? rinda
?? ripper
?? ripper.rb(91 B)
?? rss
?? rss.rb(2.84 KB)
?? rubygems
?? rubygems.rb(34.13 KB)
?? scanf.rb(23.53 KB)
?? securerandom.rb(8.46 KB)
?? set.rb(29.91 KB)
?? shell
?? shell.rb(5.9 KB)
?? shellwords.rb(3.88 KB)
?? singleton.rb(4.02 KB)
?? socket.rb(23.22 KB)
?? syck
?? syck.rb(13.91 KB)
?? sync.rb(6.87 KB)
?? tempfile.rb(10.42 KB)
?? test
?? thread.rb(6.59 KB)
?? thwait.rb(3.38 KB)
?? time.rb(17.03 KB)
?? timeout.rb(3.26 KB)
?? tmpdir.rb(3.72 KB)
?? tracer.rb(6.63 KB)
?? tsort.rb(6.79 KB)
?? ubygems.rb(268 B)
?? un.rb(8.32 KB)
?? uri
?? uri.rb(3.07 KB)
?? weakref.rb(2.29 KB)
?? webrick
?? webrick.rb(6.8 KB)
?? x86_64-linux
?? xmlrpc
?? yaml
?? yaml.rb(2.58 KB)

Editing: 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

X7ROOT File Manager

Editing: rubygems.rb

Upload File

Create Folder