diff options
Diffstat (limited to 'jni/ruby/lib/rubygems.rb')
| -rw-r--r-- | jni/ruby/lib/rubygems.rb | 1245 |
1 files changed, 1245 insertions, 0 deletions
diff --git a/jni/ruby/lib/rubygems.rb b/jni/ruby/lib/rubygems.rb new file mode 100644 index 0000000..98e7dfa --- /dev/null +++ b/jni/ruby/lib/rubygems.rb @@ -0,0 +1,1245 @@ +# -*- ruby -*- +#-- +# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. +# All rights reserved. +# See LICENSE.txt for permissions. +#++ + +require 'rbconfig' +require 'thread' + +module Gem + VERSION = '2.4.5.1' +end + +# Must be first since it unloads the prelude from 1.9.2 +require 'rubygems/compatibility' + +require 'rubygems/defaults' +require 'rubygems/deprecate' +require 'rubygems/errors' + +## +# 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 Guides}[http://guides.rubygems.org] +# * {RubyGems API}[http://rubygems.rubyforge.org/rdoc] (also available from +# <tt>gem server</tt>) +# +# == 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/defaults/operating_system.rb +# and override any defaults from lib/rubygems/defaults.rb. +# +# For Ruby implementers, provide lib/rubygems/defaults/#{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}[https://github.com/rubygems/rubygems/issues] +# on GitHub +# +# == 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 Weirich -- 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(at)fallingsnow.net +# * Steve Klabnik -- steve(at)steveklabnik.com +# +# (If your name is missing, PLEASE let us know!) +# +# See {LICENSE.txt}[rdoc-ref:lib/rubygems/LICENSE.txt] for permissions. +# +# Thanks! +# +# -The RubyGems Team + + +module Gem + RUBYGEMS_DIR = File.dirname File.expand_path(__FILE__) + + ## + # An Array of Regexps that match windows Ruby platforms. + + WIN_PATTERNS = [ + /bccwin/i, + /cygwin/i, + /djgpp/i, + /mingw/i, + /mswin/i, + /wince/i, + ] + + GEM_DEP_FILES = %w[ + gem.deps.rb + Gemfile + Isolate + ] + + ## + # Subdirectories in a gem repository + + REPOSITORY_SUBDIRECTORIES = %w[ + build_info + cache + doc + extensions + gems + specifications + ] + + ## + # Subdirectories in a gem repository for default gems + + REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES = %w[ + gems + specifications/default + ] + + @@win_platform = nil + + @configuration = nil + @loaded_specs = {} + LOADED_SPECS_MUTEX = Mutex.new + @path_to_default_spec_map = {} + @platforms = [] + @ruby = nil + @ruby_api_version = 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 + # finds the _latest_ version... regardless of loaded specs and their deps + # if another gem had a requirement that would mean we shouldn't + # activate the latest version, then either it would already be activated + # or if it was ambiguous (and thus unresolved) the code in our custom + # require will try to activate the more specific version. + + spec = Gem::Specification.find_inactive_by_path path + + unless spec + spec = Gem::Specification.find_by_path path + return true if spec && spec.activated? + return false + end + + 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 + + def self.needs + rs = Gem::RequestSet.new + + yield rs + + finish_resolve rs + end + + def self.finish_resolve(request_set=Gem::RequestSet.new) + request_set.import Gem::Specification.unresolved_deps.values + + request_set.resolve_current.each do |s| + s.full_spec.activate + end + 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? + + dep = Gem::Dependency.new name, requirements + + loaded = Gem.loaded_specs[name] + + return loaded.bin_file exec_name if loaded && dep.matches_spec?(loaded) + + specs = dep.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) + 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 + @paths = nil + @user_home = nil + Gem::Specification.reset + Gem::Security.reset if defined?(Gem::Security) + 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 to 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 and move to Gem::Specification +# and drop the extra ", gem_name" which is uselessly redundant + 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 + + # Retrieve the PathSupport object that RubyGems uses to + # lookup files. + + def self.paths + @paths ||= Gem::PathSupport.new + end + + # Initialize the filesystem paths to use from +env+. + # +env+ is a hash-like object (typically ENV) that + # is queried for 'GEM_HOME', 'GEM_PATH', and 'GEM_SPEC_CACHE' + + def self.paths=(env) + clear_paths + @paths = Gem::PathSupport.new env + Gem::Specification.dirs = @paths.path + end + + ## + # The path where gems are to be installed. + #-- + # FIXME deprecate these once everything else has been done -ebh + + def self.dir + paths.home + end + + def self.path + paths.path + end + + def self.spec_cache_dir + paths.spec_cache_dir + end + + ## + # Quietly ensure the Gem directory +dir+ contains all the proper + # subdirectories. If we can't create a directory due to a permission + # problem, then we will silently continue. + # + # If +mode+ is given, missing directories are created with this mode. + # + # World-writable directories will never be created. + + def self.ensure_gem_subdirectories dir = Gem.dir, mode = nil + ensure_subdirectories(dir, mode, REPOSITORY_SUBDIRECTORIES) + end + + ## + # Quietly ensure the Gem directory +dir+ contains all the proper + # subdirectories for handling default gems. If we can't create a + # directory due to a permission problem, then we will silently continue. + # + # If +mode+ is given, missing directories are created with this mode. + # + # World-writable directories will never be created. + + def self.ensure_default_gem_subdirectories dir = Gem.dir, mode = nil + ensure_subdirectories(dir, mode, REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES) + end + + def self.ensure_subdirectories dir, mode, subdirs # :nodoc: + old_umask = File.umask + File.umask old_umask | 002 + + require 'fileutils' + + options = {} + + options[:mode] = mode if mode + + subdirs.each do |name| + subdir = File.join dir, name + next if File.exist? subdir + FileUtils.mkdir_p subdir, options rescue nil + end + ensure + File.umask old_umask + end + + ## + # The extension API version of ruby. This includes the static vs non-static + # distinction as extensions cannot be shared between the two. + + def self.extension_api_version # :nodoc: + if 'no' == RbConfig::CONFIG['ENABLE_SHARED'] then + "#{ruby_api_version}-static" + else + ruby_api_version + end + 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. See also find_latest_files + + def self.find_files(glob, check_load_path=true) + files = [] + + files = find_files_from_load_path glob if check_load_path + + 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 + + def self.find_files_from_load_path glob # :nodoc: + $LOAD_PATH.map { |load_path| + Dir["#{File.expand_path glob, load_path}#{Gem.suffix_pattern}"] + }.flatten.select { |file| File.file? file.untaint } + end + + ## + # Returns a list of paths matching +glob+ from the latest gems that can be + # used by a gem to pick up features from other gems. For example: + # + # Gem.find_latest_files('rdoc/discover').each do |path| load path end + # + # if +check_load_path+ is true (the default), then find_latest_files also + # searches $LOAD_PATH for files as well as gems. + # + # Unlike find_files, find_latest_files will return only files from the + # latest version of a gem. + + def self.find_latest_files(glob, check_load_path=true) + files = [] + + files = find_files_from_load_path glob if check_load_path + + files.concat Gem::Specification.latest_specs(true).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 + + # FIXME deprecate these in 3.0 + + ## + # Zlib::GzipReader wrapper that unzips +data+. + + def self.gunzip(data) + require 'rubygems/util' + Gem::Util.gunzip data + end + + ## + # Zlib::GzipWriter wrapper that zips +data+. + + def self.gzip(data) + require 'rubygems/util' + Gem::Util.gzip data + end + + ## + # A Zlib::Inflate#inflate wrapper + + def self.inflate(data) + require 'rubygems/util' + Gem::Util.inflate data + end + + ## + # Top level install helper method. Allows you to install gems interactively: + # + # % irb + # >> Gem.install "minitest" + # Fetching: minitest-3.0.1.gem (100%) + # => [#<Gem::Specification:0x1013b4528 @name="minitest", ...>] + + def self.install name, version = Gem::Requirement.default, *options + require "rubygems/dependency_installer" + inst = Gem::DependencyInstaller.new(*options) + inst.install name, version + inst.installed_gems + end + + ## + # Get the default RubyGems API host. This is normally + # <tt>https://rubygems.org</tt>. + + def self.host + # TODO: move to utils + @host ||= Gem::DEFAULT_HOST + end + + ## Set the default RubyGems API host. + + def self.host= host + # TODO: move to utils + @host = host + end + + ## + # The index to insert activated gem paths into the $LOAD_PATH. The activated + # gem's paths are inserted before site lib directory by default. + + def self.load_path_insert_index + index = $LOAD_PATH.index RbConfig::CONFIG['sitelibdir'] + + index + end + + @yaml_loaded = false + + ## + # Loads YAML, preferring Psych + + def self.load_yaml + return if @yaml_loaded + return unless defined?(gem) + + 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 + + [file, lineno] + end + + ## + # The version of the Marshal format for your Ruby. + + def self.marshal_version + "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}" + 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 post-installs hook that will be passed a Gem::DependencyInstaller + # and a list of installed specifications when + # Gem::DependencyInstaller#install is complete + + def self.done_installing(&hook) + @done_installing_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(RbConfig::CONFIG['sitelibdir']) and + prefix != File.expand_path(RbConfig::CONFIG['libdir']) and + 'lib' == File.basename(RUBYGEMS_DIR) then + prefix + end + end + + ## + # Refresh available gems from disk. + + def self.refresh + Gem::Specification.reset + end + + ## + # Safely read a file in binary mode on all platforms. + + def self.read_binary(path) + open path, 'rb+' do |f| + f.flock(File::LOCK_EX) + f.read + end + rescue Errno::EACCES + open path, 'rb' do |f| + f.read + end + end + + ## + # The path to the running Ruby interpreter. + + def self.ruby + if @ruby.nil? then + @ruby = File.join(RbConfig::CONFIG['bindir'], + "#{RbConfig::CONFIG['ruby_install_name']}#{RbConfig::CONFIG['EXEEXT']}") + + @ruby = "\"#{@ruby}\"" if @ruby =~ /\s/ + end + + @ruby + end + + ## + # Returns a String containing the API compatibility version of Ruby + + def self.ruby_api_version + @ruby_api_version ||= RbConfig::CONFIG['ruby_version'].dup + end + + ## + # Returns the latest release-version specification for the gem +name+. + + def self.latest_spec_for name + dependency = Gem::Dependency.new name + fetcher = Gem::SpecFetcher.fetcher + spec_tuples, = fetcher.spec_for_dependency dependency + + spec, = spec_tuples.first + + spec + end + + ## + # Returns the latest release version of RubyGems. + + def self.latest_rubygems_version + latest_version_for('rubygems-update') or + raise "Can't find 'rubygems-update' in any repo. Check `gem source list`." + end + + ## + # Returns the version of the latest release-version of gem +name+ + + def self.latest_version_for name + spec = latest_spec_for name + spec and spec.version + 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 + + ## + # A Gem::Version for the currently running RubyGems + + def self.rubygems_version + return @rubygems_version if defined? @rubygems_version + @rubygems_version = Gem::Version.new Gem::VERSION + end + + ## + # Returns an Array of sources to fetch remote gems from. Uses + # default_sources if the sources list is empty. + + def self.sources + @sources ||= Gem::SourceList.from(default_sources) + end + + ## + # Need to be able to set the sources without calling + # Gem.sources.replace since that would cause an infinite loop. + # + # DOC: This comment is not documentation about the method itself, it's + # more of a code comment about the implementation. + + def self.sources= new_sources + if !new_sources + @sources = nil + else + @sources = Gem::SourceList.from(new_sources) + end + end + + ## + # Glob pattern for require-able path suffixes. + + def self.suffix_pattern + @suffix_pattern ||= "{#{suffixes.join(',')}}" + 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 } + end + + ## + # The home directory for the user. + + def self.user_home + @user_home ||= find_home.untaint + end + + ## + # Is this a windows platform? + + def self.win_platform? + if @@win_platform.nil? then + ruby_platform = RbConfig::CONFIG['host_os'] + @@win_platform = !!WIN_PATTERNS.find { |r| ruby_platform =~ r } + end + + @@win_platform + end + + ## + # Load +plugins+ as Ruby files + + def self.load_plugin_files plugins # :nodoc: + 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 the 'rubygems_plugin' files in the latest installed gems and load + # them + + def self.load_plugins + # Remove this env var by at least 3.0 + if ENV['RUBYGEMS_LOAD_ALL_PLUGINS'] + load_plugin_files find_files('rubygems_plugin', false) + else + load_plugin_files find_latest_files('rubygems_plugin', false) + end + 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 + + ## + # Looks for a gem dependency file at +path+ and activates the gems in the + # file if found. If the file is not found an ArgumentError is raised. + # + # If +path+ is not given the RUBYGEMS_GEMDEPS environment variable is used, + # but if no file is found no exception is raised. + # + # If '-' is given for +path+ RubyGems searches up from the current working + # directory for gem dependency files (gem.deps.rb, Gemfile, Isolate) and + # activates the gems in the first one found. + # + # You can run this automatically when rubygems starts. To enable, set + # the <code>RUBYGEMS_GEMDEPS</code> environment variable to either the path + # of your gem dependencies file or "-" to auto-discover in parent + # directories. + # + # NOTE: Enabling automatic discovery on multiuser systems can lead to + # execution of arbitrary code when used from directories outside your + # control. + + def self.use_gemdeps path = nil + raise_exception = path + + path ||= ENV['RUBYGEMS_GEMDEPS'] + return unless path + + path = path.dup + + if path == "-" then + require 'rubygems/util' + + Gem::Util.traverse_parents Dir.pwd do |directory| + dep_file = GEM_DEP_FILES.find { |f| File.file?(f) } + + next unless dep_file + + path = File.join directory, dep_file + break + end + end + + path.untaint + + unless File.file? path then + return unless raise_exception + + raise ArgumentError, "Unable to find gem dependencies file at #{path}" + end + + rs = Gem::RequestSet.new + rs.load_gemdeps path + + rs.resolve_current.map do |s| + sp = s.full_spec + sp.activate + sp + end + rescue Gem::LoadError, Gem::UnsatisfiableDependencyError => e + warn e.message + warn "You may need to `gem install -g` to install missing gems" + warn "" + end + + class << self + ## + # TODO remove with RubyGems 3.0 + + alias detect_gemdeps use_gemdeps # :nodoc: + end + + # FIX: Almost everywhere else we use the `def self.` way of defining class + # methods, and then we switch over to `class << self` here. Pick one or the + # other. + class << self + + ## + # Hash of loaded Gem::Specification keyed by name + + attr_reader :loaded_specs + + ## + # Register a Gem::Specification for default gem. + # + # Two formats for the specification are supported: + # + # * MRI 2.0 style, where spec.files contains unprefixed require names. + # The spec's filenames will be registered as-is. + # * New style, where spec.files contains files prefixed with paths + # from spec.require_paths. The prefixes are stripped before + # registering the spec's filenames. Unprefixed files are omitted. + # + + def register_default_spec(spec) + new_format = Gem.default_gems_use_full_paths? || spec.require_paths.any? {|path| spec.files.any? {|f| f.start_with? path } } + + if new_format + prefix_group = spec.require_paths.map {|f| f + "/"}.join("|") + prefix_pattern = /^(#{prefix_group})/ + end + + spec.files.each do |file| + if new_format + file = file.sub(prefix_pattern, "") + next unless $~ + end + + @path_to_default_spec_map[file] = spec + end + end + + ## + # Find a Gem::Specification of default gem from +path+ + + def find_unresolved_default_spec(path) + Gem.suffixes.each do |suffix| + spec = @path_to_default_spec_map["#{path}#{suffix}"] + return spec if spec + end + nil + end + + ## + # Remove needless Gem::Specification of default gem from + # unresolved default gem list + + def remove_unresolved_default_spec(spec) + spec.files.each do |file| + @path_to_default_spec_map.delete(file) + end + end + + ## + # Clear default gem related variables. It is for test + + def clear_default_specs + @path_to_default_spec_map.clear + end + + ## + # The list of hooks to be run after Gem::Installer#install extracts files + # and builds extensions + + attr_reader :post_build_hooks + + ## + # The list of hooks to be run after Gem::Installer#install completes + # installation + + attr_reader :post_install_hooks + + ## + # The list of hooks to be run after Gem::DependencyInstaller installs a + # set of gems + + attr_reader :done_installing_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 after Gem::Uninstaller#uninstall completes + # installation + + attr_reader :post_uninstall_hooks + + ## + # The list of hooks to be run before Gem::Installer#install does any work + + 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 before Gem::Uninstaller#uninstall does any + # work + + attr_reader :pre_uninstall_hooks + end + + ## + # Location of Marshal quick gemspecs on remote repositories + + MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/" + + autoload :ConfigFile, 'rubygems/config_file' + autoload :Dependency, 'rubygems/dependency' + autoload :DependencyList, 'rubygems/dependency_list' + autoload :DependencyResolver, 'rubygems/resolver' + autoload :Installer, 'rubygems/installer' + autoload :PathSupport, 'rubygems/path_support' + autoload :Platform, 'rubygems/platform' + autoload :RequestSet, 'rubygems/request_set' + autoload :Requirement, 'rubygems/requirement' + autoload :Resolver, 'rubygems/resolver' + autoload :Source, 'rubygems/source' + autoload :SourceList, 'rubygems/source_list' + autoload :SpecFetcher, 'rubygems/spec_fetcher' + autoload :Specification, 'rubygems/specification' + autoload :Version, 'rubygems/version' + + require "rubygems/specification" +end + +require 'rubygems/exceptions' + +# REFACTOR: This should be pulled out into some kind of hacks file. +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 + +## +# Loads the default specs. +Gem::Specification.load_defaults + +require 'rubygems/core_ext/kernel_gem' +require 'rubygems/core_ext/kernel_require' + +Gem.use_gemdeps + |