Avoid duplicated VCSApiAlg.createForkOrGetRepo call

This removes the `VCSApiAlg.createForkOrGetRepo` call in `NurtureAlg` by
reusing the result of `createForkOrGetRepoWithDefaultBranch` in
`RepoCacheAlg`.

Author: fthomas

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

@@ -73,17 +73,15 @@ final class StewardAlg[F[_]](implicit
   private def steward(repo: Repo): F[Either[Throwable, Unit]] = {
     val label = s"Steward ${repo.show}"
     logger.infoTotalTime(label) {
-      F.guarantee {
-        for {
-          _ <- logger.info(util.string.lineLeftRight(label))
-          _ <- repoCacheAlg.checkCache(repo)
-          (attentionNeeded, updates) <- pruningAlg.needsAttention(repo)
-          result <- {
-            if (attentionNeeded) nurtureAlg.nurture(repo, updates)
-            else F.pure(().asRight[Throwable])
-          }
-        } yield result
-      }(gitAlg.removeClone(repo))
+      logger.attemptLog(util.string.lineLeftRight(label), Some(label)) {
+        F.guarantee {
+          for {
+            fork <- repoCacheAlg.checkCache(repo)
+            (attentionNeeded, updates) <- pruningAlg.needsAttention(repo)
+            _ <- if (attentionNeeded) nurtureAlg.nurture(repo, fork, updates) else F.unit
+          } yield ()
+        }(gitAlg.removeClone(repo))
+      }
     }
   }
 

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

@@ -30,15 +30,13 @@ import org.scalasteward.core.git.{Branch, Commit, GitAlg}
 import org.scalasteward.core.repocache.RepoCacheRepository
 import org.scalasteward.core.repoconfig.{PullRequestUpdateStrategy, RepoConfigAlg}
 import org.scalasteward.core.scalafix.MigrationAlg
-import org.scalasteward.core.util.logger.LoggerOps
-import org.scalasteward.core.util.{BracketThrowable, DateTimeAlg, HttpExistenceClient}
-import org.scalasteward.core.vcs.data.{NewPullRequestData, Repo}
+import org.scalasteward.core.util.{BracketThrowable, HttpExistenceClient}
+import org.scalasteward.core.vcs.data.{NewPullRequestData, Repo, RepoOut}
 import org.scalasteward.core.vcs.{VCSApiAlg, VCSExtraAlg, VCSRepoAlg}
 import org.scalasteward.core.{git, util, vcs}
 
 final class NurtureAlg[F[_]](implicit
     config: Config,
-    dateTimeAlg: DateTimeAlg[F],
     editAlg: EditAlg[F],
     repoConfigAlg: RepoConfigAlg[F],
     gitAlg: GitAlg[F],
@@ -54,27 +52,20 @@ final class NurtureAlg[F[_]](implicit
     streamCompiler: Stream.Compiler[F, F],
     F: BracketThrowable[F]
 ) {
-  def nurture(repo: Repo, updates: List[Update.Single]): F[Either[Throwable, Unit]] = {
-    val label = s"Nurture ${repo.show}"
-    logger.infoTotalTime(label) {
-      logger.attemptLog(util.string.lineLeftRight(label)) {
-        cloneAndSync(repo).flatMap { case (fork, baseBranch) =>
-          updateDependencies(repo, fork, baseBranch, updates)
-        }
-      }
-    }
-  }
+  def nurture(repo: Repo, fork: RepoOut, updates: List[Update.Single]): F[Unit] =
+    for {
+      _ <- logger.info(s"Nurture ${repo.show}")
+      baseBranch <- cloneAndSync(repo, fork)
+      _ <- updateDependencies(repo, fork.repo, baseBranch, updates)
+    } yield ()
 
-  def cloneAndSync(repo: Repo): F[(Repo, Branch)] =
+  def cloneAndSync(repo: Repo, fork: RepoOut): F[Branch] =
     for {
       _ <- logger.info(s"Clone and synchronize ${repo.show}")
-      repoOut <- vcsApiAlg.createForkOrGetRepo(repo, config.doNotFork)
-      _ <-
-        gitAlg
-          .cloneExists(repo)
-          .ifM(F.unit, vcsRepoAlg.clone(repo, repoOut) >> vcsRepoAlg.syncFork(repo, repoOut))
-      defaultBranch <- vcsApiAlg.parentOrRepo(repoOut, config.doNotFork).map(_.default_branch)
-    } yield (repoOut.repo, defaultBranch)
+      cloneAndSync = vcsRepoAlg.clone(repo, fork) >> vcsRepoAlg.syncFork(repo, fork)
+      _ <- gitAlg.cloneExists(repo).ifM(F.unit, cloneAndSync)
+      baseBranch <- vcsApiAlg.parentOrRepo(fork, config.doNotFork).map(_.default_branch)
+    } yield baseBranch
 
   def updateDependencies(
       repo: Repo,

modules/core/src/main/scala/org/scalasteward/core/repocache/RepoCacheAlg.scala

@@ -25,9 +25,9 @@ import org.scalasteward.core.data.{Dependency, DependencyInfo}
 import org.scalasteward.core.git.GitAlg
 import org.scalasteward.core.repoconfig.RepoConfigAlg
 import org.scalasteward.core.util.MonadThrowable
-import org.scalasteward.core.util.logger.LoggerOps
 import org.scalasteward.core.vcs.data.{Repo, RepoOut}
 import org.scalasteward.core.vcs.{VCSApiAlg, VCSRepoAlg}
+import scala.util.control.NoStackTrace
 
 final class RepoCacheAlg[F[_]](implicit
     buildToolDispatcher: BuildToolDispatcher[F],
@@ -42,10 +42,10 @@ final class RepoCacheAlg[F[_]](implicit
     vcsRepoAlg: VCSRepoAlg[F],
     F: MonadThrowable[F]
 ) {
-  def checkCache(repo: Repo): F[Unit] =
-    logger.attemptLog_(s"Check cache of ${repo.show}") {
+  def checkCache(repo: Repo): F[RepoOut] =
+    logger.info(s"Check cache of ${repo.show}") >> {
       F.ifM(refreshErrorAlg.failedRecently(repo))(
-        logger.info(s"Skipping due to previous error"),
+        F.raiseError(new Throwable("Skipping due to previous error") with NoStackTrace),
         for {
           ((repoOut, branchOut), cachedSha1) <- (
             vcsApiAlg.createForkOrGetRepoWithDefaultBranch(repo, config.doNotFork),
@@ -54,7 +54,7 @@ final class RepoCacheAlg[F[_]](implicit
           latestSha1 = branchOut.commit.sha
           refreshRequired = cachedSha1.forall(_ =!= latestSha1)
           _ <- if (refreshRequired) cloneAndRefreshCache(repo, repoOut) else F.unit
-        } yield ()
+        } yield repoOut
       )
     }
 

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

@@ -24,24 +24,19 @@ import scala.concurrent.duration.FiniteDuration
 
 object logger {
   implicit final class LoggerOps[F[_]](private val logger: Logger[F]) extends AnyVal {
-    def attemptLog[A](message: String)(fa: F[A])(implicit
+    def attemptLog[A](label: String, errorLabel: Option[String] = None)(fa: F[A])(implicit
         F: MonadThrowable[F]
     ): F[Either[Throwable, A]] =
-      logger.info(message) >> fa.attempt.flatTap {
-        case Left(t)  => logger.error(t)(s"$message failed")
+      logger.info(label) >> fa.attempt.flatTap {
+        case Left(t)  => logger.error(t)(s"${errorLabel.getOrElse(label)} failed")
         case Right(_) => F.unit
       }
 
-    def attemptLog_[A](message: String)(fa: F[A])(implicit F: MonadThrowable[F]): F[Unit] =
-      attemptLog(message)(fa).void
-
     def infoTimed[A](msg: FiniteDuration => String)(fa: F[A])(implicit
         dateTimeAlg: DateTimeAlg[F],
         F: Monad[F]
     ): F[A] =
-      dateTimeAlg.timed(fa).flatMap { case (a, duration) =>
-        logger.info(msg(duration)) >> F.pure(a)
-      }
+      dateTimeAlg.timed(fa).flatMap { case (a, duration) => logger.info(msg(duration)).as(a) }
 
     def infoTotalTime[A](label: String)(fa: F[A])(implicit
         dateTimeAlg: DateTimeAlg[F],

modules/core/src/test/scala/org/scalasteward/core/util/loggerTest.scala

@@ -8,11 +8,11 @@ import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
 class loggerTest extends AnyFunSuite with Matchers {
-  test("attemptLog_") {
+  test("attemptLog") {
     final case class Err(msg: String) extends Throwable(msg)
     val err = Err("hmm?")
     val state = mockLogger
-      .attemptLog_("run")(Sync[MockEff].raiseError(err))
+      .attemptLog("run")(Sync[MockEff].raiseError(err))
       .runS(MockState.empty)
       .unsafeRunSync()