rubygems-update 3.1.6 → 3.2.0

data/bundler/lib/bundler/cli/issue.rb

@@ -10,7 +10,7 @@ module Bundler
         be sure to check out these resources:
 
         1. Check out our troubleshooting guide for quick fixes to common issues:
-        https://github.com/bundler/bundler/blob/master/doc/TROUBLESHOOTING.md
+        https://github.com/rubygems/rubygems/blob/master/bundler/doc/TROUBLESHOOTING.md
 
         2. Instructions for common Bundler uses can be found on the documentation
         site: https://bundler.io/
@@ -22,7 +22,7 @@ module Bundler
         still aren't working the way you expect them to, please let us know so
         that we can diagnose and help fix the problem you're having. Please
         view the Filing Issues guide for more information:
-        https://github.com/bundler/bundler/blob/master/doc/contributing/ISSUES.md
+        https://github.com/rubygems/rubygems/blob/master/bundler/doc/contributing/ISSUES.md
 
       EOS
 

data/bundler/lib/bundler/cli/list.rb

@@ -4,14 +4,16 @@ module Bundler
   class CLI::List
     def initialize(options)
       @options = options
+      @without_group = options["without-group"].map(&:to_sym)
+      @only_group = options["only-group"].map(&:to_sym)
     end
 
     def run
-      raise InvalidOption, "The `--only-group` and `--without-group` options cannot be used together" if @options["only-group"] && @options["without-group"]
+      raise InvalidOption, "The `--only-group` and `--without-group` options cannot be used together" if @only_group.any? && @without_group.any?
 
       raise InvalidOption, "The `--name-only` and `--paths` options cannot be used together" if @options["name-only"] && @options[:paths]
 
-      specs = if @options["only-group"] || @options["without-group"]
+      specs = if @only_group.any? || @without_group.any?
         filtered_specs_by_groups
       else
         Bundler.load.specs
@@ -29,12 +31,12 @@ module Bundler
       Bundler.ui.info "Use `bundle info` to print more detailed information about a gem"
     end
 
-  private
+    private
 
     def verify_group_exists(groups)
-      raise InvalidOption, "`#{@options["without-group"]}` group could not be found." if @options["without-group"] && !groups.include?(@options["without-group"].to_sym)
-
-      raise InvalidOption, "`#{@options["only-group"]}` group could not be found." if @options["only-group"] && !groups.include?(@options["only-group"].to_sym)
+      (@without_group + @only_group).each do |group|
+        raise InvalidOption, "`#{group}` group could not be found." unless groups.include?(group)
+      end
     end
 
     def filtered_specs_by_groups
@@ -44,10 +46,10 @@ module Bundler
       verify_group_exists(groups)
 
       show_groups =
-        if @options["without-group"]
-          groups.reject {|g| g == @options["without-group"].to_sym }
-        elsif @options["only-group"]
-          groups.select {|g| g == @options["only-group"].to_sym }
+        if @without_group.any?
+          groups.reject {|g| @without_group.include?(g) }
+        elsif @only_group.any?
+          groups.select {|g| @only_group.include?(g) }
         else
           groups
         end.map(&:to_sym)

data/bundler/lib/bundler/cli/outdated.rb

@@ -3,18 +3,16 @@
 module Bundler
   class CLI::Outdated
     attr_reader :options, :gems, :options_include_groups, :filter_options_patch, :sources, :strict
-    attr_accessor :outdated_gems_by_groups, :outdated_gems_list
+    attr_accessor :outdated_gems
 
     def initialize(options, gems)
       @options = options
       @gems = gems
       @sources = Array(options[:source])
 
-      @filter_options_patch = options.keys &
-        %w[filter-major filter-minor filter-patch]
+      @filter_options_patch = options.keys & %w[filter-major filter-minor filter-patch]
 
-      @outdated_gems_by_groups = {}
-      @outdated_gems_list = []
+      @outdated_gems = []
 
       @options_include_groups = [:group, :groups].any? do |v|
         options.keys.include?(v.to_s)
@@ -22,8 +20,7 @@ module Bundler
 
       # the patch level options imply strict is also true. It wouldn't make
       # sense otherwise.
-      @strict = options["filter-strict"] ||
-        Bundler::CLI::Common.patch_level_options(options).any?
+      @strict = options["filter-strict"] || Bundler::CLI::Common.patch_level_options(options).any?
     end
 
     def run
@@ -76,86 +73,64 @@ module Bundler
       end
 
       specs.sort_by(&:name).each do |current_spec|
-        next if !gems.empty? && !gems.include?(current_spec.name)
+        next unless gems.empty? || gems.include?(current_spec.name)
 
-        dependency = current_dependencies[current_spec.name]
         active_spec = retrieve_active_spec(definition, current_spec)
-
-        next if active_spec.nil?
-        next if filter_options_patch.any? &&
-          !update_present_via_semver_portions(current_spec, active_spec, options)
+        next unless filter_options_patch.empty? || update_present_via_semver_portions(current_spec, active_spec, options)
 
         gem_outdated = Gem::Version.new(active_spec.version) > Gem::Version.new(current_spec.version)
         next unless gem_outdated || (current_spec.git_version != active_spec.git_version)
-        groups = nil
+
+        dependency = current_dependencies[current_spec.name]
+        groups = ""
         if dependency && !options[:parseable]
           groups = dependency.groups.join(", ")
         end
 
-        outdated_gems_list << { :active_spec => active_spec,
-                                :current_spec => current_spec,
-                                :dependency => dependency,
-                                :groups => groups }
-
-        outdated_gems_by_groups[groups] ||= []
-        outdated_gems_by_groups[groups] << outdated_gems_list[-1]
+        outdated_gems << {
+          :active_spec => active_spec,
+          :current_spec => current_spec,
+          :dependency => dependency,
+          :groups => groups,
+        }
       end
 
-      if outdated_gems_list.empty?
-        display_nothing_outdated_message
-      else
+      if outdated_gems.empty?
         unless options[:parseable]
-          Bundler.ui.info(header_outdated_message)
+          Bundler.ui.info(nothing_outdated_message)
         end
-
+      else
         if options_include_groups
-          ordered_groups = outdated_gems_by_groups.keys.compact.sort
-          ordered_groups.insert(0, nil).each do |groups|
-            gems = outdated_gems_by_groups[groups]
-            contains_group = if groups
-              groups.split(", ").include?(options[:group])
-            else
-              options[:group] == "group"
-            end
+          relevant_outdated_gems = outdated_gems.group_by {|g| g[:groups] }.sort.flat_map do |groups, gems|
+            contains_group = groups.split(", ").include?(options[:group])
+            next unless options[:groups] || contains_group
 
-            next if (!options[:groups] && !contains_group) || gems.nil?
+            gems
+          end.compact
 
-            unless options[:parseable]
-              Bundler.ui.info(header_group_message(groups))
+          if options[:parseable]
+            relevant_outdated_gems.each do |gems|
+              print_gems(gems)
             end
-
-            print_gems(gems)
+          else
+            print_gems_table(relevant_outdated_gems)
           end
+        elsif options[:parseable]
+          print_gems(outdated_gems)
         else
-          print_gems(outdated_gems_list)
+          print_gems_table(outdated_gems)
         end
 
         exit 1
       end
     end
 
-  private
+    private
 
     def groups_text(group_text, groups)
       "#{group_text}#{groups.split(",").size > 1 ? "s" : ""} \"#{groups}\""
     end
 
-    def header_outdated_message
-      if options[:pre]
-        "Outdated gems included in the bundle (including pre-releases):"
-      else
-        "Outdated gems included in the bundle:"
-      end
-    end
-
-    def header_group_message(groups)
-      if groups
-        "===== #{groups_text("Group", groups)} ====="
-      else
-        "===== Without group ====="
-      end
-    end
-
     def nothing_outdated_message
       if filter_options_patch.any?
         display = filter_options_patch.map do |o|
@@ -182,12 +157,6 @@ module Bundler
       active_spec
     end
 
-    def display_nothing_outdated_message
-      unless options[:parseable]
-        Bundler.ui.info(nothing_outdated_message)
-      end
-    end
-
     def print_gems(gems_list)
       gems_list.each do |gem|
         print_gem(
@@ -199,6 +168,19 @@ module Bundler
       end
     end
 
+    def print_gems_table(gems_list)
+      data = gems_list.map do |gem|
+        gem_column_for(
+          gem[:current_spec],
+          gem[:active_spec],
+          gem[:dependency],
+          gem[:groups],
+        )
+      end
+
+      print_indented([table_header] + data)
+    end
+
     def print_gem(current_spec, active_spec, dependency, groups)
       spec_version = "#{active_spec.version}#{active_spec.git_version}"
       spec_version += " (from #{active_spec.loaded_from})" if Bundler.ui.debug? && active_spec.loaded_from
@@ -213,7 +195,7 @@ module Bundler
 
       output_message = if options[:parseable]
         spec_outdated_info.to_s
-      elsif options_include_groups || !groups
+      elsif options_include_groups || groups.empty?
         "  * #{spec_outdated_info}"
       else
         "  * #{spec_outdated_info} in #{groups_text("group", groups)}"
@@ -222,14 +204,22 @@ module Bundler
       Bundler.ui.info output_message.rstrip
     end
 
+    def gem_column_for(current_spec, active_spec, dependency, groups)
+      current_version = "#{current_spec.version}#{current_spec.git_version}"
+      spec_version = "#{active_spec.version}#{active_spec.git_version}"
+      dependency = dependency.requirement if dependency
+
+      ret_val = [active_spec.name, current_version, spec_version, dependency.to_s, groups.to_s]
+      ret_val << active_spec.loaded_from.to_s if Bundler.ui.debug?
+      ret_val
+    end
+
     def check_for_deployment_mode!
       return unless Bundler.frozen_bundle?
-      suggested_command = if Bundler.settings.locations("frozen")[:global]
+      suggested_command = if Bundler.settings.locations("frozen").keys.&([:global, :local]).any?
         "bundle config unset frozen"
       elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any?
         "bundle config unset deployment"
-      else
-        "bundle install --no-deployment"
       end
       raise ProductionError, "You are trying to check outdated gems in " \
         "deployment mode. Run `bundle outdated` elsewhere.\n" \
@@ -239,6 +229,8 @@ module Bundler
     end
 
     def update_present_via_semver_portions(current_spec, active_spec, options)
+      return false if active_spec.nil?
+
       current_major = current_spec.version.segments.first
       active_major = active_spec.version.segments.first
 
@@ -266,5 +258,34 @@ module Bundler
       version_section = spec.version.segments[version_portion_index, 1]
       version_section.to_a[0].to_i
     end
+
+    def print_indented(matrix)
+      header = matrix[0]
+      data = matrix[1..-1]
+
+      column_sizes = Array.new(header.size) do |index|
+        matrix.max_by {|row| row[index].length }[index].length
+      end
+
+      Bundler.ui.info justify(header, column_sizes)
+
+      data.sort_by! {|row| row[0] }
+
+      data.each do |row|
+        Bundler.ui.info justify(row, column_sizes)
+      end
+    end
+
+    def table_header
+      header = ["Gem", "Current", "Latest", "Requested", "Groups"]
+      header << "Path" if Bundler.ui.debug?
+      header
+    end
+
+    def justify(row, sizes)
+      row.each_with_index.map do |element, index|
+        element.ljust(sizes[index])
+      end.join("  ").strip + "\n"
+    end
   end
 end

data/bundler/lib/bundler/cli/plugin.rb

@@ -23,6 +23,16 @@ module Bundler
       Bundler::Plugin.install(plugins, options)
     end
 
+    desc "uninstall PLUGINS", "Uninstall the plugins"
+    long_desc <<-D
+      Uninstall given list of plugins. To uninstall all the plugins, use -all option.
+    D
+    method_option "all", :type => :boolean, :default => nil, :banner =>
+      "Uninstall all the installed plugins. If no plugin is installed, then it does nothing."
+    def uninstall(*plugins)
+      Bundler::Plugin.uninstall(plugins, options)
+    end
+
     desc "list", "List the installed plugins and available commands"
     def list
       Bundler::Plugin.list

data/bundler/lib/bundler/cli/pristine.rb

@@ -29,6 +29,11 @@ module Bundler
 
           FileUtils.rm_rf spec.full_gem_path
         when Source::Git
+          if source.local?
+            Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is locally overridden.")
+            next
+          end
+
           source.remote!
           if extension_cache_path = source.extension_cache_path(spec)
             FileUtils.rm_rf extension_cache_path

data/bundler/lib/bundler/cli/show.rb

@@ -53,7 +53,7 @@ module Bundler
       end
     end
 
-  private
+    private
 
     def fetch_latest_specs
       definition = Bundler.definition(true)

data/bundler/lib/bundler/cli/update.rb

@@ -106,6 +106,8 @@ module Bundler
       Bundler.ui.confirm "Bundle updated!"
       Bundler::CLI::Common.output_without_groups_message(:update)
       Bundler::CLI::Common.output_post_install_messages installer.post_install_messages
+
+      Bundler::CLI::Common.output_fund_metadata_summary
     end
   end
 end

data/bundler/lib/bundler/compact_index_client.rb

@@ -87,7 +87,7 @@ module Bundler
       @parsed_checksums = true
     end
 
-  private
+    private
 
     def update(local_path, remote_path)
       Bundler::CompactIndexClient.debug { "update(#{local_path}, #{remote_path})" }

data/bundler/lib/bundler/compact_index_client/cache.rb

@@ -83,7 +83,7 @@ module Bundler
         gem_line ? parse_gem(gem_line) : nil
       end
 
-    private
+      private
 
       def lines(path)
         return [] unless path.file?

data/bundler/lib/bundler/compact_index_client/updater.rb

@@ -22,13 +22,13 @@ module Bundler
 
       def initialize(fetcher)
         @fetcher = fetcher
-        require "tmpdir"
+        require_relative "../vendored_tmpdir"
       end
 
       def update(local_path, remote_path, retrying = nil)
         headers = {}
 
-        Dir.mktmpdir("bundler-compact-index-") do |local_temp_dir|
+        Bundler::Dir.mktmpdir("bundler-compact-index-") do |local_temp_dir|
           local_temp_path = Pathname.new(local_temp_dir).join(local_path.basename)
 
           # first try to fetch any new bytes on the existing file
@@ -66,8 +66,8 @@ module Bundler
             end
           end
 
-          response_etag = (response["ETag"] || "").gsub(%r{\AW/}, "")
-          if etag_for(local_temp_path) == response_etag
+          etag = (response["ETag"] || "").gsub(%r{\AW/}, "")
+          if etag.length.zero? || etag_for(local_temp_path) == etag
             SharedHelpers.filesystem_access(local_path) do
               FileUtils.mv(local_temp_path, local_path)
             end
@@ -75,7 +75,7 @@ module Bundler
           end
 
           if retrying
-            raise MisMatchedChecksumError.new(remote_path, response_etag, etag_for(local_temp_path))
+            raise MisMatchedChecksumError.new(remote_path, etag, etag_for(local_temp_path))
           end
 
           update(local_path, remote_path, :retrying)

data/bundler/lib/bundler/definition.rb

@@ -77,12 +77,17 @@ module Bundler
       @locked_bundler_version = nil
       @locked_ruby_version    = nil
       @locked_specs_incomplete_for_platform = false
+      @new_platform = nil
 
       if lockfile && File.exist?(lockfile)
         @lockfile_contents = Bundler.read_file(lockfile)
         @locked_gems = LockfileParser.new(@lockfile_contents)
         @locked_platforms = @locked_gems.platforms
-        @platforms = @locked_platforms.dup
+        if Bundler.settings[:force_ruby_platform]
+          @platforms = [Gem::Platform::RUBY]
+        else
+          @platforms = @locked_platforms.dup
+        end
         @locked_bundler_version = @locked_gems.bundler_version
         @locked_ruby_version = @locked_gems.ruby_version
 
@@ -194,10 +199,6 @@ module Bundler
       @locked_specs - specs
     end
 
-    def new_platform?
-      @new_platform
-    end
-
     def missing_specs
       missing = []
       resolve.materialize(requested_dependencies, missing)
@@ -227,16 +228,29 @@ module Bundler
       end
     end
 
+    def requested_dependencies
+      groups = requested_groups
+      groups.map!(&:to_sym)
+      dependencies_for(groups)
+    end
+
     def current_dependencies
-      dependencies.select(&:should_include?)
+      dependencies.select do |d|
+        d.should_include? && !d.gem_platforms(@platforms).empty?
+      end
     end
 
     def specs_for(groups)
-      deps = dependencies.select {|d| (d.groups & groups).any? }
-      deps.delete_if {|d| !d.should_include? }
+      deps = dependencies_for(groups)
       specs.for(expand_dependencies(deps))
     end
 
+    def dependencies_for(groups)
+      current_dependencies.reject do |d|
+        (d.groups & groups).empty?
+      end
+    end
+
     # Resolve all the dependencies specified in Gemfile. It ensures that
     # dependencies that have been already resolved via locked file and are fresh
     # are reused when resolving dependencies
@@ -312,10 +326,6 @@ module Bundler
       sources.rubygems_sources.any? {|s| s.remotes.any? }
     end
 
-    def has_local_dependencies?
-      !sources.path_sources.empty? || !sources.git_sources.empty?
-    end
-
     def spec_git_paths
       sources.git_sources.map {|s| File.realpath(s.path) if File.exist?(s.path) }.compact
     end
@@ -396,12 +406,10 @@ module Bundler
              "updated #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} to version control."
 
       unless explicit_flag
-        suggested_command = if Bundler.settings.locations("frozen")[:global]
+        suggested_command = if Bundler.settings.locations("frozen").keys.&([:global, :local]).any?
           "bundle config unset frozen"
         elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any?
           "bundle config unset deployment"
-        else
-          "bundle install --no-deployment"
         end
         msg << "\n\nIf this is a development machine, remove the #{Bundler.default_gemfile} " \
                "freeze \nby running `#{suggested_command}`."
@@ -450,9 +458,9 @@ module Bundler
       @locked_deps.each  {|name, d| both_sources[name][1] = d.source }
 
       both_sources.each do |name, (dep, lock_source)|
-        next unless (dep.nil? && !lock_source.nil?) || (!dep.nil? && !lock_source.nil? && !lock_source.can_lock?(dep))
+        next if lock_source.nil? || (dep && lock_source.can_lock?(dep))
         gemfile_source_name = (dep && dep.source) || "no specified source"
-        lockfile_source_name = lock_source || "no specified source"
+        lockfile_source_name = lock_source
         changed << "* #{name} from `#{gemfile_source_name}` to `#{lockfile_source_name}`"
       end
 
@@ -518,10 +526,6 @@ module Bundler
       raise InvalidOption, "Unable to remove the platform `#{platform}` since the only platforms are #{@platforms.join ", "}"
     end
 
-    def add_current_platform
-      current_platforms.each {|platform| add_platform(platform) }
-    end
-
     def find_resolved_spec(current_spec)
       specs.find_by_name_and_platform(current_spec.name, current_spec.platform)
     end
@@ -541,14 +545,14 @@ module Bundler
       @unlocking
     end
 
-  private
+    private
+
+    def add_current_platform
+      current_platforms.each {|platform| add_platform(platform) }
+    end
 
     def current_platforms
-      current_platform = Bundler.local_platform
-      [].tap do |platforms|
-        platforms << current_platform if Bundler.feature_flag.specific_platform?
-        platforms << generic(current_platform)
-      end
+      [local_platform, generic_local_platform].uniq
     end
 
     def change_reason
@@ -706,9 +710,6 @@ module Bundler
         elsif dep.source
           dep.source = sources.get(dep.source)
         end
-        if dep.source.is_a?(Source::Gemspec)
-          dep.platforms.concat(@platforms.map {|p| Dependency::REVERSE_PLATFORM_MAP[p] }.flatten(1)).uniq!
-        end
       end
 
       changes = false
@@ -818,7 +819,7 @@ module Bundler
       end
 
       resolve = SpecSet.new(converged)
-      @locked_specs_incomplete_for_platform = !resolve.for(expand_dependencies(deps), @unlock[:gems], true, true)
+      @locked_specs_incomplete_for_platform = !resolve.for(expand_dependencies(requested_dependencies & deps), @unlock[:gems], true, true)
       resolve = resolve.for(expand_dependencies(deps, true), @unlock[:gems], false, false, false)
       diff    = nil
 
@@ -856,11 +857,7 @@ module Bundler
 
     def metadata_dependencies
       @metadata_dependencies ||= begin
-        ruby_versions = concat_ruby_version_requirements(@ruby_version)
-        if ruby_versions.empty? || !@ruby_version.exact?
-          concat_ruby_version_requirements(RubyVersion.system)
-          concat_ruby_version_requirements(locked_ruby_version_object) unless @unlock[:ruby]
-        end
+        ruby_versions = ruby_version_requirements(@ruby_version)
         [
           Dependency.new("Ruby\0", ruby_versions),
           Dependency.new("RubyGems\0", Gem::VERSION),
@@ -868,49 +865,37 @@ module Bundler
       end
     end
 
-    def concat_ruby_version_requirements(ruby_version, ruby_versions = [])
-      return ruby_versions unless ruby_version
+    def ruby_version_requirements(ruby_version)
+      return [] unless ruby_version
       if ruby_version.patchlevel
-        ruby_versions << ruby_version.to_gem_version_with_patchlevel
+        [ruby_version.to_gem_version_with_patchlevel]
       else
-        ruby_versions.concat(ruby_version.versions.map do |version|
+        ruby_version.versions.map do |version|
           requirement = Gem::Requirement.new(version)
           if requirement.exact?
             "~> #{version}.0"
           else
             requirement
           end
-        end)
+        end
       end
     end
 
     def expand_dependencies(dependencies, remote = false)
-      sorted_platforms = Resolver.sort_platforms(@platforms)
       deps = []
       dependencies.each do |dep|
         dep = Dependency.new(dep, ">= 0") unless dep.respond_to?(:name)
-        next if !remote && !dep.current_platform?
-        platforms = dep.gem_platforms(sorted_platforms)
-        if platforms.empty? && !Bundler.settings[:disable_platform_warnings]
-          mapped_platforms = dep.expanded_platforms
-          Bundler.ui.warn \
-            "The dependency #{dep} will be unused by any of the platforms Bundler is installing for. " \
-            "Bundler is installing for #{@platforms.join ", "} but the dependency " \
-            "is only for #{mapped_platforms.join ", "}. " \
-            "To add those platforms to the bundle, " \
-            "run `bundle lock --add-platform #{mapped_platforms.join " "}`."
-        end
-        platforms.each do |p|
-          deps << DepProxy.new(dep, p) if remote || p == generic_local_platform
-        end
+        next unless remote || dep.current_platform?
+        target_platforms = dep.gem_platforms(remote ? Resolver.sort_platforms(@platforms) : [generic_local_platform])
+        deps += expand_dependency_with_platforms(dep, target_platforms)
       end
       deps
     end
 
-    def requested_dependencies
-      groups = requested_groups
-      groups.map!(&:to_sym)
-      dependencies.reject {|d| !d.should_include? || (d.groups & groups).empty? }
+    def expand_dependency_with_platforms(dep, platforms)
+      platforms.map do |p|
+        DepProxy.new(dep, p)
+      end
     end
 
     def source_requirements
@@ -985,8 +970,9 @@ module Bundler
       @locked_gems.specs.reduce({}) do |requirements, locked_spec|
         name = locked_spec.name
         dependency = dependencies_by_name[name]
+        next requirements unless dependency
         next requirements if @locked_gems.dependencies[name] != dependency
-        next requirements if dependency && dependency.source.is_a?(Source::Path)
+        next requirements if dependency.source.is_a?(Source::Path)
         dep = Gem::Dependency.new(name, ">= #{locked_spec.version}")
         requirements[name] = DepProxy.new(dep, locked_spec.platform)
         requirements