bundler 1.9.10 → 1.10.0.pre

data/lib/bundler/deployment.rb

@@ -33,6 +33,7 @@ module Bundler
             set :bundle_dir,      File.join(fetch(:shared_path), 'bundle')
             set :bundle_flags,    "--deployment --quiet"
             set :bundle_without,  [:development, :test]
+            set :bundle_with,     [:mysql]
             set :bundle_cmd,      "bundle" # e.g. "/opt/ruby/bin/bundle"
             set :bundle_roles,    #{role_default} # e.g. [:app, :batch]
         DESC
@@ -42,6 +43,7 @@ module Bundler
           bundle_dir     = context.fetch(:bundle_dir, File.join(context.fetch(:shared_path), 'bundle'))
           bundle_gemfile = context.fetch(:bundle_gemfile, "Gemfile")
           bundle_without = [*context.fetch(:bundle_without, [:development, :test])].compact
+          bundle_with    = [*context.fetch(:bundle_with, [])].compact
           app_path = context.fetch(:latest_release)
           if app_path.to_s.empty?
             raise error_type.new("Cannot detect current release path - make sure you have deployed at least once.")
@@ -50,6 +52,7 @@ module Bundler
           args << "--path #{bundle_dir}" unless bundle_dir.to_s.empty?
           args << bundle_flags.to_s
           args << "--without #{bundle_without.join(" ")}" unless bundle_without.empty?
+          args << "--with #{bundle_with.join(" ")}" unless bundle_with.empty?
 
           run "cd #{app_path} && #{bundle_cmd} install #{args.join(' ')}"
         end

data/lib/bundler/dsl.rb

@@ -16,32 +16,30 @@ module Bundler
     attr_accessor :dependencies
 
     def initialize
-      @source          = nil
-      @sources         = SourceList.new
-      @git_sources     = {}
-      @dependencies    = []
-      @groups          = []
-      @platforms       = []
-      @env             = nil
-      @ruby_version    = nil
+      @source               = nil
+      @sources              = SourceList.new
+      @git_sources          = {}
+      @dependencies         = []
+      @groups               = []
+      @install_conditionals = []
+      @optional_groups      = []
+      @platforms            = []
+      @env                  = nil
+      @ruby_version         = nil
       add_git_sources
     end
 
     def eval_gemfile(gemfile, contents = nil)
       contents ||= Bundler.read_file(gemfile.to_s)
       instance_eval(contents, gemfile.to_s, 1)
-    rescue SyntaxError => e
-      syntax_msg = e.message.gsub("#{gemfile}:", 'on line ')
-      raise GemfileError, "Gemfile syntax error #{syntax_msg}"
-    rescue ScriptError, RegexpError, NameError, ArgumentError, RuntimeError => e
-      e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
-      Bundler.ui.warn e.backtrace.join("\n       ")
-      raise GemfileError, "There was an error in your Gemfile," \
-        " and Bundler cannot continue."
+    rescue Exception => e
+      message = "There was an error parsing `#{File.basename gemfile.to_s}`: #{e.message}"
+      raise DSLError.new(message, gemfile, e.backtrace, contents)
     end
 
     def gemspec(opts = nil)
       path              = opts && opts[:path] || '.'
+      glob              = opts && opts[:glob]
       name              = opts && opts[:name] || '{,*}'
       development_group = opts && opts[:development_group] || :development
       expanded_path     = File.expand_path(path, Bundler.default_gemfile.dirname)
@@ -52,7 +50,7 @@ module Bundler
       when 1
         spec = Bundler.load_gemspec(gemspecs.first)
         raise InvalidOption, "There was an error loading the gemspec at #{gemspecs.first}." unless spec
-        gem spec.name, :path => path
+        gem spec.name, :path => path, :glob => glob
         group(development_group) do
           spec.development_dependencies.each do |dep|
             gem dep.name, *(dep.requirement.as_list + [:type => :development])
@@ -158,16 +156,32 @@ module Bundler
     end
 
     def to_definition(lockfile, unlock)
-      Definition.new(lockfile, @dependencies, @sources, unlock, @ruby_version)
+      Definition.new(lockfile, @dependencies, @sources, unlock, @ruby_version, @optional_groups)
     end
 
     def group(*args, &blk)
+      opts = Hash === args.last ? args.pop.dup : {}
+      normalize_group_options(opts, args)
+
       @groups.concat args
+
+      if opts["optional"]
+        optional_groups = args - @optional_groups
+        @optional_groups.concat optional_groups
+      end
+
       yield
     ensure
       args.each { @groups.pop }
     end
 
+    def install_if(*args, &blk)
+      @install_conditionals.concat args
+      blk.call
+    ensure
+      args.each { @groups.pop }
+    end
+
     def platforms(*platforms)
       @platforms.concat platforms
       yield
@@ -184,9 +198,7 @@ module Bundler
     end
 
     def method_missing(name, *args)
-      location = caller[0].split(':')[0..1].join(':')
-      raise GemfileError, "Undefined local variable or method `#{name}' for Gemfile\n" \
-        "        from #{location}"
+      raise GemfileError, "Undefined local variable or method `#{name}' for Gemfile"
     end
 
   private
@@ -224,7 +236,7 @@ module Bundler
     end
 
     def valid_keys
-      @valid_keys ||= %w(group groups git path name branch ref tag require submodules platform platforms type source)
+      @valid_keys ||= %w(group groups git path glob name branch ref tag require submodules platform platforms type source install_if)
     end
 
     def normalize_options(name, version, opts)
@@ -238,25 +250,19 @@ module Bundler
       normalize_hash(opts)
 
       git_names = @git_sources.keys.map(&:to_s)
-
-      invalid_keys = opts.keys - (valid_keys + git_names)
-      if invalid_keys.any?
-        message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "
-        message << if invalid_keys.size > 1
-                     "as options for gem '#{name}', but they are invalid."
-                   else
-                     "as an option for gem '#{name}', but it is invalid."
-                   end
-
-        message << " Valid options are: #{valid_keys.join(", ")}"
-        raise InvalidOption, message
-      end
+      validate_keys("gem '#{name}'", opts, valid_keys + git_names)
 
       groups = @groups.dup
       opts["group"] = opts.delete("groups") || opts["group"]
       groups.concat Array(opts.delete("group"))
       groups = [:default] if groups.empty?
 
+      install_if = @install_conditionals.dup
+      install_if.concat Array(opts.delete("install_if"))
+      install_if = install_if.reduce(true) do |memo, val|
+        memo && (val.respond_to?(:call) ? val.call : val)
+      end
+
       platforms = @platforms.dup
       opts["platforms"] = opts["platform"] || opts["platforms"]
       platforms.concat Array(opts.delete("platforms"))
@@ -289,10 +295,35 @@ module Bundler
         end
       end
 
-      opts["source"]  ||= @source
-      opts["env"]     ||= @env
-      opts["platforms"] = platforms.dup
-      opts["group"]     = groups
+      opts["source"]       ||= @source
+      opts["env"]          ||= @env
+      opts["platforms"]      = platforms.dup
+      opts["group"]          = groups
+      opts["should_include"] = install_if
+    end
+
+    def normalize_group_options(opts, groups)
+      normalize_hash(opts)
+
+      groups = groups.map {|group| ":#{group}" }.join(", ")
+      validate_keys("group #{groups}", opts, %w(optional))
+
+      opts["optional"] ||= false
+    end
+
+    def validate_keys(command, opts, valid_keys)
+      invalid_keys = opts.keys - valid_keys
+      if invalid_keys.any?
+        message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "
+        message << if invalid_keys.size > 1
+                     "as options for #{command}, but they are invalid."
+                   else
+                     "as an option for #{command}, but it is invalid."
+                   end
+
+        message << " Valid options are: #{valid_keys.join(", ")}"
+        raise InvalidOption, message
+      end
     end
 
     def normalize_source(source)
@@ -327,5 +358,107 @@ module Bundler
       end
     end
 
+    class DSLError < GemfileError
+      # @return [String] the description that should be presented to the user.
+      #
+      attr_reader :description
+
+      # @return [String] the path of the dsl file that raised the exception.
+      #
+      attr_reader :dsl_path
+
+      # @return [Exception] the backtrace of the exception raised by the
+      #         evaluation of the dsl file.
+      #
+      attr_reader :backtrace
+
+      # @param [Exception] backtrace @see backtrace
+      # @param [String]    dsl_path  @see dsl_path
+      #
+      def initialize(description, dsl_path, backtrace, contents = nil)
+        @status_code = $!.respond_to?(:status_code) && $!.status_code
+
+        @description = description
+        @dsl_path    = dsl_path
+        @backtrace   = backtrace
+        @contents    = contents
+      end
+
+      def status_code
+        @status_code || super
+      end
+
+      # @return [String] the contents of the DSL that cause the exception to
+      #         be raised.
+      #
+      def contents
+        @contents ||= begin
+          dsl_path && File.exist?(dsl_path) && File.read(dsl_path)
+        end
+      end
+
+      # The message of the exception reports the content of podspec for the
+      # line that generated the original exception.
+      #
+      # @example Output
+      #
+      #   Invalid podspec at `RestKit.podspec` - undefined method
+      #   `exclude_header_search_paths=' for #<Pod::Specification for
+      #   `RestKit/Network (0.9.3)`>
+      #
+      #       from spec-repos/master/RestKit/0.9.3/RestKit.podspec:36
+      #       -------------------------------------------
+      #           # because it would break: #import <CoreData/CoreData.h>
+      #    >      ns.exclude_header_search_paths = 'Code/RestKit.h'
+      #         end
+      #       -------------------------------------------
+      #
+      # @return [String] the message of the exception.
+      #
+      def message
+        @message ||= begin
+          trace_line, description = parse_line_number_from_description
+
+          m = "\n[!] "
+          m << description
+          m << ". Bundler cannot continue.\n"
+
+          return m unless backtrace && dsl_path && contents
+
+          trace_line = backtrace.find { |l| l.include?(dsl_path.to_s) } || trace_line
+          return m unless trace_line
+          line_numer = trace_line.split(':')[1].to_i - 1
+          return m unless line_numer
+
+          lines      = contents.lines.to_a
+          indent     = ' #  '
+          indicator  = indent.gsub('#', '>')
+          first_line = (line_numer.zero?)
+          last_line  = (line_numer == (lines.count - 1))
+
+          m << "\n"
+          m << "#{indent}from #{trace_line.gsub(/:in.*$/, '')}\n"
+          m << "#{indent}-------------------------------------------\n"
+          m << "#{indent}#{    lines[line_numer - 1] }" unless first_line
+          m << "#{indicator}#{ lines[line_numer] }"
+          m << "#{indent}#{    lines[line_numer + 1] }" unless last_line
+          m << "\n" unless m.end_with?("\n")
+          m << "#{indent}-------------------------------------------\n"
+        end
+      end
+
+      private
+
+      def parse_line_number_from_description
+        description = self.description
+        if dsl_path && description =~ /((#{Regexp.quote File.expand_path(dsl_path)}|#{Regexp.quote dsl_path.to_s}):\d+)/
+          trace_line = Regexp.last_match[1]
+          description = description.sub(/#{Regexp.quote trace_line}:\s*/, '').sub("\n", ' - ')
+        end
+        [trace_line, description]
+      end
+    end
+
   end
+
 end

data/lib/bundler/endpoint_specification.rb

@@ -4,7 +4,7 @@ module Bundler
     include MatchPlatform
 
     attr_reader :name, :version, :platform, :dependencies
-    attr_accessor :source, :source_uri
+    attr_accessor :source, :remote
 
     def initialize(name, version, platform, dependencies)
       @name         = name

data/lib/bundler/fetcher.rb

@@ -1,11 +1,15 @@
 require 'bundler/vendored_persistent'
-require 'securerandom'
 require 'cgi'
+require 'securerandom'
 
 module Bundler
 
   # Handles all the fetching with the rubygems server
   class Fetcher
+    autoload :Downloader, 'bundler/fetcher/downloader'
+    autoload :Dependency, 'bundler/fetcher/dependency'
+    autoload :Index, 'bundler/fetcher/index'
+
     # This error is raised when it looks like the network is down
     class NetworkDownError < HTTPError; end
     # This error is raised if the API returns a 413 (only printed in verbose)
@@ -52,97 +56,21 @@ module Bundler
 
     class << self
       attr_accessor :disable_endpoint, :api_timeout, :redirect_limit, :max_retries
-
-      def download_gem_from_uri(spec, uri)
-        spec.fetch_platform
-
-        download_path = Bundler.requires_sudo? ? Bundler.tmp(spec.full_name) : Bundler.rubygems.gem_dir
-        gem_path = "#{Bundler.rubygems.gem_dir}/cache/#{spec.full_name}.gem"
-
-        FileUtils.mkdir_p("#{download_path}/cache")
-        Bundler.rubygems.download_gem(spec, uri, download_path)
-
-        if Bundler.requires_sudo?
-          Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/cache"
-          Bundler.sudo "mv #{download_path}/cache/#{spec.full_name}.gem #{gem_path}"
-        end
-
-        gem_path
-      ensure
-        Bundler.rm_rf(download_path) if Bundler.requires_sudo?
-      end
-
-      def user_agent
-        @user_agent ||= begin
-          ruby = Bundler.ruby_version
-
-          agent = "bundler/#{Bundler::VERSION}"
-          agent << " rubygems/#{Gem::VERSION}"
-          agent << " ruby/#{ruby.version}"
-          agent << " (#{ruby.host})"
-          agent << " command/#{ARGV.first}"
-
-          if ruby.engine != "ruby"
-            # engine_version raises on unknown engines
-            engine_version = ruby.engine_version rescue "???"
-            agent << " #{ruby.engine}/#{engine_version}"
-          end
-
-          agent << " options/#{Bundler.settings.all.join(",")}"
-
-          # add a random ID so we can consolidate runs server-side
-          agent << " " << SecureRandom.hex(8)
-
-          # add any user agent strings set in the config
-          extra_ua = Bundler.settings[:user_agent]
-          agent << " " << extra_ua if extra_ua
-
-          agent
-        end
-      end
-
     end
 
-    def initialize(remote_uri)
-      @redirect_limit = 5  # How many redirects to allow in one request
-      @api_timeout    = 10 # How long to wait for each API call
-      @max_retries    = 3  # How many retries for the API call
+    self.redirect_limit = Bundler.settings[:redirect]  # How many redirects to allow in one request
+    self.api_timeout    = Bundler.settings[:timeout] # How long to wait for each API call
+    self.max_retries    = Bundler.settings[:retry] # How many retries for the API call
 
-      @anonymizable_uri = configured_uri_for(remote_uri)
+    def initialize(remote)
+      @remote = remote
 
       Socket.do_not_reverse_lookup = true
       connection # create persistent connection
     end
 
-    def connection
-      @connection ||= begin
-        needs_ssl = remote_uri.scheme == "https" ||
-          Bundler.settings[:ssl_verify_mode] ||
-          Bundler.settings[:ssl_client_cert]
-        raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
-
-        con = Net::HTTP::Persistent.new 'bundler', :ENV
-
-        if remote_uri.scheme == "https"
-          con.verify_mode = (Bundler.settings[:ssl_verify_mode] ||
-            OpenSSL::SSL::VERIFY_PEER)
-          con.cert_store = bundler_cert_store
-        end
-
-        if Bundler.settings[:ssl_client_cert]
-          pem = File.read(Bundler.settings[:ssl_client_cert])
-          con.cert = OpenSSL::X509::Certificate.new(pem)
-          con.key  = OpenSSL::PKey::RSA.new(pem)
-        end
-
-        con.read_timeout = @api_timeout
-        con.override_headers["User-Agent"] = self.class.user_agent
-        con
-      end
-    end
-
     def uri
-      @anonymizable_uri.without_credentials
+      @remote.anonymized_uri
     end
 
     # fetch a gem specification
@@ -156,37 +84,26 @@ module Bundler
       elsif cached_spec_path = gemspec_cached_path(spec_file_name)
         Bundler.load_gemspec(cached_spec_path)
       else
-        Bundler.load_marshal Gem.inflate(fetch(uri))
+        Bundler.load_marshal Gem.inflate(downloader.fetch uri)
       end
     rescue MarshalError
       raise HTTPError, "Gemspec #{spec} contained invalid data.\n" \
         "Your network or your gem server is probably having issues right now."
     end
 
-    # cached gem specification path, if one exists
-    def gemspec_cached_path spec_file_name
-      paths = Bundler.rubygems.spec_cache_dirs.map { |dir| File.join(dir, spec_file_name) }
-      paths = paths.select {|path| File.file? path }
-      paths.first
-    end
-
     # return the specs in the bundler format as an index
     def specs(gem_names, source)
       old = Bundler.rubygems.sources
-      index = Index.new
-
-      if gem_names && use_api
-        specs = fetch_remote_specs(gem_names)
-      end
-
-      if specs.nil?
-        # API errors mean we should treat this as a non-API source
-        @use_api = false
+      index = Bundler::Index.new
 
-        specs = Bundler::Retry.new("source fetch", AUTH_ERRORS).attempts do
-          fetch_all_remote_specs
+      specs = {}
+      fetchers.dup.each do |f|
+        unless f.api_fetcher? && !gem_names
+          break if specs = f.specs(gem_names)
         end
+        fetchers.delete(f)
       end
+      @use_api = false if fetchers.none?(&:api_fetcher?)
 
       specs[remote_uri].each do |name, version, platform, dependencies|
         next if name == 'bundler'
@@ -197,189 +114,111 @@ module Bundler
           spec = RemoteSpecification.new(name, version, platform, self)
         end
         spec.source = source
-        spec.source_uri = @anonymizable_uri
+        spec.remote = @remote
         index << spec
       end
 
       index
-    rescue CertificateFailureError => e
+    rescue CertificateFailureError
       Bundler.ui.info "" if gem_names && use_api # newline after dots
-      raise e
+      raise
     ensure
       Bundler.rubygems.sources = old
     end
 
-    # fetch index
-    def fetch_remote_specs(gem_names, full_dependency_list = [], last_spec_list = [])
-      query_list = gem_names - full_dependency_list
-
-      # only display the message on the first run
-      if Bundler.ui.debug?
-        Bundler.ui.debug "Query List: #{query_list.inspect}"
-      else
-        Bundler.ui.info ".", false
-      end
-
-      return {remote_uri => last_spec_list} if query_list.empty?
-
-      remote_specs = Bundler::Retry.new("dependency api", AUTH_ERRORS).attempts do
-        fetch_dependency_remote_specs(query_list)
-      end
-
-      spec_list, deps_list = remote_specs
-      returned_gems = spec_list.map {|spec| spec.first }.uniq
-      fetch_remote_specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list)
-    rescue HTTPError, MarshalError, GemspecError
-      Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over
-      Bundler.ui.debug "could not fetch from the dependency API, trying the full index"
-      @use_api = false
-      return nil
-    end
-
     def use_api
       return @use_api if defined?(@use_api)
 
       if remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
         @use_api = false
-      elsif fetch(dependency_api_uri)
-        @use_api = true
+      else
+        fetchers.reject! { |f| f.api_fetcher? && !f.api_available? }
+        @use_api = fetchers.any?(&:api_fetcher?)
       end
-    rescue NetworkDownError => e
-      raise HTTPError, e.message
-    rescue AuthenticationRequiredError
-      # We got a 401 from the server. Don't fall back to the full index, just fail.
-      raise
-    rescue HTTPError
-      @use_api = false
     end
 
-    def inspect
-      "#<#{self.class}:0x#{object_id} uri=#{uri}>"
-    end
+    def user_agent
+      @user_agent ||= begin
+        ruby = Bundler.ruby_version
 
-  private
+        agent = "bundler/#{Bundler::VERSION}"
+        agent << " rubygems/#{Gem::VERSION}"
+        agent << " ruby/#{ruby.version}"
+        agent << " (#{ruby.host})"
+        agent << " command/#{ARGV.first}"
 
-    HTTP_ERRORS = [
-      Timeout::Error, EOFError, SocketError, Errno::ENETDOWN,
-      Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
-      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
-      Net::HTTP::Persistent::Error
-    ]
+        if ruby.engine != "ruby"
+          # engine_version raises on unknown engines
+          engine_version = ruby.engine_version rescue "???"
+          agent << " #{ruby.engine}/#{engine_version}"
+        end
 
-    def fetch(uri, counter = 0)
-      raise HTTPError, "Too many redirects" if counter >= @redirect_limit
+        agent << " options/#{Bundler.settings.all.join(",")}"
 
-      response = request(uri)
-      Bundler.ui.debug("HTTP #{response.code} #{response.message}")
+        # add a random ID so we can consolidate runs server-side
+        agent << " " << SecureRandom.hex(8)
 
-      case response
-      when Net::HTTPRedirection
-        new_uri = URI.parse(response["location"])
-        if new_uri.host == uri.host
-          new_uri.user = uri.user
-          new_uri.password = uri.password
-        end
-        fetch(new_uri, counter + 1)
-      when Net::HTTPSuccess
-        response.body
-      when Net::HTTPRequestEntityTooLarge
-        raise FallbackError, response.body
-      when Net::HTTPUnauthorized
-        raise AuthenticationRequiredError, remote_uri.host
-      else
-        raise HTTPError, "#{response.class}: #{response.body}"
+        # add any user agent strings set in the config
+        extra_ua = Bundler.settings[:user_agent]
+        agent << " " << extra_ua if extra_ua
+
+        agent
       end
     end
 
-    def request(uri)
-      Bundler.ui.debug "HTTP GET #{uri}"
-      req = Net::HTTP::Get.new uri.request_uri
-      if uri.user
-        user = CGI.unescape(uri.user)
-        password = uri.password ? CGI.unescape(uri.password) : nil
-        req.basic_auth(user, password)
-      end
-      connection.request(uri, req)
-    rescue OpenSSL::SSL::SSLError
-      raise CertificateFailureError.new(uri)
-    rescue *HTTP_ERRORS => e
-      Bundler.ui.trace e
-      case e.message
-      when /host down:/, /getaddrinfo: nodename nor servname provided/
-        raise NetworkDownError, "Could not reach host #{uri.host}. Check your network " \
-        "connection and try again."
-      else
-        raise HTTPError, "Network error while fetching #{uri}"
-      end
+    def fetchers
+      @fetchers ||= FETCHERS.map { |f| f.new(downloader, remote_uri, fetch_uri, uri) }
     end
 
-    def dependency_api_uri(gem_names = [])
-      uri = fetch_uri + "api/v1/dependencies"
-      uri.query = "gems=#{URI.encode(gem_names.join(","))}" if gem_names.any?
-      uri
+    def inspect
+      "#<#{self.class}:0x#{object_id} uri=#{uri}>"
     end
 
-    # fetch from Gemcutter Dependency Endpoint API
-    def fetch_dependency_remote_specs(gem_names)
-      Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(',')}"
-      gem_list = []
-      deps_list = []
+  private
 
-      gem_names.each_slice(Source::Rubygems::API_REQUEST_SIZE) do |names|
-        marshalled_deps = fetch dependency_api_uri(names)
-        gem_list += Bundler.load_marshal(marshalled_deps)
-      end
+    FETCHERS = [Dependency, Index]
 
-      spec_list = gem_list.map do |s|
-        dependencies = s[:dependencies].map do |name, requirement|
-          dep = well_formed_dependency(name, requirement.split(", "))
-          deps_list << dep.name
-          dep
-        end
+    def connection
+      @connection ||= begin
+        needs_ssl = remote_uri.scheme == "https" ||
+          Bundler.settings[:ssl_verify_mode] ||
+          Bundler.settings[:ssl_client_cert]
+        raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
 
-        [s[:name], Gem::Version.new(s[:number]), s[:platform], dependencies]
-      end
+        con = Net::HTTP::Persistent.new 'bundler', :ENV
 
-      [spec_list, deps_list.uniq]
-    end
+        if remote_uri.scheme == "https"
+          con.verify_mode = (Bundler.settings[:ssl_verify_mode] ||
+            OpenSSL::SSL::VERIFY_PEER)
+          con.cert_store = bundler_cert_store
+        end
 
-    # fetch from modern index: specs.4.8.gz
-    def fetch_all_remote_specs
-      old_sources = Bundler.rubygems.sources
-      Bundler.rubygems.sources = [remote_uri.to_s]
-      Bundler.rubygems.fetch_all_remote_specs
-    rescue Gem::RemoteFetcher::FetchError, OpenSSL::SSL::SSLError => e
-      case e.message
-      when /certificate verify failed/
-        raise CertificateFailureError.new(uri)
-      when /401/
-        raise AuthenticationRequiredError, remote_uri
-      when /403/
-        if remote_uri.userinfo
-          raise BadAuthenticationError, remote_uri
-        else
-          raise AuthenticationRequiredError, remote_uri
+        if Bundler.settings[:ssl_client_cert]
+          pem = File.read(Bundler.settings[:ssl_client_cert])
+          con.cert = OpenSSL::X509::Certificate.new(pem)
+          con.key  = OpenSSL::PKey::RSA.new(pem)
         end
-      else
-        Bundler.ui.trace e
-        raise HTTPError, "Could not fetch specs from #{uri}"
+
+        con.read_timeout = Fetcher.api_timeout
+        con.override_headers["User-Agent"] = user_agent
+        con
       end
-    ensure
-      Bundler.rubygems.sources = old_sources
     end
 
-    def well_formed_dependency(name, *requirements)
-      Gem::Dependency.new(name, *requirements)
-    rescue ArgumentError => e
-      illformed = 'Ill-formed requirement ["#<YAML::Syck::DefaultKey'
-      raise e unless e.message.include?(illformed)
-      puts # we shouldn't print the error message on the "fetching info" status line
-      raise GemspecError,
-        "Unfortunately, the gem #{s[:name]} (#{s[:number]}) has an invalid " \
-        "gemspec. \nPlease ask the gem author to yank the bad version to fix " \
-        "this issue. For more information, see http://bit.ly/syck-defaultkey."
+    # cached gem specification path, if one exists
+    def gemspec_cached_path spec_file_name
+      paths = Bundler.rubygems.spec_cache_dirs.map { |dir| File.join(dir, spec_file_name) }
+      paths = paths.select {|path| File.file? path }
+      paths.first
     end
 
+    HTTP_ERRORS = [
+      Timeout::Error, EOFError, SocketError, Errno::ENETDOWN,
+      Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
+      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
+      Net::HTTP::Persistent::Error
+    ]
+
     def bundler_cert_store
       store = OpenSSL::X509::Store.new
       if Bundler.settings[:ssl_ca_cert]
@@ -398,12 +237,6 @@ module Bundler
 
   private
 
-    def configured_uri_for(uri)
-      uri = Bundler::Source.mirror_for(uri)
-      config_auth = Bundler.settings[uri.to_s] || Bundler.settings[uri.host]
-      AnonymizableURI.new(uri, config_auth)
-    end
-
     def fetch_uri
       @fetch_uri ||= begin
         if remote_uri.host == "rubygems.org"
@@ -417,7 +250,12 @@ module Bundler
     end
 
     def remote_uri
-      @anonymizable_uri.original_uri
+      @remote.uri
+    end
+
+    def downloader
+      @downloader ||= Downloader.new(connection, self.class.redirect_limit)
     end
+
   end
 end