rubygems-update 2.6.1 → 3.5.0

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Install
+    attr_reader :options
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.ui.level = "warn" if options[:quiet]
+
+      warn_if_root
+
+      Bundler.self_manager.install_locked_bundler_and_restart_with_it_if_needed
+
+      Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Bundler::FREEBSD
+
+      # Disable color in deployment mode
+      Bundler.ui.shell = Thor::Shell::Basic.new if options[:deployment]
+
+      check_for_options_conflicts
+
+      check_trust_policy
+
+      if options[:deployment] || options[:frozen] || Bundler.frozen_bundle?
+        unless Bundler.default_lockfile.exist?
+          flag   = "--deployment flag" if options[:deployment]
+          flag ||= "--frozen flag"     if options[:frozen]
+          flag ||= "deployment setting"
+          raise ProductionError, "The #{flag} requires a lockfile. Please make " \
+                                 "sure you have checked your #{SharedHelpers.relative_lockfile_path} into version control " \
+                                 "before deploying."
+        end
+
+        options[:local] = true if Bundler.app_cache.exist?
+
+        Bundler.settings.set_command_option :deployment, true if options[:deployment]
+        Bundler.settings.set_command_option :frozen, true if options[:frozen]
+      end
+
+      # When install is called with --no-deployment, disable deployment mode
+      if options[:deployment] == false
+        Bundler.settings.set_command_option :frozen, nil
+        options[:system] = true
+      end
+
+      normalize_settings
+
+      Bundler::Fetcher.disable_endpoint = options["full-index"]
+
+      if options["binstubs"]
+        Bundler::SharedHelpers.major_deprecation 2,
+          "The --binstubs option will be removed in favor of `bundle binstubs --all`",
+          removed_message: "The --binstubs option have been removed in favor of `bundle binstubs --all`"
+      end
+
+      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
+
+      definition = Bundler.definition
+      definition.validate_runtime!
+
+      installer = Installer.install(Bundler.root, definition, options)
+
+      Bundler.settings.temporary(cache_all_platforms: options[:local] ? false : Bundler.settings[:cache_all_platforms]) do
+        Bundler.load.cache(nil, options[:local]) if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.frozen_bundle?
+      end
+
+      Bundler.ui.confirm "Bundle complete! #{dependencies_count_for(definition)}, #{gems_installed_for(definition)}."
+      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."
+      else
+        relative_path = Bundler.configured_bundle_path.base_path_relative_to_pwd
+        Bundler.ui.confirm "Bundled gems are installed into `#{relative_path}`"
+      end
+
+      Bundler::CLI::Common.output_post_install_messages installer.post_install_messages
+
+      warn_ambiguous_gems
+
+      if CLI::Common.clean_after_install?
+        require_relative "clean"
+        Bundler::CLI::Clean.new(options).run
+      end
+
+      Bundler::CLI::Common.output_fund_metadata_summary
+    rescue Gem::InvalidSpecificationException
+      Bundler.ui.warn "You have one or more invalid gemspecs that need to be fixed."
+      raise
+    end
+
+    private
+
+    def warn_if_root
+      return if Bundler.settings[:silence_root_warning] || Gem.win_platform? || !Process.uid.zero?
+      Bundler.ui.warn "Don't run Bundler as root. Installing your bundle as root " \
+                      "will break this application for all non-root users on this machine.", wrap: true
+    end
+
+    def dependencies_count_for(definition)
+      count = definition.dependencies.count
+      "#{count} Gemfile #{count == 1 ? "dependency" : "dependencies"}"
+    end
+
+    def gems_installed_for(definition)
+      count = definition.specs.count
+      "#{count} #{count == 1 ? "gem" : "gems"} now installed"
+    end
+
+    def check_for_group_conflicts_in_cli_options
+      conflicting_groups = Array(options[:without]) & Array(options[:with])
+      return if conflicting_groups.empty?
+      raise InvalidOption, "You can't list a group in both with and without." \
+        " The offending groups are: #{conflicting_groups.join(", ")}."
+    end
+
+    def check_for_options_conflicts
+      if (options[:path] || options[:deployment]) && options[:system]
+        error_message = String.new
+        error_message << "You have specified both --path as well as --system. Please choose only one option.\n" if options[:path]
+        error_message << "You have specified both --deployment as well as --system. Please choose only one option.\n" if options[:deployment]
+        raise InvalidOption.new(error_message)
+      end
+    end
+
+    def check_trust_policy
+      trust_policy = options["trust-policy"]
+      unless Bundler.rubygems.security_policies.keys.unshift(nil).include?(trust_policy)
+        raise InvalidOption, "RubyGems doesn't know about trust policy '#{trust_policy}'. " \
+          "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
+      end
+      Bundler.settings.set_command_option_if_given :"trust-policy", trust_policy
+    end
+
+    def normalize_groups
+      check_for_group_conflicts_in_cli_options
+
+      # 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]
+      Bundler.settings.set_command_option :with,    options[:with]
+    end
+
+    def normalize_settings
+      Bundler.settings.set_command_option :path, nil if options[:system]
+      Bundler.settings.set_command_option_if_given :path, options[:path]
+
+      if options["standalone"] && Bundler.settings[:path].nil? && !options["local"]
+        Bundler.settings.temporary(path_relative_to_cwd: false) do
+          Bundler.settings.set_command_option :path, "bundle"
+        end
+      end
+
+      bin_option = options["binstubs"]
+      bin_option = nil if bin_option&.empty?
+      Bundler.settings.set_command_option :bin, bin_option if options["binstubs"]
+
+      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
+
+      Bundler.settings.set_command_option_if_given :jobs, options["jobs"]
+
+      Bundler.settings.set_command_option_if_given :no_prune, options["no-prune"]
+
+      Bundler.settings.set_command_option_if_given :no_install, options["no-install"]
+
+      Bundler.settings.set_command_option_if_given :clean, options["clean"]
+
+      normalize_groups if options[:without] || options[:with]
+
+      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.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
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Bundler
+  class CLI::Issue
+    def run
+      Bundler.ui.info <<~EOS
+        Did you find an issue with Bundler? Before filing a new issue,
+        be sure to check out these resources:
+
+        1. Check out our troubleshooting guide for quick fixes to common issues:
+        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/
+
+        3. Information about each Bundler command can be found in the Bundler
+        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, by filling
+        in the new issue form located at
+        https://github.com/rubygems/rubygems/issues/new?labels=Bundler&template=bundler-related-issue.md,
+        and copy and pasting the information below.
+
+      EOS
+
+      Bundler.ui.info Bundler::Env.report
+
+      Bundler.ui.info "\n## Bundle Doctor"
+      doctor
+    end
+
+    def doctor
+      require_relative "doctor"
+      Bundler::CLI::Doctor.new({}).run
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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 @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 @only_group.any? || @without_group.any?
+        filtered_specs_by_groups
+      else
+        begin
+          Bundler.load.specs
+        rescue GemNotFound => e
+          Bundler.ui.error e.message
+          Bundler.ui.warn "Install missing gems with `bundle install`."
+          exit 1
+        end
+      end.reject {|s| s.name == "bundler" }.sort_by(&:name)
+
+      return Bundler.ui.info "No gems in the Gemfile" if specs.empty?
+
+      return specs.each {|s| Bundler.ui.info s.name } if @options["name-only"]
+      return specs.each {|s| Bundler.ui.info s.full_gem_path } if @options["paths"]
+
+      Bundler.ui.info "Gems included by the bundle:"
+
+      specs.each {|s| Bundler.ui.info "  * #{s.name} (#{s.version}#{s.git_version})" }
+
+      Bundler.ui.info "Use `bundle info` to print more detailed information about a gem"
+    end
+
+    private
+
+    def verify_group_exists(groups)
+      (@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
+      definition = Bundler.definition
+      groups = definition.groups
+
+      verify_group_exists(groups)
+
+      show_groups =
+        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)
+
+      definition.specs_for(show_groups)
+    end
+  end
+end

data/bundler/lib/bundler/cli/lock.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Lock
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      unless Bundler.default_gemfile
+        Bundler.ui.error "Unable to find a Gemfile to lock"
+        exit 1
+      end
+
+      print = options[:print]
+      previous_ui_level = Bundler.ui.level
+      Bundler.ui.level = "silent" if print
+
+      Bundler::Fetcher.disable_endpoint = options["full-index"]
+
+      update = options[:update]
+      conservative = options[:conservative]
+      bundler = options[:bundler]
+
+      if update.is_a?(Array) # unlocking specific gems
+        Bundler::CLI::Common.ensure_all_gems_in_lockfile!(update)
+        update = { gems: update, conservative: conservative }
+      elsif update && conservative
+        update = { conservative: conservative }
+      elsif update && bundler
+        update = { bundler: bundler }
+      end
+
+      Bundler.settings.temporary(frozen: false) do
+        definition = Bundler.definition(update)
+
+        Bundler::CLI::Common.configure_gem_version_promoter(definition, options) if options[:update]
+
+        options["remove-platform"].each do |platform|
+          definition.remove_platform(platform)
+        end
+
+        options["add-platform"].each do |platform_string|
+          platform = Gem::Platform.new(platform_string)
+          if platform.to_s == "unknown"
+            Bundler.ui.warn "The platform `#{platform_string}` is unknown to RubyGems " \
+              "and adding it will likely lead to resolution errors"
+          end
+          definition.add_platform(platform)
+        end
+
+        if definition.platforms.empty?
+          raise InvalidOption, "Removing all platforms from the bundle is not allowed"
+        end
+
+        definition.resolve_remotely! unless options[:local]
+
+        if print
+          puts definition.to_lock
+        else
+          file = options[:lockfile]
+          file = file ? File.expand_path(file) : Bundler.default_lockfile
+          puts "Writing lockfile to #{file}"
+          definition.lock(file)
+        end
+      end
+
+      Bundler.ui.level = previous_ui_level
+    end
+  end
+end

data/bundler/lib/bundler/cli/open.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Open
+    attr_reader :options, :name, :path
+    def initialize(options, name)
+      @options = options
+      @name = name
+      @path = options[:path] unless options[:path].nil?
+    end
+
+    def run
+      raise InvalidOption, "Cannot specify `--path` option without a value" if !@path.nil? && @path.empty?
+      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)
+      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
+        root_path = spec.full_gem_path
+        require "shellwords"
+        command = Shellwords.split(editor) << File.join([root_path, path].compact)
+        Bundler.with_original_env do
+          system(*command, { chdir: root_path })
+        end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Outdated
+    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!
+
+      gems.each do |gem_name|
+        Bundler::CLI::Common.select_spec(gem_name)
+      end
+
+      Bundler.definition.validate_runtime!
+      current_specs = Bundler.ui.silence { Bundler.definition.resolve }
+
+      current_dependencies = Bundler.ui.silence do
+        Bundler.load.dependencies.map {|dep| [dep.name, dep] }.to_h
+      end
+
+      definition = if gems.empty? && sources.empty?
+        # We're doing a full update
+        Bundler.definition(true)
+      else
+        Bundler.definition(gems: gems, sources: sources)
+      end
+
+      Bundler::CLI::Common.configure_gem_version_promoter(
+        Bundler.definition,
+        options.merge(strict: @strict)
+      )
+
+      definition_resolution = proc do
+        options[:local] ? definition.resolve_with_cache! : definition.resolve_remotely!
+      end
+
+      if options[:parseable]
+        Bundler.ui.silence(&definition_resolution)
+      else
+        definition_resolution.call
+      end
+
+      Bundler.ui.info ""
+
+      # Loop through the current specs
+      gemfile_specs, dependency_specs = current_specs.partition do |spec|
+        current_dependencies.key? spec.name
+      end
+
+      specs = if options["only-explicit"]
+        gemfile_specs
+      else
+        gemfile_specs + dependency_specs
+      end
+
+      specs.sort_by(&:name).uniq(&:name).each do |current_spec|
+        next unless gems.empty? || gems.include?(current_spec.name)
+
+        active_spec = retrieve_active_spec(definition, current_spec)
+        next unless active_spec
+
+        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)
+
+        dependency = current_dependencies[current_spec.name]
+        groups = ""
+        if dependency && !options[:parseable]
+          groups = dependency.groups.join(", ")
+        end
+
+        outdated_gems << {
+          active_spec: active_spec,
+          current_spec: current_spec,
+          dependency: dependency,
+          groups: groups,
+        }
+      end
+
+      if outdated_gems.empty?
+        unless options[:parseable]
+          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
+
+            gems
+          end.compact
+
+          if options[:parseable]
+            print_gems(relevant_outdated_gems)
+          else
+            print_gems_table(relevant_outdated_gems)
+          end
+        elsif options[:parseable]
+          print_gems(outdated_gems)
+        else
+          print_gems_table(outdated_gems)
+        end
+
+        exit 1
+      end
+    end
+
+    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 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)
+      active_spec = definition.resolve.find_by_name_and_platform(current_spec.name, current_spec.platform)
+      return unless 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 print_gems(gems_list)
+      gems_list.each do |gem|
+        print_gem(
+          gem[:current_spec],
+          gem[:active_spec],
+          gem[:dependency],
+          gem[:groups],
+        )
+      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}"
+      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&.specific?
+        dependency_version = %(, requested #{dependency.requirement})
+      end
+
+      spec_outdated_info = "#{active_spec.name} (newest #{spec_version}, " \
+        "installed #{current_version}#{dependency_version})"
+
+      output_message = if options[:parseable]
+        spec_outdated_info.to_s
+      elsif options_include_groups || groups.empty?
+        "  * #{spec_outdated_info}"
+      else
+        "  * #{spec_outdated_info} in #{groups_text("group", groups)}"
+      end
+
+      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 << 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").keys.&([:global, :local]).any?
+        "bundle config unset frozen"
+      elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any?
+        "bundle config unset deployment"
+      end
+      raise ProductionError, "You are trying to check outdated gems in " \
+        "deployment mode. Run `bundle outdated` elsewhere.\n" \
+        "\nIf this is a development machine, remove the " \
+        "#{Bundler.default_gemfile} freeze" \
+        "\nby running `#{suggested_command}`."
+    end
+
+    def update_present_via_semver_portions(current_spec, active_spec, options)
+      current_major = current_spec.version.segments.first
+      active_major = active_spec.version.segments.first
+
+      update_present = false
+      update_present = active_major > current_major if options["filter-major"]
+
+      if !update_present && (options["filter-minor"] || options["filter-patch"]) && current_major == active_major
+        current_minor = get_version_semver_portion_value(current_spec, 1)
+        active_minor = get_version_semver_portion_value(active_spec, 1)
+
+        update_present = active_minor > current_minor if options["filter-minor"]
+
+        if !update_present && options["filter-patch"] && current_minor == active_minor
+          current_patch = get_version_semver_portion_value(current_spec, 2)
+          active_patch = get_version_semver_portion_value(active_spec, 2)
+
+          update_present = active_patch > current_patch
+        end
+      end
+
+      update_present
+    end
+
+    def get_version_semver_portion_value(spec, version_portion_index)
+      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