bundler 1.3.6 → 1.4.0.pre.1

data/lib/bundler/runtime.rb

@@ -50,6 +50,7 @@ module Bundler
       /^Missing \w+ (?:file\s*)?([^\s]+.rb)$/i,
       /^Missing API definition file in (.+)$/i,
       /^cannot load such file -- (.+)$/i,
+      /^dlopen\([^)]*\): Library not loaded: (.+)$/i,
     ]
 
     def require(*groups)
@@ -68,6 +69,8 @@ module Bundler
           # dependency. If there are none, use the dependency's name
           # as the autorequire.
           Array(dep.autorequire || dep.name).each do |file|
+            # Allow `require: true` as an alias for `require: <name>`
+            file = dep.name if file == true
             required_file = file
             Kernel.require file
           end
@@ -224,9 +227,13 @@ module Bundler
       rubyopt = [ENV["RUBYOPT"]].compact
       if rubyopt.empty? || rubyopt.first !~ /-rbundler\/setup/
         rubyopt.unshift %|-rbundler/setup|
-        rubyopt.unshift %|-I#{File.expand_path('../..', __FILE__)}|
         ENV["RUBYOPT"] = rubyopt.join(' ')
       end
+
+      # Set RUBYLIB
+      rubylib = (ENV["RUBYLIB"] || "").split(File::PATH_SEPARATOR)
+      rubylib.unshift File.expand_path('../..', __FILE__)
+      ENV["RUBYLIB"] = rubylib.uniq.join(File::PATH_SEPARATOR)
     end
 
   private

data/lib/bundler/safe_catch.rb

@@ -0,0 +1,101 @@
+# SafeCatch provides a mechanism to safely deepen the stack, performing
+# stack-unrolling similar to catch/throw, but using Fiber or Thread to avoid
+# deepening the stack too quickly.
+#
+# The API is the same as that of catch/throw: SafeCatch#safe_catch takes a "tag"
+# to be rescued when some code deeper in the process raises it. If the catch
+# block completes successfully, that value is returned. If the tag is "thrown"
+# by safe_throw, the tag's value is returned. Other exceptions propagate out as
+# normal.
+#
+# The implementation, however, uses fibers or threads along with raise/rescue to
+# handle "deepening" the stack and unrolling it. On implementations where Fiber
+# is available, it will be used. If Fiber is not available, Thread will be used.
+# If neither of these classes are available, Proc will be used, effectively
+# deepening the stack for each recursion as in normal catch/throw.
+#
+# In order to avoid causing a new issue of creating too many fibers or threads,
+# especially on implementations where fibers are actually backed by native
+# threads, the "safe" recursion mechanism is only used every 20 recursions.
+# Based on experiments with JRuby (which seems to suffer the most from
+# excessively deep stacks), this appears to be a sufficient granularity to
+# prevent stack overflow without spinning up excessive numbers of fibers or
+# threads. This value can be adjusted with the BUNDLER_SAFE_RECURSE_EVERY env
+# var; setting it to zero effectively disables safe recursion.
+
+module Bundler
+  module SafeCatch
+    def safe_catch(tag, &block)
+      if Bundler.current_ruby.jruby?
+        Internal.catch(tag, &block)
+      else
+        catch(tag, &block)
+      end
+    end
+
+    def safe_throw(tag, value = nil)
+      if Bundler.current_ruby.jruby?
+        Internal.throw(tag, value)
+      else
+        throw(tag, value)
+      end
+    end
+
+    module Internal
+      SAFE_RECURSE_EVERY = (ENV['BUNDLER_SAFE_RECURSE_EVERY'] || 20).to_i
+
+      SAFE_RECURSE_CLASS, SAFE_RECURSE_START = case
+      when defined?(Fiber)
+        [Fiber, :resume]
+      when defined?(Thread)
+        [Thread, :join]
+      else
+        [Proc, :call]
+      end
+
+      @recurse_count = 0
+
+      def self.catch(tag, &block)
+        @recurse_count += 1
+        if SAFE_RECURSE_EVERY >= 0 && @recurse_count % SAFE_RECURSE_EVERY == 0
+          SAFE_RECURSE_CLASS.new(&block).send(SAFE_RECURSE_START)
+        else
+          block.call
+        end
+      rescue Result.matcher(tag)
+        $!.value
+      end
+
+      def self.throw(tag, value = nil)
+        raise Result.new(tag, value)
+      end
+
+      class Result < StopIteration
+        def initialize(tag, value)
+          @tag = tag
+          @value = value
+        end
+
+        attr_reader :tag, :value
+
+        # The Matcher class is never instantiated; it is dup'ed and used as a
+        # rescue-clause argument to match Result exceptions based on their tags.
+        module Matcher
+          class << self
+            attr_accessor :tag
+
+            def ===(other)
+              other.respond_to? :tag and @tag.equal? other.tag
+            end
+          end
+        end
+
+        def self.matcher(tag)
+          matcher = Matcher.dup
+          matcher.tag = tag
+          matcher
+        end
+      end
+    end
+  end
+end

data/lib/bundler/shared_helpers.rb

@@ -1,7 +1,9 @@
 require 'pathname'
 require 'rubygems'
 
+require 'bundler/constants'
 require 'bundler/rubygems_integration'
+require 'bundler/current_ruby'
 
 module Gem
   class Dependency
@@ -31,6 +33,30 @@ module Bundler
       find_gemfile
     end
 
+    if Bundler.current_ruby.mswin? || Bundler.current_ruby.jruby?
+      require 'monitor'
+      @chdir_monitor = Monitor.new
+      def chdir(dir, &blk)
+        @chdir_monitor.synchronize do
+          Dir.chdir dir, &blk
+        end
+      end
+
+      def pwd
+        @chdir_monitor.synchronize do
+          Dir.pwd
+        end
+      end
+    else
+      def chdir(dir, &blk)
+        Dir.chdir dir, &blk
+      end
+
+      def pwd
+        Dir.pwd
+      end
+    end
+
   private
 
     def find_gemfile
@@ -38,7 +64,7 @@ module Bundler
       return given if given && !given.empty?
 
       previous = nil
-      current  = File.expand_path(Dir.pwd)
+      current  = File.expand_path(SharedHelpers.pwd)
 
       until !File.directory?(current) || current == previous
         if ENV['BUNDLE_SPEC_RUN']

data/lib/bundler/source/git.rb

@@ -151,7 +151,7 @@ module Bundler
       end
 
       def install(spec)
-        Bundler.ui.info "Using #{spec.name} (#{spec.version}) from #{to_s} "
+        Bundler.ui.info "Using #{spec.name} (#{spec.version}) from #{to_s}"
         if requires_checkout? && !@copied
           Bundler.ui.debug "  * Checking out revision: #{ref}"
           git_proxy.copy_to(install_path, submodules)
@@ -159,6 +159,7 @@ module Bundler
           @copied = true
         end
         generate_bin(spec)
+        nil
       end
 
       def cache(spec)

data/lib/bundler/source/git/git_proxy.rb

@@ -58,7 +58,7 @@ module Bundler
             File.chmod((0777 & ~File.umask), destination)
           end
 
-          Dir.chdir(destination) do
+          SharedHelpers.chdir(destination) do
             git %|fetch --force --quiet --tags "#{path}"|
             git "reset --hard #{@revision}"
 
@@ -95,7 +95,7 @@ module Bundler
             out
           else
             raise GitError, "Bundler is trying to run a `git #{command}` at runtime. You probably need to run `bundle install`. However, " \
-                            "this error message could probably be more useful. Please submit a ticket at http://github.com/carlhuda/bundler/issues " \
+                            "this error message could probably be more useful. Please submit a ticket at http://github.com/bundler/bundler/issues " \
                             "with steps to reproduce as well as the following\n\nCALLER: #{caller.join("\n")}"
           end
         end
@@ -127,7 +127,7 @@ module Bundler
 
         def in_path(&blk)
           checkout unless path.exist?
-          Dir.chdir(path, &blk)
+          SharedHelpers.chdir(path, &blk)
         end
 
         def allowed_in_path

data/lib/bundler/source/path.rb

@@ -70,8 +70,9 @@ module Bundler
       end
 
       def install(spec)
-        Bundler.ui.info "Using #{spec.name} (#{spec.version}) from #{to_s} "
+        Bundler.ui.info "Using #{spec.name} (#{spec.version}) from #{to_s}"
         generate_bin(spec, :disable_extensions)
+        nil
       end
 
       def cache(spec)
@@ -189,7 +190,7 @@ module Bundler
         Bundler.ui.warn "The validation message from Rubygems was:\n  #{e.message}"
       ensure
         if gem_dir && gem_file
-          Dir.chdir(gem_dir){ FileUtils.rm_rf(gem_file) if File.exist?(gem_file) }
+          FileUtils.rm_rf(gem_dir.join gem_file)
         end
       end
 

data/lib/bundler/source/rubygems.rb

@@ -68,12 +68,12 @@ module Bundler
       end
 
       def install(spec)
-        if installed_specs[spec].any? && gem_dir_exists?(spec)
-          Bundler.ui.info "Using #{spec.name} (#{spec.version}) "
+        if installed_specs[spec].any?
+          Bundler.ui.info "Using #{spec.name} (#{spec.version})"
           return
         end
 
-        Bundler.ui.info "Installing #{spec.name} (#{spec.version}) "
+        Bundler.ui.info "Installing #{spec.name} (#{spec.version})"
         path = cached_gem(spec)
         if Bundler.requires_sudo?
           install_path = Bundler.tmp
@@ -94,10 +94,6 @@ module Bundler
           ).install
         end
 
-        if spec.post_install_message
-          Installer.post_install_messages[spec.name] = spec.post_install_message
-        end
-
         # SUDO HAX
         if Bundler.requires_sudo?
           Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/gems"
@@ -109,8 +105,10 @@ module Bundler
             Bundler.sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Bundler.system_bindir}"
           end
         end
+        Bundler.ui.info "Installed #{spec.name} (#{spec.version})"
         installed_spec.loaded_from = "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
         spec.loaded_from = "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
+        spec.post_install_message
       end
 
       def cache(spec)
@@ -250,16 +248,6 @@ module Bundler
           Bundler.rubygems.sources = old
         end
       end
-
-      def gem_dir_exists?(spec)
-        return true if spec.name == "bundler"
-        # Ruby 2 default gems
-        return true if spec.loaded_from.include?("specifications/default/")
-        # Ruby 1.9 default gems
-        return true if spec.summary =~ /is bundled with Ruby/
-
-        File.directory?(spec.full_gem_path)
-      end
     end
 
   end

data/lib/bundler/spec_set.rb

@@ -109,7 +109,22 @@ module Bundler
 
     def sorted
       rake = @specs.find { |s| s.name == 'rake' }
-      @sorted ||= ([rake] + tsort).compact.uniq
+      begin
+        @sorted ||= ([rake] + tsort).compact.uniq
+      rescue TSort::Cyclic => error
+        cgems = extract_circular_gems(error)
+        raise CyclicDependencyError, "Your Gemfile requires gems that depend" \
+          " depend on each other, creating an infinite loop. Please remove" \
+          " either gem '#{cgems[1]}' or gem '#{cgems[0]}' and try again."
+      end
+    end
+
+    def extract_circular_gems(error)
+      if Bundler.current_ruby.mri? && Bundler.current_ruby.on_19?
+        error.message.scan(/(\w+) \([^)]/).flatten
+      else
+        error.message.scan(/@name="(.*?)"/).flatten
+      end
     end
 
     def lookup

data/lib/bundler/templates/newgem/newgem.gemspec.tt

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = ""
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]

data/lib/bundler/vendor/net/http/persistent.rb

@@ -1,5 +1,9 @@
 require 'net/http'
-require 'net/https'
+begin
+  require 'net/https'
+rescue LoadError
+  # net/https or openssl
+end if RUBY_VERSION < '1.9' # but only for 1.8
 require 'net/http/faster'
 require 'uri'
 require 'cgi' # for escaping
@@ -9,6 +13,8 @@ begin
 rescue LoadError
 end
 
+autoload :OpenSSL, 'openssl'
+
 ##
 # Persistent connections for Net::HTTP
 #
@@ -37,6 +43,11 @@ end
 #   # perform a GET
 #   response = http.request uri
 #
+#   # or
+#
+#   get = Net::HTTP::Get.new uri.request_uri
+#   response = http.request get
+#
 #   # create a POST
 #   post_uri = uri + 'create'
 #   post = Net::HTTP::Post.new post_uri.path
@@ -45,6 +56,10 @@ end
 #   # perform the POST, the URI is always required
 #   response http.request post_uri, post
 #
+# Note that for GET, HEAD and other requests that do not have a body you want
+# to use URI#request_uri not URI#path.  The request_uri contains the query
+# params which are sent in the body for other requests.
+#
 # == SSL
 #
 # SSL connections are automatically created depending upon the scheme of the
@@ -105,6 +120,13 @@ end
 # The amount of time allowed between reading two chunks from the socket.  Set
 # through #read_timeout
 #
+# === Max Requests
+#
+# The number of requests that should be made before opening a new connection.
+# Typically many keep-alive capable servers tune this to 100 or less, so the
+# 101st request will fail with ECONNRESET. If unset (default), this value has no
+# effect, if set, connections will be reset on the request after max_requests.
+#
 # === Open Timeout
 #
 # The amount of time to wait for a connection to be opened.  Set through
@@ -173,10 +195,30 @@ class Net::HTTP::Persistent
 
   EPOCH = Time.at 0 # :nodoc:
 
+  ##
+  # Is OpenSSL available?  This test works with autoload
+
+  HAVE_OPENSSL = defined? OpenSSL::SSL # :nodoc:
+
   ##
   # The version of Net::HTTP::Persistent you are using
 
-  VERSION = '2.8'
+  VERSION = '2.9'
+
+  ##
+  # Exceptions rescued for automatic retry on ruby 2.0.0.  This overlaps with
+  # the exception list for ruby 1.x.
+
+  RETRIED_EXCEPTIONS = [ # :nodoc:
+    (Net::ReadTimeout if Net.const_defined? :ReadTimeout),
+    IOError,
+    EOFError,
+    Errno::ECONNRESET,
+    Errno::ECONNABORTED,
+    Errno::EPIPE,
+    (OpenSSL::SSL::SSLError if HAVE_OPENSSL),
+    Timeout::Error,
+  ].compact
 
   ##
   # Error class for errors raised by Net::HTTP::Persistent.  Various
@@ -226,6 +268,8 @@ class Net::HTTP::Persistent
       $stderr.puts "sleeping #{sleep_time}" if $DEBUG
       sleep sleep_time
     end
+  rescue
+    # ignore StandardErrors, we've probably found the idle timeout.
   ensure
     http.shutdown
 
@@ -287,6 +331,12 @@ class Net::HTTP::Persistent
 
   attr_accessor :idle_timeout
 
+  ##
+  # Maximum number of requests on a connection before it is considered expired
+  # and automatically closed.
+
+  attr_accessor :max_requests
+
   ##
   # The value sent in the Keep-Alive header.  Defaults to 30.  Not needed for
   # HTTP/1.1 servers.
@@ -442,6 +492,7 @@ class Net::HTTP::Persistent
     @open_timeout     = nil
     @read_timeout     = nil
     @idle_timeout     = 5
+    @max_requests     = nil
     @socket_options   = []
 
     @socket_options << [Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1] if
@@ -458,15 +509,22 @@ class Net::HTTP::Persistent
     @private_key        = nil
     @ssl_version        = nil
     @verify_callback    = nil
-    @verify_mode        = OpenSSL::SSL::VERIFY_PEER
+    @verify_mode        = nil
     @cert_store         = nil
 
     @generation         = 0 # incremented when proxy URI changes
     @ssl_generation     = 0 # incremented when SSL session variables change
-    @reuse_ssl_sessions = OpenSSL::SSL.const_defined? :Session
+
+    if HAVE_OPENSSL then
+      @verify_mode        = OpenSSL::SSL::VERIFY_PEER
+      @reuse_ssl_sessions = OpenSSL::SSL.const_defined? :Session
+    end
 
     @retry_change_requests = false
 
+    @ruby_1 = RUBY_VERSION < '2'
+    @retried_on_ruby_2 = !@ruby_1
+
     self.proxy = proxy if proxy
   end
 
@@ -536,6 +594,9 @@ class Net::HTTP::Persistent
     use_ssl = uri.scheme.downcase == 'https'
 
     if use_ssl then
+      raise Net::HTTP::Persistent::Error, 'OpenSSL is not available' unless
+        HAVE_OPENSSL
+
       ssl_generation = @ssl_generation
 
       ssl_cleanup ssl_generation
@@ -606,10 +667,12 @@ class Net::HTTP::Persistent
   end
 
   ##
-  # Returns true if the connection should be reset due to an idle timeout,
-  # false otherwise.
+  # Returns true if the connection should be reset due to an idle timeout, or
+  # maximum request count, false otherwise.
 
   def expired? connection
+    requests = Thread.current[@request_key][connection.object_id]
+    return true  if     @max_requests && requests >= @max_requests
     return false unless @idle_timeout
     return true  if     @idle_timeout.zero?
 
@@ -679,10 +742,15 @@ class Net::HTTP::Persistent
   end
 
   ##
-  # Is the request idempotent or is retry_change_requests allowed
+  # Is the request +req+ idempotent or is retry_change_requests allowed.
+  #
+  # If +retried_on_ruby_2+ is true, true will be returned if we are on ruby,
+  # retry_change_requests is allowed and the request is not idempotent.
 
-  def can_retry? req
-    retry_change_requests or idempotent?(req)
+  def can_retry? req, retried_on_ruby_2 = false
+    return @retry_change_requests && !idempotent?(req) if retried_on_ruby_2
+
+    @retry_change_requests || idempotent?(req)
   end
 
   if RUBY_VERSION > '1.9' then
@@ -901,31 +969,14 @@ class Net::HTTP::Persistent
   #
   # +req+ must be a Net::HTTPRequest subclass (see Net::HTTP for a list).
   #
-  # If there is an error and the request is idempontent according to RFC 2616
+  # If there is an error and the request is idempotent according to RFC 2616
   # it will be retried automatically.
 
   def request uri, req = nil, &block
     retried      = false
     bad_response = false
 
-    req = Net::HTTP::Get.new uri.request_uri unless req
-
-    @headers.each do |pair|
-      req.add_field(*pair)
-    end
-
-    if uri.user or uri.password
-      req.basic_auth uri.user, uri.password
-    end
-
-    @override_headers.each do |name, value|
-      req[name] = value
-    end
-
-    unless req['Connection'] then
-      req.add_field 'Connection', 'keep-alive'
-      req.add_field 'Keep-Alive', @keep_alive
-    end
+    req = request_setup req || uri
 
     connection = connection_for uri
     connection_id = connection.object_id
@@ -950,23 +1001,25 @@ class Net::HTTP::Persistent
 
       bad_response = true
       retry
-    rescue IOError, EOFError, Timeout::Error,
-           Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
-           Errno::EINVAL, OpenSSL::SSL::SSLError => e
-
-      if retried or not can_retry? req
-        due_to = "(due to #{e.message} - #{e.class})"
-        message = error_message connection
+    rescue *RETRIED_EXCEPTIONS => e # retried on ruby 2
+      request_failed e, req, connection if
+        retried or not can_retry? req, @retried_on_ruby_2
 
-        finish connection
+      reset connection
 
-        raise Error, "too many connection resets #{due_to} #{message}"
-      end
+      retried = true
+      retry
+    rescue Errno::EINVAL, Errno::ETIMEDOUT => e # not retried on ruby 2
+      request_failed e, req, connection if retried or not can_retry? req
 
       reset connection
 
       retried = true
       retry
+    rescue Exception => e
+      finish connection
+
+      raise
     ensure
       Thread.current[@timeout_key][connection_id] = Time.now
     end
@@ -976,6 +1029,51 @@ class Net::HTTP::Persistent
     response
   end
 
+  ##
+  # Raises an Error for +exception+ which resulted from attempting the request
+  # +req+ on the +connection+.
+  #
+  # Finishes the +connection+.
+
+  def request_failed exception, req, connection # :nodoc:
+    due_to = "(due to #{exception.message} - #{exception.class})"
+    message = "too many connection resets #{due_to} #{error_message connection}"
+
+    finish connection
+
+
+    raise Error, message, exception.backtrace
+  end
+
+  ##
+  # Creates a GET request if +req_or_uri+ is a URI and adds headers to the
+  # request.
+  #
+  # Returns the request.
+
+  def request_setup req_or_uri # :nodoc:
+    req = if URI === req_or_uri then
+            Net::HTTP::Get.new req_or_uri.request_uri
+          else
+            req_or_uri
+          end
+
+    @headers.each do |pair|
+      req.add_field(*pair)
+    end
+
+    @override_headers.each do |name, value|
+      req[name] = value
+    end
+
+    unless req['Connection'] then
+      req.add_field 'Connection', 'keep-alive'
+      req.add_field 'Keep-Alive', @keep_alive
+    end
+
+    req
+  end
+
   ##
   # Shuts down all connections for +thread+.
   #