rubygems-update 2.6.8 → 2.6.9

data/bundler/lib/bundler/env.rb

@@ -12,44 +12,49 @@ module Bundler
       print_gemfile = options.delete(:print_gemfile)
       print_gemspecs = options.delete(:print_gemspecs)
 
-      out = String.new("Environment\n\n")
-      out << "    Bundler   #{Bundler::VERSION}\n"
-      out << "    Rubygems  #{Gem::VERSION}\n"
-      out << "    Ruby      #{ruby_version}"
-      out << "    GEM_HOME  #{ENV["GEM_HOME"]}\n" unless ENV["GEM_HOME"].nil? || ENV["GEM_HOME"].empty?
-      out << "    GEM_PATH  #{ENV["GEM_PATH"]}\n" unless ENV["GEM_PATH"] == ENV["GEM_HOME"]
-      out << "    RVM       #{ENV["rvm_version"]}\n" if ENV["rvm_version"]
-      out << "    Git       #{git_version}\n"
-      out << "    Platform  #{Gem::Platform.local}\n"
-      out << "    OpenSSL   #{OpenSSL::OPENSSL_VERSION}\n" if defined?(OpenSSL::OPENSSL_VERSION)
+      out = String.new("## Environment\n\n```\n")
+      out << "Bundler   #{Bundler::VERSION}\n"
+      out << "Rubygems  #{Gem::VERSION}\n"
+      out << "Ruby      #{ruby_version}"
+      out << "GEM_HOME  #{ENV["GEM_HOME"]}\n" unless ENV["GEM_HOME"].nil? || ENV["GEM_HOME"].empty?
+      out << "GEM_PATH  #{ENV["GEM_PATH"]}\n" unless ENV["GEM_PATH"] == ENV["GEM_HOME"]
+      out << "RVM       #{ENV["rvm_version"]}\n" if ENV["rvm_version"]
+      out << "Git       #{git_version}\n"
+      out << "Platform  #{Gem::Platform.local}\n"
+      out << "OpenSSL   #{OpenSSL::OPENSSL_VERSION}\n" if defined?(OpenSSL::OPENSSL_VERSION)
       %w(rubygems-bundler open_gem).each do |name|
         specs = Bundler.rubygems.find_name(name)
-        out << "    #{name} (#{specs.map(&:version).join(",")})\n" unless specs.empty?
+        out << "#{name} (#{specs.map(&:version).join(",")})\n" unless specs.empty?
       end
 
-      out << "\nBundler settings\n\n" unless Bundler.settings.all.empty?
+      out << "```\n"
+
+      out << "\n## Bundler settings\n\n```\n" unless Bundler.settings.all.empty?
       Bundler.settings.all.each do |setting|
-        out << "    " << setting << "\n"
+        out << setting << "\n"
         Bundler.settings.pretty_values_for(setting).each do |line|
-          out << "      " << line << "\n"
+          out << "  " << line << "\n"
         end
       end
+      out << "```\n"
 
       return out unless SharedHelpers.in_bundle?
 
       if print_gemfile
-        out << "\n#{Bundler.default_gemfile.relative_path_from(SharedHelpers.pwd)}\n\n"
-        out << "    " << read_file(Bundler.default_gemfile).gsub(/\n/, "\n    ") << "\n"
+        out << "\n## Gemfile\n"
+        out << "\n### #{Bundler.default_gemfile.relative_path_from(SharedHelpers.pwd)}\n\n"
+        out << "```ruby\n" << read_file(Bundler.default_gemfile).chomp << "\n```\n"
 
-        out << "\n#{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}\n\n"
-        out << "    " << read_file(Bundler.default_lockfile).gsub(/\n/, "\n    ") << "\n"
+        out << "\n### #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}\n\n"
+        out << "```\n" << read_file(Bundler.default_lockfile).chomp << "\n```\n"
       end
 
       if print_gemspecs
         dsl = Dsl.new.tap {|d| d.eval_gemfile(Bundler.default_gemfile) }
+        out << "\n## Gemspecs\n" unless dsl.gemspecs.empty?
         dsl.gemspecs.each do |gs|
-          out << "\n#{File.basename(gs.loaded_from)}"
-          out << "\n\n    " << read_file(gs.loaded_from).gsub(/\n/, "\n    ") << "\n"
+          out << "\n### #{File.basename(gs.loaded_from)}"
+          out << "\n\n```ruby\n" << read_file(gs.loaded_from).chomp << "\n```\n"
         end
       end
 

data/bundler/lib/bundler/errors.rb

@@ -53,6 +53,7 @@ module Bundler
   class GemfileLockNotFound < BundlerError; status_code(22); end
   class PluginError < BundlerError; status_code(29); end
   class SudoNotPermittedError < BundlerError; status_code(30); end
+  class ThreadCreationError < BundlerError; status_code(33); end
   class GemfileEvalError < GemfileError; end
   class MarshalError < StandardError; end
 
@@ -132,4 +133,24 @@ module Bundler
 
     status_code(28)
   end
+
+  class NoSpaceOnDeviceError < PermissionError
+    def message
+      "There was an error while trying to #{action} `#{@path}`. " \
+      "There was insufficent space remaining on the device."
+    end
+
+    status_code(31)
+  end
+
+  class GenericSystemCallError < BundlerError
+    attr_reader :underlying_error
+
+    def initialize(underlying_error, message)
+      @underlying_error = underlying_error
+      super("#{message}\nThe underlying system error is #{@underlying_error.class}: #{@underlying_error}")
+    end
+
+    status_code(32)
+  end
 end

data/bundler/lib/bundler/fetcher.rb

@@ -237,7 +237,7 @@ module Bundler
           Bundler.settings[:ssl_client_cert]
         raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
 
-        con = Net::HTTP::Persistent.new "bundler", :ENV
+        con = Bundler::Persistent::Net::HTTP::Persistent.new "bundler", :ENV
         if gem_proxy = Bundler.rubygems.configuration[:http_proxy]
           con.proxy = URI.parse(gem_proxy) if gem_proxy != :no_proxy
         end
@@ -273,7 +273,7 @@ module Bundler
       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, Zlib::BufError, Errno::EHOSTUNREACH
+      Bundler::Persistent::Net::HTTP::Persistent::Error, Zlib::BufError, Errno::EHOSTUNREACH
     ].freeze
 
     def bundler_cert_store

data/bundler/lib/bundler/fetcher/compact_index.rb

@@ -3,10 +3,10 @@ require "bundler/fetcher/base"
 require "bundler/worker"
 
 module Bundler
+  autoload :CompactIndexClient, "bundler/compact_index_client"
+
   class Fetcher
     class CompactIndex < Base
-      require "bundler/compact_index_client"
-
       def self.compact_index_request(method_name)
         method = instance_method(method_name)
         undef_method(method_name)
@@ -61,6 +61,7 @@ module Bundler
       compact_index_request :fetch_spec
 
       def available?
+        return nil unless md5_available?
         user_home = Bundler.user_home
         return nil unless user_home.directory? && user_home.writable?
         # Read info file checksums out of /versions, so we can know if gems are up to date
@@ -95,7 +96,7 @@ module Bundler
       def bundle_worker(func = nil)
         @bundle_worker ||= begin
           worker_name = "Compact Index (#{display_uri.host})"
-          Bundler::Worker.new(25, worker_name, func)
+          Bundler::Worker.new(Bundler.current_ruby.rbx? ? 1 : 25, worker_name, func)
         end
         @bundle_worker.tap do |worker|
           worker.instance_variable_set(:@func, func) if func
@@ -119,6 +120,17 @@ module Bundler
           Net::HTTPNotModified.new(nil, nil, nil)
         end
       end
+
+      def md5_available?
+        begin
+          require "openssl"
+          return false if defined?(OpenSSL::OPENSSL_FIPS) && OpenSSL::OPENSSL_FIPS
+        rescue LoadError
+          nil
+        end
+
+        true
+      end
     end
   end
 end

data/bundler/lib/bundler/friendly_errors.rb

@@ -58,25 +58,41 @@ module Bundler
     def request_issue_report_for(e)
       Bundler.ui.info <<-EOS.gsub(/^ {8}/, "")
         --- ERROR REPORT TEMPLATE -------------------------------------------------------
-        - What did you do?
+        # Error Report
+
+        ## Questions
+
+        Please fill out answers to these questions, it'll help us figure out
+        why things are going wrong.
+
+        - **What did you do?**
 
           I ran the command `#{$PROGRAM_NAME} #{ARGV.join(" ")}`
 
-        - What did you expect to happen?
+        - **What did you expect to happen?**
 
           I expected Bundler to...
 
-        - What happened instead?
+        - **What happened instead?**
 
           Instead, what happened was...
 
+        - **Have you tried any solutions posted on similar issues in our issue tracker, stack overflow, or google?**
+
+          I tried...
+
+        - **Have you read our issues document, https://github.com/bundler/bundler/blob/master/ISSUES.md?**
+
+          ...
 
-        Error details
+        ## Backtrace
 
-            #{e.class}: #{e.message}
-              #{e.backtrace && e.backtrace.join("\n              ")}
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace && e.backtrace.join("\n          ").chomp}
+        ```
 
-        #{Bundler::Env.new.report(:print_gemfile => false, :print_gemspecs => false).gsub(/\n/, "\n      ").strip}
+        #{Bundler::Env.new.report(:print_gemfile => false, :print_gemspecs => false)}
         --- TEMPLATE END ----------------------------------------------------------------
 
       EOS

data/bundler/lib/bundler/index.rb

@@ -109,14 +109,19 @@ module Bundler
 
     # returns a list of the dependencies
     def unmet_dependency_names
-      names = dependency_names
-      names.delete_if {|n| n == "bundler" }
-      names.select {|n| search(n).empty? }
+      dependency_names.select do |name|
+        name != "bundler" && search(name).empty?
+      end
     end
 
     def dependency_names
       names = []
-      each {|s| names.concat(s.dependencies.map(&:name)) }
+      each do |spec|
+        spec.dependencies.each do |dep|
+          next if dep.type == :development
+          names << dep.name
+        end
+      end
       names.uniq
     end
 

data/bundler/lib/bundler/inline.rb

@@ -60,7 +60,7 @@ def gemfile(install = false, options = {}, &gemfile)
 
   Bundler.ui = ui if install
   if install || missing_specs.call
-    installer = Bundler::Installer.install(Bundler.root, definition, :system => true)
+    installer = Bundler::Installer.install(Bundler.root, definition, :system => true, :inline => true)
     installer.post_install_messages.each do |name, message|
       Bundler.ui.info "Post-install message from #{name}:\n#{message}"
     end

data/bundler/lib/bundler/installer.rb

@@ -212,7 +212,7 @@ module Bundler
     end
 
     def resolve_if_need(options)
-      if Bundler.default_lockfile.exist? && !options["update"]
+      if Bundler.default_lockfile.exist? && !options["update"] && !options[:inline]
         local = Bundler.ui.silence do
           begin
             tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)

data/bundler/lib/bundler/installer/gem_installer.rb

@@ -52,12 +52,12 @@ module Bundler
     end
 
     def install
-      spec.source.install(spec, :force => force, :ensure_builtin_gems_cached => standalone)
+      spec.source.install(spec, :force => force, :ensure_builtin_gems_cached => standalone, :build_args => [spec_settings])
     end
 
     def install_with_settings
       # Build arguments are global, so this is mutexed
-      Bundler.rubygems.with_build_args([spec_settings]) { install }
+      Bundler.rubygems.install_with_build_args([spec_settings]) { install }
     end
 
     def out_of_space_message

data/bundler/lib/bundler/installer/parallel_installer.rb

@@ -47,23 +47,22 @@ module Bundler
       # sure needed dependencies have been installed.
       def dependencies_installed?(all_specs)
         installed_specs = all_specs.select(&:installed?).map(&:name)
-        dependencies(all_specs.map(&:name)).all? {|d| installed_specs.include? d.name }
+        dependencies.all? {|d| installed_specs.include? d.name }
       end
 
       # Represents only the non-development dependencies, the ones that are
       # itself and are in the total list.
-      def dependencies(all_spec_names)
+      def dependencies
         @dependencies ||= begin
-          deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
-          missing = deps.reject {|dep| all_spec_names.include? dep.name }
-          unless missing.empty?
-            raise Bundler::LockfileError, "Your Gemfile.lock is corrupt. The following #{missing.size > 1 ? "gems are" : "gem is"} missing " \
-                                "from the DEPENDENCIES section: '#{missing.map(&:name).join('\' \'')}'"
-          end
-          deps
+          all_dependencies.reject {|dep| ignorable_dependency? dep }
         end
       end
 
+      def missing_lockfile_dependencies(all_spec_names)
+        deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
+        deps.reject {|dep| all_spec_names.include? dep.name }
+      end
+
       # Represents all dependencies
       def all_dependencies
         @spec.dependencies
@@ -79,6 +78,8 @@ module Bundler
       [Bundler.settings[:jobs].to_i - 1, 1].max
     end
 
+    attr_reader :size
+
     def initialize(installer, all_specs, size, standalone, force)
       @installer = installer
       @size = size
@@ -88,6 +89,11 @@ module Bundler
     end
 
     def call
+      # Since `autoload` has the potential for threading issues on 1.8.7
+      # TODO:  remove in bundler 2.0
+      require "bundler/gem_remote_fetcher" if RUBY_VERSION < "1.9"
+
+      check_for_corrupt_lockfile
       enqueue_specs
       process_specs until @specs.all?(&:installed?) || @specs.any?(&:failed?)
       handle_error if @specs.any?(&:failed?)
@@ -131,6 +137,31 @@ module Bundler
       raise Bundler::InstallError, errors.map(&:to_s).join("\n\n")
     end
 
+    def check_for_corrupt_lockfile
+      missing_dependencies = @specs.map do |s|
+        [
+          s,
+          s.missing_lockfile_dependencies(@specs.map(&:name)),
+        ]
+      end.reject { |a| a.last.empty? }
+      return if missing_dependencies.empty?
+
+      warning = []
+      warning << "Your lockfile was created by an old Bundler that left some things out."
+      if @size != 1
+        warning << "Because of the missing DEPENDENCIES, we can only install gems one at a time, instead of installing #{@size} at a time."
+        @size = 1
+      end
+      warning << "You can fix this by adding the missing gems to your Gemfile, running bundle install, and then removing the gems from your Gemfile."
+      warning << "The missing gems are:"
+
+      missing_dependencies.each do |spec, missing|
+        warning << "* #{missing.map(&:name).join(", ")} depended upon by #{spec.name}"
+      end
+
+      Bundler.ui.warn(warning.join("\n"))
+    end
+
     # Keys in the remains hash represent uninstalled gems specs.
     # We enqueue all gem specs that do not have any dependencies.
     # Later we call this lambda again to install specs that depended on

data/bundler/lib/bundler/lockfile_parser.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "strscan"
 
 # Some versions of the Bundler 1.1 RC series introduced corrupted
 # lockfiles. There were two major problems:

data/bundler/lib/bundler/match_platform.rb

@@ -6,10 +6,18 @@ module Bundler
     include GemHelpers
 
     def match_platform(p)
-      Gem::Platform::RUBY == platform ||
-        platform.nil? || p == platform ||
-        generic(Gem::Platform.new(platform)) === p ||
-        Gem::Platform.new(platform) === p
+      MatchPlatform.platforms_match?(platform, p)
+    end
+
+    def self.platforms_match?(gemspec_platform, local_platform)
+      return true if gemspec_platform.nil?
+      return true if Gem::Platform::RUBY == gemspec_platform
+      return true if local_platform == gemspec_platform
+      gemspec_platform = Gem::Platform.new(gemspec_platform)
+      return true if GemHelpers.generic(gemspec_platform) === local_platform
+      return true if gemspec_platform === local_platform
+
+      false
     end
   end
 end

data/bundler/lib/bundler/plugin/api.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "bundler/plugin/api/source"
 
 module Bundler
   # This is the interfacing class represents the API that we intend to provide
@@ -24,6 +23,8 @@ module Bundler
   # and hooks).
   module Plugin
     class API
+      autoload :Source, "bundler/plugin/api/source"
+
       # The plugins should declare that they handle a command through this helper.
       #
       # @param [String] command being handled by them

data/bundler/lib/bundler/plugin/api/source.rb

@@ -93,7 +93,7 @@ module Bundler
         # It should be called in `install` after the plugin is done placing the
         # gem at correct install location.
         #
-        # It also runs Gem hooks `post_install`, `post_build` and `post_install`
+        # It also runs Gem hooks `pre_install`, `post_build` and `post_install`
         #
         # Note: Do not override if you don't know what you are doing.
         def post_install(spec, disable_exts = false)

data/bundler/lib/bundler/postit_trampoline.rb

@@ -8,11 +8,11 @@ environment = BundlerVendoredPostIt::PostIt::Environment.new([])
 version = Gem::Requirement.new(environment.bundler_version)
 if version.requirements.size == 1 && version.requirements.first.first == "=" # version.exact?
   if version.requirements.first.last.segments.first >= 2
-    ENV["BUNDLE_ENABLE_TRAMPOLINE"] = "true"
+    ENV["BUNDLE_TRAMPOLINE_FORCE"] = "true"
   end
 end
 
-if ENV["BUNDLE_ENABLE_TRAMPOLINE"] && !ENV["BUNDLE_DISABLE_POSTIT"]
+if ENV["BUNDLE_TRAMPOLINE_FORCE"] && !ENV["BUNDLE_TRAMPOLINE_DISABLE"]
   installed_version =
     if defined?(Bundler::VERSION)
       Bundler::VERSION
@@ -70,4 +70,4 @@ You're running Bundler #{installed_version} but this project uses #{running_vers
     abort "The running bundler (#{running_version}) does not match the required `#{version}`"
   end
 
-end # if ENV["BUNDLE_ENABLE_TRAMPOLINE"] && !ENV["BUNDLE_DISABLE_POSTIT"]
+end # if ENV["BUNDLE_TRAMPOLINE_FORCE"] && !ENV["BUNDLE_TRAMPOLINE_DISABLE"]

data/bundler/lib/bundler/resolver.rb

@@ -365,8 +365,13 @@ module Bundler
                        "Source does not contain any versions of '#{requirement}'"
                      end
         else
+          cache_message = begin
+                            " or in gems cached in #{Bundler.settings.app_cache_path}" if Bundler.app_cache.exist?
+                          rescue GemfileNotFound
+                            nil
+                          end
           message = "Could not find gem '#{requirement}' in any of the gem sources " \
-            "listed in your Gemfile or available on this machine."
+            "listed in your Gemfile#{cache_message}."
         end
         raise GemNotFound, message
       end