Take redirections into account in UrlChecker

modules/core/src/main/scala/org/scalasteward/core/application/SelfCheckAlg.scala

@@ -81,9 +81,9 @@ final class SelfCheckAlg[F[_]](config: Config)(implicit
 
   private def checkUrlChecker: F[Unit] =
     config.urlCheckerTestUrls.traverse_ { url =>
-      urlChecker.exists(url).flatMap { urlExists =>
+      urlChecker.validate(url).flatMap { res =>
         val msg = s"Self check of UrlChecker failed: checking that $url exists failed"
-        F.whenA(!urlExists)(logger.warn(msg))
+        F.whenA(res.notExists)(logger.warn(msg))
       }
     }
 }

modules/core/src/main/scala/org/scalasteward/core/nurture/NurtureAlg.scala

@@ -206,7 +206,7 @@ final class NurtureAlg[F[_]](config: ForgeCfg)(implicit
         .traverse { case (_, dependency) =>
           coursierAlg
             .getMetadata(dependency, resolvers)
-            .flatMap(_.filterUrls(urlChecker.exists))
+            .flatMap(_.filterUrls(uri => urlChecker.validate(uri).map(_.exists)))
             .tupleLeft(dependency)
         }
         .map(_.toMap)

modules/core/src/main/scala/org/scalasteward/core/nurture/UpdateInfoUrl.scala

@@ -22,13 +22,23 @@
 /** A URL of a resource that provides additional information for an update. */
 sealed trait UpdateInfoUrl {
   def url: Uri
+
+  def withUrl(url: Uri): UpdateInfoUrl
 }
 
 object UpdateInfoUrl {
-  final case class CustomChangelog(url: Uri) extends UpdateInfoUrl
-  final case class CustomReleaseNotes(url: Uri) extends UpdateInfoUrl
-  final case class GitHubReleaseNotes(url: Uri) extends UpdateInfoUrl
-  final case class VersionDiff(url: Uri) extends UpdateInfoUrl
+  final case class CustomChangelog(url: Uri) extends UpdateInfoUrl {
+    override def withUrl(url: Uri): UpdateInfoUrl = CustomChangelog(url)
+  }
+  final case class CustomReleaseNotes(url: Uri) extends UpdateInfoUrl {
+    override def withUrl(url: Uri): UpdateInfoUrl = CustomReleaseNotes(url)
+  }
+  final case class GitHubReleaseNotes(url: Uri) extends UpdateInfoUrl {
+    override def withUrl(url: Uri): UpdateInfoUrl = GitHubReleaseNotes(url)
+  }
+  final case class VersionDiff(url: Uri) extends UpdateInfoUrl {
+    override def withUrl(url: Uri): UpdateInfoUrl = VersionDiff(url)
+  }
 
   implicit val updateInfoUrlOrder: Order[UpdateInfoUrl] =
     Order.by {

modules/core/src/main/scala/org/scalasteward/core/nurture/UpdateInfoUrlFinder.scala

@@ -16,7 +16,7 @@
 
 package org.scalasteward.core.nurture
 
-import cats.Monad
+import cats.{Functor, Monad, Parallel}
 import cats.syntax.all.*
 import org.http4s.Uri
 import org.scalasteward.core.application.Config.ForgeCfg
@@ -31,22 +31,37 @@
 final class UpdateInfoUrlFinder[F[_]](implicit
     config: ForgeCfg,
     urlChecker: UrlChecker[F],
+    parallel: Parallel[F],
     F: Monad[F]
 ) {
   def findUpdateInfoUrls(
       dependency: DependencyMetadata,
       versionUpdate: Version.Update
   ): F[List[UpdateInfoUrl]] = {
-    val updateInfoUrls: List[UpdateInfoUrl] =
-      dependency.releaseNotesUrl.toList.map(CustomReleaseNotes.apply) ++
-        dependency.forgeRepo.toSeq.flatMap(forgeRepo =>
-          possibleUpdateInfoUrls(forgeRepo, versionUpdate)
-        )
+    val updateInfoUrls: F[List[UpdateInfoUrl]] =
+      dependency.forgeRepo.toList
+        .flatTraverse(forgeRepo => possibleUpdateInfoUrls(urlChecker)(forgeRepo, versionUpdate))
+        .map(dependency.releaseNotesUrl.toList.map(CustomReleaseNotes.apply) ++ _)
 
-    updateInfoUrls
-      .sorted(UpdateInfoUrl.updateInfoUrlOrder.toOrdering)
-      .distinctBy(_.url)
-      .filterA(updateInfoUrl => urlChecker.exists(updateInfoUrl.url))
+    for {
+      urls <- updateInfoUrls
+        .map(
+          _.sorted(UpdateInfoUrl.updateInfoUrlOrder.toOrdering)
+            .distinctBy(_.url)
+        )
+      checkedUrls <-
+        urls.parFlatTraverse(updateInfoUrl =>
+          urlChecker
+            .validate(updateInfoUrl.url)
+            .map(
+              _.fold(
+                exists = List(updateInfoUrl),
+                notExists = List.empty,
+                redirectTo = u => List(updateInfoUrl.withUrl(u))
+              )
+            )
+        )
+    } yield checkedUrls
   }
 }
 
@@ -81,17 +96,31 @@
     repoForge.diffUrlFor(tagName(update.currentVersion), tagName(update.nextVersion))
   )
 
-  private[nurture] def possibleUpdateInfoUrls(
+  private[nurture] def possibleUpdateInfoUrls[F[_]: Functor](urlChecker: UrlChecker[F])(
       forgeRepo: ForgeRepo,
       update: Version.Update
-  ): List[UpdateInfoUrl] = {
+  ): F[List[UpdateInfoUrl]] = {
     def customUrls(wrap: Uri => UpdateInfoUrl, fileNames: List[String]): List[UpdateInfoUrl] =
       fileNames.map(f => wrap(forgeRepo.fileUrlFor(f)))
 
-    gitHubReleaseNotesFor(forgeRepo, update.nextVersion) ++
-      customUrls(CustomReleaseNotes.apply, possibleReleaseNotesFilenames) ++
-      customUrls(CustomChangelog.apply, possibleChangelogFilenames) ++
-      possibleVersionDiffs(forgeRepo, update)
+    for {
+      forgeRepoMaybe <- urlChecker
+        .validate(forgeRepo.repoUrl)
+        .map(
+          _.fold(
+            exists = forgeRepo.some,
+            notExists = none,
+            redirectTo = u => forgeRepo.copy(repoUrl = u).some
+          )
+        )
+      urls =
+        forgeRepoMaybe.toList.flatMap(forgeRepoChecked =>
+          gitHubReleaseNotesFor(forgeRepoChecked, update.nextVersion) ++
+            customUrls(CustomReleaseNotes.apply, possibleReleaseNotesFilenames) ++
+            customUrls(CustomChangelog.apply, possibleChangelogFilenames) ++
+            possibleVersionDiffs(forgeRepoChecked, update)
+        )
+    } yield urls
   }
 
   private def gitHubReleaseNotesFor(

modules/core/src/main/scala/org/scalasteward/core/util/UrlChecker.scala

@@ -20,28 +20,51 @@ import cats.effect.Sync
 import cats.syntax.all.*
 import com.github.benmanes.caffeine.cache.Caffeine
 import org.http4s.client.Client
+import org.http4s.headers.Location
 import org.http4s.{Method, Request, Status, Uri}
 import org.scalasteward.core.application.Config
 import org.typelevel.log4cats.Logger
 import scalacache.Entry
 import scalacache.caffeine.CaffeineCache
 
 trait UrlChecker[F[_]] {
-  def exists(url: Uri): F[Boolean]
+  def validate(url: Uri): F[UrlChecker.UrlValidationResult]
 }
 
 final case class UrlCheckerClient[F[_]](client: Client[F]) extends AnyVal
 
 object UrlChecker {
+
+  sealed abstract class UrlValidationResult extends Product with Serializable {
+    def exists: Boolean =
+      fold(exists = true, notExists = false, redirectTo = _ => false)
+
+    def notExists: Boolean =
+      fold(exists = false, notExists = true, redirectTo = _ => false)
+
+    def fold[A](exists: => A, notExists: => A, redirectTo: Uri => A): A =
+      this match {
+        case UrlValidationResult.Exists          => exists
+        case UrlValidationResult.NotExists       => notExists
+        case UrlValidationResult.RedirectTo(url) => redirectTo(url)
+      }
+  }
+
+  object UrlValidationResult {
+    case object Exists extends UrlValidationResult
+    case object NotExists extends UrlValidationResult
+    final case class RedirectTo(url: Uri) extends UrlValidationResult
+  }
+
   private def buildCache[F[_]](config: Config)(implicit
       F: Sync[F]
-  ): F[CaffeineCache[F, String, Status]] =
+  ): F[CaffeineCache[F, String, UrlValidationResult]] =
     F.delay {
       val cache = Caffeine
         .newBuilder()
         .maximumSize(16384L)
         .expireAfterWrite(config.cacheTtl.length, config.cacheTtl.unit)
-        .build[String, Entry[Status]]()
+        .build[String, Entry[UrlValidationResult]]()
       CaffeineCache(cache)
     }
 
@@ -52,16 +75,45 @@ object UrlChecker {
   ): F[UrlChecker[F]] =
     buildCache(config).map { statusCache =>
       new UrlChecker[F] {
-        override def exists(url: Uri): F[Boolean] =
-          status(url).map(_ === Status.Ok).handleErrorWith { throwable =>
-            logger.debug(throwable)(s"Failed to check if $url exists").as(false)
-          }
+        override def validate(url: Uri): F[UrlValidationResult] =
+          check(url).handleErrorWith(th =>
+            logger
+              .debug(th)(s"Failed to check if $url exists")
+              .as(UrlValidationResult.NotExists)
+          )
+
+        /** While checking for the [[Uri]]s presence, we perform up to 3 recursive lookups when
+          * receiving a `MovedPermanently` response.
+          */
+        private def check(url: Uri): F[UrlValidationResult] = {
+          def lookup(url: Uri, maxDepth: Int): F[Option[Uri]] =
+            Option(maxDepth).filter(_ > 0).flatTraverse { depth =>
+              val req = Request[F](method = Method.HEAD, uri = url)
+
+              modify(req).flatMap(r =>
+                urlCheckerClient.client.run(r).use {
+                  case resp if resp.status === Status.Ok =>
+                    F.pure(url.some)
+
+                  case resp if resp.status === Status.MovedPermanently =>
+                    resp.headers
+                      .get[Location]
+                      .flatTraverse(location => lookup(location.uri, depth - 1))
+
+                  case _ =>
+                    F.pure(none)
+                }
+              )
+            }
 
-        private def status(url: Uri): F[Status] =
           statusCache.cachingF(url.renderString)(None) {
-            val req = Request[F](method = Method.HEAD, uri = url)
-            modify(req).flatMap(urlCheckerClient.client.status)
+            lookup(url, maxDepth = 3).map {
+              case Some(u) if u === url => UrlValidationResult.Exists
+              case Some(u)              => UrlValidationResult.RedirectTo(u)
+              case None                 => UrlValidationResult.NotExists
+            }
           }
+        }
       }
     }
 }