Remove some noise in GitAlg

Author: fthomas

modules/core/src/main/scala/org/scalasteward/core/git/GitAlg.scala

@@ -71,7 +71,6 @@ trait GitAlg[F[_]] {
 }
 
 object GitAlg {
-
   def create[F[_]](implicit
       config: Config,
       fileAlg: FileAlg[F],
@@ -80,25 +79,22 @@ object GitAlg {
       F: BracketThrowable[F]
   ): GitAlg[F] =
     new GitAlg[F] {
-      private val sign: String =
-        if (config.signCommits) "--gpg-sign" else "--no-gpg-sign"
-
       override def branchAuthors(repo: Repo, branch: Branch, base: Branch): F[List[String]] =
         workspaceAlg.repoDir(repo).flatMap { repoDir =>
-          exec(Nel.of("log", "--pretty=format:'%an'", dotdot(base, branch)), repoDir)
+          git("log", "--pretty=format:'%an'", dotdot(base, branch))(repoDir)
         }
 
       override def checkoutBranch(repo: Repo, branch: Branch): F[Unit] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          _ <- exec(Nel.of("checkout", branch.name), repoDir)
+          _ <- git("checkout", branch.name)(repoDir)
         } yield ()
 
       override def clone(repo: Repo, url: Uri): F[Unit] =
         for {
           rootDir <- workspaceAlg.rootDir
           repoDir <- workspaceAlg.repoDir(repo)
-          _ <- exec(Nel.of("clone", "--recursive", url.toString, repoDir.pathAsString), rootDir)
+          _ <- git("clone", "--recursive", url.toString, repoDir.pathAsString)(rootDir)
         } yield ()
 
       override def cloneExists(repo: Repo): F[Boolean] =
@@ -110,38 +106,38 @@ object GitAlg {
       override def commitAll(repo: Repo, message: String): F[Commit] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          _ <- exec(Nel.of("commit", "--all", sign, "-m", message), repoDir)
+          _ <- git("commit", "--all", sign, "-m", message)(repoDir)
         } yield Commit()
 
       override def containsChanges(repo: Repo): F[Boolean] =
         workspaceAlg.repoDir(repo).flatMap { repoDir =>
-          val args = Nel.of("status", "--porcelain", "--untracked-files=no", "--ignore-submodules")
-          exec(args, repoDir).map(_.nonEmpty)
+          val args = List("status", "--porcelain", "--untracked-files=no", "--ignore-submodules")
+          git(args: _*)(repoDir).map(_.nonEmpty)
         }
 
       override def createBranch(repo: Repo, branch: Branch): F[Unit] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          _ <- exec(Nel.of("checkout", "-b", branch.name), repoDir)
+          _ <- git("checkout", "-b", branch.name)(repoDir)
         } yield ()
 
       override def currentBranch(repo: Repo): F[Branch] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          lines <- exec(Nel.of("rev-parse", "--abbrev-ref", Branch.head.name), repoDir)
+          lines <- git("rev-parse", "--abbrev-ref", Branch.head.name)(repoDir)
         } yield Branch(lines.mkString.trim)
 
       override def findFilesContaining(repo: Repo, string: String): F[List[String]] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          args = Nel.of("grep", "-I", "--fixed-strings", "--files-with-matches", string)
-          lines <- exec(args, repoDir).handleError(_ => List.empty[String])
+          args = List("grep", "-I", "--fixed-strings", "--files-with-matches", string)
+          lines <- git(args: _*)(repoDir).handleError(_ => List.empty)
         } yield lines.filter(_.nonEmpty)
 
       override def hasConflicts(repo: Repo, branch: Branch, base: Branch): F[Boolean] =
         workspaceAlg.repoDir(repo).flatMap { repoDir =>
-          val tryMerge = exec(Nel.of("merge", "--no-commit", "--no-ff", branch.name), repoDir)
-          val abortMerge = exec(Nel.of("merge", "--abort"), repoDir).void
+          val tryMerge = git("merge", "--no-commit", "--no-ff", branch.name)(repoDir)
+          val abortMerge = git("merge", "--abort")(repoDir).void
 
           returnToCurrentBranch(repo) {
             checkoutBranch(repo, base) >> F.guarantee(tryMerge)(abortMerge).attempt.map(_.isLeft)
@@ -150,39 +146,39 @@ object GitAlg {
 
       override def isMerged(repo: Repo, branch: Branch, base: Branch): F[Boolean] =
         workspaceAlg.repoDir(repo).flatMap { repoDir =>
-          exec(Nel.of("log", "--pretty=format:'%h'", dotdot(base, branch)), repoDir).map(_.isEmpty)
+          git("log", "--pretty=format:'%h'", dotdot(base, branch))(repoDir).map(_.isEmpty)
         }
 
       override def latestSha1(repo: Repo, branch: Branch): F[Sha1] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          lines <- exec(Nel.of("rev-parse", "--verify", branch.name), repoDir)
+          lines <- git("rev-parse", "--verify", branch.name)(repoDir)
           sha1 <- F.fromEither(Sha1.from(lines.mkString("").trim))
         } yield sha1
 
       override def mergeTheirs(repo: Repo, branch: Branch): F[Option[Commit]] =
         for {
           before <- latestSha1(repo, Branch.head)
           repoDir <- workspaceAlg.repoDir(repo)
-          _ <- exec(Nel.of("merge", "--strategy-option=theirs", sign, branch.name), repoDir)
+          _ <- git("merge", "--strategy-option=theirs", sign, branch.name)(repoDir).void
             .handleErrorWith { throwable =>
               // Resolve CONFLICT (modify/delete) by deleting unmerged files:
               for {
-                unmergedFiles <- exec(Nel.of("diff", "--name-only", "--diff-filter=U"), repoDir)
+                unmergedFiles <- git("diff", "--name-only", "--diff-filter=U")(repoDir)
                 _ <- Nel.fromList(unmergedFiles.filter(_.nonEmpty)) match {
-                  case Some(files) => files.traverse(file => exec(Nel.of("rm", file), repoDir))
+                  case Some(files) => files.traverse(file => git("rm", file)(repoDir))
                   case None        => F.raiseError(throwable)
                 }
-                _ <- exec(Nel.of("commit", "--all", "--no-edit", sign), repoDir)
-              } yield List.empty
+                _ <- git("commit", "--all", "--no-edit", sign)(repoDir)
+              } yield ()
             }
           after <- latestSha1(repo, Branch.head)
         } yield Option.when(before =!= after)(Commit())
 
       override def push(repo: Repo, branch: Branch): F[Unit] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          _ <- exec(Nel.of("push", "--force", "--set-upstream", "origin", branch.name), repoDir)
+          _ <- git("push", "--force", "--set-upstream", "origin", branch.name)(repoDir)
         } yield ()
 
       override def removeClone(repo: Repo): F[Unit] =
@@ -191,8 +187,8 @@ object GitAlg {
       override def setAuthor(repo: Repo, author: Author): F[Unit] =
         for {
           repoDir <- workspaceAlg.repoDir(repo)
-          _ <- exec(Nel.of("config", "user.email", author.email), repoDir)
-          _ <- exec(Nel.of("config", "user.name", author.name), repoDir)
+          _ <- git("config", "user.email", author.email)(repoDir)
+          _ <- git("config", "user.name", author.name)(repoDir)
         } yield ()
 
       override def syncFork(repo: Repo, upstreamUrl: Uri, defaultBranch: Branch): F[Unit] =
@@ -201,14 +197,19 @@ object GitAlg {
           remote = "upstream"
           branch = defaultBranch.name
           remoteBranch = s"$remote/$branch"
-          _ <- exec(Nel.of("remote", "add", remote, upstreamUrl.toString), repoDir)
-          _ <- exec(Nel.of("fetch", "--tags", remote, branch), repoDir)
-          _ <- exec(Nel.of("checkout", "-B", branch, "--track", remoteBranch), repoDir)
-          _ <- exec(Nel.of("merge", remoteBranch), repoDir)
+          _ <- git("remote", "add", remote, upstreamUrl.toString)(repoDir)
+          _ <- git("fetch", "--tags", remote, branch)(repoDir)
+          _ <- git("checkout", "-B", branch, "--track", remoteBranch)(repoDir)
+          _ <- git("merge", remoteBranch)(repoDir)
           _ <- push(repo, defaultBranch)
         } yield ()
 
-      private def exec(command: Nel[String], cwd: File): F[List[String]] =
-        processAlg.exec("git" :: command, cwd, "GIT_ASKPASS" -> config.gitAskPass.pathAsString)
+      private def git(args: String*)(cwd: File): F[List[String]] = {
+        val extraEnv = "GIT_ASKPASS" -> config.gitAskPass.pathAsString
+        processAlg.exec(Nel.of("git", args: _*), cwd, extraEnv)
+      }
+
+      private val sign: String =
+        if (config.signCommits) "--gpg-sign" else "--no-gpg-sign"
     }
 }