rubygems-update 3.0.3 → 3.4.7

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

@@ -2,17 +2,29 @@
 
 module Bundler
   class CLI::Outdated
-    attr_reader :options, :gems
+    attr_reader :options, :gems, :options_include_groups, :filter_options_patch, :sources, :strict
+    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]
+
+      @outdated_gems = []
+
+      @options_include_groups = [:group, :groups].any? do |v|
+        options.keys.include?(v.to_s)
+      end
+
+      # 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?
     end
 
     def run
-      check_for_deployment_mode
-
-      sources = Array(options[:source])
+      check_for_deployment_mode!
 
       gems.each do |gem_name|
         Bundler::CLI::Common.select_spec(gem_name)
@@ -20,11 +32,9 @@ module Bundler
 
       Bundler.definition.validate_runtime!
       current_specs = Bundler.ui.silence { Bundler.definition.resolve }
-      current_dependencies = {}
-      Bundler.ui.silence do
-        Bundler.load.dependencies.each do |dep|
-          current_dependencies[dep.name] = dep
-        end
+
+      current_dependencies = Bundler.ui.silence do
+        Bundler.load.dependencies.map {|dep| [dep.name, dep] }.to_h
       end
 
       definition = if gems.empty? && sources.empty?
@@ -36,17 +46,9 @@ module Bundler
 
       Bundler::CLI::Common.configure_gem_version_promoter(
         Bundler.definition,
-        options
+        options.merge(:strict => @strict)
       )
 
-      # the patch level options imply strict is also true. It wouldn't make
-      # sense otherwise.
-      strict = options[:strict] ||
-        Bundler::CLI::Common.patch_level_options(options).any?
-
-      filter_options_patch = options.keys &
-        %w[filter-major filter-minor filter-patch]
-
       definition_resolution = proc do
         options[:local] ? definition.resolve_with_cache! : definition.resolve_remotely!
       end
@@ -58,8 +60,6 @@ module Bundler
       end
 
       Bundler.ui.info ""
-      outdated_gems_by_groups = {}
-      outdated_gems_list = []
 
       # Loop through the current specs
       gemfile_specs, dependency_specs = current_specs.partition do |spec|
@@ -72,132 +72,126 @@ module Bundler
         gemfile_specs + dependency_specs
       end
 
-      specs.sort_by(&:name).each do |current_spec|
-        next if !gems.empty? && !gems.include?(current_spec.name)
+      specs.sort_by(&:name).uniq(&:name).each do |current_spec|
+        next unless gems.empty? || gems.include?(current_spec.name)
 
-        dependency = current_dependencies[current_spec.name]
-        active_spec = retrieve_active_spec(strict, definition, current_spec)
+        active_spec = retrieve_active_spec(definition, current_spec)
+        next unless active_spec
 
-        next if active_spec.nil?
-        if filter_options_patch.any?
-          update_present = update_present_via_semver_portions(current_spec, active_spec, options)
-          next unless update_present
-        end
+        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] << { :active_spec => active_spec,
-                                             :current_spec => current_spec,
-                                             :dependency => dependency,
-                                             :groups => groups }
+        outdated_gems << {
+          :active_spec => active_spec,
+          :current_spec => current_spec,
+          :dependency => dependency,
+          :groups => groups,
+        }
       end
 
-      if outdated_gems_list.empty?
-        display_nothing_outdated_message(filter_options_patch)
-      else
+      if outdated_gems.empty?
         unless options[:parseable]
-          if options[:pre]
-            Bundler.ui.info "Outdated gems included in the bundle (including " \
-              "pre-releases):"
-          else
-            Bundler.ui.info "Outdated gems included in the bundle:"
-          end
+          Bundler.ui.info(nothing_outdated_message)
         end
+      else
+        if options_include_groups
+          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
 
-        options_include_groups = [:group, :groups].select do |v|
-          options.keys.include?(v.to_s)
-        end
+            gems
+          end.compact
 
-        if options_include_groups.any?
-          ordered_groups = outdated_gems_by_groups.keys.compact.sort
-          [nil, ordered_groups].flatten.each do |groups|
-            gems = outdated_gems_by_groups[groups]
-            contains_group = if groups
-              groups.split(",").include?(options[:group])
-            else
-              options[:group] == "group"
-            end
-
-            next if (!options[:groups] && !contains_group) || gems.nil?
-
-            unless options[:parseable]
-              if groups
-                Bundler.ui.info "===== Group #{groups} ====="
-              else
-                Bundler.ui.info "===== Without group ====="
-              end
-            end
-
-            gems.each do |gem|
-              print_gem(
-                gem[:current_spec],
-                gem[:active_spec],
-                gem[:dependency],
-                groups,
-                options_include_groups.any?
-              )
-            end
+          if options[:parseable]
+            print_gems(relevant_outdated_gems)
+          else
+            print_gems_table(relevant_outdated_gems)
           end
+        elsif options[:parseable]
+          print_gems(outdated_gems)
         else
-          outdated_gems_list.each do |gem|
-            print_gem(
-              gem[:current_spec],
-              gem[:active_spec],
-              gem[:dependency],
-              gem[:groups],
-              options_include_groups.any?
-            )
-          end
+          print_gems_table(outdated_gems)
         end
 
         exit 1
       end
     end
 
-  private
+    private
+
+    def loaded_from_for(spec)
+      return unless spec.respond_to?(:loaded_from)
+
+      spec.loaded_from
+    end
+
+    def groups_text(group_text, groups)
+      "#{group_text}#{groups.split(",").size > 1 ? "s" : ""} \"#{groups}\""
+    end
 
-    def retrieve_active_spec(strict, definition, current_spec)
-      if strict
-        active_spec = definition.find_resolved_spec(current_spec)
+    def nothing_outdated_message
+      if filter_options_patch.any?
+        display = filter_options_patch.map do |o|
+          o.sub("filter-", "")
+        end.join(" or ")
+
+        "No #{display} updates to display.\n"
       else
-        active_specs = definition.find_indexed_specs(current_spec)
-        if !current_spec.version.prerelease? && !options[:pre] && active_specs.size > 1
-          active_specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
-        end
-        active_spec = active_specs.last
+        "Bundle up to date!\n"
       end
+    end
+
+    def retrieve_active_spec(definition, current_spec)
+      active_spec = definition.resolve.find_by_name_and_platform(current_spec.name, current_spec.platform)
+      return unless active_spec
 
-      active_spec
+      return active_spec if strict
+
+      active_specs = active_spec.source.specs.search(current_spec.name).select {|spec| spec.match_platform(current_spec.platform) }.sort_by(&:version)
+      if !current_spec.version.prerelease? && !options[:pre] && active_specs.size > 1
+        active_specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
+      end
+      active_specs.last
     end
 
-    def display_nothing_outdated_message(filter_options_patch)
-      unless options[:parseable]
-        if filter_options_patch.any?
-          display = filter_options_patch.map do |o|
-            o.sub("filter-", "")
-          end.join(" or ")
+    def print_gems(gems_list)
+      gems_list.each do |gem|
+        print_gem(
+          gem[:current_spec],
+          gem[:active_spec],
+          gem[:dependency],
+          gem[:groups],
+        )
+      end
+    end
 
-          Bundler.ui.info "No #{display} updates to display.\n"
-        else
-          Bundler.ui.info "Bundle up to date!\n"
-        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, options_include_groups)
+    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
+      if Bundler.ui.debug?
+        loaded_from = loaded_from_for(active_spec)
+        spec_version += " (from #{loaded_from})" if loaded_from
+      end
       current_version = "#{current_spec.version}#{current_spec.git_version}"
 
       if dependency && dependency.specific?
@@ -209,23 +203,31 @@ 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 \"#{groups}\""
+        "  * #{spec_outdated_info} in #{groups_text("group", groups)}"
       end
 
       Bundler.ui.info output_message.rstrip
     end
 
-    def check_for_deployment_mode
+    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 << loaded_from_for(active_spec).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]
-        "bundle config --delete frozen"
+      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 --delete deployment"
-      else
-        "bundle install --no-deployment"
+        "bundle config unset deployment"
       end
       raise ProductionError, "You are trying to check outdated gems in " \
         "deployment mode. Run `bundle outdated` elsewhere.\n" \
@@ -260,7 +262,36 @@ module Bundler
 
     def get_version_semver_portion_value(spec, version_portion_index)
       version_section = spec.version.segments[version_portion_index, 1]
-      version_section.nil? ? 0 : (version_section.first || 0)
+      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/platform.rb

@@ -9,7 +9,7 @@ module Bundler
 
     def run
       platforms, ruby_version = Bundler.ui.silence do
-        locked_ruby_version = Bundler.locked_gems && Bundler.locked_gems.ruby_version
+        locked_ruby_version = Bundler.locked_gems && Bundler.locked_gems.ruby_version&.gsub(/p\d+\Z/, "")
         gemfile_ruby_version = Bundler.definition.ruby_version && Bundler.definition.ruby_version.single_version_string
         [Bundler.definition.platforms.map {|p| "* #{p}" },
          locked_ruby_version || gemfile_ruby_version]
@@ -23,7 +23,7 @@ module Bundler
           output << "No ruby version specified"
         end
       else
-        output << "Your platform is: #{RUBY_PLATFORM}"
+        output << "Your platform is: #{Gem::Platform.local}"
         output << "Your app has gems that work on these platforms:\n#{platforms.join("\n")}"
 
         if ruby_version

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "bundler/vendored_thor"
+require_relative "../vendored_thor"
 module Bundler
   class CLI::Plugin < Thor
     desc "install PLUGINS", "Install the plugin from the source"
     long_desc <<-D
-      Install plugins either from the rubygems source provided (with --source option) or from a git source provided with (--git option). If no sources are provided, it uses Gem.sources
+      Install plugins either from the rubygems source provided (with --source option) or from a git source provided with --git (for remote repos) or --local_git (for local repos). If no sources are provided, it uses Gem.sources
    D
     method_option "source", :type => :string, :default => nil, :banner =>
       "URL of the RubyGems source to fetch the plugin from"
@@ -13,6 +13,8 @@ module Bundler
       "The version of the plugin to fetch"
     method_option "git", :type => :string, :default => nil, :banner =>
       "URL of the git repo to fetch from"
+    method_option "local_git", :type => :string, :default => nil, :banner =>
+      "Path of the local git repo to fetch from"
     method_option "branch", :type => :string, :default => nil, :banner =>
       "The git branch to checkout"
     method_option "ref", :type => :string, :default => nil, :banner =>
@@ -20,5 +22,20 @@ module Bundler
     def install(*plugins)
       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
+    end
   end
 end

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

@@ -29,11 +29,16 @@ 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
           end
-          FileUtils.rm_rf spec.extension_dir if spec.respond_to?(:extension_dir)
+          FileUtils.rm_rf spec.extension_dir
           FileUtils.rm_rf spec.full_gem_path
         else
           Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is sourced from local path.")

data/bundler/lib/bundler/cli/remove.rb

@@ -11,8 +11,7 @@ module Bundler
       raise InvalidOption, "Please specify gems to remove." if @gems.empty?
 
       Injector.remove(@gems, {})
-
-      Installer.install(Bundler.root, Bundler.definition) if @options["install"]
+      Installer.install(Bundler.root, Bundler.definition)
     end
   end
 end

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

@@ -18,13 +18,13 @@ module Bundler
 
       if gem_name
         if gem_name == "bundler"
-          path = File.expand_path("../../../..", __FILE__)
+          path = File.expand_path("../../..", __dir__)
         else
           spec = Bundler::CLI::Common.select_spec(gem_name, :regex_match)
           return unless spec
           path = spec.full_gem_path
           unless File.directory?(path)
-            Bundler.ui.warn "The gem #{gem_name} has been deleted. It was installed at:"
+            return Bundler.ui.warn "The gem #{gem_name} has been deleted. It was installed at: #{path}"
           end
         end
         return Bundler.ui.info(path)
@@ -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

@@ -9,27 +9,36 @@ module Bundler
     end
 
     def run
-      Bundler.ui.level = "error" if options[:quiet]
+      Bundler.ui.level = "warn" if options[:quiet]
+
+      update_bundler = options[:bundler]
+
+      Bundler.self_manager.update_bundler_and_restart_with_it_if_needed(update_bundler) if update_bundler
 
       Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
 
       sources = Array(options[:source])
       groups  = Array(options[:group]).map(&:to_sym)
 
-      full_update = gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !options[:bundler]
+      full_update = gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !update_bundler
 
       if full_update && !options[:all]
         if Bundler.feature_flag.update_requires_all_flag?
           raise InvalidOption, "To update everything, pass the `--all` flag."
         end
-        SharedHelpers.major_deprecation 2, "Pass --all to `bundle update` to update everything"
+        SharedHelpers.major_deprecation 3, "Pass --all to `bundle update` to update everything"
       elsif !full_update && options[:all]
         raise InvalidOption, "Cannot specify --all along with specific options."
       end
 
+      conservative = options[:conservative]
+
       if full_update
-        # We're doing a full update
-        Bundler.definition(true)
+        if conservative
+          Bundler.definition(:conservative => conservative)
+        else
+          Bundler.definition(true)
+        end
       else
         unless Bundler.default_lockfile.exist?
           raise GemfileLockNotFound, "This Bundle hasn't been installed yet. " \
@@ -43,8 +52,8 @@ module Bundler
         end
 
         Bundler.definition(:gems => gems, :sources => sources, :ruby => options[:ruby],
-                           :lock_shared_dependencies => options[:conservative],
-                           :bundler => options[:bundler])
+                           :conservative => conservative,
+                           :bundler => update_bundler)
       end
 
       Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options)
@@ -58,24 +67,44 @@ module Bundler
       Bundler.settings.set_command_option_if_given :jobs, opts["jobs"]
 
       Bundler.definition.validate_runtime!
+
+      if locked_gems = Bundler.definition.locked_gems
+        previous_locked_info = locked_gems.specs.reduce({}) do |h, s|
+          h[s.name] = { :spec => s, :version => s.version, :source => s.source.identifier }
+          h
+        end
+      end
+
       installer = Installer.install Bundler.root, Bundler.definition, opts
       Bundler.load.cache if Bundler.app_cache.exist?
 
       if CLI::Common.clean_after_install?
-        require "bundler/cli/clean"
+        require_relative "clean"
         Bundler::CLI::Clean.new(options).run
       end
 
-      if locked_gems = Bundler.definition.locked_gems
+      if locked_gems
         gems.each do |name|
-          locked_version = locked_gems.specs.find {|s| s.name == name }
-          locked_version &&= locked_version.version
-          next unless locked_version
-          new_version = Bundler.definition.specs[name].first
-          new_version &&= new_version.version
-          if !new_version
-            Bundler.ui.warn "Bundler attempted to update #{name} but it was removed from the bundle"
-          elsif new_version < locked_version
+          locked_info = previous_locked_info[name]
+          next unless locked_info
+
+          locked_spec = locked_info[:spec]
+          new_spec = Bundler.definition.specs[name].first
+          unless new_spec
+            unless locked_spec.match_platform(Bundler.local_platform)
+              Bundler.ui.warn "Bundler attempted to update #{name} but it was not considered because it is for a different platform from the current one"
+            end
+
+            next
+          end
+
+          locked_source = locked_info[:source]
+          new_source = new_spec.source.identifier
+          next if locked_source != new_source
+
+          new_version = new_spec.version
+          locked_version = locked_info[:version]
+          if new_version < locked_version
             Bundler.ui.warn "Note: #{name} version regressed from #{locked_version} to #{new_version}"
           elsif new_version == locked_version
             Bundler.ui.warn "Bundler attempted to update #{name} but its version stayed the same"
@@ -84,8 +113,10 @@ module Bundler
       end
 
       Bundler.ui.confirm "Bundle updated!"
-      Bundler::CLI::Common.output_without_groups_message
+      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/cli/viz.rb

@@ -23,7 +23,7 @@ module Bundler
       Bundler.ui.warn "Make sure you have the graphviz ruby gem. You can install it with:"
       Bundler.ui.warn "`gem install ruby-graphviz`"
     rescue StandardError => e
-      raise unless e.message =~ /GraphViz not installed or dot not in PATH/
+      raise unless e.message.to_s.include?("GraphViz not installed or dot not in PATH")
       Bundler.ui.error e.message
       Bundler.ui.warn "Please install GraphViz. On a Mac with Homebrew, you can run `brew install graphviz`."
     end