dependabot-common 0.244.0 → 0.246.0

data/lib/dependabot/pull_request_creator/github.rb

@@ -1,12 +1,14 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "octokit"
 require "securerandom"
 require "sorbet-runtime"
+
 require "dependabot/clients/github_with_retries"
 require "dependabot/pull_request_creator"
 require "dependabot/pull_request_creator/commit_signer"
+
 module Dependabot
   class PullRequestCreator
     # rubocop:disable Metrics/ClassLength
@@ -17,11 +19,72 @@ module Dependabot
       # https://github.com/orgs/community/discussions/27190#discussioncomment-3726017
       PR_DESCRIPTION_MAX_LENGTH = 65_535 # 0 based count
 
-      attr_reader :source, :branch_name, :base_commit, :credentials,
-                  :files, :pr_description, :pr_name, :commit_message,
-                  :author_details, :signature_key, :custom_headers,
-                  :labeler, :reviewers, :assignees, :milestone
+      sig { returns(Dependabot::Source) }
+      attr_reader :source
+
+      sig { returns(String) }
+      attr_reader :branch_name
+
+      sig { returns(String) }
+      attr_reader :base_commit
+
+      sig { returns(T::Array[Dependabot::Credential]) }
+      attr_reader :credentials
+
+      sig { returns(T::Array[Dependabot::DependencyFile]) }
+      attr_reader :files
+
+      sig { returns(String) }
+      attr_reader :pr_description
+
+      sig { returns(String) }
+      attr_reader :pr_name
+
+      sig { returns(String) }
+      attr_reader :commit_message
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :author_details
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :signature_key
+
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_reader :custom_headers
 
+      sig { returns(Dependabot::PullRequestCreator::Labeler) }
+      attr_reader :labeler
+
+      sig { returns(T.nilable(T::Hash[String, T::Array[String]])) }
+      attr_reader :reviewers
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :assignees
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :milestone
+
+      sig do
+        params(
+          source: Dependabot::Source,
+          branch_name: String,
+          base_commit: String,
+          credentials: T::Array[Dependabot::Credential],
+          files: T::Array[Dependabot::DependencyFile],
+          commit_message: String,
+          pr_description: String,
+          pr_name: String,
+          author_details: T.nilable(T::Hash[Symbol, String]),
+          signature_key: T.nilable(String),
+          custom_headers: T.nilable(T::Hash[String, String]),
+          labeler: Dependabot::PullRequestCreator::Labeler,
+          reviewers: T.nilable(T::Hash[String, T::Array[String]]),
+          assignees: T.nilable(T::Array[String]),
+          milestone: T.nilable(Integer),
+          require_up_to_date_base: T::Boolean
+        )
+          .void
+      end
       def initialize(source:, branch_name:, base_commit:, credentials:,
                      files:, commit_message:, pr_description:, pr_name:,
                      author_details:, signature_key:, custom_headers:,
@@ -45,6 +108,7 @@ module Dependabot
         @require_up_to_date_base = require_up_to_date_base
       end
 
+      sig { returns(T.untyped) }
       def create
         if branch_exists?(branch_name) && unmerged_pull_request_exists?
           raise UnmergedPRExists, "PR ##{unmerged_pull_requests.first.number} already exists"
@@ -60,11 +124,13 @@ module Dependabot
 
       private
 
+      sig { returns(T::Boolean) }
       def require_up_to_date_base?
         @require_up_to_date_base
       end
 
       # rubocop:disable Metrics/PerceivedComplexity
+      sig { params(name: String).returns(T::Boolean) }
       def branch_exists?(name)
         git_metadata_fetcher.ref_names.include?(name)
       rescue Dependabot::GitDependenciesNotReachable => e
@@ -82,48 +148,60 @@ module Dependabot
       end
       # rubocop:enable Metrics/PerceivedComplexity
 
+      sig { returns(T::Boolean) }
       def unmerged_pull_request_exists?
         unmerged_pull_requests.any?
       end
 
+      sig { returns(T::Array[T.untyped]) }
       def unmerged_pull_requests
         pull_requests_for_branch.reject(&:merged)
       end
 
+      sig { returns(T::Array[T.untyped]) }
       def pull_requests_for_branch
         @pull_requests_for_branch ||=
-          begin
-            github_client_for_source.pull_requests(
-              source.repo,
-              head: "#{source.repo.split('/').first}:#{branch_name}",
-              state: "all"
-            )
-          rescue Octokit::InternalServerError
-            # A GitHub bug sometimes means adding `state: all` causes problems.
-            # In that case, fall back to making two separate requests.
-            open_prs = github_client_for_source.pull_requests(
-              source.repo,
-              head: "#{source.repo.split('/').first}:#{branch_name}",
-              state: "open"
-            )
-
-            closed_prs = github_client_for_source.pull_requests(
-              source.repo,
-              head: "#{source.repo.split('/').first}:#{branch_name}",
-              state: "closed"
-            )
-            [*open_prs, *closed_prs]
-          end
+          T.let(
+            begin
+              T.unsafe(github_client_for_source).pull_requests(
+                source.repo,
+                head: "#{source.repo.split('/').first}:#{branch_name}",
+                state: "all"
+              )
+            rescue Octokit::InternalServerError
+              # A GitHub bug sometimes means adding `state: all` causes problems.
+              # In that case, fall back to making two separate requests.
+              open_prs = T.unsafe(github_client_for_source).pull_requests(
+                source.repo,
+                head: "#{source.repo.split('/').first}:#{branch_name}",
+                state: "open"
+              )
+
+              closed_prs = T.unsafe(github_client_for_source).pull_requests(
+                source.repo,
+                head: "#{source.repo.split('/').first}:#{branch_name}",
+                state: "closed"
+              )
+              [*open_prs, *closed_prs]
+            end,
+            T.nilable(T::Array[T.untyped])
+          )
       end
 
+      sig { returns(T::Boolean) }
       def base_commit_is_up_to_date?
         head_commit == base_commit
       end
 
+      sig { returns(T.nilable(String)) }
       def head_commit
-        @head_commit ||= git_metadata_fetcher.head_commit_for_ref(target_branch)
+        @head_commit ||= T.let(
+          git_metadata_fetcher.head_commit_for_ref(target_branch),
+          T.nilable(String)
+        )
       end
 
+      sig { returns(T.untyped) }
       def create_annotated_pull_request
         commit = create_commit
         branch = create_or_update_branch(commit)
@@ -141,18 +219,20 @@ module Dependabot
         pull_request
       end
 
+      sig { returns(T::Boolean) }
       def repo_exists?
-        github_client_for_source.repo(source.repo)
+        T.unsafe(github_client_for_source).repo(source.repo)
         true
       rescue Octokit::NotFound
         false
       end
 
+      sig { returns(T.untyped) }
       def create_commit
         tree = create_tree
 
         begin
-          github_client_for_source.create_commit(
+          T.unsafe(github_client_for_source).create_commit(
             source.repo,
             commit_message,
             tree.sha,
@@ -164,6 +244,7 @@ module Dependabot
 
           # Sometimes a race condition on GitHub's side means we get an error
           # here. No harm in retrying if we do.
+          @commit_creation ||= T.let(0, T.nilable(Integer))
           raise_or_increment_retry_counter(counter: @commit_creation, limit: 3)
           sleep(rand(1..1.99))
           retry
@@ -171,11 +252,13 @@ module Dependabot
       rescue Octokit::UnprocessableEntity => e
         raise unless e.message == "Tree SHA does not exist"
 
+        @tree_creation ||= T.let(0, T.nilable(Integer))
         raise_or_increment_retry_counter(counter: @tree_creation, limit: 1)
         sleep(rand(1..1.99))
         retry
       end
 
+      sig { params(tree: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
       def commit_options(tree)
         options = author_details&.any? ? { author: author_details } : {}
 
@@ -187,6 +270,7 @@ module Dependabot
         options
       end
 
+      sig { returns(T.untyped) }
       def create_tree
         file_trees = files.map do |file|
           if file.type == "submodule"
@@ -200,7 +284,7 @@ module Dependabot
             content = if file.operation == Dependabot::DependencyFile::Operation::DELETE
                         { sha: nil }
                       elsif file.binary?
-                        sha = github_client_for_source.create_blob(
+                        sha = T.unsafe(github_client_for_source).create_blob(
                           source.repo, file.content, "base64"
                         )
                         { sha: sha }
@@ -216,13 +300,14 @@ module Dependabot
           end
         end
 
-        github_client_for_source.create_tree(
+        T.unsafe(github_client_for_source).create_tree(
           source.repo,
           file_trees,
           base_tree: base_commit
         )
       end
 
+      sig { params(commit: T.untyped).returns(T.untyped) }
       def create_or_update_branch(commit)
         if branch_exists?(branch_name)
           update_branch(commit)
@@ -241,12 +326,13 @@ module Dependabot
         retry
       end
 
+      sig { params(commit: T.untyped).returns(T.untyped) }
       def create_branch(commit)
         ref = "refs/heads/#{branch_name}"
 
         begin
           branch =
-            github_client_for_source.create_ref(source.repo, ref, commit.sha)
+            T.unsafe(github_client_for_source).create_ref(source.repo, ref, commit.sha)
           @branch_name = ref.gsub(%r{^refs/heads/}, "")
           branch
         rescue Octokit::UnprocessableEntity => e
@@ -264,8 +350,9 @@ module Dependabot
         end
       end
 
+      sig { params(commit: T.untyped).void }
       def update_branch(commit)
-        github_client_for_source.update_ref(
+        T.unsafe(github_client_for_source).update_ref(
           source.repo,
           "heads/#{branch_name}",
           commit.sha,
@@ -273,6 +360,7 @@ module Dependabot
         )
       end
 
+      sig { params(pull_request: T.untyped).void }
       def annotate_pull_request(pull_request)
         labeler.label_pull_request(pull_request.number)
         add_reviewers_to_pull_request(pull_request) if reviewers&.any?
@@ -280,11 +368,12 @@ module Dependabot
         add_milestone_to_pull_request(pull_request) if milestone
       end
 
+      sig { params(pull_request: T.untyped).void }
       def add_reviewers_to_pull_request(pull_request)
         reviewers_hash =
-          reviewers.keys.to_h { |k| [k.to_sym, reviewers[k]] }
+          T.must(reviewers).keys.to_h { |k| [k.to_sym, T.must(reviewers)[k]] }
 
-        github_client_for_source.request_pull_request_review(
+        T.unsafe(github_client_for_source).request_pull_request_review(
           source.repo,
           pull_request.number,
           reviewers: reviewers_hash[:reviewers] || [],
@@ -302,6 +391,7 @@ module Dependabot
         raise
       end
 
+      sig { params(message: String).returns(T::Boolean) }
       def invalid_reviewer?(message)
         return true if message.include?("Could not resolve to a node")
         return true if message.include?("not a collaborator")
@@ -310,9 +400,10 @@ module Dependabot
         false
       end
 
+      sig { params(pull_request: T.untyped, message: String).void }
       def comment_with_invalid_reviewer(pull_request, message)
         reviewers_hash =
-          reviewers.keys.to_h { |k| [k.to_sym, reviewers[k]] }
+          T.must(reviewers).keys.to_h { |k| [k.to_sym, T.must(reviewers)[k]] }
         reviewers = []
         reviewers += reviewers_hash[:reviewers] || []
         reviewers += (reviewers_hash[:team_reviewers] || [])
@@ -333,15 +424,16 @@ module Dependabot
                "#{message}\n" \
                "```"
 
-        github_client_for_source.add_comment(
+        T.unsafe(github_client_for_source).add_comment(
           source.repo,
           pull_request.number,
           msg
         )
       end
 
+      sig { params(pull_request: T.untyped).void }
       def add_assignees_to_pull_request(pull_request)
-        github_client_for_source.add_assignees(
+        T.unsafe(github_client_for_source).add_assignees(
           source.repo,
           pull_request.number,
           assignees
@@ -351,8 +443,9 @@ module Dependabot
         nil
       end
 
+      sig { params(pull_request: T.untyped).void }
       def add_milestone_to_pull_request(pull_request)
-        github_client_for_source.update_issue(
+        T.unsafe(github_client_for_source).update_issue(
           source.repo,
           pull_request.number,
           milestone: milestone
@@ -361,8 +454,9 @@ module Dependabot
         raise unless e.message.include?("code: invalid")
       end
 
+      sig { returns(T.untyped) }
       def create_pull_request
-        github_client_for_source.create_pull_request(
+        T.unsafe(github_client_for_source).create_pull_request(
           source.repo,
           target_branch,
           branch_name,
@@ -381,47 +475,65 @@ module Dependabot
         retry
       end
 
+      sig { returns(String) }
       def target_branch
         source.branch || default_branch
       end
 
+      sig { returns(String) }
       def default_branch
         @default_branch ||=
-          github_client_for_source.repository(source.repo).default_branch
+          T.let(
+            T.unsafe(github_client_for_source).repo(source.repo).default_branch,
+            T.nilable(String)
+          )
       end
 
+      sig { returns(Dependabot::GitMetadataFetcher) }
       def git_metadata_fetcher
         @git_metadata_fetcher ||=
-          GitMetadataFetcher.new(
-            url: source.url,
-            credentials: credentials
+          T.let(
+            GitMetadataFetcher.new(
+              url: source.url,
+              credentials: credentials
+            ),
+            T.nilable(Dependabot::GitMetadataFetcher)
           )
       end
 
+      sig do
+        params(tree: T.untyped, author_details_with_date: T::Hash[Symbol, String]).returns(String)
+      end
       def commit_signature(tree, author_details_with_date)
         CommitSigner.new(
           author_details: author_details_with_date,
           commit_message: commit_message,
           tree_sha: tree.sha,
           parent_sha: base_commit,
-          signature_key: signature_key
+          signature_key: T.must(signature_key)
         ).signature
       end
 
+      sig { params(counter: T.nilable(Integer), limit: Integer).void }
       def raise_or_increment_retry_counter(counter:, limit:)
         counter ||= 0
         counter += 1
         raise if counter > limit
       end
 
+      sig { returns(Dependabot::Clients::GithubWithRetries) }
       def github_client_for_source
         @github_client_for_source ||=
-          Dependabot::Clients::GithubWithRetries.for_source(
-            source: source,
-            credentials: credentials
+          T.let(
+            Dependabot::Clients::GithubWithRetries.for_source(
+              source: source,
+              credentials: credentials
+            ),
+            T.nilable(Dependabot::Clients::GithubWithRetries)
           )
       end
 
+      sig { params(err: StandardError).returns(T.noreturn) }
       def handle_error(err)
         cause = case err
                 when AnnotationError
@@ -452,6 +564,7 @@ module Dependabot
         end
       end
 
+      sig { params(base_err: StandardError, type: T.class_of(StandardError), message: String).returns(T.noreturn) }
       def raise_custom_error(base_err, type, message)
         case base_err
         when AnnotationError

data/lib/dependabot/pull_request_creator/gitlab.rb

@@ -1,18 +1,78 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "gitlab"
+require "sorbet-runtime"
+
 require "dependabot/clients/gitlab_with_retries"
 require "dependabot/pull_request_creator"
-require "gitlab"
 
 module Dependabot
   class PullRequestCreator
     class Gitlab
-      attr_reader :source, :branch_name, :base_commit, :credentials,
-                  :files, :pr_description, :pr_name, :commit_message,
-                  :author_details, :labeler, :approvers, :assignees,
-                  :milestone, :target_project_id
+      extend T::Sig
+
+      sig { returns(Dependabot::Source) }
+      attr_reader :source
+
+      sig { returns(String) }
+      attr_reader :branch_name
+
+      sig { returns(String) }
+      attr_reader :base_commit
+
+      sig { returns(T::Array[Dependabot::Credential]) }
+      attr_reader :credentials
+
+      sig { returns(T::Array[Dependabot::DependencyFile]) }
+      attr_reader :files
+
+      sig { returns(String) }
+      attr_reader :pr_description
+
+      sig { returns(String) }
+      attr_reader :pr_name
+
+      sig { returns(String) }
+      attr_reader :commit_message
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :author_details
 
+      sig { returns(Dependabot::PullRequestCreator::Labeler) }
+      attr_reader :labeler
+
+      sig { returns(T.nilable(T::Hash[Symbol, T::Array[Integer]])) }
+      attr_reader :approvers
+
+      sig { returns(T.nilable(T::Array[Integer])) }
+      attr_reader :assignees
+
+      sig { returns(T.nilable(T.any(T::Array[String], Integer))) }
+      attr_reader :milestone
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :target_project_id
+
+      sig do
+        params(
+          source: Dependabot::Source,
+          branch_name: String,
+          base_commit: String,
+          credentials: T::Array[Dependabot::Credential],
+          files: T::Array[Dependabot::DependencyFile],
+          commit_message: String,
+          pr_description: String,
+          pr_name: String,
+          author_details: T.nilable(T::Hash[Symbol, String]),
+          labeler: Dependabot::PullRequestCreator::Labeler,
+          approvers: T.nilable(T::Hash[Symbol, T::Array[Integer]]),
+          assignees: T.nilable(T::Array[Integer]),
+          milestone: T.nilable(T.any(T::Array[String], Integer)),
+          target_project_id: T.nilable(Integer)
+        )
+          .void
+      end
       def initialize(source:, branch_name:, base_commit:, credentials:,
                      files:, commit_message:, pr_description:, pr_name:,
                      author_details:, labeler:, approvers:, assignees:,
@@ -33,6 +93,7 @@ module Dependabot
         @target_project_id = target_project_id
       end
 
+      sig { returns(T.nilable(::Gitlab::ObjectifiedHash)) }
       def create
         return if branch_exists? && merge_request_exists?
 
@@ -54,30 +115,43 @@ module Dependabot
 
       private
 
+      sig { returns(Dependabot::Clients::GitlabWithRetries) }
       def gitlab_client_for_source
         @gitlab_client_for_source ||=
-          Dependabot::Clients::GitlabWithRetries.for_source(
-            source: source,
-            credentials: credentials
+          T.let(
+            Dependabot::Clients::GitlabWithRetries.for_source(
+              source: source,
+              credentials: credentials
+            ),
+            T.nilable(Dependabot::Clients::GitlabWithRetries)
           )
       end
 
+      sig { returns(T::Boolean) }
       def branch_exists?
         @branch_ref ||=
-          gitlab_client_for_source.branch(source.repo, branch_name)
+          T.let(
+            T.unsafe(gitlab_client_for_source).branch(source.repo, branch_name),
+            T.nilable(::Gitlab::ObjectifiedHash)
+          )
         true
       rescue ::Gitlab::Error::NotFound
         false
       end
 
+      sig { returns(T::Boolean) }
       def commit_exists?
         @commits ||=
-          gitlab_client_for_source.commits(source.repo, ref_name: branch_name)
+          T.let(
+            T.unsafe(gitlab_client_for_source).commits(source.repo, ref_name: branch_name),
+            T.nilable(::Gitlab::PaginatedResponse)
+          )
         @commits.first.message == commit_message
       end
 
+      sig { returns(T::Boolean) }
       def merge_request_exists?
-        gitlab_client_for_source.merge_requests(
+        T.unsafe(gitlab_client_for_source).merge_requests(
           target_project_id || source.repo,
           source_branch: branch_name,
           target_branch: source.branch || default_branch,
@@ -85,16 +159,18 @@ module Dependabot
         ).any?
       end
 
+      sig { returns(::Gitlab::ObjectifiedHash) }
       def create_branch
-        gitlab_client_for_source.create_branch(
+        T.unsafe(gitlab_client_for_source).create_branch(
           source.repo,
           branch_name,
           base_commit
         )
       end
 
+      sig { returns(::Gitlab::ObjectifiedHash) }
       def create_commit
-        return create_submodule_update_commit if files.count == 1 && files.first.type == "submodule"
+        return create_submodule_update_commit if files.count == 1 && T.must(files.first).type == "submodule"
 
         gitlab_client_for_source.create_commit(
           source.repo,
@@ -104,10 +180,11 @@ module Dependabot
         )
       end
 
+      sig { returns(::Gitlab::ObjectifiedHash) }
       def create_submodule_update_commit
-        file = files.first
+        file = T.must(files.first)
 
-        gitlab_client_for_source.edit_submodule(
+        T.unsafe(gitlab_client_for_source).edit_submodule(
           source.repo,
           file.path.gsub(%r{^/}, ""),
           branch: branch_name,
@@ -116,8 +193,9 @@ module Dependabot
         )
       end
 
+      sig { returns(T.nilable(::Gitlab::ObjectifiedHash)) }
       def create_merge_request
-        gitlab_client_for_source.create_merge_request(
+        T.unsafe(gitlab_client_for_source).create_merge_request(
           source.repo,
           pr_name,
           source_branch: branch_name,
@@ -132,16 +210,18 @@ module Dependabot
         )
       end
 
+      sig { params(merge_request: ::Gitlab::ObjectifiedHash).returns(T.nilable(::Gitlab::ObjectifiedHash)) }
       def annotate_merge_request(merge_request)
         add_approvers_to_merge_request(merge_request)
       end
 
+      sig { params(merge_request: ::Gitlab::ObjectifiedHash).returns(T.nilable(::Gitlab::ObjectifiedHash)) }
       def add_approvers_to_merge_request(merge_request)
         return unless approvers_hash[:approvers] || approvers_hash[:group_approvers]
 
-        gitlab_client_for_source.create_merge_request_level_rule(
+        T.unsafe(gitlab_client_for_source).create_merge_request_level_rule(
           target_project_id || source.repo,
-          merge_request.iid,
+          T.unsafe(merge_request).iid,
           name: "dependency-updates",
           approvals_required: 1,
           user_ids: approvers_hash[:approvers],
@@ -149,13 +229,21 @@ module Dependabot
         )
       end
 
+      sig { returns(T::Hash[Symbol, T::Array[Integer]]) }
       def approvers_hash
-        @approvers_hash ||= approvers || {}
+        @approvers_hash ||= T.let(
+          approvers || {},
+          T.nilable(T::Hash[Symbol, T::Array[Integer]])
+        )
       end
 
+      sig { returns(String) }
       def default_branch
         @default_branch ||=
-          gitlab_client_for_source.project(source.repo).default_branch
+          T.let(
+            T.unsafe(gitlab_client_for_source).project(source.repo).default_branch,
+            T.nilable(String)
+          )
       end
     end
   end