bundler 1.10.6 → 1.11.0.pre.1

data/lib/bundler/environment.rb

@@ -6,7 +6,7 @@ module Bundler
       @root = root
       @definition = definition
 
-      env_file = Bundler.app_config_path.join('environment.rb')
+      env_file = Bundler.app_config_path.join("environment.rb")
       env_file.rmtree if env_file.exist?
     end
 
@@ -37,6 +37,5 @@ module Bundler
     def update(*gems)
       # Nothing
     end
-
   end
 end

data/lib/bundler/errors.rb

@@ -0,0 +1,82 @@
+module Bundler
+  class BundlerError < StandardError
+    def self.status_code(code)
+      define_method(:status_code) { code }
+    end
+  end
+
+  class GemfileNotFound < BundlerError; status_code(10); end
+  class GemNotFound < BundlerError; status_code(7); end
+  class GemfileError < BundlerError; status_code(4); end
+  class InstallError < BundlerError; status_code(5); end
+  class InstallHookError < BundlerError; status_code(8); end
+  class PathError < BundlerError; status_code(13); end
+  class GitError < BundlerError; status_code(11); end
+  class DeprecatedError < BundlerError; status_code(12); end
+  class GemspecError < BundlerError; status_code(14); end
+  class InvalidOption < BundlerError; status_code(15); end
+  class ProductionError < BundlerError; status_code(16); end
+  class HTTPError < BundlerError; status_code(17); end
+  class RubyVersionMismatch < BundlerError; status_code(18); end
+  class SecurityError < BundlerError; status_code(19); end
+  class LockfileError < BundlerError; status_code(20); end
+  class CyclicDependencyError < BundlerError; status_code(21); end
+  class GemfileLockNotFound < BundlerError; status_code(22); end
+  class GemfileEvalError < GemfileError; end
+  class MarshalError < StandardError; end
+
+  # Internal errors, should be rescued
+  class VersionConflict < BundlerError
+    attr_reader :conflicts
+
+    def initialize(conflicts, msg = nil)
+      super(msg)
+      @conflicts = conflicts
+    end
+
+    status_code(6)
+  end
+
+  class GemRequireError < BundlerError
+    attr_reader :orig_exception
+
+    def initialize(orig_exception, msg)
+      super(msg)
+      @orig_exception = orig_exception
+    end
+
+    status_code(24)
+  end
+
+  class PermissionError < BundlerError
+    def initialize(path, permission_type = :write)
+      @path = path
+      @permission_type = permission_type
+    end
+
+    def message
+      action = case @permission_type
+               when :read then "read from"
+               when :write then "write to"
+               when :executable, :exec then "execute"
+               else @permission_type.to_s
+      end
+      "There was an error while trying to #{action} `#{@path}`. " \
+      "It is likely that you need to grant #{@permission_type} permissions " \
+      "for that path."
+    end
+
+    status_code(23)
+  end
+
+  class YAMLSyntaxError < BundlerError
+    attr_reader :orig_exception
+
+    def initialize(orig_exception, msg)
+      super(msg)
+      @orig_exception = orig_exception
+    end
+
+    status_code(25)
+  end
+end

data/lib/bundler/fetcher.rb

@@ -1,14 +1,14 @@
-require 'bundler/vendored_persistent'
-require 'cgi'
-require 'securerandom'
+require "bundler/vendored_persistent"
+require "cgi"
+require "securerandom"
+require "zlib"
 
 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'
+    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
@@ -21,7 +21,7 @@ module Bundler
           " is a chance you are experiencing a man-in-the-middle attack, but" \
           " most likely your system doesn't have the CA certificates needed" \
           " for verification. For information about OpenSSL certificates, see" \
-          " bit.ly/ruby-ssl. To connect without using SSL, edit your Gemfile" \
+          " http://bit.ly/ruby-ssl. To connect without using SSL, edit your Gemfile" \
           " sources and change 'https' to 'http'."
       end
     end
@@ -58,7 +58,7 @@ module Bundler
       attr_accessor :disable_endpoint, :api_timeout, :redirect_limit, :max_retries
     end
 
-    self.redirect_limit = Bundler.settings[:redirect]  # How many redirects to allow in one request
+    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
 
@@ -75,11 +75,11 @@ module Bundler
 
     # fetch a gem specification
     def fetch_spec(spec)
-      spec = spec - [nil, 'ruby', '']
-      spec_file_name = "#{spec.join '-'}.gemspec"
+      spec -= [nil, "ruby", ""]
+      spec_file_name = "#{spec.join "-"}.gemspec"
 
       uri = URI.parse("#{remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}.rz")
-      if uri.scheme == 'file'
+      if uri.scheme == "file"
         Bundler.load_marshal Gem.inflate(Gem.read_binary(uri.path))
       elsif cached_spec_path = gemspec_cached_path(spec_file_name)
         Bundler.load_gemspec(cached_spec_path)
@@ -91,6 +91,13 @@ module Bundler
         "Your network or your gem server is probably having issues right now."
     end
 
+    # return the specs in the bundler format as an index with retries
+    def specs_with_retry(gem_names, source)
+      Bundler::Retry.new("fetcher").attempts do
+        specs(gem_names, source)
+      end
+    end
+
     # return the specs in the bundler format as an index
     def specs(gem_names, source)
       old = Bundler.rubygems.sources
@@ -98,15 +105,13 @@ module Bundler
 
       specs = {}
       fetchers.dup.each do |f|
-        unless f.api_fetcher? && !gem_names
-          break if specs = f.specs(gem_names)
-        end
+        break unless f.api_fetcher? && !gem_names || !specs = f.specs(gem_names)
         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'
+        next if name == "bundler"
         spec = nil
         if dependencies
           spec = EndpointSpecification.new(name, version, platform, dependencies)
@@ -132,7 +137,7 @@ module Bundler
       if remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
         @use_api = false
       else
-        fetchers.reject! { |f| f.api_fetcher? && !f.api_available? }
+        fetchers.reject! {|f| f.api_fetcher? && !f.api_available? }
         @use_api = fetchers.any?(&:api_fetcher?)
       end
     end
@@ -149,7 +154,11 @@ module Bundler
 
         if ruby.engine != "ruby"
           # engine_version raises on unknown engines
-          engine_version = ruby.engine_version rescue "???"
+          engine_version = begin
+                             ruby.engine_version
+                           rescue
+                             "???"
+                           end
           agent << " #{ruby.engine}/#{engine_version}"
         end
 
@@ -169,7 +178,13 @@ module Bundler
     end
 
     def fetchers
-      @fetchers ||= FETCHERS.map { |f| f.new(downloader, remote_uri, fetch_uri, uri) }
+      @fetchers ||= FETCHERS.map {|f| f.new(downloader, @remote, uri) }
+    end
+
+    def http_proxy
+      if uri = connection.proxy_uri
+        uri.to_s
+      end
     end
 
     def inspect
@@ -192,7 +207,7 @@ module Bundler
         "CI_NAME" => ENV["CI_NAME"],
         "CI" => "ci"
       }
-      env_cis.find_all{ |env, ci| ENV[env]}.map{ |env, ci| ci }
+      env_cis.find_all {|env, _| ENV[env] }.map {|_, ci| ci }
     end
 
     def connection
@@ -202,7 +217,10 @@ module Bundler
           Bundler.settings[:ssl_client_cert]
         raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
 
-        con = Net::HTTP::Persistent.new 'bundler', :ENV
+        con = Net::HTTP::Persistent.new "bundler", :ENV
+        if gem_proxy = Bundler.rubygems.configuration[:http_proxy]
+          con.proxy = URI.parse(gem_proxy)
+        end
 
         if remote_uri.scheme == "https"
           con.verify_mode = (Bundler.settings[:ssl_verify_mode] ||
@@ -218,22 +236,23 @@ module Bundler
 
         con.read_timeout = Fetcher.api_timeout
         con.override_headers["User-Agent"] = user_agent
+        con.override_headers["X-Gemfile-Source"] = @remote.original_uri.to_s if @remote.original_uri
         con
       end
     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) }
+    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,
+      Timeout::Error, EOFError, SocketError, Errno::ENETDOWN, Errno::ENETUNREACH,
       Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
       Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
-      Net::HTTP::Persistent::Error
+      Net::HTTP::Persistent::Error, Zlib::BufError
     ]
 
     def bundler_cert_store
@@ -247,25 +266,13 @@ module Bundler
       else
         store.set_default_paths
         certs = File.expand_path("../ssl_certs/*.pem", __FILE__)
-        Dir.glob(certs).each { |c| store.add_file c }
+        Dir.glob(certs).each {|c| store.add_file c }
       end
       store
     end
 
   private
 
-    def fetch_uri
-      @fetch_uri ||= begin
-        if remote_uri.host == "rubygems.org"
-          uri = remote_uri.dup
-          uri.host = "bundler.rubygems.org"
-          uri
-        else
-          remote_uri
-        end
-      end
-    end
-
     def remote_uri
       @remote.uri
     end
@@ -273,6 +280,5 @@ module Bundler
     def downloader
       @downloader ||= Downloader.new(connection, self.class.redirect_limit)
     end
-
   end
 end

data/lib/bundler/fetcher/base.rb

@@ -2,18 +2,32 @@ module Bundler
   class Fetcher
     class Base
       attr_reader :downloader
-      attr_reader :remote_uri
-      attr_reader :fetch_uri
       attr_reader :display_uri
+      attr_reader :remote
 
-      def initialize(downloader, remote_uri, fetch_uri, display_uri)
-        raise 'Abstract class' if self.class == Base
+      def initialize(downloader, remote, display_uri)
+        raise "Abstract class" if self.class == Base
         @downloader = downloader
-        @remote_uri = remote_uri
-        @fetch_uri = fetch_uri
+        @remote = remote
         @display_uri = display_uri
       end
 
+      def remote_uri
+        @remote.uri
+      end
+
+      def fetch_uri
+        @fetch_uri ||= begin
+          if remote_uri.host == "rubygems.org"
+            uri = remote_uri.dup
+            uri.host = "bundler.rubygems.org"
+            uri
+          else
+            remote_uri
+          end
+        end
+      end
+
       def api_available?
         api_fetcher?
       end
@@ -21,7 +35,6 @@ module Bundler
       def api_fetcher?
         false
       end
-
     end
   end
 end

data/lib/bundler/fetcher/dependency.rb

@@ -1,4 +1,5 @@
-require 'bundler/fetcher/base'
+require "bundler/fetcher/base"
+require "cgi"
 
 module Bundler
   class Fetcher
@@ -27,7 +28,7 @@ module Bundler
           Bundler.ui.info ".", false
         end
 
-        return {remote_uri => last_spec_list} if query_list.empty?
+        return { remote_uri => last_spec_list } if query_list.empty?
 
         remote_specs = Bundler::Retry.new("dependency api", AUTH_ERRORS).attempts do
           dependency_specs(query_list)
@@ -43,7 +44,7 @@ module Bundler
       end
 
       def dependency_specs(gem_names)
-        Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(',')}"
+        Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(",")}"
         gem_list = []
         deps_list = []
 
@@ -67,7 +68,7 @@ module Bundler
 
       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.query = "gems=#{CGI.escape(gem_names.join(","))}" if gem_names.any?
         uri
       end
 
@@ -82,7 +83,6 @@ module Bundler
           "gemspec. \nPlease ask the gem author to yank the bad version to fix " \
           "this issue. For more information, see http://bit.ly/syck-defaultkey."
       end
-
     end
   end
 end

data/lib/bundler/fetcher/downloader.rb

@@ -55,7 +55,6 @@ module Bundler
           raise HTTPError, "Network error while fetching #{uri}"
         end
       end
-
     end
   end
-end
+end

data/lib/bundler/fetcher/index.rb

@@ -1,13 +1,12 @@
-require 'bundler/fetcher/base'
+require "bundler/fetcher/base"
+require "rubygems/remote_fetcher"
 
 module Bundler
   class Fetcher
     class Index < Base
       def specs(_gem_names)
-        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
+        Bundler.rubygems.fetch_all_remote_specs(remote)
+      rescue Gem::RemoteFetcher::FetchError, OpenSSL::SSL::SSLError, Net::HTTPFatalError => e
         case e.message
         when /certificate verify failed/
           raise CertificateFailureError.new(display_uri)
@@ -23,8 +22,6 @@ module Bundler
           Bundler.ui.trace e
           raise HTTPError, "Could not fetch specs from #{display_uri}"
         end
-      ensure
-        Bundler.rubygems.sources = old_sources
       end
     end
   end

data/lib/bundler/friendly_errors.rb

@@ -5,9 +5,17 @@ require "bundler/vendored_thor"
 module Bundler
   def self.with_friendly_errors
     yield
+  rescue YAMLSyntaxError => e
+    Bundler.ui.error e.message
+    Bundler.ui.trace e.orig_exception
+    exit e.status_code
   rescue Bundler::Dsl::DSLError => e
     Bundler.ui.error e.message
     exit e.status_code
+  rescue Bundler::GemRequireError => e
+    Bundler.ui.error e.message
+    Bundler.ui.trace e.orig_exception, nil, true
+    exit e.status_code
   rescue Bundler::BundlerError => e
     Bundler.ui.error e.message, :wrap => true
     Bundler.ui.trace e
@@ -43,11 +51,11 @@ module Bundler
   end
 
   def self.request_issue_report_for(e)
-    Bundler.ui.info <<-EOS.gsub(/^ {6}/, '')
-      #{'--- ERROR REPORT TEMPLATE -------------------------------------------------------'}
+    Bundler.ui.info <<-EOS.gsub(/^ {6}/, "")
+      --- ERROR REPORT TEMPLATE -------------------------------------------------------
       - What did you do?
 
-        I ran the command `#{$PROGRAM_NAME} #{ARGV.join(' ')}`
+        I ran the command `#{$PROGRAM_NAME} #{ARGV.join(" ")}`
 
       - What did you expect to happen?
 
@@ -63,14 +71,14 @@ module Bundler
           #{e.class}: #{e.message}
             #{e.backtrace.join("\n            ")}
 
-      #{Bundler::Env.new.report(:print_gemfile => false).gsub(/\n/, "\n      ").strip}
-      #{'--- TEMPLATE END ----------------------------------------------------------------'}
+      #{Bundler::Env.new.report(:print_gemfile => false, :print_gemspecs => false).gsub(/\n/, "\n      ").strip}
+      --- TEMPLATE END ----------------------------------------------------------------
 
     EOS
 
     Bundler.ui.error "Unfortunately, an unexpected error occurred, and Bundler cannot continue."
 
-    Bundler.ui.warn <<-EOS.gsub(/^ {6}/, '')
+    Bundler.ui.warn <<-EOS.gsub(/^ {6}/, "")
 
       First, try this link to see if there are any existing issue reports for this error:
       #{issues_url(e)}
@@ -81,8 +89,7 @@ module Bundler
   end
 
   def self.issues_url(exception)
-    'https://github.com/bundler/bundler/search?q=' \
+    "https://github.com/bundler/bundler/search?q=" \
     "#{CGI.escape(exception.message.lines.first.chomp)}&type=Issues"
   end
-
 end