Proposal: Improve branch selection

docs/faq.md

@@ -43,13 +43,27 @@ Updates for `sbt` and `scalafmt` can be controlled by using the following `group
 { groupId = "org.scalameta", artifactId = "scalafmt-core" }
 ```
 
+## Can Scala Steward update multiple branches in a repository?
+
+Yes! You can update multiple branches of a repository by adding it several times to the "repos.md" file
+and a suffix with a different branch on each occurence (`owner/repo:branch`). For example:
+
+```md
+// repos.md
+- owner/repo
+- owner/repo:0.1.x
+- owner/repo:0.2.x
+```
+
+This configuration will update the default branch, as well as the branches `0.1.x` and `0.2.x` in the repo `owner/repo`.
+
 ## Can Scala Steward update dependencies in giter8 templates ?
 
 Scala Steward can update versions in giter8 templates if the dependencies of the template 
 are also added as dependencies of the template build.
 An example is [library.g8](https://github.com/ChristopherDavenport/library.g8) ([example PR](https://github.com/ChristopherDavenport/library.g8/pull/100/files))
 
-## Why do Scala Steward updates provide no URLs in PRs
+## Why do Scala Steward updates provide no URLs in PRs?
 
 Scala Steward updates can only provide links to release notes, diffs and changelogs if
 the `ivy.xml` file contain the `homepage` attribute or the `pom.xml` contains either

docs/help.md

@@ -38,5 +38,4 @@ All command line arguments for the `scala-steward` application.
   --github-app-key-file  FILE                        Github application key file
   --github-app-id  ID                                Github application id
   --refresh-backoff-period DURATION                  Period of time a failed build won't be triggered again, default: "7 days"
-  --default-branch BRANCH                            A fixed branch name to use as default instead of the repository's default branch
 ```

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

@@ -59,8 +59,7 @@ object Cli {
       githubAppId: Option[Long] = None,
       urlCheckerTestUrl: Option[Uri] = None,
       defaultMavenRepo: Option[String] = None,
-      refreshBackoffPeriod: FiniteDuration = 7.days,
-      defaultBranch: Option[String] = None
+      refreshBackoffPeriod: FiniteDuration = 7.days
   )
 
   final case class EnvVar(name: String, value: String)

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

@@ -25,7 +25,7 @@ import org.http4s.syntax.literals._
 import org.scalasteward.core.application.Cli.EnvVar
 import org.scalasteward.core.application.Config._
 import org.scalasteward.core.data.Resolver
-import org.scalasteward.core.git.{Author, Branch}
+import org.scalasteward.core.git.Author
 import org.scalasteward.core.io.{ProcessAlg, WorkspaceAlg}
 import org.scalasteward.core.util
 import org.scalasteward.core.util.Nel
@@ -74,8 +74,7 @@ final case class Config(
     githubApp: Option[GitHubApp],
     urlCheckerTestUrl: Uri,
     defaultResolver: Resolver,
-    refreshBackoffPeriod: FiniteDuration,
-    defaultBranch: Option[Branch]
+    refreshBackoffPeriod: FiniteDuration
 ) {
   def vcsUser[F[_]](implicit
       processAlg: ProcessAlg[F],
@@ -184,7 +183,6 @@ object Config {
       defaultResolver = args.defaultMavenRepo
         .map(url => Resolver.MavenRepository("default", url, None))
         .getOrElse(Resolver.mavenCentral),
-      refreshBackoffPeriod = args.refreshBackoffPeriod,
-      defaultBranch = args.defaultBranch.map(Branch(_))
+      refreshBackoffPeriod = args.refreshBackoffPeriod
     )
 }

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

@@ -33,6 +33,7 @@ import org.scalasteward.core.vcs.data.Repo
 import org.scalasteward.core.vcs.github.{GitHubApp, GitHubAppApiAlg, GitHubAuthAlg}
 import org.typelevel.log4cats.Logger
 import scala.concurrent.duration._
+import org.scalasteward.core.git.Branch
 
 final class StewardAlg[F[_]](config: Config)(implicit
     dateTimeAlg: DateTimeAlg[F],
@@ -53,9 +54,12 @@ final class StewardAlg[F[_]](config: Config)(implicit
     Stream.evals[F, List, Repo] {
       fileAlg.readFile(reposFile).map { maybeContent =>
         val regex = """-\s+(.+)/([^/]+)""".r
+        val regexWithBranch = """-\s+(.+)/([^/]+):([^/]+)""".r
         val content = maybeContent.getOrElse("")
-        content.linesIterator.collect { case regex(owner, repo) =>
-          Repo(owner.trim, repo.trim)
+        content.linesIterator.collect {
+          case regexWithBranch(owner, repo, branch) =>
+            Repo(owner.trim, repo.trim, Some(Branch(branch.trim)))
+          case regex(owner, repo) => Repo(owner.trim, repo.trim)
         }.toList
       }
     }

modules/core/src/main/scala/org/scalasteward/core/edit/EditAlg.scala

@@ -66,7 +66,10 @@ final class EditAlg[F[_]](implicit
                     runScalafixMigrations(repo, data.config, migrations) <*
                     bumpVersion(update, files)
               updateEdit <- gitAlg
-                .commitAllIfDirty(repo, git.commitMsgFor(update, data.config.commits))
+                .commitAllIfDirty(
+                  repo,
+                  git.commitMsgFor(update, data.config.commits, data.repo.branch)
+                )
                 .map(_.map(commit => UpdateEdit(update, commit)))
               hooksEdits <- hookExecutor.execPostUpdateHooks(data, update)
             } yield scalafixEdits ++ updateEdit ++ hooksEdits

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

@@ -16,6 +16,7 @@
 
 package org.scalasteward.core
 
+import cats.syntax.all._
 import org.scalasteward.core.data.Update
 import org.scalasteward.core.repoconfig.CommitsConfig
 import org.scalasteward.core.update.show
@@ -24,16 +25,22 @@ import org.scalasteward.core.vcs.data.Repo
 package object git {
   type GitAlg[F[_]] = GenGitAlg[F, Repo]
 
-  def branchFor(update: Update): Branch =
-    Branch(s"update/${update.name}-${update.nextVersion}")
+  def branchFor(update: Update, baseBranch: Option[Branch]): Branch =
+    baseBranch
+      .map(branch => Branch(s"update/${branch.name}/${update.name}-${update.nextVersion}"))
+      .getOrElse(Branch(s"update/${update.name}-${update.nextVersion}"))
 
-  def commitMsgFor(update: Update, commitsConfig: CommitsConfig): String = {
+  def commitMsgFor(update: Update, commitsConfig: CommitsConfig, branch: Option[Branch]): String = {
     val artifact = show.oneLiner(update)
-    val defaultMessage = s"Update $artifact to ${update.nextVersion}"
+    val defaultMessage = branch match {
+      case Some(value) => s"Update $artifact to ${update.nextVersion} in ${value.name}"
+      case None        => s"Update $artifact to ${update.nextVersion}"
+    }
     commitsConfig.messageOrDefault
       .replace("${default}", defaultMessage)
       .replace("${artifactName}", artifact)
       .replace("${currentVersion}", update.currentVersion)
       .replace("${nextVersion}", update.nextVersion)
+      .replace("${branchName}", branch.map(_.name).orEmpty)
   }
 }

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

@@ -74,8 +74,8 @@ final class NurtureAlg[F[_]](config: VCSCfg)(implicit
       _ <- NurtureAlg.processUpdates(
         grouped,
         update => {
-          val updateData =
-            UpdateData(data, fork, update, baseBranch, baseSha1, git.branchFor(update))
+          val updateBranch = git.branchFor(update, data.repo.branch)
+          val updateData = UpdateData(data, fork, update, baseBranch, baseSha1, updateBranch)
           processUpdate(updateData)
         },
         data.config.updates.limit
@@ -130,7 +130,7 @@ final class NurtureAlg[F[_]](config: VCSCfg)(implicit
         _ <- pullRequestRepository.changeState(data.repo, oldUrl, PullRequestState.Closed)
         comment = s"Superseded by ${vcsApiAlg.referencePullRequest(newNumber)}."
         _ <- vcsApiAlg.commentPullRequest(data.repo, oldNumber, comment)
-        oldBranch = git.branchFor(oldUpdate)
+        oldBranch = git.branchFor(oldUpdate, data.repo.branch)
         oldRemoteBranch = oldBranch.withPrefix("origin/")
         oldBranchExists <- gitAlg.branchExists(data.repo, oldRemoteBranch)
         authors <-

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

@@ -43,11 +43,7 @@ final class RepoCacheAlg[F[_]](config: Config)(implicit
     logger.info(s"Check cache of ${repo.show}") >>
       refreshErrorAlg.skipIfFailedRecently(repo) {
         (
-          vcsApiAlg.createForkOrGetRepoWithDefaultBranch(
-            repo,
-            config.vcsCfg.doNotFork,
-            config.defaultBranch
-          ),
+          vcsApiAlg.createForkOrGetRepoWithBranch(repo, config.vcsCfg.doNotFork),
           repoCacheRepository.findCache(repo)
         ).parTupled.flatMap { case ((repoOut, branchOut), maybeCache) =>
           val latestSha1 = branchOut.commit.sha

modules/core/src/main/scala/org/scalasteward/core/vcs/VCSApiAlg.scala

@@ -42,27 +42,15 @@ trait VCSApiAlg[F[_]] {
   final def createForkOrGetRepo(repo: Repo, doNotFork: Boolean): F[RepoOut] =
     if (doNotFork) getRepo(repo) else createFork(repo)
 
-  final def createForkOrGetRepoWithDefaultBranch(
-      repo: Repo,
-      doNotFork: Boolean,
-      defaultBranch: Option[Branch]
-  )(implicit
+  final def createForkOrGetRepoWithBranch(repo: Repo, doNotFork: Boolean)(implicit
       F: MonadThrow[F]
   ): F[(RepoOut, BranchOut)] =
     for {
       forkOrRepo <- createForkOrGetRepo(repo, doNotFork)
-      forkOrRepoWithDefaultBranch = applyDefaultBranch(forkOrRepo, defaultBranch)
+      forkOrRepoWithDefaultBranch = repo.branch.fold(forkOrRepo)(forkOrRepo.withBranch)
       defaultBranch <- getDefaultBranchOfParentOrRepo(forkOrRepoWithDefaultBranch, doNotFork)
     } yield (forkOrRepoWithDefaultBranch, defaultBranch)
 
-  final def applyDefaultBranch(repoOut: RepoOut, defaultBranch: Option[Branch]): RepoOut =
-    defaultBranch.fold(repoOut) { branch =>
-      repoOut.copy(
-        default_branch = branch,
-        parent = repoOut.parent.map(_.copy(default_branch = branch))
-      )
-    }
-
   final def getDefaultBranchOfParentOrRepo(repoOut: RepoOut, doNotFork: Boolean)(implicit
       F: MonadThrow[F]
   ): F[BranchOut] =

modules/core/src/main/scala/org/scalasteward/core/vcs/VCSRepoAlg.scala

@@ -34,13 +34,12 @@ final class VCSRepoAlg[F[_]](config: Config)(implicit
     F: MonadThrow[F]
 ) {
   def cloneAndSync(repo: Repo, repoOut: RepoOut): F[Unit] =
-    clone(repo, repoOut) >> maybeSyncFork(repo, repoOut) >> initSubmodules(repo)
+    clone(repo, repoOut) >> maybeCheckoutBranchOrSyncFork(repo, repoOut) >> initSubmodules(repo)
 
   private def clone(repo: Repo, repoOut: RepoOut): F[Unit] =
     logger.info(s"Clone ${repoOut.repo.show}") >>
       gitAlg.clone(repo, withLogin(repoOut.clone_url)).adaptErr(adaptCloneError) >>
-      gitAlg.setAuthor(repo, config.gitCfg.gitAuthor) >>
-      config.defaultBranch.fold(F.unit)(gitAlg.checkoutBranch(repo, _))
+      gitAlg.setAuthor(repo, config.gitCfg.gitAuthor)
 
   private val adaptCloneError: PartialFunction[Throwable, Throwable] = {
     case throwable if config.vcsCfg.tpe === GitHub && !config.vcsCfg.doNotFork =>
@@ -52,8 +51,9 @@ final class VCSRepoAlg[F[_]](config: Config)(implicit
       new Throwable(message, throwable)
   }
 
-  private def maybeSyncFork(repo: Repo, repoOut: RepoOut): F[Unit] =
-    if (config.vcsCfg.doNotFork) F.unit else syncFork(repo, repoOut)
+  private def maybeCheckoutBranchOrSyncFork(repo: Repo, repoOut: RepoOut): F[Unit] =
+    if (config.vcsCfg.doNotFork) repo.branch.fold(F.unit)(gitAlg.checkoutBranch(repo, _))
+    else syncFork(repo, repoOut)
 
   private def syncFork(repo: Repo, repoOut: RepoOut): F[Unit] =
     repoOut.parentOrRaise[F].flatMap { parent =>

modules/core/src/main/scala/org/scalasteward/core/vcs/bitbucket/BitbucketApiAlg.scala

@@ -63,7 +63,7 @@ class BitbucketApiAlg[F[_]](config: VCSCfg, modify: Repo => Request[F] => F[Requ
     val payload = CreatePullRequestRequest(
       data.title,
       Branch(data.head),
-      Repo(sourceBranchOwner, repo.repo),
+      Repo(sourceBranchOwner, repo.repo, repo.branch),
       data.base,
       data.body
     )

modules/core/src/main/scala/org/scalasteward/core/vcs/bitbucket/RepositoryResponse.scala

@@ -36,8 +36,9 @@ private[bitbucket] object RepositoryResponse {
   implicit private val repoDecoder: Decoder[Repo] = Decoder.instance { c =>
     c.as[String].map(_.split('/')).flatMap { parts =>
       parts match {
-        case Array(owner, name) => Repo(owner, name).asRight
-        case _                  => DecodingFailure("Repo", c.history).asLeft
+        case Array(owner, name)         => Repo(owner, name).asRight
+        case Array(owner, name, branch) => Repo(owner, name, Some(Branch(branch))).asRight
+        case _                          => DecodingFailure("Repo", c.history).asLeft
       }
     }
   }

modules/core/src/main/scala/org/scalasteward/core/vcs/data/NewPullRequestData.scala

@@ -204,7 +204,7 @@ object NewPullRequestData {
       filesWithOldVersion: List[String] = List.empty
   ): NewPullRequestData =
     NewPullRequestData(
-      title = git.commitMsgFor(data.update, data.repoConfig.commits),
+      title = git.commitMsgFor(data.update, data.repoConfig.commits, data.repoData.repo.branch),
       body = bodyFor(data.update, edits, artifactIdToUrl, releaseRelatedUrls, filesWithOldVersion),
       head = branchName,
       base = data.baseBranch

modules/core/src/main/scala/org/scalasteward/core/vcs/data/Repo.scala

@@ -18,14 +18,22 @@ package org.scalasteward.core.vcs.data
 
 import cats.Eq
 import io.circe.KeyEncoder
+import org.scalasteward.core.git.Branch
 
 final case class Repo(
     owner: String,
-    repo: String
+    repo: String,
+    branch: Option[Branch] = None
 ) {
-  def show: String = s"$owner/$repo"
+  def show: String = branch match {
+    case Some(value) => s"$owner/$repo:${value.name}"
+    case None        => s"$owner/$repo"
+  }
 
-  def toPath: String = s"$owner/$repo"
+  def toPath: String = branch match {
+    case Some(value) => s"$owner/$repo/${value.name}"
+    case None        => s"$owner/$repo"
+  }
 }
 
 object Repo {

modules/core/src/main/scala/org/scalasteward/core/vcs/data/RepoOut.scala

@@ -35,6 +35,10 @@ final case class RepoOut(
 
   def repo: Repo =
     Repo(owner.login, name)
+
+  def withBranch(branch: Branch): RepoOut =
+    copy(default_branch = branch, parent = parent.map(_.withBranch(branch)))
+
 }
 
 object RepoOut {

modules/core/src/test/scala/org/scalasteward/core/application/CliTest.scala

@@ -29,8 +29,7 @@ class CliTest extends FunSuite {
         List("--artifact-migrations", "/opt/scala-steward/extra-artifact-migrations.conf"),
         List("--github-app-id", "12345678"),
         List("--github-app-key-file", "example_app_key"),
-        List("--refresh-backoff-period", "1 day"),
-        List("--default-branch", "1.x")
+        List("--refresh-backoff-period", "1 day")
       ).flatten
     )
     val expected = Success(
@@ -51,8 +50,7 @@ class CliTest extends FunSuite {
         artifactMigrations = List(uri"/opt/scala-steward/extra-artifact-migrations.conf"),
         githubAppId = Some(12345678),
         githubAppKeyFile = Some(File("example_app_key")),
-        refreshBackoffPeriod = 1.day,
-        defaultBranch = Some("1.x")
+        refreshBackoffPeriod = 1.day
       )
     )
     assertEquals(obtained, expected)

modules/core/src/test/scala/org/scalasteward/core/git/gitTest.scala

@@ -10,24 +10,50 @@ import org.scalasteward.core.update.show
 class gitTest extends ScalaCheckSuite {
   test("commitMsgFor should work with static message") {
     val commitsConfig = CommitsConfig(Some("Static message"))
-    forAll { update: Update => assertEquals(commitMsgFor(update, commitsConfig), "Static message") }
+    forAll { update: Update =>
+      assertEquals(commitMsgFor(update, commitsConfig, None), "Static message")
+    }
+  }
+
+  test("commitMsgFor adds branch if provided") {
+    val commitsConfig = CommitsConfig(Some(s"$${default}"))
+    val branch = Branch("some-branch")
+    forAll { update: Update =>
+      val expected = s"Update ${show.oneLiner(update)} to ${update.nextVersion} in ${branch.name}"
+      assertEquals(commitMsgFor(update, commitsConfig, Some(branch)), expected)
+    }
   }
 
   test("commitMsgFor should work with default message") {
-    val commitsConfig = CommitsConfig(Some("${default}"))
+    val commitsConfig = CommitsConfig(Some(s"$${default}"))
     forAll { update: Update =>
       val expected = s"Update ${show.oneLiner(update)} to ${update.nextVersion}"
-      assertEquals(commitMsgFor(update, commitsConfig), expected)
+      assertEquals(commitMsgFor(update, commitsConfig, None), expected)
     }
   }
 
   test("commitMsgFor should work with templated message") {
     val commitsConfig =
-      CommitsConfig(Some("Update ${artifactName} from ${currentVersion} to ${nextVersion}"))
+      CommitsConfig(Some(s"Update $${artifactName} from $${currentVersion} to $${nextVersion}"))
     forAll { update: Update =>
       val expected =
         s"Update ${show.oneLiner(update)} from ${update.currentVersion} to ${update.nextVersion}"
-      assertEquals(commitMsgFor(update, commitsConfig), expected)
+      assertEquals(commitMsgFor(update, commitsConfig, None), expected)
+    }
+  }
+
+  test("commitMsgFor should work with templated message and non-default branch") {
+    val commitsConfig =
+      CommitsConfig(
+        Some(
+          s"Update $${artifactName} from $${currentVersion} to $${nextVersion} in $${branchName}"
+        )
+      )
+    val branch = Branch("some-branch")
+    forAll { update: Update =>
+      val expected =
+        s"Update ${show.oneLiner(update)} from ${update.currentVersion} to ${update.nextVersion} in ${branch.name}"
+      assertEquals(commitMsgFor(update, commitsConfig, Some(branch)), expected)
     }
   }
 }

modules/core/src/test/scala/org/scalasteward/core/vcs/VCSPackageTest.scala

@@ -13,7 +13,7 @@ class VCSPackageTest extends FunSuite {
   private val repo = Repo("foo", "bar")
   private val update =
     Update.Single("ch.qos.logback" % "logback-classic" % "1.2.0", Nel.of("1.2.3"))
-  private val updateBranch = git.branchFor(update)
+  private val updateBranch = git.branchFor(update, None)
 
   test("listingBranch") {
     assertEquals(listingBranch(GitHub, repo, updateBranch), s"foo/bar:${updateBranch.name}")