rubygems-update 1.8.30 → 2.0.0.preview2

data/lib/rubygems/compatibility.rb

@@ -0,0 +1,51 @@
+# This file contains all sorts of little compatibility hacks that we've
+# had to introduce over the years. Quarantining them into one file helps
+# us know when we can get rid of them.
+
+# Ruby 1.9.x has introduced some things that are awkward, and we need to
+# support them, so we define some constants to use later.
+module Gem
+  # Only MRI 1.9.2 has the custom prelude.
+  GEM_PRELUDE_SUCKAGE = RUBY_VERSION =~ /^1\.9\.2/ and RUBY_ENGINE == "ruby"
+end
+
+# Gem::QuickLoader exists in the gem prelude code in ruby 1.9.2 itself.
+# We gotta get rid of it if it's there, before we do anything else.
+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
+
+module Gem
+  RubyGemsVersion = VERSION
+
+  RbConfigPriorities = %w[
+    EXEEXT RUBY_SO_NAME arch bindir datadir libdir ruby_install_name
+    ruby_version rubylibprefix sitedir sitelibdir vendordir vendorlibdir
+    rubylibdir
+  ]
+
+  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
+end

data/lib/rubygems/config_file.rb

@@ -5,9 +5,9 @@
 #++
 
 ##
-# Gem::ConfigFile RubyGems options and gem command options from ~/.gemrc.
+# Gem::ConfigFile RubyGems options and gem command options from gemrc.
 #
-# ~/.gemrc is a YAML file that uses strings to match gem command arguments and
+# gemrc is a YAML file that uses strings to match gem command arguments and
 # symbols to match RubyGems options.
 #
 # Gem command arguments use a String key that matches the command name and
@@ -21,16 +21,19 @@
 # RubyGems options use symbol keys.  Valid options are:
 #
 # +:backtrace+:: See #backtrace
-# +:benchmark+:: See #benchmark
 # +:sources+:: Sets Gem::sources
 # +:verbose+:: See #verbose
-
-require 'rbconfig'
+#
+# gemrc files may exist in various locations and are read and merged in
+# the following order:
+#
+# - system wide (/etc/gemrc)
+# - per user (~/.gemrc)
+# - per environment (gemrc files listed in the GEMRC environment variable)
 
 class Gem::ConfigFile
 
   DEFAULT_BACKTRACE = false
-  DEFAULT_BENCHMARK = false
   DEFAULT_BULK_THRESHOLD = 1000
   DEFAULT_VERBOSITY = true
   DEFAULT_UPDATE_SOURCES = true
@@ -96,11 +99,6 @@ class Gem::ConfigFile
 
   attr_writer :backtrace
 
-  ##
-  # True if we are benchmarking this run.
-
-  attr_accessor :benchmark
-
   ##
   # Bulk threshold value.  If the number of missing gems are above this
   # threshold value, then a bulk download technique is used.  (deprecated)
@@ -131,6 +129,10 @@ class Gem::ConfigFile
   attr_reader :api_keys
 
   ##
+  # True if we want to force specification of gem server when pushing a gem
+
+  attr_accessor :disable_default_gem_server
+
   # openssl verify mode value, used for remote https connection
 
   attr_reader :ssl_verify_mode
@@ -158,29 +160,29 @@ class Gem::ConfigFile
   # <tt>--debug</tt>::
   #   Enable Ruby level debug messages.  Handled early for the same reason as
   #   --backtrace.
+  #--
+  # TODO: parse options upstream, pass in options directly
 
-  def initialize(arg_list)
+  def initialize(args)
     @config_file_name = nil
     need_config_file_name = false
 
-    arg_list = arg_list.map do |arg|
+    arg_list = []
+
+    args.each do |arg|
       if need_config_file_name then
         @config_file_name = arg
         need_config_file_name = false
-        nil
       elsif arg =~ /^--config-file=(.*)/ then
         @config_file_name = $1
-        nil
       elsif arg =~ /^--config-file$/ then
         need_config_file_name = true
-        nil
       else
-        arg
+        arg_list << arg
       end
-    end.compact
+    end
 
     @backtrace = DEFAULT_BACKTRACE
-    @benchmark = DEFAULT_BENCHMARK
     @bulk_threshold = DEFAULT_BULK_THRESHOLD
     @verbose = DEFAULT_VERBOSITY
     @update_sources = DEFAULT_UPDATE_SOURCES
@@ -189,19 +191,25 @@ class Gem::ConfigFile
     platform_config = Marshal.load Marshal.dump(PLATFORM_DEFAULTS)
     system_config = load_file SYSTEM_WIDE_CONFIG_FILE
     user_config = load_file config_file_name.dup.untaint
+    environment_config = (ENV['GEMRC'] || '').split(/[:;]/).inject({}) do |result, file|
+      result.merge load_file file
+    end
+
 
     @hash = operating_system_config.merge platform_config
     @hash = @hash.merge system_config
     @hash = @hash.merge user_config
+    @hash = @hash.merge environment_config
 
     # HACK these override command-line args, which is bad
-    @backtrace        = @hash[:backtrace]        if @hash.key? :backtrace
-    @benchmark        = @hash[:benchmark]        if @hash.key? :benchmark
-    @bulk_threshold   = @hash[:bulk_threshold]   if @hash.key? :bulk_threshold
-    @home             = @hash[:gemhome]          if @hash.key? :gemhome
-    @path             = @hash[:gempath]          if @hash.key? :gempath
-    @update_sources   = @hash[:update_sources]   if @hash.key? :update_sources
-    @verbose          = @hash[:verbose]          if @hash.key? :verbose
+    @backtrace                  = @hash[:backtrace]                  if @hash.key? :backtrace
+    @bulk_threshold             = @hash[:bulk_threshold]             if @hash.key? :bulk_threshold
+    @home                       = @hash[:gemhome]                    if @hash.key? :gemhome
+    @path                       = @hash[:gempath]                    if @hash.key? :gempath
+    @update_sources             = @hash[:update_sources]             if @hash.key? :update_sources
+    @verbose                    = @hash[:verbose]                    if @hash.key? :verbose
+    @disable_default_gem_server = @hash[:disable_default_gem_server] if @hash.key? :disable_default_gem_server
+
     @ssl_verify_mode  = @hash[:ssl_verify_mode]  if @hash.key? :ssl_verify_mode
     @ssl_ca_cert      = @hash[:ssl_ca_cert]      if @hash.key? :ssl_ca_cert
 
@@ -224,6 +232,7 @@ class Gem::ConfigFile
                 else
                   @hash
                 end
+
     if @api_keys.key? :rubygems_api_key then
       @rubygems_api_key = @api_keys[:rubygems_api_key]
       @api_keys[:rubygems] = @api_keys.delete :rubygems_api_key unless @api_keys.key? :rubygems
@@ -238,7 +247,8 @@ class Gem::ConfigFile
 
     Gem.load_yaml
 
-    File.open(credentials_path, 'w') do |f|
+    permissions = 0600 & (~File.umask)
+    File.open(credentials_path, 'w', permissions) do |f|
       f.write config.to_yaml
     end
 
@@ -249,13 +259,21 @@ class Gem::ConfigFile
     Gem.load_yaml
 
     return {} unless filename and File.exist? filename
+
     begin
-      YAML.load(File.read(filename))
+      content = YAML.load(File.read(filename))
+      unless content.kind_of? Hash
+        warn "Failed to load #{config_file_name} because it doesn't contain valid YAML hash"
+        return {}
+      end
+      return content
     rescue ArgumentError
       warn "Failed to load #{config_file_name}"
     rescue Errno::EACCES
       warn "Failed to load #{config_file_name} due to permissions problem."
-    end or {}
+    end
+
+    {}
   end
 
   # True if the backtrace option has been specified, or debug is on.
@@ -273,13 +291,11 @@ class Gem::ConfigFile
     hash = @hash.dup
     hash.delete :update_sources
     hash.delete :verbose
-    hash.delete :benchmark
     hash.delete :backtrace
     hash.delete :bulk_threshold
 
     yield :update_sources, @update_sources
     yield :verbose, @verbose
-    yield :benchmark, @benchmark
     yield :backtrace, @backtrace
     yield :bulk_threshold, @bulk_threshold
 
@@ -296,8 +312,6 @@ class Gem::ConfigFile
       case arg
       when /^--(backtrace|traceback)$/ then
         @backtrace = true
-      when /^--bench(mark)?$/ then
-        @benchmark = true
       when /^--debug$/ then
         $DEBUG = true
       else
@@ -309,25 +323,41 @@ class Gem::ConfigFile
   # Really verbose mode gives you extra output.
   def really_verbose
     case verbose
-    when true, false, nil then false
-    else true
+    when true, false, nil then
+      false
+    else
+      true
     end
   end
 
   # to_yaml only overwrites things you can't override on the command line.
   def to_yaml # :nodoc:
     yaml_hash = {}
-    yaml_hash[:backtrace] = @hash.key?(:backtrace) ? @hash[:backtrace] :
-      DEFAULT_BACKTRACE
-    yaml_hash[:benchmark] = @hash.key?(:benchmark) ? @hash[:benchmark] :
-      DEFAULT_BENCHMARK
-    yaml_hash[:bulk_threshold] = @hash.key?(:bulk_threshold) ?
-      @hash[:bulk_threshold] : DEFAULT_BULK_THRESHOLD
-    yaml_hash[:sources] = Gem.sources
-    yaml_hash[:update_sources] = @hash.key?(:update_sources) ?
-      @hash[:update_sources] : DEFAULT_UPDATE_SOURCES
-    yaml_hash[:verbose] = @hash.key?(:verbose) ? @hash[:verbose] :
-      DEFAULT_VERBOSITY
+    yaml_hash[:backtrace] = if @hash.key?(:backtrace)
+                              @hash[:backtrace]
+                            else
+                              DEFAULT_BACKTRACE
+                            end
+
+    yaml_hash[:bulk_threshold] = if @hash.key?(:bulk_threshold)
+                                   @hash[:bulk_threshold]
+                                 else
+                                   DEFAULT_BULK_THRESHOLD
+                                 end
+
+    yaml_hash[:sources] = Gem.sources.to_a
+
+    yaml_hash[:update_sources] = if @hash.key?(:update_sources)
+                                   @hash[:update_sources]
+                                 else
+                                   DEFAULT_UPDATE_SOURCES
+                                 end
+
+    yaml_hash[:verbose] = if @hash.key?(:verbose)
+                            @hash[:verbose]
+                          else
+                            DEFAULT_VERBOSITY
+                          end
 
     keys = yaml_hash.keys.map { |key| key.to_s }
     keys << 'debug'
@@ -361,15 +391,13 @@ class Gem::ConfigFile
 
   def ==(other) # :nodoc:
     self.class === other and
-    @backtrace == other.backtrace and
-    @benchmark == other.benchmark and
-    @bulk_threshold == other.bulk_threshold and
-    @verbose == other.verbose and
-    @update_sources == other.update_sources and
-    @hash == other.hash
+      @backtrace == other.backtrace and
+      @bulk_threshold == other.bulk_threshold and
+      @verbose == other.verbose and
+      @update_sources == other.update_sources and
+      @hash == other.hash
   end
 
-  protected
-
   attr_reader :hash
+  protected :hash
 end

data/lib/rubygems/core_ext/kernel_gem.rb

@@ -0,0 +1,53 @@
+module Kernel
+
+  # REFACTOR: This should be pulled out into some kind of hacks file.
+  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
+
+    if gem_name.kind_of? Gem::Dependency
+      unless Gem::Deprecate.skip
+        warn "#{Gem.location_of_caller.join ':'}:Warning: Kernel.gem no longer "\
+          "accepts a Gem::Dependency object, please pass the name "\
+          "and requirements directly"
+      end
+
+      requirements = gem_name.requirement
+      gem_name = gem_name.name
+    end
+
+    spec = Gem::Dependency.new(gem_name, *requirements).to_spec
+    spec.activate if spec
+  end
+
+  private :gem
+
+end

data/lib/rubygems/core_ext/kernel_require.rb

@@ -0,0 +1,119 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+module Kernel
+
+  if defined?(gem_original_require) then
+    # Ruby ships with a custom_require, override its require
+    remove_method :require
+  else
+    ##
+    # The Kernel#require from before RubyGems was loaded.
+
+    alias gem_original_require require
+    private :gem_original_require
+  end
+
+  ##
+  # When RubyGems is required, Kernel#require is replaced with our own which
+  # is capable of loading gems on demand.
+  #
+  # When you call <tt>require 'x'</tt>, this is what happens:
+  # * If the file can be loaded from the existing Ruby loadpath, it
+  #   is.
+  # * Otherwise, installed gems are searched for a file that matches.
+  #   If it's found in gem 'y', that gem is activated (added to the
+  #   loadpath).
+  #
+  # The normal <tt>require</tt> functionality of returning false if
+  # that file has already been loaded is preserved.
+
+  def require path
+    spec = Gem.find_unresolved_default_spec(path)
+    if spec
+      Gem.remove_unresolved_default_spec(spec)
+      gem(spec.name)
+    end
+
+    # If there are no unresolved deps, then we can use just try
+    # normal require handle loading a gem from the rescue below.
+
+    if Gem::Specification.unresolved_deps.empty? then
+      return gem_original_require(path)
+    end
+
+    # If +path+ is for a gem that has already been loaded, don't
+    # bother trying to find it in an unresolved gem, just go straight
+    # to normal require.
+    #--
+    # TODO request access to the C implementation of this to speed up RubyGems
+
+    spec = Gem::Specification.find { |s|
+      s.activated? and s.contains_requirable_file? path
+    }
+
+    return gem_original_require(path) if spec
+
+    # Attempt to find +path+ in any unresolved gems...
+
+    found_specs = Gem::Specification.find_in_unresolved path
+
+    # If there are no directly unresolved gems, then try and find +path+
+    # in any gems that are available via the currently unresolved gems.
+    # For example, given:
+    #
+    #   a => b => c => d
+    #
+    # If a and b are currently active with c being unresolved and d.rb is
+    # requested, then find_in_unresolved_tree will find d.rb in d because
+    # it's a dependency of c.
+    #
+    if found_specs.empty? then
+      found_specs = Gem::Specification.find_in_unresolved_tree path
+
+      found_specs.each do |found_spec|
+        found_spec.activate
+      end
+
+    # We found +path+ directly in an unresolved gem. Now we figure out, of
+    # the possible found specs, which one we should activate.
+    else
+
+      # Check that all the found specs are just different
+      # versions of the same gem
+      names = found_specs.map(&:name).uniq
+
+      if names.size > 1 then
+        raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
+      end
+
+      # Ok, now find a gem that has no conflicts, starting
+      # at the highest version.
+      valid = found_specs.select { |s| s.conflicts.empty? }.last
+
+      unless valid then
+        le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
+        le.name = names.first
+        raise le
+      end
+
+      valid.activate
+    end
+
+    gem_original_require path
+  rescue LoadError => load_error
+    if load_error.message.start_with?("Could not find") or
+        (load_error.message.end_with?(path) and Gem.try_activate(path)) then
+      return gem_original_require(path)
+    end
+
+    raise load_error
+  end
+
+  private :require
+
+end
+