rubygems-update 2.6.14 → 2.7.0

data/bundler/lib/bundler/vendor/thor/lib/thor/shell/color.rb

@@ -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/bundler/lib/bundler/vendor/thor/lib/thor/shell/html.rb

@@ -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/bundler/lib/bundler/vendor/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/bundler/lib/bundler/vendor/thor/lib/thor/version.rb

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

data/bundler/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/bundler/lib/bundler/vendored_molinillo.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
+
 module Bundler; end
 require "bundler/vendor/molinillo/lib/molinillo"

data/bundler/lib/bundler/vendored_persistent.rb

@@ -1,4 +1,5 @@
 # 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
@@ -15,3 +16,37 @@ module Bundler
   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
+
+    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/bundler/lib/bundler/vendored_thor.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
-module Bundler; end
+
+module Bundler
+  def self.require_thor_actions
+    Kernel.send(:require, "bundler/vendor/thor/lib/thor/actions")
+  end
+end
 require "bundler/vendor/thor/lib/thor"
-require "bundler/vendor/thor/lib/thor/actions"

data/bundler/lib/bundler/version.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+# frozen_string_literal: false
 
 # Ruby 1.9.3 and old RubyGems don't play nice with frozen version strings
 # rubocop:disable MutableConstant
@@ -7,5 +7,22 @@ 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.14.0.pre.2" unless defined?(::Bundler::VERSION)
+  VERSION = "1.16.0" 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/bundler/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/bundler/lib/bundler/vlad.rb

@@ -1,4 +1,9 @@
 # frozen_string_literal: true
+
+require "bundler/shared_helpers"
+Bundler::SharedHelpers.major_deprecation 2,
+  "The Bundler task for Vlad"
+
 # Vlad task for Bundler.
 #
 # Add "require 'bundler/vlad'" in your Vlad deploy.rb, and

data/bundler/lib/bundler/worker.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "thread"
 
 module Bundler
@@ -27,7 +28,7 @@ module Bundler
       @func = func
       @size = size
       @threads = nil
-      trap("INT") { abort_threads }
+      SharedHelpers.trap("INT") { abort_threads }
     end
 
     # Enqueue a request to be executed in the worker pool
@@ -76,6 +77,7 @@ module Bundler
 
     def abort_threads
       return unless @threads
+      Bundler.ui.debug("\n#{caller.join("\n")}")
       @threads.each(&:exit)
       exit 1
     end

data/bundler/lib/bundler/yaml_serializer.rb

@@ -37,7 +37,7 @@ module Bundler
     HASH_REGEX = /
       ^
       ([ ]*) # indentations
-      (.*) # key
+      (.+) # key
       (?::(?=(?:\s|$))) # :  (without the lookahead the #key includes this when : is present in value)
       [ ]?
       (?: !\s)? # optional exclamation mark found with ruby 1.9.3
@@ -54,10 +54,10 @@ module Bundler
       last_empty_key = nil
       str.split(/\r?\n/).each do |line|
         if match = HASH_REGEX.match(line)
-          indent, key, _, val = match.captures
+          indent, key, quote, val = match.captures
           key = convert_to_backward_compatible_key(key)
           depth = indent.scan(/  /).length
-          if val.empty?
+          if quote.empty? && val.empty?
             new_hash = {}
             stack[depth][key] = new_hash
             stack[depth + 1] = new_hash

data/bundler/man/bundle-add.ronn

@@ -0,0 +1,29 @@
+bundle-add(1) -- Add gem to the Gemfile and run bundle install
+================================================================
+
+## SYNOPSIS
+
+`bundle add` <GEM_NAME> [--group=GROUP] [--version=VERSION] [--source=SOURCE]
+
+## DESCRIPTION
+Adds the named gem to the Gemfile and run `bundle install`.
+
+Example:
+
+bundle add rails
+
+bundle add rails --version "< 3.0, > 1.1"
+
+bundle add rails --version "~> 5.0.0" --source "https://gems.example.com" --group "development"
+
+bundle add rails --group "development, test"
+
+## OPTIONS
+* `--version`, `-v`:
+  Specify version requirements(s) for the added gem.
+
+* `--group`, `-g`:
+  Specify the group(s) for the added gem. Multiple groups should be separated by commas.
+
+* `--source`, , `-s`:
+  Specify the source for the added gem.

data/bundler/man/bundle-binstubs.ronn

@@ -7,6 +7,17 @@ bundle-binstubs(1) -- Install the binstubs of the listed gems
 
 ## DESCRIPTION
 
+Binstubs are scripts that wrap aroung executables. Bundler creates a
+small Ruby file (a binstub) that loads Bundler, runs the command,
+and puts it into `bin/`. Binstubs are a shortcut-or alternative-
+to always using `bundle exec`. This gives you a file that can by run
+directly, and one that will always run the correct gem version
+used by the application.
+
+For example, if you run `bundle binstubs rspec-core`, Bundler will create
+the file `bin/rspec`. That file will contain enough code to load Bundler,
+tell it to load the bundled gems, and then run rspec.
+
 This command generates binstubs for executables in `GEM_NAME`.
 Binstubs are put into `bin`, or the `--path` directory if one has been set.
 Calling binstubs with [GEM [GEM]] will create binstubs for all given gems.
@@ -23,6 +34,9 @@ Calling binstubs with [GEM [GEM]] will create binstubs for all given gems.
   Makes binstubs that can work without depending on Rubygems or Bundler at
   runtime.
 
+* `--sheband`:
+  Specify a different shebang executable name than the default (default 'ruby')
+
 ## BUNDLE INSTALL --BINSTUBS
 
 To create binstubs for all the gems in the bundle you can use the `--binstubs`

data/bundler/man/bundle-check.ronn

@@ -0,0 +1,26 @@
+bundle-check(1) -- Verifies if dependencies are satisfied by installed gems
+===========================================================================
+
+## SYNOPSIS
+
+`bundle check` [--dry-run]
+               [--gemfile=FILE]
+               [--path=PATH]
+
+## DESCRIPTION
+
+`check` searches the local machine for each of the gems requested in the
+Gemfile. If all gems are found, Bundler prints a success message and exits with
+a status of 0.
+
+If not, the first missing gem is listed and Bundler exits status 1.
+
+## OPTIONS
+
+* `--dry-run`:
+  Locks the `Gemfile(5)` before running the command.
+* `--gemfile`:
+  Use the specified gemfile instead of the `Gemfile(5)`
+* `--path`:
+  Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME).
+  Bundler will remember this value for future installs on this machine.

data/bundler/man/bundle-clean.ronn

@@ -0,0 +1,18 @@
+bundle-clean(1) -- Cleans up unused gems in your bundler directory
+==================================================================
+
+## SYNOPSIS
+
+`bundle clean` [--dry-run] [--force]
+
+## DESCRIPTION
+
+This command will remove all unused gems in your bundler directory. This is
+useful when you have made many changes to your gem dependencies.
+
+## OPTIONS
+
+* `--dry-run`:
+  Print the changes, but do not clean the unused gems.
+* `--force`:
+  Force a clean even if `--path` is not set.