dependabot-common 0.236.0 → 0.237.0

data/lib/dependabot/errors.rb

@@ -1,20 +1,25 @@
 # typed: true
 # frozen_string_literal: true
 
+require "sorbet-runtime"
 require "dependabot/utils"
 
 module Dependabot
   class DependabotError < StandardError
+    extend T::Sig
+
     BASIC_AUTH_REGEX = %r{://(?<auth>[^:@]*:[^@%\s/]+(@|%40))}
     # Remove any path segment from fury.io sources
     FURY_IO_PATH_REGEX = %r{fury\.io/(?<path>.+)}
 
+    sig { params(message: T.any(T.nilable(String), MatchData)).void }
     def initialize(message = nil)
       super(sanitize_message(message))
     end
 
     private
 
+    sig { params(message: T.any(T.nilable(String), MatchData)).returns(T.any(T.nilable(String), MatchData)) }
     def sanitize_message(message)
       return message unless message.is_a?(String)
 
@@ -26,18 +31,25 @@ module Dependabot
       filter_sensitive_data(message)
     end
 
+    sig { params(message: String).returns(String) }
     def filter_sensitive_data(message)
       replace_capture_groups(message, BASIC_AUTH_REGEX, "")
     end
 
+    sig { params(source: String).returns(String) }
     def sanitize_source(source)
       source = filter_sensitive_data(source)
       replace_capture_groups(source, FURY_IO_PATH_REGEX, "<redacted>")
     end
 
+    sig do
+      params(
+        string: String,
+        regex: Regexp,
+        replacement: String
+      ).returns(String)
+    end
     def replace_capture_groups(string, regex, replacement)
-      return string unless string.is_a?(String)
-
       string.scan(regex).flatten.compact.reduce(string) do |original_msg, match|
         original_msg.gsub(match, replacement)
       end
@@ -55,8 +67,12 @@ module Dependabot
   #####################
 
   class DirectoryNotFound < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :directory_name
 
+    sig { params(directory_name: String, msg: T.nilable(String)).void }
     def initialize(directory_name, msg = nil)
       @directory_name = directory_name
       super(msg)
@@ -64,8 +80,12 @@ module Dependabot
   end
 
   class BranchNotFound < DependabotError
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
     attr_reader :branch_name
 
+    sig { params(branch_name: T.nilable(String), msg: T.nilable(String)).void }
     def initialize(branch_name, msg = nil)
       @branch_name = branch_name
       super(msg)
@@ -73,8 +93,12 @@ module Dependabot
   end
 
   class RepoNotFound < DependabotError
+    extend T::Sig
+
+    sig { returns(T.any(Dependabot::Source, String)) }
     attr_reader :source
 
+    sig { params(source: T.any(Dependabot::Source, String), msg: T.nilable(String)).void }
     def initialize(source, msg = nil)
       @source = source
       super(msg)
@@ -86,8 +110,24 @@ module Dependabot
   #####################
 
   class ToolVersionNotSupported < DependabotError
-    attr_reader :tool_name, :detected_version, :supported_versions
+    extend T::Sig
 
+    sig { returns(String) }
+    attr_reader :tool_name
+
+    sig { returns(String) }
+    attr_reader :detected_version
+
+    sig { returns(String) }
+    attr_reader :supported_versions
+
+    sig do
+      params(
+        tool_name: String,
+        detected_version: String,
+        supported_versions: String
+      ).void
+    end
     def initialize(tool_name, detected_version, supported_versions)
       @tool_name = tool_name
       @detected_version = detected_version
@@ -100,6 +140,9 @@ module Dependabot
   end
 
   class DependencyFileNotFound < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :file_path
 
     def initialize(file_path, msg = nil)
@@ -107,31 +150,39 @@ module Dependabot
       super(msg || "#{file_path} not found")
     end
 
+    sig { returns(String) }
     def file_name
-      file_path.split("/").last
+      T.must(file_path.split("/").last)
     end
 
+    sig { returns(String) }
     def directory
       # Directory should always start with a `/`
-      file_path.split("/")[0..-2].join("/").sub(%r{^/*}, "/")
+      T.must(file_path.split("/")[0..-2]).join("/").sub(%r{^/*}, "/")
     end
   end
 
   class DependencyFileNotParseable < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :file_path
 
+    sig { params(file_path: String, msg: T.nilable(String)).void }
     def initialize(file_path, msg = nil)
       @file_path = file_path
       super(msg || "#{file_path} not parseable")
     end
 
+    sig { returns(String) }
     def file_name
-      file_path.split("/").last
+      T.must(file_path.split("/").last)
     end
 
+    sig { returns(String) }
     def directory
       # Directory should always start with a `/`
-      file_path.split("/")[0..-2].join("/").sub(%r{^/*}, "/")
+      T.must(file_path.split("/")[0..-2]).join("/").sub(%r{^/*}, "/")
     end
   end
 
@@ -144,10 +195,13 @@ module Dependabot
   #######################
 
   class PrivateSourceAuthenticationFailure < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :source
 
     def initialize(source)
-      @source = sanitize_source(source)
+      @source = T.let(sanitize_source(source), String)
       msg = "The following source could not be reached as it requires " \
             "authentication (and any provided details were invalid or lacked " \
             "the required permissions): #{@source}"
@@ -156,26 +210,38 @@ module Dependabot
   end
 
   class PrivateSourceTimedOut < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :source
 
+    sig { params(source: String).void }
     def initialize(source)
-      @source = sanitize_source(source)
+      @source = T.let(sanitize_source(source), String)
       super("The following source timed out: #{@source}")
     end
   end
 
   class PrivateSourceCertificateFailure < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :source
 
+    sig { params(source: String).void }
     def initialize(source)
-      @source = sanitize_source(source)
+      @source = T.let(sanitize_source(source), String)
       super("Could not verify the SSL certificate for #{@source}")
     end
   end
 
   class MissingEnvironmentVariable < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :environment_variable
 
+    sig { params(environment_variable: String).void }
     def initialize(environment_variable)
       @environment_variable = environment_variable
       super("Missing environment variable #{@environment_variable}")
@@ -191,11 +257,15 @@ module Dependabot
   ###########################
 
   class GitDependenciesNotReachable < DependabotError
+    extend T::Sig
+
+    sig { returns(T::Array[String]) }
     attr_reader :dependency_urls
 
+    sig { params(dependency_urls: T.any(String, T::Array[String])).void }
     def initialize(*dependency_urls)
       @dependency_urls =
-        dependency_urls.flatten.map { |uri| filter_sensitive_data(uri) }
+        T.let(dependency_urls.flatten.map { |uri| filter_sensitive_data(uri) }, T::Array[String])
 
       msg = "The following git URLs could not be retrieved: " \
             "#{@dependency_urls.join(', ')}"
@@ -204,8 +274,12 @@ module Dependabot
   end
 
   class GitDependencyReferenceNotFound < DependabotError
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :dependency
 
+    sig { params(dependency: String).void }
     def initialize(dependency)
       @dependency = dependency
 
@@ -216,10 +290,14 @@ module Dependabot
   end
 
   class PathDependenciesNotReachable < DependabotError
+    extend T::Sig
+
+    sig { returns(T::Array[String]) }
     attr_reader :dependencies
 
+    sig { params(dependencies: T.any(String, T::Array[String])).void }
     def initialize(*dependencies)
-      @dependencies = dependencies.flatten
+      @dependencies = T.let(dependencies.flatten, T::Array[String])
       msg = "The following path based dependencies could not be retrieved: " \
             "#{@dependencies.join(', ')}"
       super(msg)
@@ -227,8 +305,18 @@ module Dependabot
   end
 
   class GoModulePathMismatch < DependabotError
-    attr_reader :go_mod, :declared_path, :discovered_path
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :go_mod
+
+    sig { returns(String) }
+    attr_reader :declared_path
+
+    sig { returns(String) }
+    attr_reader :discovered_path
 
+    sig { params(go_mod: String, declared_path: String, discovered_path: String).void }
     def initialize(go_mod, declared_path, discovered_path)
       @go_mod = go_mod
       @declared_path = declared_path