rubygems-update 3.4.22 → 3.5.0

data/bundler/lib/bundler/checksum.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Checksum
+    ALGO_SEPARATOR = "="
+    DEFAULT_ALGORITHM = "sha256"
+    private_constant :DEFAULT_ALGORITHM
+    DEFAULT_BLOCK_SIZE = 16_384
+    private_constant :DEFAULT_BLOCK_SIZE
+
+    class << self
+      def from_gem_package(gem_package, algo = DEFAULT_ALGORITHM)
+        return if Bundler.settings[:disable_checksum_validation]
+        return unless source = gem_package.instance_variable_get(:@gem)
+        return unless source.respond_to?(:with_read_io)
+
+        source.with_read_io do |io|
+          from_gem(io, source.path)
+        ensure
+          io.rewind
+        end
+      end
+
+      def from_gem(io, pathname, algo = DEFAULT_ALGORITHM)
+        digest = Bundler::SharedHelpers.digest(algo.upcase).new
+        buf = String.new(capacity: DEFAULT_BLOCK_SIZE)
+        digest << io.readpartial(DEFAULT_BLOCK_SIZE, buf) until io.eof?
+        Checksum.new(algo, digest.hexdigest!, Source.new(:gem, pathname))
+      end
+
+      def from_api(digest, source_uri, algo = DEFAULT_ALGORITHM)
+        return if Bundler.settings[:disable_checksum_validation]
+        Checksum.new(algo, to_hexdigest(digest, algo), Source.new(:api, source_uri))
+      end
+
+      def from_lock(lock_checksum, lockfile_location)
+        algo, digest = lock_checksum.strip.split(ALGO_SEPARATOR, 2)
+        Checksum.new(algo, to_hexdigest(digest, algo), Source.new(:lock, lockfile_location))
+      end
+
+      def to_hexdigest(digest, algo = DEFAULT_ALGORITHM)
+        return digest unless algo == DEFAULT_ALGORITHM
+        return digest if digest.match?(/\A[0-9a-f]{64}\z/i)
+        if digest.match?(%r{\A[-0-9a-z_+/]{43}={0,2}\z}i)
+          digest = digest.tr("-_", "+/") # fix urlsafe base64
+          return digest.unpack1("m0").unpack1("H*")
+        end
+        raise ArgumentError, "#{digest.inspect} is not a valid SHA256 hex or base64 digest"
+      end
+    end
+
+    attr_reader :algo, :digest, :sources
+
+    def initialize(algo, digest, source)
+      @algo = algo
+      @digest = digest
+      @sources = [source]
+    end
+
+    def ==(other)
+      match?(other) && other.sources == sources
+    end
+
+    alias_method :eql?, :==
+
+    def match?(other)
+      other.is_a?(self.class) && other.digest == digest && other.algo == algo
+    end
+
+    def hash
+      digest.hash
+    end
+
+    def to_s
+      "#{to_lock} (from #{sources.first}#{", ..." if sources.size > 1})"
+    end
+
+    def to_lock
+      "#{algo}#{ALGO_SEPARATOR}#{digest}"
+    end
+
+    def merge!(other)
+      return nil unless match?(other)
+      @sources.concat(other.sources).uniq!
+      self
+    end
+
+    def formatted_sources
+      sources.join("\n    and ").concat("\n")
+    end
+
+    def removable?
+      sources.all?(&:removable?)
+    end
+
+    def removal_instructions
+      msg = +""
+      i = 1
+      sources.each do |source|
+        msg << "  #{i}. #{source.removal}\n"
+        i += 1
+      end
+      msg << "  #{i}. run `bundle install`\n"
+    end
+
+    def inspect
+      abbr = "#{algo}#{ALGO_SEPARATOR}#{digest[0, 8]}"
+      from = "from #{sources.join(" and ")}"
+      "#<#{self.class}:#{object_id} #{abbr} #{from}>"
+    end
+
+    class Source
+      attr_reader :type, :location
+
+      def initialize(type, location)
+        @type = type
+        @location = location
+      end
+
+      def removable?
+        type == :lock || type == :gem
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.type == type && other.location == location
+      end
+
+      # phrased so that the usual string format is grammatically correct
+      #   rake (10.3.2) sha256=abc123 from #{to_s}
+      def to_s
+        case type
+        when :lock
+          "the lockfile CHECKSUMS at #{location}"
+        when :gem
+          "the gem at #{location}"
+        when :api
+          "the API at #{location}"
+        else
+          "#{location} (#{type})"
+        end
+      end
+
+      # A full sentence describing how to remove the checksum
+      def removal
+        case type
+        when :lock
+          "remove the matching checksum in #{location}"
+        when :gem
+          "remove the gem at #{location}"
+        when :api
+          "checksums from #{location} cannot be locally modified, you may need to update your sources"
+        else
+          "remove #{location} (#{type})"
+        end
+      end
+    end
+
+    class Store
+      attr_reader :store
+      protected :store
+
+      def initialize
+        @store = {}
+      end
+
+      def initialize_copy(other)
+        @store = {}
+        other.store.each do |lock_name, checksums|
+          store[lock_name] = checksums.dup
+        end
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} size=#{store.size}>"
+      end
+
+      def fetch(spec, algo = DEFAULT_ALGORITHM)
+        store[spec.name_tuple.lock_name]&.fetch(algo, nil)
+      end
+
+      # Replace when the new checksum is from the same source.
+      # The primary purpose of this registering checksums from gems where there are
+      # duplicates of the same gem (according to full_name) in the index.
+      # In particular, this is when 2 gems have two similar platforms, e.g.
+      # "darwin20" and "darwin-20", both of which resolve to darwin-20.
+      # In the Index, the later gem replaces the former, so we do that here.
+      #
+      # However, if the new checksum is from a different source, we register like normal.
+      # This ensures a mismatch error where there are multiple top level sources
+      # that contain the same gem with different checksums.
+      def replace(spec, checksum)
+        return unless checksum
+
+        lock_name = spec.name_tuple.lock_name
+        checksums = (store[lock_name] ||= {})
+        existing = checksums[checksum.algo]
+
+        # we assume only one source because this is used while building the index
+        if !existing || existing.sources.first == checksum.sources.first
+          checksums[checksum.algo] = checksum
+        else
+          register_checksum(lock_name, checksum)
+        end
+      end
+
+      def register(spec, checksum)
+        return unless checksum
+        register_checksum(spec.name_tuple.lock_name, checksum)
+      end
+
+      def merge!(other)
+        other.store.each do |lock_name, checksums|
+          checksums.each do |_algo, checksum|
+            register_checksum(lock_name, checksum)
+          end
+        end
+      end
+
+      def to_lock(spec)
+        lock_name = spec.name_tuple.lock_name
+        if checksums = store[lock_name]
+          "#{lock_name} #{checksums.values.map(&:to_lock).sort.join(",")}"
+        else
+          lock_name
+        end
+      end
+
+      private
+
+      def register_checksum(lock_name, checksum)
+        return unless checksum
+        checksums = (store[lock_name] ||= {})
+        existing = checksums[checksum.algo]
+
+        if !existing
+          checksums[checksum.algo] = checksum
+        elsif existing.merge!(checksum)
+          checksum
+        else
+          raise ChecksumMismatchError.new(lock_name, existing, checksum)
+        end
+      end
+    end
+  end
+end

data/bundler/lib/bundler/ci_detector.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Bundler
+  module CIDetector
+    # NOTE: Any changes made here will need to be made to both lib/rubygems/ci_detector.rb and
+    # bundler/lib/bundler/ci_detector.rb (which are enforced duplicates).
+    # TODO: Drop that duplication once bundler drops support for RubyGems 3.4
+    #
+    # ## Recognized CI providers, their signifiers, and the relevant docs ##
+    #
+    # Travis CI   - CI, TRAVIS            https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
+    # Cirrus CI   - CI, CIRRUS_CI         https://cirrus-ci.org/guide/writing-tasks/#environment-variables
+    # Circle CI   - CI, CIRCLECI          https://circleci.com/docs/variables/#built-in-environment-variables
+    # Gitlab CI   - CI, GITLAB_CI         https://docs.gitlab.com/ee/ci/variables/
+    # AppVeyor    - CI, APPVEYOR          https://www.appveyor.com/docs/environment-variables/
+    # CodeShip    - CI_NAME               https://docs.cloudbees.com/docs/cloudbees-codeship/latest/pro-builds-and-configuration/environment-variables#_default_environment_variables
+    # dsari       - CI, DSARI             https://github.com/rfinnie/dsari#running
+    # Jenkins     - BUILD_NUMBER          https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables
+    # TeamCity    - TEAMCITY_VERSION      https://www.jetbrains.com/help/teamcity/predefined-build-parameters.html#Predefined+Server+Build+Parameters
+    # Appflow     - CI_BUILD_ID           https://ionic.io/docs/appflow/automation/environments#predefined-environments
+    # TaskCluster - TASKCLUSTER_ROOT_URL  https://docs.taskcluster.net/docs/manual/design/env-vars
+    # Semaphore   - CI, SEMAPHORE         https://docs.semaphoreci.com/ci-cd-environment/environment-variables/
+    # BuildKite   - CI, BUILDKITE         https://buildkite.com/docs/pipelines/environment-variables
+    # GoCD        - GO_SERVER_URL         https://docs.gocd.org/current/faq/dev_use_current_revision_in_build.html
+    # GH Actions  - CI, GITHUB_ACTIONS    https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
+    #
+    # ### Some "standard" ENVs that multiple providers may set ###
+    #
+    # * CI - this is set by _most_ (but not all) CI providers now; it's approaching a standard.
+    # * CI_NAME - Not as frequently used, but some providers set this to specify their own name
+
+    # Any of these being set is a reasonably reliable indicator that we are
+    # executing in a CI environment.
+    ENV_INDICATORS = [
+      "CI",
+      "CI_NAME",
+      "CONTINUOUS_INTEGRATION",
+      "BUILD_NUMBER",
+      "CI_APP_ID",
+      "CI_BUILD_ID",
+      "CI_BUILD_NUMBER",
+      "RUN_ID",
+      "TASKCLUSTER_ROOT_URL",
+    ].freeze
+
+    # For each CI, this env suffices to indicate that we're on _that_ CI's
+    # containers. (A few of them only supply a CI_NAME variable, which is also
+    # nice). And if they set "CI" but we can't tell which one they are, we also
+    # want to know that - a bare "ci" without another token tells us as much.
+    ENV_DESCRIPTORS = {
+      "TRAVIS" => "travis",
+      "CIRCLECI" => "circle",
+      "CIRRUS_CI" => "cirrus",
+      "DSARI" => "dsari",
+      "SEMAPHORE" => "semaphore",
+      "JENKINS_URL" => "jenkins",
+      "BUILDKITE" => "buildkite",
+      "GO_SERVER_URL" => "go",
+      "GITLAB_CI" => "gitlab",
+      "GITHUB_ACTIONS" => "github",
+      "TASKCLUSTER_ROOT_URL" => "taskcluster",
+      "CI" => "ci",
+    }.freeze
+
+    def self.ci?
+      ENV_INDICATORS.any? {|var| ENV.include?(var) }
+    end
+
+    def self.ci_strings
+      matching_names = ENV_DESCRIPTORS.select {|env, _| ENV[env] }.values
+      matching_names << ENV["CI_NAME"].downcase if ENV["CI_NAME"]
+      matching_names.reject(&:empty?).sort.uniq
+    end
+  end
+end

data/bundler/lib/bundler/cli/add.rb

@@ -28,9 +28,9 @@ module Bundler
       dependencies = gems.map {|g| Bundler::Dependency.new(g, version, options) }
 
       Injector.inject(dependencies,
-        :conservative_versioning => options[:version].nil?, # Perform conservative versioning only when version is not specified
-        :optimistic => options[:optimistic],
-        :strict => options[:strict])
+        conservative_versioning: options[:version].nil?, # Perform conservative versioning only when version is not specified
+        optimistic: options[:optimistic],
+        strict: options[:strict])
     end
 
     def validate_options!

data/bundler/lib/bundler/cli/binstubs.rb

@@ -17,9 +17,9 @@ module Bundler
       installer = Installer.new(Bundler.root, Bundler.definition)
 
       installer_opts = {
-        :force => options[:force],
-        :binstubs_cmd => true,
-        :all_platforms => options["all-platforms"],
+        force: options[:force],
+        binstubs_cmd: true,
+        all_platforms: options["all-platforms"],
       }
 
       if options[:all]
@@ -45,7 +45,7 @@ module Bundler
             next
           end
 
-          Bundler.settings.temporary(:path => (Bundler.settings[:path] || Bundler.root)) do
+          Bundler.settings.temporary(path: (Bundler.settings[:path] || Bundler.root)) do
             installer.generate_standalone_bundler_executable_stubs(spec, installer_opts)
           end
         else

data/bundler/lib/bundler/cli/cache.rb

@@ -19,7 +19,7 @@ module Bundler
       # TODO: move cache contents here now that all bundles are locked
       custom_path = Bundler.settings[:path] if options[:path]
 
-      Bundler.settings.temporary(:cache_all_platforms => options["all-platforms"]) do
+      Bundler.settings.temporary(cache_all_platforms: options["all-platforms"]) do
         Bundler.load.cache(custom_path)
       end
     end

data/bundler/lib/bundler/cli/check.rb

@@ -32,7 +32,7 @@ module Bundler
         Bundler.ui.error "This bundle has been frozen, but there is no #{SharedHelpers.relative_lockfile_path} present"
         exit 1
       else
-        Bundler.load.lock(:preserve_unknown_sections => true) unless options[:"dry-run"]
+        Bundler.load.lock(preserve_unknown_sections: true) unless options[:"dry-run"]
         Bundler.ui.info "The Gemfile's dependencies are satisfied"
       end
     end

data/bundler/lib/bundler/cli/common.rb

@@ -54,9 +54,12 @@ module Bundler
 
       Bundler.definition.specs.each do |spec|
         return spec if spec.name == name
-        specs << spec if regexp && spec.name =~ regexp
+        specs << spec if regexp && spec.name.match?(regexp)
       end
 
+      default_spec = default_gem_spec(name)
+      specs << default_spec if default_spec
+
       case specs.count
       when 0
         dep_in_other_group = Bundler.definition.current_dependencies.find {|dep|dep.name == name }
@@ -75,6 +78,11 @@ module Bundler
       raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
     end
 
+    def self.default_gem_spec(name)
+      gem_spec = Gem::Specification.find_all_by_name(name).last
+      gem_spec if gem_spec&.default_gem?
+    end
+
     def self.ask_for_spec_from(specs)
       specs.each_with_index do |spec, index|
         Bundler.ui.info "#{index.succ} : #{spec.name}", true

data/bundler/lib/bundler/cli/config.rb

@@ -2,17 +2,17 @@
 
 module Bundler
   class CLI::Config < Thor
-    class_option :parseable, :type => :boolean, :banner => "Use minimal formatting for more parseable output"
+    class_option :parseable, type: :boolean, banner: "Use minimal formatting for more parseable output"
 
     def self.scope_options
-      method_option :global, :type => :boolean, :banner => "Only change the global config"
-      method_option :local, :type => :boolean, :banner => "Only change the local config"
+      method_option :global, type: :boolean, banner: "Only change the global config"
+      method_option :local, type: :boolean, banner: "Only change the local config"
     end
     private_class_method :scope_options
 
-    desc "base NAME [VALUE]", "The Bundler 1 config interface", :hide => true
+    desc "base NAME [VALUE]", "The Bundler 1 config interface", hide: true
     scope_options
-    method_option :delete, :type => :boolean, :banner => "delete"
+    method_option :delete, type: :boolean, banner: "delete"
     def base(name = nil, *value)
       new_args =
         if ARGV.size == 1
@@ -25,8 +25,9 @@ module Bundler
           ["config", "get", ARGV[1]]
         end
 
-      SharedHelpers.major_deprecation 3,
-        "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."
+      message = "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."
+      removed_message = "Using the `config` command without a subcommand [list, get, set, unset] is has been removed. Use `bundle #{new_args.join(" ")}` instead."
+      SharedHelpers.major_deprecation 3, message, removed_message: removed_message
 
       Base.new(options, name, value, self).run
     end

data/bundler/lib/bundler/cli/console.rb

@@ -9,8 +9,9 @@ module Bundler
     end
 
     def run
-      Bundler::SharedHelpers.major_deprecation 2, "bundle console will be replaced " \
-                           "by `bin/console` generated by `bundle gem <name>`"
+      message = "bundle console will be replaced by `bin/console` generated by `bundle gem <name>`"
+      removed_message = "bundle console has been replaced by `bin/console` generated by `bundle gem <name>`"
+      Bundler::SharedHelpers.major_deprecation 2, message, removed_message: removed_message
 
       group ? Bundler.require(:default, *group.split(" ").map!(&:to_sym)) : Bundler.require
       ARGV.clear

data/bundler/lib/bundler/cli/doctor.rb

@@ -6,8 +6,8 @@ require "fiddle"
 
 module Bundler
   class CLI::Doctor
-    DARWIN_REGEX = /\s+(.+) \(compatibility /.freeze
-    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/.freeze
+    DARWIN_REGEX = /\s+(.+) \(compatibility /
+    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/
 
     attr_reader :options
 

data/bundler/lib/bundler/cli/exec.rb

@@ -12,7 +12,7 @@ module Bundler
       @options = options
       @cmd = args.shift
       @args = args
-      @args << { :close_others => !options.keep_file_descriptors? } unless Bundler.current_ruby.jruby?
+      @args << { close_others: !options.keep_file_descriptors? } unless Bundler.current_ruby.jruby?
     end
 
     def run

data/bundler/lib/bundler/cli/gem.rb

@@ -11,7 +11,7 @@ module Bundler
   class CLI::Gem
     TEST_FRAMEWORK_VERSIONS = {
       "rspec" => "3.0",
-      "minitest" => "5.0",
+      "minitest" => "5.16",
       "test-unit" => "3.0",
     }.freeze
 
@@ -59,23 +59,23 @@ module Bundler
       end
 
       config = {
-        :name => name,
-        :underscored_name => underscored_name,
-        :namespaced_path => namespaced_path,
-        :makefile_path => "#{underscored_name}/#{underscored_name}",
-        :constant_name => constant_name,
-        :constant_array => constant_array,
-        :author => git_author_name.empty? ? "TODO: Write your name" : git_author_name,
-        :email => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
-        :test => options[:test],
-        :ext => extension,
-        :exe => options[:exe],
-        :bundler_version => bundler_dependency_version,
-        :git => use_git,
-        :github_username => github_username.empty? ? "[USERNAME]" : github_username,
-        :required_ruby_version => required_ruby_version,
-        :rust_builder_required_rubygems_version => rust_builder_required_rubygems_version,
-        :minitest_constant_name => minitest_constant_name,
+        name: name,
+        underscored_name: underscored_name,
+        namespaced_path: namespaced_path,
+        makefile_path: "#{underscored_name}/#{underscored_name}",
+        constant_name: constant_name,
+        constant_array: constant_array,
+        author: git_author_name.empty? ? "TODO: Write your name" : git_author_name,
+        email: git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
+        test: options[:test],
+        ext: extension,
+        exe: options[:exe],
+        bundler_version: bundler_dependency_version,
+        git: use_git,
+        github_username: github_username.empty? ? "[USERNAME]" : github_username,
+        required_ruby_version: required_ruby_version,
+        rust_builder_required_rubygems_version: rust_builder_required_rubygems_version,
+        minitest_constant_name: minitest_constant_name,
       }
       ensure_safe_gem_name(name, constant_array)
 
@@ -236,7 +236,7 @@ module Bundler
       end
 
       if use_git
-        IO.popen(%w[git add .], { :chdir => target }, &:read)
+        IO.popen(%w[git add .], { chdir: target }, &:read)
       end
 
       # Open gemspec in editor
@@ -349,7 +349,7 @@ module Bundler
         Bundler.ui.confirm "Do you want to add a code linter and formatter to your gem? " \
           "Supported Linters:\n" \
           "* RuboCop:       https://rubocop.org\n" \
-          "* Standard:      https://github.com/testdouble/standard\n" \
+          "* Standard:      https://github.com/standardrb/standard\n" \
           "\n"
         Bundler.ui.info hint_text("linter")
 
@@ -380,15 +380,20 @@ module Bundler
     def deprecated_rubocop_option
       if !options[:rubocop].nil?
         if options[:rubocop]
-          Bundler::SharedHelpers.major_deprecation 2, "--rubocop is deprecated, use --linter=rubocop"
+          Bundler::SharedHelpers.major_deprecation 2,
+            "--rubocop is deprecated, use --linter=rubocop",
+            removed_message: "--rubocop has been removed, use --linter=rubocop"
           "rubocop"
         else
-          Bundler::SharedHelpers.major_deprecation 2, "--no-rubocop is deprecated, use --linter"
+          Bundler::SharedHelpers.major_deprecation 2,
+            "--no-rubocop is deprecated, use --linter",
+            removed_message: "--no-rubocop has been removed, use --linter"
           false
         end
       elsif !Bundler.settings["gem.rubocop"].nil?
         Bundler::SharedHelpers.major_deprecation 2,
-          "config gem.rubocop is deprecated; we've updated your config to use gem.linter instead"
+          "config gem.rubocop is deprecated; we've updated your config to use gem.linter instead",
+          removed_message: "config gem.rubocop has been removed; we've updated your config to use gem.linter instead"
         Bundler.settings["gem.rubocop"] ? "rubocop" : false
       end
     end

data/bundler/lib/bundler/cli/info.rb

@@ -25,19 +25,8 @@ module Bundler
 
     private
 
-    def spec_for_gem(gem_name)
-      spec = Bundler.definition.specs.find {|s| s.name == gem_name }
-      spec || default_gem_spec(gem_name) || Bundler::CLI::Common.select_spec(gem_name, :regex_match)
-    end
-
-    def default_gem_spec(gem_name)
-      return unless Gem::Specification.respond_to?(:find_all_by_name)
-      gem_spec = Gem::Specification.find_all_by_name(gem_name).last
-      gem_spec if gem_spec&.default_gem?
-    end
-
-    def spec_not_found(gem_name)
-      raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(gem_name, Bundler.definition.dependencies)
+    def spec_for_gem(name)
+      Bundler::CLI::Common.select_spec(name, :regex_match)
     end
 
     def print_gem_version(spec)

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

@@ -51,7 +51,8 @@ module Bundler
 
       if options["binstubs"]
         Bundler::SharedHelpers.major_deprecation 2,
-          "The --binstubs option will be removed in favor of `bundle binstubs --all`"
+          "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?
@@ -61,7 +62,7 @@ module Bundler
 
       installer = Installer.install(Bundler.root, definition, options)
 
-      Bundler.settings.temporary(:cache_all_platforms => options[:local] ? false : Bundler.settings[:cache_all_platforms]) do
+      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
 
@@ -95,7 +96,7 @@ module Bundler
     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
+                      "will break this application for all non-root users on this machine.", wrap: true
     end
 
     def dependencies_count_for(definition)
@@ -148,7 +149,7 @@ module Bundler
       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.temporary(path_relative_to_cwd: false) do
           Bundler.settings.set_command_option :path, "bundle"
         end
       end

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

@@ -5,7 +5,7 @@ require "rbconfig"
 module Bundler
   class CLI::Issue
     def run
-      Bundler.ui.info <<-EOS.gsub(/^ {8}/, "")
+      Bundler.ui.info <<~EOS
         Did you find an issue with Bundler? Before filing a new issue,
         be sure to check out these resources:
 

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

@@ -26,14 +26,14 @@ module Bundler
 
       if update.is_a?(Array) # unlocking specific gems
         Bundler::CLI::Common.ensure_all_gems_in_lockfile!(update)
-        update = { :gems => update, :conservative => conservative }
+        update = { gems: update, conservative: conservative }
       elsif update && conservative
-        update = { :conservative => conservative }
+        update = { conservative: conservative }
       elsif update && bundler
-        update = { :bundler => bundler }
+        update = { bundler: bundler }
       end
 
-      Bundler.settings.temporary(:frozen => false) do
+      Bundler.settings.temporary(frozen: false) do
         definition = Bundler.definition(update)
 
         Bundler::CLI::Common.configure_gem_version_promoter(definition, options) if options[:update]

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

@@ -21,7 +21,7 @@ module Bundler
         require "shellwords"
         command = Shellwords.split(editor) << File.join([root_path, path].compact)
         Bundler.with_original_env do
-          system(*command, { :chdir => root_path })
+          system(*command, { chdir: root_path })
         end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
       end
     end