dependabot-common 0.245.0 → 0.246.0

data/lib/dependabot/pull_request_creator/codecommit.rb

@@ -1,20 +1,66 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "sorbet-runtime"
+
 require "dependabot/clients/codecommit"
 require "dependabot/pull_request_creator"
 
 module Dependabot
   class PullRequestCreator
     class Codecommit
-      attr_reader :source, :branch_name, :base_commit, :credentials,
-                  :files, :commit_message, :pr_description, :pr_name,
-                  :author_details, :labeler
+      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 :commit_message
+
+      sig { returns(String) }
+      attr_reader :pr_description
+
+      sig { returns(String) }
+      attr_reader :pr_name
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :author_details
+
+      sig { returns(T.nilable(Dependabot::PullRequestCreator::Labeler)) }
+      attr_reader :labeler
 
       # CodeCommit limits PR descriptions to a max length of 10,240 characters:
       # https://docs.aws.amazon.com/codecommit/latest/APIReference/API_PullRequest.html
       PR_DESCRIPTION_MAX_LENGTH = 10_239 # 0 based count
 
+      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: T.nilable(Dependabot::PullRequestCreator::Labeler),
+          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:, labeler:, require_up_to_date_base:)
@@ -31,6 +77,7 @@ module Dependabot
         @require_up_to_date_base = require_up_to_date_base
       end
 
+      sig { void }
       def create
         return if branch_exists?(branch_name) && unmerged_pull_request_exists?
         return if require_up_to_date_base? && !base_commit_is_up_to_date?
@@ -40,10 +87,12 @@ module Dependabot
 
       private
 
+      sig { returns(T::Boolean) }
       def require_up_to_date_base?
         @require_up_to_date_base
       end
 
+      sig { returns(T::Boolean) }
       def base_commit_is_up_to_date?
         codecommit_client_for_source.fetch_commit(
           source.repo,
@@ -51,6 +100,7 @@ module Dependabot
         ) == base_commit
       end
 
+      sig { returns(T.nilable(Aws::CodeCommit::Types::CreatePullRequestOutput)) }
       def create_pull_request
         branch = create_or_get_branch(base_commit)
         return unless branch
@@ -69,6 +119,7 @@ module Dependabot
         pull_request
       end
 
+      sig { params(commit: String).returns(T.nilable(String)) }
       def create_or_get_branch(commit)
         # returns the branch name
         if branch_exists?(branch_name)
@@ -78,6 +129,7 @@ module Dependabot
         end
       end
 
+      sig { params(commit: String).returns(String) }
       def create_branch(commit)
         # codecommit returns an empty response on create branch success
         codecommit_client_for_source.create_branch(source.repo, branch_name,
@@ -86,49 +138,64 @@ module Dependabot
         branch_name
       end
 
+      sig { returns(Dependabot::Clients::CodeCommit) }
       def codecommit_client_for_source
         @codecommit_client_for_source ||=
-          Dependabot::Clients::CodeCommit.for_source(
-            source: source,
-            credentials: credentials
+          T.let(
+            Dependabot::Clients::CodeCommit.for_source(
+              source: source,
+              credentials: credentials
+            ),
+            T.nilable(Dependabot::Clients::CodeCommit)
           )
       end
 
+      sig { params(branch_name: String).returns(T::Boolean) }
       def branch_exists?(branch_name)
-        @branch_ref ||= codecommit_client_for_source.branch(branch_name)
+        @branch_ref ||= T.let(
+          codecommit_client_for_source.branch(branch_name),
+          T.nilable(String)
+        )
+        !@branch_ref.nil?
         rescue Aws::CodeCommit::Errors::BranchDoesNotExistException
           false
       end
 
+      sig { returns(T::Boolean) }
       def unmerged_pull_request_exists?
         unmerged_prs = []
         pull_requests_for_branch.each do |pr|
-          unless pr.pull_request
-                   .pull_request_targets[0].merge_metadata.is_merged
+          unless T.unsafe(pr).pull_request
+                  .pull_request_targets[0].merge_metadata.is_merged
             unmerged_prs << pr
           end
         end
         unmerged_prs.any?
       end
 
+      sig { returns(T::Array[Aws::CodeCommit::Types::PullRequest]) }
       def pull_requests_for_branch
         @pull_requests_for_branch ||=
-          begin
-            open_prs = codecommit_client_for_source.pull_requests(
-              source.repo,
-              "open",
-              source.branch || default_branch
-            )
-            closed_prs = codecommit_client_for_source.pull_requests(
-              source.repo,
-              "closed",
-              source.branch || default_branch
-            )
-
-            [*open_prs, *closed_prs]
-          end
+          T.let(
+            begin
+              open_prs = codecommit_client_for_source.pull_requests(
+                source.repo,
+                "open",
+                source.branch || default_branch
+              )
+              closed_prs = codecommit_client_for_source.pull_requests(
+                source.repo,
+                "closed",
+                source.branch || default_branch
+              )
+
+              [*open_prs, *closed_prs]
+            end,
+            T.nilable(T::Array[Aws::CodeCommit::Types::PullRequest])
+          )
       end
 
+      sig { void }
       def create_commit
         author = author_details&.slice(:name, :email, :date)
         author = nil unless author&.any?
@@ -142,9 +209,13 @@ module Dependabot
         )
       end
 
+      sig { returns(String) }
       def default_branch
         @default_branch ||=
-          codecommit_client_for_source.fetch_default_branch(source.repo)
+          T.let(
+            codecommit_client_for_source.fetch_default_branch(source.repo),
+            T.nilable(String)
+          )
       end
     end
   end

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