rubygems-update 3.0.6 → 3.2.14

data/bundler/lib/bundler/cli/init.rb

@@ -38,10 +38,10 @@ module Bundler
       puts "Writing new #{gemfile} to #{SharedHelpers.pwd}/#{gemfile}"
     end
 
-  private
+    private
 
     def gemfile
-      @gemfile ||= Bundler.feature_flag.init_gems_rb? ? "gems.rb" : "Gemfile"
+      @gemfile ||= Bundler.preferred_gemfile_name
     end
   end
 end

data/bundler/lib/bundler/cli/inject.rb

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

data/bundler/lib/bundler/cli/install.rb

@@ -12,8 +12,6 @@ module Bundler
 
       warn_if_root
 
-      normalize_groups
-
       Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Bundler::FREEBSD
 
       # Disable color in deployment mode
@@ -38,7 +36,8 @@ module Bundler
         if Bundler.feature_flag.deployment_means_frozen?
           Bundler.settings.set_command_option :deployment, true
         else
-          Bundler.settings.set_command_option :frozen, true
+          Bundler.settings.set_command_option :deployment, true if options[:deployment]
+          Bundler.settings.set_command_option :frozen, true if options[:frozen]
         end
       end
 
@@ -54,7 +53,7 @@ module Bundler
 
       if options["binstubs"]
         Bundler::SharedHelpers.major_deprecation 2,
-          "The --binstubs option will be removed in favor of `bundle binstubs`"
+          "The --binstubs option will be removed in favor of `bundle binstubs --all`"
       end
 
       Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
@@ -66,7 +65,7 @@ module Bundler
       Bundler.load.cache if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.frozen_bundle?
 
       Bundler.ui.confirm "Bundle complete! #{dependencies_count_for(definition)}, #{gems_installed_for(definition)}."
-      Bundler::CLI::Common.output_without_groups_message
+      Bundler::CLI::Common.output_without_groups_message(:install)
 
       if Bundler.use_system_gems?
         Bundler.ui.confirm "Use `bundle info [gemname]` to see where a bundled gem is installed."
@@ -80,9 +79,11 @@ module Bundler
       warn_ambiguous_gems
 
       if CLI::Common.clean_after_install?
-        require "bundler/cli/clean"
+        require_relative "clean"
         Bundler::CLI::Clean.new(options).run
       end
+
+      Bundler::CLI::Common.output_fund_metadata_summary
     rescue GemNotFound, VersionConflict => e
       if options[:local] && Bundler.app_cache.exist?
         Bundler.ui.warn "Some gems seem to be missing from your #{Bundler.settings.app_cache_path} directory."
@@ -101,7 +102,7 @@ module Bundler
       raise e
     end
 
-  private
+    private
 
     def warn_if_root
       return if Bundler.settings[:silence_root_warning] || Bundler::WINDOWS || !Process.uid.zero?
@@ -164,12 +165,20 @@ module Bundler
 
       options[:with]    = with
       options[:without] = without
+
+      unless Bundler.settings[:without] == options[:without] && Bundler.settings[:with] == options[:with]
+        # need to nil them out first to get around validation for backwards compatibility
+        Bundler.settings.set_command_option :without, nil
+        Bundler.settings.set_command_option :with,    nil
+        Bundler.settings.set_command_option :without, options[:without] - options[:with]
+        Bundler.settings.set_command_option :with,    options[:with]
+      end
     end
 
     def normalize_settings
       Bundler.settings.set_command_option :path, nil if options[:system]
       Bundler.settings.temporary(:path_relative_to_cwd => false) do
-        Bundler.settings.set_command_option :path, "vendor/bundle" if options[:deployment]
+        Bundler.settings.set_command_option :path, "vendor/bundle" if Bundler.settings[:deployment] && Bundler.settings[:path].nil?
       end
       Bundler.settings.set_command_option_if_given :path, options[:path]
       Bundler.settings.temporary(:path_relative_to_cwd => false) do
@@ -190,27 +199,22 @@ module Bundler
 
       Bundler.settings.set_command_option_if_given :clean, options["clean"]
 
-      unless Bundler.settings[:without] == options[:without] && Bundler.settings[:with] == options[:with]
-        # need to nil them out first to get around validation for backwards compatibility
-        Bundler.settings.set_command_option :without, nil
-        Bundler.settings.set_command_option :with,    nil
-        Bundler.settings.set_command_option :without, options[:without] - options[:with]
-        Bundler.settings.set_command_option :with,    options[:with]
-      end
+      normalize_groups
 
       options[:force] = options[:redownload]
     end
 
     def warn_ambiguous_gems
+      # TODO: remove this when we drop Bundler 1.x support
       Installer.ambiguous_gems.to_a.each do |name, installed_from_uri, *also_found_in_uris|
-        Bundler.ui.error "Warning: the gem '#{name}' was found in multiple sources."
-        Bundler.ui.error "Installed from: #{installed_from_uri}"
-        Bundler.ui.error "Also found in:"
-        also_found_in_uris.each {|uri| Bundler.ui.error "  * #{uri}" }
-        Bundler.ui.error "You should add a source requirement to restrict this gem to your preferred source."
-        Bundler.ui.error "For example:"
-        Bundler.ui.error "    gem '#{name}', :source => '#{installed_from_uri}'"
-        Bundler.ui.error "Then uninstall the gem '#{name}' (or delete all bundled gems) and then install again."
+        Bundler.ui.warn "Warning: the gem '#{name}' was found in multiple sources."
+        Bundler.ui.warn "Installed from: #{installed_from_uri}"
+        Bundler.ui.warn "Also found in:"
+        also_found_in_uris.each {|uri| Bundler.ui.warn "  * #{uri}" }
+        Bundler.ui.warn "You should add a source requirement to restrict this gem to your preferred source."
+        Bundler.ui.warn "For example:"
+        Bundler.ui.warn "    gem '#{name}', :source => '#{installed_from_uri}'"
+        Bundler.ui.warn "Then uninstall the gem '#{name}' (or delete all bundled gems) and then install again."
       end
     end
   end

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

@@ -10,19 +10,19 @@ 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: http://bundler.io/
+        site: https://bundler.io/
 
         3. Information about each Bundler command can be found in the Bundler
-        man pages: http://bundler.io/man/bundle.1.html
+        man pages: https://bundler.io/man/bundle.1.html
 
         Hopefully the troubleshooting steps above resolved your problem!  If things
         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
 
@@ -33,7 +33,7 @@ module Bundler
     end
 
     def doctor
-      require "bundler/cli/doctor"
+      require_relative "doctor"
       Bundler::CLI::Doctor.new({}).run
     end
   end

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/open.rb

@@ -14,12 +14,16 @@ module Bundler
       editor = [ENV["BUNDLER_EDITOR"], ENV["VISUAL"], ENV["EDITOR"]].find {|e| !e.nil? && !e.empty? }
       return Bundler.ui.info("To open a bundled gem, set $EDITOR or $BUNDLER_EDITOR") unless editor
       return unless spec = Bundler::CLI::Common.select_spec(name, :regex_match)
-      path = spec.full_gem_path
-      Dir.chdir(path) do
-        command = Shellwords.split(editor) + [path]
-        Bundler.with_original_env do
-          system(*command)
-        end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
+      if spec.default_gem?
+        Bundler.ui.info "Unable to open #{name} because it's a default gem, so the directory it would normally be installed to does not exist."
+      else
+        path = spec.full_gem_path
+        Dir.chdir(path) do
+          command = Shellwords.split(editor) + [path]
+          Bundler.with_original_env do
+            system(*command)
+          end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
+        end
       end
     end
   end

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?
@@ -39,14 +49,6 @@ module Bundler
         options
       )
 
-      # 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|
@@ -73,101 +73,79 @@ 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(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
-        end
-
-        options_include_groups = [:group, :groups].select do |v|
-          options.keys.include?(v.to_s)
+          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
 
-        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?
+            gems
+          end.compact
 
-            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?
-              )
+          if options[:parseable]
+            relevant_outdated_gems.each do |gems|
+              print_gems(gems)
             end
+          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 retrieve_active_spec(strict, definition, current_spec)
+    def groups_text(group_text, groups)
+      "#{group_text}#{groups.split(",").size > 1 ? "s" : ""} \"#{groups}\""
+    end
+
+    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
+        "Bundle up to date!\n"
+      end
+    end
+
+    def retrieve_active_spec(definition, current_spec)
       if strict
         active_spec = definition.find_resolved_spec(current_spec)
       else
@@ -181,21 +159,31 @@ module Bundler
       active_spec
     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
       current_version = "#{current_spec.version}#{current_spec.git_version}"
@@ -209,23 +197,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 << 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]
-        "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 +256,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