Autofix Layout/DotPosition with rubocop -a

bin/dry-run.rb

@@ -499,8 +499,8 @@ def log_conflicting_dependencies(conflicting_dependencies)
   commit: $options[:commit]
 )
 
-always_clone = Dependabot::Utils.
-               always_clone_for_package_manager?($package_manager)
+always_clone = Dependabot::Utils
+               .always_clone_for_package_manager?($package_manager)
 vendor_dependencies = $options[:vendor_dependencies]
 $repo_contents_path = File.expand_path(File.join("tmp", $repo_name.split("/"))) if vendor_dependencies || always_clone
 
@@ -586,8 +586,8 @@ def ignored_versions_for(dep)
         update_types: ic["update-types"]
       )
     end
-    Dependabot::Config::UpdateConfig.new(ignore_conditions: ignore_conditions).
-      ignored_versions_for(dep, security_updates_only: $options[:security_updates_only])
+    Dependabot::Config::UpdateConfig.new(ignore_conditions: ignore_conditions)
+                                    .ignored_versions_for(dep, security_updates_only: $options[:security_updates_only])
   else
     $update_config.ignored_versions_for(dep)
   end
@@ -617,17 +617,17 @@ def peer_dependency_should_update_instead?(dependency_name, updated_deps)
   # peer dependency getting updated.
   return false if $options[:security_updates_only]
 
-  updated_deps.
-    reject { |dep| dep.name == dependency_name }.
-    any? do |dep|
+  updated_deps
+    .reject { |dep| dep.name == dependency_name }
+    .any? do |dep|
       original_peer_dep = ::Dependabot::Dependency.new(
         name: dep.name,
         version: dep.previous_version,
         requirements: dep.previous_requirements,
         package_manager: dep.package_manager
       )
-      update_checker_for(original_peer_dep).
-        can_update?(requirements_to_unlock: :own)
+      update_checker_for(original_peer_dep)
+        .can_update?(requirements_to_unlock: :own)
     end
 end
 

bundler/helpers/v1/lib/functions.rb

@@ -10,14 +10,14 @@
 module Functions
   def self.parsed_gemfile(**args)
     set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
-    FileParser.new(lockfile_name: args.fetch(:lockfile_name)).
-      parsed_gemfile(gemfile_name: args.fetch(:gemfile_name))
+    FileParser.new(lockfile_name: args.fetch(:lockfile_name))
+              .parsed_gemfile(gemfile_name: args.fetch(:gemfile_name))
   end
 
   def self.parsed_gemspec(**args)
     set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
-    FileParser.new(lockfile_name: args.fetch(:lockfile_name)).
-      parsed_gemspec(gemspec_name: args.fetch(:gemspec_name))
+    FileParser.new(lockfile_name: args.fetch(:lockfile_name))
+              .parsed_gemspec(gemspec_name: args.fetch(:gemspec_name))
   end
 
   def self.vendor_cache_dir(**args)
@@ -88,18 +88,18 @@ def self.jfrog_source(**args)
     # Set flags and credentials
     set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
 
-    Bundler::Definition.build(args.fetch(:gemfile_name), nil, {}).
-      send(:sources).
-      rubygems_remotes.
-      find { |uri| uri.host.include?("jfrog") }&.
-      host
+    Bundler::Definition.build(args.fetch(:gemfile_name), nil, {})
+                       .send(:sources)
+                       .rubygems_remotes
+                       .find { |uri| uri.host.include?("jfrog") }
+      &.host
   end
 
   def self.git_specs(**args)
     set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
 
-    git_specs = Bundler::Definition.build(args.fetch(:gemfile_name), nil, {}).dependencies.
-                select do |spec|
+    git_specs = Bundler::Definition.build(args.fetch(:gemfile_name), nil, {}).dependencies
+                                   .select do |spec|
       spec.source.is_a?(Bundler::Source::Git)
     end
     git_specs.map do |spec|
@@ -157,12 +157,12 @@ def self.relevant_credentials(credentials)
   end
 
   def self.private_registry_credentials(credentials)
-    credentials.
-      select { |cred| cred["type"] == "rubygems_server" }
+    credentials
+      .select { |cred| cred["type"] == "rubygems_server" }
   end
 
   def self.git_source_credentials(credentials)
-    credentials.
-      select { |cred| cred["type"] == "git_source" }
+    credentials
+      .select { |cred| cred["type"] == "git_source" }
   end
 end

bundler/helpers/v1/lib/functions/dependency_source.rb

@@ -37,13 +37,13 @@ def latest_git_version(dependency_source_url:, dependency_source_branch:)
     def private_registry_versions
       bundler_source = specified_source || default_source
 
-      bundler_source.
-        fetchers.flat_map do |fetcher|
-          fetcher.
-            specs_with_retry([dependency_name], bundler_source).
-            search_all(dependency_name)
-        end.
-        map(&:version)
+      bundler_source
+        .fetchers.flat_map do |fetcher|
+          fetcher
+            .specs_with_retry([dependency_name], bundler_source)
+            .search_all(dependency_name)
+        end
+        .map(&:version)
     end
 
     private
@@ -67,8 +67,8 @@ def type_of(bundler_source)
     def specified_source
       return @specified_source if defined? @specified_source
 
-      @specified_source = definition.dependencies.
-                          find { |dep| dep.name == dependency_name }&.source
+      @specified_source = definition.dependencies
+                                    .find { |dep| dep.name == dependency_name }&.source
     end
 
     def default_source

bundler/helpers/v1/lib/functions/file_parser.rb

@@ -11,16 +11,16 @@ def initialize(lockfile_name:)
     attr_reader :lockfile_name
 
     def parsed_gemfile(gemfile_name:)
-      Bundler::Definition.build(gemfile_name, nil, {}).
-        dependencies.select(&:current_platform?).
-        reject { |dep| local_sources.include?(dep.source.class) }.
-        map { |dep| serialize_bundler_dependency(dep) }
+      Bundler::Definition.build(gemfile_name, nil, {})
+                         .dependencies.select(&:current_platform?)
+                         .reject { |dep| local_sources.include?(dep.source.class) }
+                         .map { |dep| serialize_bundler_dependency(dep) }
     end
 
     def parsed_gemspec(gemspec_name:)
-      Bundler.load_gemspec_uncached(gemspec_name).
-        dependencies.
-        map { |dep| serialize_bundler_dependency(dep) }
+      Bundler.load_gemspec_uncached(gemspec_name)
+             .dependencies
+             .map { |dep| serialize_bundler_dependency(dep) }
     end
 
     private

bundler/helpers/v1/lib/functions/force_updater.rb

@@ -62,9 +62,9 @@ def run
 
     def new_dependencies_to_unlock_from(error:, already_unlocked:)
       potentials_deps =
-        relevant_conflicts(error, already_unlocked).
-        flat_map(&:requirement_trees).
-        reject do |tree|
+        relevant_conflicts(error, already_unlocked)
+        .flat_map(&:requirement_trees)
+        .reject do |tree|
           # If the final requirement wasn't specific, it can't be binding
           next true if tree.last.requirement == Gem::Requirement.new(">= 0")
 
@@ -79,10 +79,10 @@ def new_dependencies_to_unlock_from(error:, already_unlocked:)
           )
         end.map(&:first)
 
-      potentials_deps.
-        reject { |dep| already_unlocked.map(&:name).include?(dep.name) }.
-        reject { |dep| [dependency_name, "ruby\0"].include?(dep.name) }.
-        uniq
+      potentials_deps
+        .reject { |dep| already_unlocked.map(&:name).include?(dep.name) }
+        .reject { |dep| [dependency_name, "ruby\0"].include?(dep.name) }
+        .uniq
     end
 
     def relevant_conflicts(error, dependencies_being_unlocked)
@@ -92,12 +92,12 @@ def relevant_conflicts(error, dependencies_being_unlocked)
       # 1) caused by a new requirement introduced by our unlocking, or
       # 2) caused by an old requirement that prohibits the update.
       # Hence, we look at the beginning and end of the requirement trees
-      error.cause.conflicts.values.
-        select do |conflict|
-          conflict.requirement_trees.any? do |t|
-            names.include?(t.last.name) || names.include?(t.first.name)
-          end
+      error.cause.conflicts.values
+           .select do |conflict|
+        conflict.requirement_trees.any? do |t|
+          names.include?(t.last.name) || names.include?(t.first.name)
         end
+      end
     end
 
     def build_definition(dependencies_to_unlock:)
@@ -115,8 +115,8 @@ def build_definition(dependencies_to_unlock:)
         unlock_gem(definition: definition, gem_name: gem_name)
       end
 
-      dep = definition.dependencies.
-            find { |d| d.name == dependency_name }
+      dep = definition.dependencies
+                      .find { |d| d.name == dependency_name }
 
       # If the dependency is not found in the Gemfile it means this is a
       # transitive dependency that we can't force update.
@@ -146,19 +146,19 @@ def subdependencies
       # subdependencies
       return [] unless lockfile
 
-      all_deps =  Bundler::LockfileParser.new(lockfile).
-                  specs.map { |x| x.name.to_s }
-      top_level = Bundler::Definition.
-                  build(gemfile_name, lockfile_name, {}).
-                  dependencies.map { |x| x.name.to_s }
+      all_deps =  Bundler::LockfileParser.new(lockfile)
+                                         .specs.map { |x| x.name.to_s }
+      top_level = Bundler::Definition
+                  .build(gemfile_name, lockfile_name, {})
+                  .dependencies.map { |x| x.name.to_s }
 
       all_deps - top_level
     end
 
     def unlock_gem(definition:, gem_name:)
       dep = definition.dependencies.find { |d| d.name == gem_name }
-      version = definition.locked_gems.specs.
-                find { |d| d.name == gem_name }.version
+      version = definition.locked_gems.specs
+                          .find { |d| d.name == gem_name }.version
 
       dep&.instance_variable_set(
         :@requirement,

bundler/helpers/v1/lib/functions/lockfile_updater.rb

@@ -63,8 +63,8 @@ def generate_lockfile # rubocop:disable Metrics/PerceivedComplexity
     def cache_vendored_gems(definition)
       # Dependencies that have been unlocked for the update (including
       # sub-dependencies)
-      unlocked_gems = definition.instance_variable_get(:@unlock).
-                      fetch(:gems)
+      unlocked_gems = definition.instance_variable_get(:@unlock)
+                                .fetch(:gems)
       bundler_opts = {
         cache_all: true,
         cache_all_platforms: true,
@@ -129,28 +129,28 @@ def prune_git_and_path_cache(resolve, cache_path)
     def unlock_yanked_gem(dependencies_to_unlock, error)
       raise unless error.message.match?(GEM_NOT_FOUND_ERROR_REGEX)
 
-      gem_name = error.message.match(GEM_NOT_FOUND_ERROR_REGEX).
-                 named_captures["name"]
+      gem_name = error.message.match(GEM_NOT_FOUND_ERROR_REGEX)
+                      .named_captures["name"]
       raise if dependencies_to_unlock.include?(gem_name)
 
       dependencies_to_unlock << gem_name
     end
 
     def unlock_blocking_subdeps(dependencies_to_unlock, error)
-      all_deps =  Bundler::LockfileParser.new(lockfile).
-                  specs.map { |x| x.name.to_s }
-      top_level = build_definition([]).dependencies.
-                  map { |x| x.name.to_s }
+      all_deps =  Bundler::LockfileParser.new(lockfile)
+                                         .specs.map { |x| x.name.to_s }
+      top_level = build_definition([]).dependencies
+                                      .map { |x| x.name.to_s }
       allowed_new_unlocks = all_deps - top_level - dependencies_to_unlock
 
       raise if allowed_new_unlocks.none?
 
       # Unlock any sub-dependencies that Bundler reports caused the
       # conflict
       potentials_deps =
-        error.cause.conflicts.values.
-        flat_map(&:requirement_trees).
-        filter_map do |tree|
+        error.cause.conflicts.values
+             .flat_map(&:requirement_trees)
+             .filter_map do |tree|
           tree.find { |req| allowed_new_unlocks.include?(req.name) }
         end.map(&:name)
 

bundler/helpers/v1/lib/functions/version_resolver.rb

@@ -81,10 +81,10 @@ def subdependencies
       # subdependencies
       return [] unless lockfile
 
-      all_deps =  ::Bundler::LockfileParser.new(lockfile).
-                  specs.map { |x| x.name.to_s }.uniq
-      top_level = build_definition([]).dependencies.
-                  map { |x| x.name.to_s }
+      all_deps =  ::Bundler::LockfileParser.new(lockfile)
+                                           .specs.map { |x| x.name.to_s }.uniq
+      top_level = build_definition([]).dependencies
+                                      .map { |x| x.name.to_s }
 
       all_deps - top_level
     end
@@ -104,8 +104,8 @@ def build_definition(dependencies_to_unlock)
     def unlock_yanked_gem(dependencies_to_unlock, error)
       raise unless error.message.match?(GEM_NOT_FOUND_ERROR_REGEX)
 
-      gem_name = error.message.match(GEM_NOT_FOUND_ERROR_REGEX).
-                 named_captures["name"]
+      gem_name = error.message.match(GEM_NOT_FOUND_ERROR_REGEX)
+                      .named_captures["name"]
       raise if dependencies_to_unlock.include?(gem_name)
 
       dependencies_to_unlock << gem_name

bundler/helpers/v1/monkey_patches/definition_bundler_version_patch.rb

@@ -7,8 +7,8 @@
 module BundlerDefinitionBundlerVersionPatch
   def expanded_dependencies
     @expanded_dependencies ||=
-      expand_dependencies(dependencies + metadata_dependencies, @remote).
-      reject { |d| d.name == "bundler" }
+      expand_dependencies(dependencies + metadata_dependencies, @remote)
+      .reject { |d| d.name == "bundler" }
   end
 end
 

bundler/helpers/v1/monkey_patches/fileutils_keyword_splat_patch.rb

@@ -10,9 +10,9 @@ module BundlerFileUtilsKeywordSplatPatch
   def entries
     opts = {}
     opts[:encoding] = ::Encoding::UTF_8 if fu_windows?
-    Dir.entries(path, **opts).
-      reject { |n| n == "." || n == ".." }.
-      map { |n| self.class.new(prefix, join(rel, n.untaint)) }
+    Dir.entries(path, **opts)
+       .reject { |n| n == "." || n == ".." }
+       .map { |n| self.class.new(prefix, join(rel, n.untaint)) }
   end
 end
 

bundler/helpers/v1/monkey_patches/git_source_patch.rb

@@ -35,8 +35,8 @@ class Git < Path
 
       def serialize_gemspecs_in(destination)
         original_load_paths = $LOAD_PATH.dup
-        reduced_load_paths = original_load_paths.
-                             reject { |p| p.include?("/gems/") }
+        reduced_load_paths = original_load_paths
+                             .reject { |p| p.include?("/gems/") }
 
         $LOAD_PATH.shift until $LOAD_PATH.empty?
         reduced_load_paths.each { |p| $LOAD_PATH << p }