rubygems-update 1.8.30 → 2.0.0.preview2

data/lib/rubygems/path_support.rb

@@ -1,4 +1,5 @@
 ##
+#
 # Gem::PathSupport facilitates the GEM_HOME and GEM_PATH environment settings
 # to the rest of RubyGems.
 #
@@ -42,16 +43,18 @@ class Gem::PathSupport
   # Set the Gem search path (as reported by Gem.path).
 
   def path=(gpaths)
-    gem_path = [@home]
+    # FIX: it should be [home, *path], not [*path, home]
+
+    gem_path = []
 
     # FIX: I can't tell wtf this is doing.
     gpaths ||= (ENV['GEM_PATH'] || "").empty? ? nil : ENV["GEM_PATH"]
 
-    if gpaths then
-      if gpaths.kind_of?(Array) then
-        gem_path.push(*gpaths)
+    if gpaths
+      if gpaths.kind_of?(Array)
+        gem_path = gpaths.dup
       else
-        gem_path.push(*gpaths.split(File::PATH_SEPARATOR))
+        gem_path = gpaths.split(Gem.path_separator)
       end
 
       if File::ALT_SEPARATOR then
@@ -59,10 +62,14 @@ class Gem::PathSupport
           this_path.gsub File::ALT_SEPARATOR, File::SEPARATOR
         end
       end
+
+      gem_path << @home
     else
-      gem_path.push(*Gem.default_path)
+      gem_path = Gem.default_path + [@home]
 
-      gem_path << APPLE_GEM_HOME if defined?(APPLE_GEM_HOME)
+      if defined?(APPLE_GEM_HOME)
+        gem_path << APPLE_GEM_HOME
+      end
     end
 
     @path = gem_path.uniq

data/lib/rubygems/platform.rb

@@ -21,7 +21,8 @@ class Gem::Platform
 
   def self.match(platform)
     Gem.platforms.any? do |local_platform|
-      platform.nil? or local_platform == platform or
+      platform.nil? or
+        local_platform == platform or
         (local_platform != Gem::Platform::RUBY and local_platform =~ platform)
     end
   end
@@ -65,28 +66,28 @@ class Gem::Platform
       @cpu, os = nil, cpu if os.nil? # legacy jruby
 
       @os, @version = case os
-                      when /aix(\d+)/ then             [ 'aix',       $1  ]
-                      when /cygwin/ then               [ 'cygwin',    nil ]
-                      when /darwin(\d+)?/ then         [ 'darwin',    $1  ]
-                      when /^macruby$/ then            [ 'macruby',   nil ]
-                      when /freebsd(\d+)/ then         [ 'freebsd',   $1  ]
-                      when /hpux(\d+)/ then            [ 'hpux',      $1  ]
-                      when /^java$/, /^jruby$/ then    [ 'java',      nil ]
-                      when /^java([\d.]*)/ then        [ 'java',      $1  ]
-                      when /^dotnet$/ then             [ 'dotnet',    nil ]
-                      when /^dotnet([\d.]*)/ then      [ 'dotnet',    $1  ]
-                      when /linux/ then                [ 'linux',     $1  ]
-                      when /mingw32/ then              [ 'mingw32',   nil ]
+                      when /aix(\d+)?/ then             [ 'aix',       $1  ]
+                      when /cygwin/ then                [ 'cygwin',    nil ]
+                      when /darwin(\d+)?/ then          [ 'darwin',    $1  ]
+                      when /^macruby$/ then             [ 'macruby',   nil ]
+                      when /freebsd(\d+)?/ then         [ 'freebsd',   $1  ]
+                      when /hpux(\d+)?/ then            [ 'hpux',      $1  ]
+                      when /^java$/, /^jruby$/ then     [ 'java',      nil ]
+                      when /^java([\d.]*)/ then         [ 'java',      $1  ]
+                      when /^dotnet$/ then              [ 'dotnet',    nil ]
+                      when /^dotnet([\d.]*)/ then       [ 'dotnet',    $1  ]
+                      when /linux/ then                 [ 'linux',     $1  ]
+                      when /mingw32/ then               [ 'mingw32',   nil ]
                       when /(mswin\d+)(\_(\d+))?/ then
                         os, version = $1, $3
                         @cpu = 'x86' if @cpu.nil? and os =~ /32$/
                         [os, version]
-                      when /netbsdelf/ then            [ 'netbsdelf', nil ]
-                      when /openbsd(\d+\.\d+)/ then    [ 'openbsd',   $1  ]
-                      when /solaris(\d+\.\d+)/ then    [ 'solaris',   $1  ]
+                      when /netbsdelf/ then             [ 'netbsdelf', nil ]
+                      when /openbsd(\d+\.\d+)?/ then    [ 'openbsd',   $1  ]
+                      when /solaris(\d+\.\d+)?/ then    [ 'solaris',   $1  ]
                       # test
-                      when /^(\w+_platform)(\d+)/ then [ $1,          $2  ]
-                      else                             [ 'unknown',   nil ]
+                      when /^(\w+_platform)(\d+)?/ then [ $1,          $2  ]
+                      else                              [ 'unknown',   nil ]
                       end
     when Gem::Platform then
       @cpu = arch.cpu
@@ -109,10 +110,6 @@ class Gem::Platform
     to_a.compact.join '-'
   end
 
-  def empty?
-    to_s.empty?
-  end
-
   ##
   # Is +other+ equal to this platform?  Two platforms are equal if they have
   # the same CPU, OS and version.
@@ -186,9 +183,5 @@ class Gem::Platform
   # This will be replaced with Gem::Platform::local.
 
   CURRENT = 'current'
-
-  extend Gem::Deprecate
-
-  deprecate :empty?, :none, 2011, 11
 end
 

data/lib/rubygems/rdoc.rb

@@ -0,0 +1,316 @@
+require 'rubygems'
+require 'rubygems/user_interaction'
+require 'fileutils'
+
+begin
+  gem 'rdoc'
+rescue Gem::LoadError
+  # swallow
+else
+  # This will force any deps that 'rdoc' might have
+  # (such as json) that are ambigious to be activated, which
+  # is important because we end up using Specification.reset
+  # and we don't want the warning it pops out.
+  Gem.finish_resolve
+end
+
+loaded_hook = false
+
+begin
+  require 'rdoc/rubygems_hook'
+  loaded_hook = true
+  module Gem
+    RDoc = RDoc::RubygemsHook
+  end
+rescue LoadError
+end
+
+##
+# Gem::RDoc provides methods to generate RDoc and ri data for installed gems.
+# It works for RDoc 1.0.1 (in Ruby 1.8) up to RDoc 3.6.
+#
+# This implementation is considered obsolete.  The RDoc project is the
+# appropriate location to find this functionality.  This file provides the
+# hooks to load RDoc generation code from the "rdoc" gem and a fallback in
+# case the installed version of RDoc does not have them.
+
+class Gem::RDoc # :nodoc: all
+
+  include Gem::UserInteraction
+
+  @rdoc_version = nil
+  @specs = []
+
+  ##
+  # Force installation of documentation?
+
+  attr_accessor :force
+
+  ##
+  # Generate rdoc?
+
+  attr_accessor :generate_rdoc
+
+  ##
+  # Generate ri data?
+
+  attr_accessor :generate_ri
+
+  class << self
+
+    ##
+    # Loaded version of RDoc.  Set by ::load_rdoc
+
+    attr_reader :rdoc_version
+
+  end
+
+  ##
+  # Post installs hook that generates documentation for each specification in
+  # +specs+
+
+  def self.generation_hook installer, specs
+    types     = installer.document
+
+    generate_rdoc = types.include? 'rdoc'
+    generate_ri   = types.include? 'ri'
+
+    specs.each do |spec|
+      new(spec, generate_rdoc, generate_ri).generate
+    end
+  end
+
+  ##
+  # Loads the RDoc generator
+
+  def self.load_rdoc
+    return if @rdoc_version
+
+    begin
+      require 'rdoc/rdoc'
+
+      @rdoc_version = if ::RDoc.const_defined? :VERSION then
+                        Gem::Version.new ::RDoc::VERSION
+                      else
+                        Gem::Version.new '1.0.1'
+                      end
+
+    rescue LoadError => e
+      raise Gem::DocumentError, "RDoc is not installed: #{e}"
+    end
+  end
+
+  ##
+  # Creates a new documentation generator for +spec+.  RDoc and ri data
+  # generation can be enabled or disabled through +generate_rdoc+ and
+  # +generate_ri+ respectively.
+  #
+  # Only +generate_ri+ is enabled by default.
+
+  def initialize spec, generate_rdoc = false, generate_ri = true
+    @doc_dir   = spec.doc_dir
+    @file_info = nil
+    @force     = false
+    @rdoc      = nil
+    @spec      = spec
+
+    @generate_rdoc = generate_rdoc
+    @generate_ri   = generate_ri
+
+    @rdoc_dir = spec.doc_dir 'rdoc'
+    @ri_dir   = spec.doc_dir 'ri'
+  end
+
+  ##
+  # Removes legacy rdoc arguments from +args+
+
+  def delete_legacy_args args
+    args.delete '--inline-source'
+    args.delete '--promiscuous'
+    args.delete '-p'
+    args.delete '--one-file'
+  end
+
+  ##
+  # Generates documentation using the named +generator+ ("darkfish" or "ri")
+  # and following the given +options+.
+  #
+  # Documentation will be generated into +destination+
+
+  def document generator, options, destination
+    options = options.dup
+    options.exclude ||= [] # TODO maybe move to RDoc::Options#finish
+    options.setup_generator generator
+    options.op_dir = destination
+    options.finish
+
+    @rdoc.options = options
+    @rdoc.generator = options.generator.new options
+
+    say "Installing #{generator} documentation for #{@spec.full_name}"
+
+    FileUtils.mkdir_p options.op_dir
+
+    Dir.chdir options.op_dir do
+      begin
+        @rdoc.class.current = @rdoc
+        @rdoc.generator.generate @file_info
+      ensure
+        @rdoc.class.current = nil
+      end
+    end
+  end
+
+  ##
+  # Generates RDoc and ri data
+
+  def generate
+    return unless @generate_ri or @generate_rdoc
+
+    setup
+
+    if Gem::Requirement.new('< 3').satisfied_by? self.class.rdoc_version then
+      generate_legacy
+    else
+      ::RDoc::TopLevel.reset # TODO ::RDoc::RDoc.reset
+      ::RDoc::Parser::C.reset
+
+      options = ::RDoc::Options.new
+      options.default_title = "#{@spec.full_name} Documentation"
+      options.files = []
+      options.files.push(*@spec.require_paths)
+      options.files.push(*@spec.extra_rdoc_files)
+
+      args = @spec.rdoc_options
+
+      case config_args = Gem.configuration[:rdoc]
+      when String then
+        args = args.concat config_args.split
+      when Array then
+        args = args.concat config_args
+      end
+
+      delete_legacy_args args
+      options.parse args
+      options.quiet = !Gem.configuration.really_verbose
+
+      @rdoc = new_rdoc
+      @rdoc.options = options
+
+      Dir.chdir @spec.full_gem_path do
+        @file_info = @rdoc.parse_files options.files
+      end
+
+      document 'ri',       options, @ri_dir if
+        @generate_ri   and (@force or not File.exist? @ri_dir)
+
+      document 'darkfish', options, @rdoc_dir if
+        @generate_rdoc and (@force or not File.exist? @rdoc_dir)
+    end
+  end
+
+  ##
+  # Generates RDoc and ri data for legacy RDoc versions.  This method will not
+  # exist in future versions.
+
+  def generate_legacy
+    if @generate_rdoc then
+      FileUtils.rm_rf @rdoc_dir
+      say "Installing RDoc documentation for #{@spec.full_name}"
+      legacy_rdoc '--op', @rdoc_dir
+    end
+
+    if @generate_ri then
+      FileUtils.rm_rf @ri_dir
+      say "Installing ri documentation for #{@spec.full_name}"
+      legacy_rdoc '--ri', '--op', @ri_dir
+    end
+  end
+
+  ##
+  # Generates RDoc using a legacy version of RDoc from the ARGV-like +args+.
+  # This method will not exist in future versions.
+
+  def legacy_rdoc *args
+    args << @spec.rdoc_options
+    args << '--quiet'
+    args << @spec.require_paths.clone
+    args << @spec.extra_rdoc_files
+    args << '--title' << "#{@spec.full_name} Documentation"
+    args = args.flatten.map do |arg| arg.to_s end
+
+    delete_legacy_args args if
+      Gem::Requirement.new('>= 2.4.0') =~ self.class.rdoc_version
+
+    r = new_rdoc
+    say "rdoc #{args.join ' '}" if Gem.configuration.really_verbose
+
+    Dir.chdir @spec.full_gem_path do
+      begin
+        r.document args
+      rescue Errno::EACCES => e
+        dirname = File.dirname e.message.split("-")[1].strip
+        raise Gem::FilePermissionError, dirname
+      rescue Interrupt => e
+        raise e
+      rescue Exception => ex
+        alert_error "While generating documentation for #{@spec.full_name}"
+        ui.errs.puts "... MESSAGE:   #{ex}"
+        ui.errs.puts "... RDOC args: #{args.join(' ')}"
+        ui.backtrace ex
+        ui.errs.puts "(continuing with the rest of the installation)"
+      ensure
+      end
+    end
+  end
+
+  ##
+  # #new_rdoc creates a new RDoc instance.  This method is provided only to
+  # make testing easier.
+
+  def new_rdoc
+    ::RDoc::RDoc.new
+  end
+
+  ##
+  # Is rdoc documentation installed?
+
+  def rdoc_installed?
+    File.exist? @rdoc_dir
+  end
+
+  ##
+  # Removes generated RDoc and ri data
+
+  def remove
+    base_dir = @spec.base_dir
+
+    raise Gem::FilePermissionError, base_dir unless File.writable? base_dir
+
+    FileUtils.rm_rf @rdoc_dir
+    FileUtils.rm_rf @ri_dir
+  end
+
+  ##
+  # Is ri data installed?
+
+  def ri_installed?
+    File.exist? @ri_dir
+  end
+
+  ##
+  # Prepares the spec for documentation generation
+
+  def setup
+    self.class.load_rdoc
+
+    raise Gem::FilePermissionError, @doc_dir if
+      File.exist?(@doc_dir) and not File.writable?(@doc_dir)
+
+    FileUtils.mkdir_p @doc_dir unless File.exist? @doc_dir
+  end
+
+end unless loaded_hook
+
+Gem.done_installing(&Gem::RDoc.method(:generation_hook))
+

data/lib/rubygems/remote_fetcher.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rubygems/user_interaction'
 require 'uri'
+require 'resolv'
 
 ##
 # RemoteFetcher handles the details of fetching gems and gem information from
@@ -8,8 +9,6 @@ require 'uri'
 
 class Gem::RemoteFetcher
 
-  BuiltinSSLCerts = File.expand_path("./ssl_certs/*.pem", File.dirname(__FILE__))
-
   include Gem::UserInteraction
 
   ##
@@ -34,6 +33,13 @@ class Gem::RemoteFetcher
 
   end
 
+  ##
+  # A FetchError that indicates that the reason for not being
+  # able to fetch data was that the host could not be contacted
+
+  class UnknownHostError < FetchError
+  end
+
   @fetcher = nil
 
   ##
@@ -53,8 +59,11 @@ class Gem::RemoteFetcher
   # * nil: respect environment variables (HTTP_PROXY, HTTP_PROXY_USER,
   #        HTTP_PROXY_PASS)
   # * <tt>:no_proxy</tt>: ignore environment variables and _don't_ use a proxy
+  #
+  # +dns+: An object to use for DNS resolution of the API endpoint.
+  #        By default, use Resolv::DNS.
 
-  def initialize(proxy = nil)
+  def initialize(proxy=nil, dns=Resolv::DNS.new)
     require 'net/http'
     require 'stringio'
     require 'time'
@@ -72,6 +81,27 @@ class Gem::RemoteFetcher
       else URI.parse(proxy)
       end
     @user_agent = user_agent
+    @env_no_proxy = get_no_proxy_from_env
+
+    @dns = dns
+  end
+
+  ##
+  #
+  # Given a source at +uri+, calculate what hostname to actually
+  # connect to query the data for it.
+
+  def api_endpoint(uri)
+    host = uri.host
+
+    begin
+      res = @dns.getresource "_rubygems._tcp.#{host}",
+                             Resolv::DNS::Resource::IN::SRV
+    rescue Resolv::ResolvError
+      uri
+    else
+      URI.parse "#{res.target}#{uri.path}"
+    end
   end
 
   ##
@@ -82,14 +112,13 @@ class Gem::RemoteFetcher
   # larger, more emcompassing effort. -erikh
 
   def download_to_cache dependency
-    found = Gem::SpecFetcher.fetcher.fetch dependency, true, true,
-                                           dependency.prerelease?
+    found, _ = Gem::SpecFetcher.fetcher.spec_for_dependency dependency
 
     return if found.empty?
 
-    spec, source_uri = found.sort_by { |(s,_)| s.version }.last
+    spec, source = found.sort_by { |(s,_)| s.version }.last
 
-    download spec, source_uri
+    download spec, source.uri.to_s
   end
 
   ##
@@ -100,11 +129,14 @@ class Gem::RemoteFetcher
   def download(spec, source_uri, install_dir = Gem.dir)
     Gem.ensure_gem_subdirectories(install_dir) rescue nil
 
-    if File.writable?(install_dir)
-      cache_dir = File.join install_dir, "cache"
-    else
-      cache_dir = File.join Gem.user_dir, "cache"
-    end
+    cache_dir =
+      if Dir.pwd == install_dir then # see fetch_command
+        install_dir
+      elsif File.writable? install_dir then
+        File.join install_dir, "cache"
+      else
+        File.join Gem.user_dir, "cache"
+      end
 
     gem_file_name = File.basename spec.cache_file
     local_gem_path = File.join cache_dir, gem_file_name
@@ -123,6 +155,8 @@ class Gem::RemoteFetcher
     # URI.parse gets confused by MS Windows paths with forward slashes.
     scheme = nil if scheme =~ /^[a-z]$/i
 
+    # REFACTOR: split this up and dispatch on scheme (eg download_http)
+    # REFACTOR: be sure to clean up fake fetcher when you do this... cleaner
     case scheme
     when 'http', 'https' then
       unless File.exist? local_gem_path then
@@ -132,7 +166,7 @@ class Gem::RemoteFetcher
 
           remote_gem_path = source_uri + "gems/#{gem_file_name}"
 
-          gem = self.fetch_path remote_gem_path
+          self.cache_update_path remote_gem_path, local_gem_path
         rescue Gem::RemoteFetcher::FetchError
           raise if spec.original_platform == spec.platform
 
@@ -143,11 +177,7 @@ class Gem::RemoteFetcher
 
           remote_gem_path = source_uri + "gems/#{alternate_name}"
 
-          gem = self.fetch_path remote_gem_path
-        end
-
-        File.open local_gem_path, 'wb' do |fp|
-          fp.write gem
+          self.cache_update_path remote_gem_path, local_gem_path
         end
       end
     when 'file' then
@@ -184,7 +214,7 @@ class Gem::RemoteFetcher
       say "Using local gem #{local_gem_path}" if
         Gem.configuration.really_verbose
     else
-      raise Gem::InstallError, "unsupported URI scheme #{source_uri.scheme}"
+      raise ArgumentError, "unsupported URI scheme #{source_uri.scheme}"
     end
 
     local_gem_path
@@ -232,18 +262,54 @@ class Gem::RemoteFetcher
     uri = URI.parse uri unless URI::Generic === uri
 
     raise ArgumentError, "bad uri: #{uri}" unless uri
-    raise ArgumentError, "uri scheme is invalid: #{uri.scheme.inspect}" unless
-      uri.scheme
+
+    unless uri.scheme
+      raise ArgumentError, "uri scheme is invalid: #{uri.scheme.inspect}"
+    end
 
     data = send "fetch_#{uri.scheme}", uri, mtime, head
-    data = Gem.gunzip data if data and not head and uri.to_s =~ /gz$/
+
+    if data and !head and uri.to_s =~ /gz$/
+      begin
+        data = Gem.gunzip data
+      rescue Zlib::GzipFile::Error
+        raise FetchError.new("server did not return a valid file", uri.to_s)
+      end
+    end
+
     data
   rescue FetchError
     raise
   rescue Timeout::Error
-    raise FetchError.new('timed out', uri.to_s)
+    raise UnknownHostError.new('timed out', uri.to_s)
   rescue IOError, SocketError, SystemCallError => e
-    raise FetchError.new("#{e.class}: #{e}", uri.to_s)
+    if e.message =~ /getaddrinfo/
+      raise UnknownHostError.new('no such name', uri.to_s)
+    else
+      raise FetchError.new("#{e.class}: #{e}", uri.to_s)
+    end
+  end
+
+  ##
+  # Downloads +uri+ to +path+ if necessary. If no path is given, it just
+  # passes the data.
+
+  def cache_update_path(uri, path = nil)
+    mtime = path && File.stat(path).mtime rescue nil
+
+    if mtime && Net::HTTPNotModified === fetch_path(uri, mtime, true)
+      Gem.read_binary(path)
+    else
+      data = fetch_path(uri)
+
+      if path
+        open(path, 'wb') do |io|
+          io.write data
+        end
+      end
+
+      data
+    end
   end
 
   ##
@@ -273,6 +339,17 @@ class Gem::RemoteFetcher
     URI
   end
 
+  ##
+  # Returns list of no_proxy entries (if any) from the environment
+
+  def get_no_proxy_from_env
+    env_no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']
+
+    return [] if env_no_proxy.nil?  or env_no_proxy.empty?
+
+    env_no_proxy.split(/\s*,\s*/)
+  end
+
   ##
   # Returns an HTTP proxy URI if one is set in the environment variables.
 
@@ -296,7 +373,7 @@ class Gem::RemoteFetcher
   # Normalize the URI by adding "http://" if it is missing.
 
   def normalize_uri(uri)
-    (uri =~ /^(https?|ftp|file):/) ? uri : "http://#{uri}"
+    (uri =~ /^(https?|ftp|file):/i) ? uri : "http://#{uri}"
   end
 
   ##
@@ -306,7 +383,7 @@ class Gem::RemoteFetcher
   def connection_for(uri)
     net_http_args = [uri.host, uri.port]
 
-    if @proxy_uri then
+    if @proxy_uri and not no_proxy?(uri.host) then
       net_http_args += [
         @proxy_uri.host,
         @proxy_uri.port,
@@ -319,37 +396,23 @@ class Gem::RemoteFetcher
     @connections[connection_id] ||= Net::HTTP.new(*net_http_args)
     connection = @connections[connection_id]
 
-    if https?(uri) and !connection.started? then
+    if https?(uri) and not connection.started? then
       configure_connection_for_https(connection)
-
-      # Don't refactor this with the else branch. We don't want the
-      # http-only code path to not depend on anything in OpenSSL.
-      #
-      begin
-        connection.start
-      rescue OpenSSL::SSL::SSLError, Errno::EHOSTDOWN => e
-        raise FetchError.new(e.message, uri)
-      end
-    else
-      begin
-        connection.start unless connection.started?
-      rescue Errno::EHOSTDOWN => e
-        raise FetchError.new(e.message, uri)
-      end
     end
 
+    connection.start unless connection.started?
+
     connection
+  rescue OpenSSL::SSL::SSLError, Errno::EHOSTDOWN => e
+    raise FetchError.new(e.message, uri)
   end
 
   def configure_connection_for_https(connection)
     require 'net/https'
-
     connection.use_ssl = true
     connection.verify_mode =
       Gem.configuration.ssl_verify_mode || OpenSSL::SSL::VERIFY_PEER
-
     store = OpenSSL::X509::Store.new
-
     if Gem.configuration.ssl_ca_cert
       if File.directory? Gem.configuration.ssl_ca_cert
         store.add_path Gem.configuration.ssl_ca_cert
@@ -360,12 +423,12 @@ class Gem::RemoteFetcher
       store.set_default_paths
       add_rubygems_trusted_certs(store)
     end
-
     connection.cert_store = store
   end
 
   def add_rubygems_trusted_certs(store)
-    Dir.glob(BuiltinSSLCerts).each do |ssl_cert_file|
+    pattern = File.expand_path("./ssl_certs/*.pem", File.dirname(__FILE__))
+    Dir.glob(pattern).each do |ssl_cert_file|
       store.add_file ssl_cert_file
     end
   end
@@ -378,13 +441,13 @@ class Gem::RemoteFetcher
     end
   end
 
-  ##
-  # Read the data from the (source based) URI, but if it is a file:// URI,
-  # read from the filesystem instead.
-
-  def open_uri_or_path(uri, last_modified = nil, head = false, depth = 0)
-    raise "NO: Use fetch_path instead"
-    # TODO: deprecate for fetch_path
+  def no_proxy? host
+    host = host.downcase
+    @env_no_proxy.each do |pattern|
+      pattern = pattern.downcase
+      return true if host[-pattern.length, pattern.length ] == pattern
+    end
+    return false
   end
 
   ##