bundler 1.9.0 → 1.17.3

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/shell/color.rb

@@ -1,4 +1,4 @@
-require "thor/shell/basic"
+require "bundler/vendor/thor/lib/thor/shell/basic"
 
 class Bundler::Thor
   module Shell
@@ -134,7 +134,7 @@ class Bundler::Thor
       # for diff.
       #
       def diff_lcs_loaded? #:nodoc:
-        return true  if defined?(Diff::LCS)
+        return true if defined?(Diff::LCS)
         return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
 
         @diff_lcs_loaded = begin

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/shell/html.rb

@@ -1,4 +1,4 @@
-require "thor/shell/basic"
+require "bundler/vendor/thor/lib/thor/shell/basic"
 
 class Bundler::Thor
   module Shell
@@ -51,13 +51,13 @@ class Bundler::Thor
       def set_color(string, *colors)
         if colors.all? { |color| color.is_a?(Symbol) || color.is_a?(String) }
           html_colors = colors.map { |color| lookup_color(color) }
-          "<span style=\"#{html_colors.join("; ")};\">#{string}</span>"
+          "<span style=\"#{html_colors.join('; ')};\">#{string}</span>"
         else
           color, bold = colors
           html_color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
           styles = [html_color]
           styles << BOLD if bold
-          "<span style=\"#{styles.join("; ")};\">#{string}</span>"
+          "<span style=\"#{styles.join('; ')};\">#{string}</span>"
         end
       end
 
@@ -68,7 +68,7 @@ class Bundler::Thor
       #
       # TODO: Implement #ask for Bundler::Thor::Shell::HTML
       def ask(statement, color = nil)
-        fail NotImplementedError, "Implement #ask for Bundler::Thor::Shell::HTML"
+        raise NotImplementedError, "Implement #ask for Bundler::Thor::Shell::HTML"
       end
 
     protected
@@ -111,7 +111,7 @@ class Bundler::Thor
       # for diff.
       #
       def diff_lcs_loaded? #:nodoc:
-        return true  if defined?(Diff::LCS)
+        return true if defined?(Diff::LCS)
         return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
 
         @diff_lcs_loaded = begin

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/util.rb

@@ -64,7 +64,7 @@ class Bundler::Thor
         new_constants = Bundler::Thor::Base.subclasses.dup
         Bundler::Thor::Base.subclasses.replace(old_constants)
 
-        new_constants.map! { |c| c.namespace }
+        new_constants.map!(&:namespace)
         new_constants.compact!
         new_constants
       end
@@ -72,7 +72,7 @@ class Bundler::Thor
       # Returns the thor classes declared inside the given class.
       #
       def thor_classes_in(klass)
-        stringfied_constants = klass.constants.map { |c| c.to_s }
+        stringfied_constants = klass.constants.map(&:to_s)
         Bundler::Thor::Base.subclasses.select do |subclass|
           next unless subclass.name
           stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ""))
@@ -103,7 +103,7 @@ class Bundler::Thor
       #
       def camel_case(str)
         return str if str !~ /_/ && str =~ /[A-Z]+.*/
-        str.split("_").map { |i| i.capitalize }.join
+        str.split("_").map(&:capitalize).join
       end
 
       # Receives a namespace and tries to retrieve a Bundler::Thor or Bundler::Thor::Group class
@@ -135,7 +135,8 @@ class Bundler::Thor
           klass   = Bundler::Thor::Util.find_by_namespace(pieces.join(":"))
         end
         unless klass # look for a Bundler::Thor::Group with the right name
-          klass, command = Bundler::Thor::Util.find_by_namespace(namespace), nil
+          klass = Bundler::Thor::Util.find_by_namespace(namespace)
+          command = nil
         end
         if !klass && fallback # try a command in the default namespace
           command = namespace
@@ -163,7 +164,7 @@ class Bundler::Thor
         end
       end
 
-      def user_home # rubocop:disable MethodLength
+      def user_home
         @@user_home ||= if ENV["HOME"]
           ENV["HOME"]
         elsif ENV["USERPROFILE"]
@@ -188,7 +189,7 @@ class Bundler::Thor
       # Returns the root where thor files are located, depending on the OS.
       #
       def thor_root
-        File.join(user_home, ".thor").gsub(/\\/, "/")
+        File.join(user_home, ".thor").tr('\\', "/")
       end
 
       # Returns the files in the thor root. On Windows thor_root will be something
@@ -216,7 +217,7 @@ class Bundler::Thor
       # Return the path to the ruby interpreter taking into account multiple
       # installations and windows extensions.
       #
-      def ruby_command # rubocop:disable MethodLength
+      def ruby_command
         @ruby_command ||= begin
           ruby_name = RbConfig::CONFIG["ruby_install_name"]
           ruby = File.join(RbConfig::CONFIG["bindir"], ruby_name)

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/version.rb

@@ -1,3 +1,3 @@
 class Bundler::Thor
-  VERSION = "0.19.1"
+  VERSION = "0.20.0"
 end

data/lib/bundler/vendored_fileutils.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Bundler; end
+if RUBY_VERSION >= "2.4"
+  require "bundler/vendor/fileutils/lib/fileutils"
+else
+  # the version we vendor is 2.4+
+  require "fileutils"
+end

data/lib/bundler/vendored_molinillo.rb

@@ -1,5 +1,4 @@
-vendor = File.expand_path('../vendor/Molinillo-0.2.1/lib', __FILE__)
-loaded = $:.include?(vendor)
-$:.unshift(vendor) unless loaded
-require 'molinillo'
-$:.delete(vendor) unless loaded
+# frozen_string_literal: true
+
+module Bundler; end
+require "bundler/vendor/molinillo/lib/molinillo"

data/lib/bundler/vendored_persistent.rb

@@ -1,11 +1,52 @@
+# frozen_string_literal: true
+
 # We forcibly require OpenSSL, because net/http/persistent will only autoload
 # it. On some Rubies, autoload fails but explicit require succeeds.
 begin
-  require 'openssl'
+  require "openssl"
 rescue LoadError
   # some Ruby builds don't have OpenSSL
 end
+module Bundler
+  module Persistent
+    module Net
+      module HTTP
+      end
+    end
+  end
+end
+require "bundler/vendor/net-http-persistent/lib/net/http/persistent"
+
+module Bundler
+  class PersistentHTTP < Persistent::Net::HTTP::Persistent
+    def connection_for(uri)
+      connection = super
+      warn_old_tls_version_rubygems_connection(uri, connection)
+      connection
+    end
 
-vendor = File.expand_path('../vendor', __FILE__)
-$:.unshift(vendor) unless $:.include?(vendor)
-require 'net/http/persistent'
+    def warn_old_tls_version_rubygems_connection(uri, connection)
+      return unless connection.use_ssl?
+      return unless (uri.host || "").end_with?("rubygems.org")
+
+      socket = connection.instance_variable_get(:@socket)
+      return unless socket
+      socket_io = socket.io
+      return unless socket_io.respond_to?(:ssl_version)
+      ssl_version = socket_io.ssl_version
+
+      case ssl_version
+      when /TLSv([\d\.]+)/
+        version = Gem::Version.new($1)
+        if version < Gem::Version.new("1.2")
+          Bundler.ui.warn \
+            "Warning: Your Ruby version is compiled against a copy of OpenSSL that is very old. " \
+            "Starting in January 2018, RubyGems.org will refuse connection requests from these " \
+            "very old versions of OpenSSL. If you will need to continue installing gems after " \
+            "January 2018, please follow this guide to upgrade: http://ruby.to/tls-outdated.",
+            :wrap => true
+        end
+      end
+    end
+  end
+end

data/lib/bundler/vendored_thor.rb

@@ -1,5 +1,8 @@
-vendor = File.expand_path('../vendor/thor-0.19.1/lib', __FILE__)
-loaded = $:.include?(vendor)
-$:.unshift(vendor) unless loaded
-require 'thor'
-require 'thor/actions'
+# frozen_string_literal: true
+
+module Bundler
+  def self.require_thor_actions
+    Kernel.send(:require, "bundler/vendor/thor/lib/thor/actions")
+  end
+end
+require "bundler/vendor/thor/lib/thor"

data/lib/bundler/version.rb

@@ -1,6 +1,28 @@
+# frozen_string_literal: false
+
+# Ruby 1.9.3 and old RubyGems don't play nice with frozen version strings
+# rubocop:disable MutableConstant
+
 module Bundler
   # We're doing this because we might write tests that deal
   # with other versions of bundler and we are unsure how to
   # handle this better.
-  VERSION = "1.9.0" unless defined?(::Bundler::VERSION)
+  VERSION = "1.17.3" unless defined?(::Bundler::VERSION)
+
+  def self.overwrite_loaded_gem_version
+    begin
+      require "rubygems"
+    rescue LoadError
+      return
+    end
+    return unless bundler_spec = Gem.loaded_specs["bundler"]
+    return if bundler_spec.version == VERSION
+    bundler_spec.version = Bundler::VERSION
+  end
+  private_class_method :overwrite_loaded_gem_version
+  overwrite_loaded_gem_version
+
+  def self.bundler_major_version
+    @bundler_major_version ||= VERSION.split(".").first.to_i
+  end
 end

data/lib/bundler/version_ranges.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Bundler
+  module VersionRanges
+    NEq = Struct.new(:version)
+    ReqR = Struct.new(:left, :right)
+    class ReqR
+      Endpoint = Struct.new(:version, :inclusive)
+      def to_s
+        "#{left.inclusive ? "[" : "("}#{left.version}, #{right.version}#{right.inclusive ? "]" : ")"}"
+      end
+      INFINITY = Object.new.freeze
+      ZERO = Gem::Version.new("0.a")
+
+      def cover?(v)
+        return false if left.inclusive && left.version > v
+        return false if !left.inclusive && left.version >= v
+
+        if right.version != INFINITY
+          return false if right.inclusive && right.version < v
+          return false if !right.inclusive && right.version <= v
+        end
+
+        true
+      end
+
+      def empty?
+        left.version == right.version && !(left.inclusive && right.inclusive)
+      end
+
+      def single?
+        left.version == right.version
+      end
+
+      UNIVERSAL = ReqR.new(ReqR::Endpoint.new(Gem::Version.new("0.a"), true), ReqR::Endpoint.new(ReqR::INFINITY, false)).freeze
+    end
+
+    def self.for_many(requirements)
+      requirements = requirements.map(&:requirements).flatten(1).map {|r| r.join(" ") }
+      requirements << ">= 0.a" if requirements.empty?
+      requirement = Gem::Requirement.new(requirements)
+      self.for(requirement)
+    end
+
+    def self.for(requirement)
+      ranges = requirement.requirements.map do |op, v|
+        case op
+        when "=" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(v, true))
+        when "!=" then NEq.new(v)
+        when ">=" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(ReqR::INFINITY, false))
+        when ">" then ReqR.new(ReqR::Endpoint.new(v, false), ReqR::Endpoint.new(ReqR::INFINITY, false))
+        when "<" then ReqR.new(ReqR::Endpoint.new(ReqR::ZERO, true), ReqR::Endpoint.new(v, false))
+        when "<=" then ReqR.new(ReqR::Endpoint.new(ReqR::ZERO, true), ReqR::Endpoint.new(v, true))
+        when "~>" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(v.bump, false))
+        else raise "unknown version op #{op} in requirement #{requirement}"
+        end
+      end.uniq
+      ranges, neqs = ranges.partition {|r| !r.is_a?(NEq) }
+
+      [ranges.sort_by {|range| [range.left.version, range.left.inclusive ? 0 : 1] }, neqs.map(&:version)]
+    end
+
+    def self.empty?(ranges, neqs)
+      !ranges.reduce(ReqR::UNIVERSAL) do |last_range, curr_range|
+        next false unless last_range
+        next false if curr_range.single? && neqs.include?(curr_range.left.version)
+        next curr_range if last_range.right.version == ReqR::INFINITY
+        case last_range.right.version <=> curr_range.left.version
+        when 1 then next curr_range
+        when 0 then next(last_range.right.inclusive && curr_range.left.inclusive && !neqs.include?(curr_range.left.version) && curr_range)
+        when -1 then next false
+        end
+      end
+    end
+  end
+end

data/lib/bundler/vlad.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/shared_helpers"
+Bundler::SharedHelpers.major_deprecation 2,
+  "The Bundler task for Vlad"
+
 # Vlad task for Bundler.
 #
-# Just add "require 'bundler/vlad'" in your Vlad deploy.rb, and
+# Add "require 'bundler/vlad'" in your Vlad deploy.rb, and
 # include the vlad:bundle:install task in your vlad:deploy task.
-require 'bundler/deployment'
+require "bundler/deployment"
 
 include Rake::DSL if defined? Rake::DSL
 

data/lib/bundler/worker.rb

@@ -1,4 +1,6 @@
-require 'thread'
+# frozen_string_literal: true
+
+require "thread"
 
 module Bundler
   class Worker
@@ -11,22 +13,29 @@ module Bundler
       end
     end
 
+    # @return [String] the name of the worker
+    attr_reader :name
+
     # Creates a worker pool of specified size
     #
     # @param size [Integer] Size of pool
+    # @param name [String] name the name of the worker
     # @param func [Proc] job to run in inside the worker pool
-    def initialize(size, func)
+    def initialize(size, name, func)
+      @name = name
       @request_queue = Queue.new
       @response_queue = Queue.new
       @func = func
-      @threads = size.times.map { |i| Thread.start { process_queue(i) } }
-      trap("INT") { abort_threads }
+      @size = size
+      @threads = nil
+      SharedHelpers.trap("INT") { abort_threads }
     end
 
     # Enqueue a request to be executed in the worker pool
     #
     # @param obj [String] mostly it is name of spec that should be downloaded
     def enq(obj)
+      create_threads unless @threads
       @request_queue.enq obj
     end
 
@@ -60,14 +69,38 @@ module Bundler
     # Stop the worker threads by sending a poison object down the request queue
     # so as worker threads after retrieving it, shut themselves down
     def stop_threads
+      return unless @threads
       @threads.each { @request_queue.enq POISON }
-      @threads.each { |thread| thread.join }
+      @threads.each(&:join)
+      @threads = nil
     end
 
     def abort_threads
-      @threads.each {|i| i.exit }
+      return unless @threads
+      Bundler.ui.debug("\n#{caller.join("\n")}")
+      @threads.each(&:exit)
       exit 1
     end
 
+    def create_threads
+      creation_errors = []
+
+      @threads = Array.new(@size) do |i|
+        begin
+          Thread.start { process_queue(i) }.tap do |thread|
+            thread.name = "#{name} Worker ##{i}" if thread.respond_to?(:name=)
+          end
+        rescue ThreadError => e
+          creation_errors << e
+          nil
+        end
+      end.compact
+
+      return if creation_errors.empty?
+
+      message = "Failed to create threads for the #{name} worker: #{creation_errors.map(&:to_s).uniq.join(", ")}"
+      raise ThreadCreationError, message if @threads.empty?
+      Bundler.ui.info message
+    end
   end
 end

data/lib/bundler/yaml_serializer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Bundler
+  # A stub yaml serializer that can handle only hashes and strings (as of now).
+  module YAMLSerializer
+  module_function
+
+    def dump(hash)
+      yaml = String.new("---")
+      yaml << dump_hash(hash)
+    end
+
+    def dump_hash(hash)
+      yaml = String.new("\n")
+      hash.each do |k, v|
+        yaml << k << ":"
+        if v.is_a?(Hash)
+          yaml << dump_hash(v).gsub(/^(?!$)/, "  ") # indent all non-empty lines
+        elsif v.is_a?(Array) # Expected to be array of strings
+          yaml << "\n- " << v.map {|s| s.to_s.gsub(/\s+/, " ").inspect }.join("\n- ") << "\n"
+        else
+          yaml << " " << v.to_s.gsub(/\s+/, " ").inspect << "\n"
+        end
+      end
+      yaml
+    end
+
+    ARRAY_REGEX = /
+      ^
+      (?:[ ]*-[ ]) # '- ' before array items
+      (['"]?) # optional opening quote
+      (.*) # value
+      \1 # matching closing quote
+      $
+    /xo
+
+    HASH_REGEX = /
+      ^
+      ([ ]*) # indentations
+      (.+) # key
+      (?::(?=(?:\s|$))) # :  (without the lookahead the #key includes this when : is present in value)
+      [ ]?
+      (?: !\s)? # optional exclamation mark found with ruby 1.9.3
+      (['"]?) # optional opening quote
+      (.*) # value
+      \3 # matching closing quote
+      $
+    /xo
+
+    def load(str)
+      res = {}
+      stack = [res]
+      last_hash = nil
+      last_empty_key = nil
+      str.split(/\r?\n/).each do |line|
+        if match = HASH_REGEX.match(line)
+          indent, key, quote, val = match.captures
+          key = convert_to_backward_compatible_key(key)
+          depth = indent.scan(/  /).length
+          if quote.empty? && val.empty?
+            new_hash = {}
+            stack[depth][key] = new_hash
+            stack[depth + 1] = new_hash
+            last_empty_key = key
+            last_hash = stack[depth]
+          else
+            stack[depth][key] = val
+          end
+        elsif match = ARRAY_REGEX.match(line)
+          _, val = match.captures
+          last_hash[last_empty_key] = [] unless last_hash[last_empty_key].is_a?(Array)
+
+          last_hash[last_empty_key].push(val)
+        end
+      end
+      res
+    end
+
+    # for settings' keys
+    def convert_to_backward_compatible_key(key)
+      key = "#{key}/" if key =~ /https?:/i && key !~ %r{/\Z}
+      key = key.gsub(".", "__") if key.include?(".")
+      key
+    end
+
+    class << self
+      private :dump_hash, :convert_to_backward_compatible_key
+    end
+  end
+end