bundler 1.15.2 → 2.4.12

data/lib/bundler/templates/newgem/standard.yml.tt

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: <%= ::Gem::Version.new(config[:required_ruby_version]).segments[0..1].join(".") %>

data/lib/bundler/templates/newgem/test/minitest/test_helper.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "<%= config[:namespaced_path] %>"
+
+require "minitest/autorun"

data/lib/bundler/templates/newgem/test/{newgem_test.rb.tt → minitest/test_newgem.rb.tt}

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
-class <%= config[:constant_name] %>Test < Minitest::Test
+class <%= config[:minitest_constant_name] %> < Minitest::Test
   def test_that_it_has_a_version_number
     refute_nil ::<%= config[:constant_name] %>::VERSION
   end

data/lib/bundler/templates/newgem/test/test-unit/newgem_test.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class <%= config[:constant_name] %>Test < Test::Unit::TestCase
+  test "VERSION" do
+    assert do
+      ::<%= config[:constant_name] %>.const_defined?(:VERSION)
+    end
+  end
+
+  test "something useful" do
+    assert_equal("expected", "actual")
+  end
+end

data/lib/bundler/templates/newgem/test/test-unit/test_helper.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "<%= config[:namespaced_path] %>"
+
+require "test-unit"

data/lib/bundler/ui/rg_proxy.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require "bundler/ui"
+
+require_relative "../ui"
 require "rubygems/user_interaction"
 
 module Bundler

data/lib/bundler/ui/shell.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
-require "bundler/vendored_thor"
+
+require_relative "../vendored_thor"
 
 module Bundler
   module UI
     class Shell
-      LEVELS = %w(silent error warn confirm info debug).freeze
+      LEVELS = %w[silent error warn confirm info debug].freeze
 
       attr_writer :shell
 
       def initialize(options = {})
-        if options["no-color"] || !STDOUT.tty?
-          Thor::Base.shell = Thor::Shell::Basic
-        end
+        Thor::Base.shell = options["no-color"] ? Thor::Shell::Basic : nil
         @shell = Thor::Base.shell.new
         @level = ENV["DEBUG"] ? "debug" : "info"
         @warning_history = []
@@ -21,26 +20,52 @@ module Bundler
         @shell.set_color(string, *color)
       end
 
-      def info(msg, newline = nil)
-        tell_me(msg, nil, newline) if level("info")
+      def info(msg = nil, newline = nil)
+        return unless info?
+
+        tell_me(msg || yield, nil, newline)
       end
 
-      def confirm(msg, newline = nil)
-        tell_me(msg, :green, newline) if level("confirm")
+      def confirm(msg = nil, newline = nil)
+        return unless confirm?
+
+        tell_me(msg || yield, :green, newline)
       end
 
-      def warn(msg, newline = nil)
+      def warn(msg = nil, newline = nil, color = :yellow)
+        return unless warn?
         return if @warning_history.include? msg
         @warning_history << msg
-        tell_me(msg, :yellow, newline) if level("warn")
+
+        tell_err(msg || yield, color, newline)
+      end
+
+      def error(msg = nil, newline = nil, color = :red)
+        return unless error?
+
+        tell_err(msg || yield, color, newline)
+      end
+
+      def debug(msg = nil, newline = nil)
+        return unless debug?
+
+        tell_me(msg || yield, nil, newline)
       end
 
-      def error(msg, newline = nil)
-        tell_me(msg, :red, newline) if level("error")
+      def info?
+        level("info")
       end
 
-      def debug(msg, newline = nil)
-        tell_me(msg, nil, newline) if debug?
+      def confirm?
+        level("confirm")
+      end
+
+      def warn?
+        level("warn")
+      end
+
+      def error?
+        level("error")
       end
 
       def debug?
@@ -79,7 +104,7 @@ module Bundler
       def trace(e, newline = nil, force = false)
         return unless debug? || force
         msg = "#{e.class}: #{e.message}\n#{e.backtrace.join("\n  ")}"
-        tell_me(msg, nil, newline)
+        tell_err(msg, nil, newline)
       end
 
       def silence(&blk)
@@ -90,7 +115,7 @@ module Bundler
         []
       end
 
-    private
+      private
 
       # valimism
       def tell_me(msg, color = nil, newline = nil)
@@ -103,6 +128,13 @@ module Bundler
       end
 
       def tell_err(message, color = nil, newline = nil)
+        return if @shell.send(:stderr).closed?
+
+        newline ||= message.to_s !~ /( |\t)\Z/
+        message = word_wrap(message) if newline.is_a?(Hash) && newline[:wrap]
+
+        color = nil if color && !$stderr.tty?
+
         buffer = @shell.send(:prepare_message, message, *color)
         buffer << "\n" if newline && !message.to_s.end_with?("\n")
 

data/lib/bundler/ui/silent.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Bundler
   module UI
     class Silent
@@ -12,30 +13,46 @@ module Bundler
         string
       end
 
-      def info(message, newline = nil)
+      def info(message = nil, newline = nil)
       end
 
-      def confirm(message, newline = nil)
+      def confirm(message = nil, newline = nil)
       end
 
-      def warn(message, newline = nil)
+      def warn(message = nil, newline = nil)
         @warnings |= [message]
       end
 
-      def error(message, newline = nil)
+      def error(message = nil, newline = nil)
+      end
+
+      def debug(message = nil, newline = nil)
       end
 
-      def debug(message, newline = nil)
+      def confirm?
+        false
+      end
+
+      def error?
+        false
       end
 
       def debug?
         false
       end
 
+      def info?
+        false
+      end
+
       def quiet?
         false
       end
 
+      def warn?
+        false
+      end
+
       def ask(message)
       end
 

data/lib/bundler/ui.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 module Bundler
   module UI
-    autoload :RGProxy, "bundler/ui/rg_proxy"
-    autoload :Shell,   "bundler/ui/shell"
-    autoload :Silent,  "bundler/ui/silent"
+    autoload :RGProxy, File.expand_path("ui/rg_proxy", __dir__)
+    autoload :Shell,   File.expand_path("ui/shell", __dir__)
+    autoload :Silent,  File.expand_path("ui/silent", __dir__)
   end
 end

data/lib/bundler/uri_credentials_filter.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
+
 module Bundler
   module URICredentialsFilter
-  module_function
+    module_function
 
     def credential_filtered_uri(uri_to_anonymize)
       return uri_to_anonymize if uri_to_anonymize.nil?
       uri = uri_to_anonymize.dup
-      uri = URI(uri.to_s) unless uri.is_a?(URI)
+      if uri.is_a?(String)
+        return uri if File.exist?(uri)
+
+        require_relative "vendored_uri"
+        uri = Bundler::URI(uri)
+      end
+
       if uri.userinfo
         # oauth authentication
         if uri.password == "x-oauth-basic" || uri.password == "x"
@@ -16,9 +23,9 @@ module Bundler
         end
         uri.password = nil
       end
-      return uri if uri_to_anonymize.is_a?(URI)
       return uri.to_s if uri_to_anonymize.is_a?(String)
-    rescue URI::InvalidURIError # uri is not canonical uri scheme
+      uri
+    rescue Bundler::URI::InvalidURIError # uri is not canonical uri scheme
       uri
     end
 

data/lib/bundler/uri_normalizer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Bundler
+  module URINormalizer
+    module_function
+
+    # Normalizes uri to a consistent version, either with or without trailing
+    # slash.
+    #
+    # TODO: Currently gem sources are locked with a trailing slash, while git
+    # sources are locked without a trailing slash. This should be normalized but
+    # the inconsistency is there for now to avoid changing all lockfiles
+    # including GIT sources. We could normalize this on the next major.
+    #
+    def normalize_suffix(uri, trailing_slash: true)
+      if trailing_slash
+        uri.end_with?("/") ? uri : "#{uri}/"
+      else
+        uri.end_with?("/") ? uri.delete_suffix("/") : uri
+      end
+    end
+  end
+end

data/lib/bundler/vendor/.document

@@ -0,0 +1 @@
+# Vendored files do not need to be documented

data/lib/bundler/vendor/connection_pool/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Mike Perham
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb

@@ -0,0 +1,174 @@
+##
+# The TimedStack manages a pool of homogeneous connections (or any resource
+# you wish to manage).  Connections are created lazily up to a given maximum
+# number.
+
+# Examples:
+#
+#    ts = TimedStack.new(1) { MyConnection.new }
+#
+#    # fetch a connection
+#    conn = ts.pop
+#
+#    # return a connection
+#    ts.push conn
+#
+#    conn = ts.pop
+#    ts.pop timeout: 5
+#    #=> raises Bundler::ConnectionPool::TimeoutError after 5 seconds
+
+class Bundler::ConnectionPool::TimedStack
+  attr_reader :max
+
+  ##
+  # Creates a new pool with +size+ connections that are created from the given
+  # +block+.
+
+  def initialize(size = 0, &block)
+    @create_block = block
+    @created = 0
+    @que = []
+    @max = size
+    @mutex = Thread::Mutex.new
+    @resource = Thread::ConditionVariable.new
+    @shutdown_block = nil
+  end
+
+  ##
+  # Returns +obj+ to the stack.  +options+ is ignored in TimedStack but may be
+  # used by subclasses that extend TimedStack.
+
+  def push(obj, options = {})
+    @mutex.synchronize do
+      if @shutdown_block
+        @shutdown_block.call(obj)
+      else
+        store_connection obj, options
+      end
+
+      @resource.broadcast
+    end
+  end
+  alias_method :<<, :push
+
+  ##
+  # Retrieves a connection from the stack.  If a connection is available it is
+  # immediately returned.  If no connection is available within the given
+  # timeout a Bundler::ConnectionPool::TimeoutError is raised.
+  #
+  # +:timeout+ is the only checked entry in +options+ and is preferred over
+  # the +timeout+ argument (which will be removed in a future release).  Other
+  # options may be used by subclasses that extend TimedStack.
+
+  def pop(timeout = 0.5, options = {})
+    options, timeout = timeout, 0.5 if Hash === timeout
+    timeout = options.fetch :timeout, timeout
+
+    deadline = current_time + timeout
+    @mutex.synchronize do
+      loop do
+        raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
+        return fetch_connection(options) if connection_stored?(options)
+
+        connection = try_create(options)
+        return connection if connection
+
+        to_wait = deadline - current_time
+        raise Bundler::ConnectionPool::TimeoutError, "Waited #{timeout} sec, #{length}/#{@max} available" if to_wait <= 0
+        @resource.wait(@mutex, to_wait)
+      end
+    end
+  end
+
+  ##
+  # Shuts down the TimedStack by passing each connection to +block+ and then
+  # removing it from the pool. Attempting to checkout a connection after
+  # shutdown will raise +Bundler::ConnectionPool::PoolShuttingDownError+ unless
+  # +:reload+ is +true+.
+
+  def shutdown(reload: false, &block)
+    raise ArgumentError, "shutdown must receive a block" unless block
+
+    @mutex.synchronize do
+      @shutdown_block = block
+      @resource.broadcast
+
+      shutdown_connections
+      @shutdown_block = nil if reload
+    end
+  end
+
+  ##
+  # Returns +true+ if there are no available connections.
+
+  def empty?
+    (@created - @que.length) >= @max
+  end
+
+  ##
+  # The number of connections available on the stack.
+
+  def length
+    @max - @created + @que.length
+  end
+
+  private
+
+  def current_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must returns true if a connection is available on the stack.
+
+  def connection_stored?(options = nil)
+    !@que.empty?
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must return a connection from the stack.
+
+  def fetch_connection(options = nil)
+    @que.pop
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must shut down all connections on the stack.
+
+  def shutdown_connections(options = nil)
+    while connection_stored?(options)
+      conn = fetch_connection(options)
+      @shutdown_block.call(conn)
+    end
+    @created = 0
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must return +obj+ to the stack.
+
+  def store_connection(obj, options = nil)
+    @que.push obj
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must create a connection if and only if the total number of
+  # connections allowed has not been met.
+
+  def try_create(options = nil)
+    unless @created == @max
+      object = @create_block.call
+      @created += 1
+      object
+    end
+  end
+end

data/lib/bundler/vendor/connection_pool/lib/connection_pool/version.rb

@@ -0,0 +1,3 @@
+class Bundler::ConnectionPool
+  VERSION = "2.3.0"
+end

data/lib/bundler/vendor/connection_pool/lib/connection_pool/wrapper.rb

@@ -0,0 +1,56 @@
+class Bundler::ConnectionPool
+  class Wrapper < ::BasicObject
+    METHODS = [:with, :pool_shutdown, :wrapped_pool]
+
+    def initialize(options = {}, &block)
+      @pool = options.fetch(:pool) { ::Bundler::ConnectionPool.new(options, &block) }
+    end
+
+    def wrapped_pool
+      @pool
+    end
+
+    def with(&block)
+      @pool.with(&block)
+    end
+
+    def pool_shutdown(&block)
+      @pool.shutdown(&block)
+    end
+
+    def pool_size
+      @pool.size
+    end
+
+    def pool_available
+      @pool.available
+    end
+
+    def respond_to?(id, *args)
+      METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
+    end
+
+    # rubocop:disable Style/MissingRespondToMissing
+    if ::RUBY_VERSION >= "3.0.0"
+      def method_missing(name, *args, **kwargs, &block)
+        with do |connection|
+          connection.send(name, *args, **kwargs, &block)
+        end
+      end
+    elsif ::RUBY_VERSION >= "2.7.0"
+      ruby2_keywords def method_missing(name, *args, &block)
+        with do |connection|
+          connection.send(name, *args, &block)
+        end
+      end
+    else
+      def method_missing(name, *args, &block)
+        with do |connection|
+          connection.send(name, *args, &block)
+        end
+      end
+    end
+    # rubocop:enable Style/MethodMissingSuper
+    # rubocop:enable Style/MissingRespondToMissing
+  end
+end

data/lib/bundler/vendor/connection_pool/lib/connection_pool.rb

@@ -0,0 +1,128 @@
+require "timeout"
+require_relative "connection_pool/version"
+
+class Bundler::ConnectionPool
+  class Error < ::RuntimeError; end
+
+  class PoolShuttingDownError < ::Bundler::ConnectionPool::Error; end
+
+  class TimeoutError < ::Timeout::Error; end
+end
+
+# Generic connection pool class for sharing a limited number of objects or network connections
+# among many threads.  Note: pool elements are lazily created.
+#
+# Example usage with block (faster):
+#
+#    @pool = Bundler::ConnectionPool.new { Redis.new }
+#    @pool.with do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Using optional timeout override (for that single invocation)
+#
+#    @pool.with(timeout: 2.0) do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Example usage replacing an existing connection (slower):
+#
+#    $redis = Bundler::ConnectionPool.wrap { Redis.new }
+#
+#    def do_work
+#      $redis.lpop('my-list') if $redis.llen('my-list') > 0
+#    end
+#
+# Accepts the following options:
+# - :size - number of connections to pool, defaults to 5
+# - :timeout - amount of time to wait for a connection if none currently available, defaults to 5 seconds
+#
+class Bundler::ConnectionPool
+  DEFAULTS = {size: 5, timeout: 5}
+
+  def self.wrap(options, &block)
+    Wrapper.new(options, &block)
+  end
+
+  def initialize(options = {}, &block)
+    raise ArgumentError, "Connection pool requires a block" unless block
+
+    options = DEFAULTS.merge(options)
+
+    @size = Integer(options.fetch(:size))
+    @timeout = options.fetch(:timeout)
+
+    @available = TimedStack.new(@size, &block)
+    @key = :"pool-#{@available.object_id}"
+    @key_count = :"pool-#{@available.object_id}-count"
+  end
+
+  def with(options = {})
+    Thread.handle_interrupt(Exception => :never) do
+      conn = checkout(options)
+      begin
+        Thread.handle_interrupt(Exception => :immediate) do
+          yield conn
+        end
+      ensure
+        checkin
+      end
+    end
+  end
+  alias_method :then, :with
+
+  def checkout(options = {})
+    if ::Thread.current[@key]
+      ::Thread.current[@key_count] += 1
+      ::Thread.current[@key]
+    else
+      ::Thread.current[@key_count] = 1
+      ::Thread.current[@key] = @available.pop(options[:timeout] || @timeout)
+    end
+  end
+
+  def checkin
+    if ::Thread.current[@key]
+      if ::Thread.current[@key_count] == 1
+        @available.push(::Thread.current[@key])
+        ::Thread.current[@key] = nil
+        ::Thread.current[@key_count] = nil
+      else
+        ::Thread.current[@key_count] -= 1
+      end
+    else
+      raise Bundler::ConnectionPool::Error, "no connections are checked out"
+    end
+
+    nil
+  end
+
+  ##
+  # Shuts down the Bundler::ConnectionPool by passing each connection to +block+ and
+  # then removing it from the pool. Attempting to checkout a connection after
+  # shutdown will raise +Bundler::ConnectionPool::PoolShuttingDownError+.
+
+  def shutdown(&block)
+    @available.shutdown(&block)
+  end
+
+  ##
+  # Reloads the Bundler::ConnectionPool by passing each connection to +block+ and then
+  # removing it the pool. Subsequent checkouts will create new connections as
+  # needed.
+
+  def reload(&block)
+    @available.shutdown(reload: true, &block)
+  end
+
+  # Size of this connection pool
+  attr_reader :size
+
+  # Number of pool entries available for checkout at this instant.
+  def available
+    @available.length
+  end
+end
+
+require_relative "connection_pool/timed_stack"
+require_relative "connection_pool/wrapper"