Merge pull request #2714 from alejandrohdezma/feature/grouping

Add support for grouping dependency updates

Author: alejandrohdezma

build.sbt

@@ -1,3 +1,5 @@
+import scala.util.Properties
+import scala.reflect.io.Path
 import com.typesafe.sbt.packager.docker._
 import sbtcrossproject.{CrossProject, CrossType, Platform}
 import sbtghactions.JavaSpec.Distribution.Adopt
@@ -196,6 +198,8 @@ lazy val core = myCrossProject("core")
     }.taskValue,
     run / fork := true,
     Test / fork := true,
+    Test / testOptions +=
+      Tests.Cleanup(() => Path(file(Properties.tmpDir) / "scala-steward").deleteRecursively()),
     Compile / unmanagedResourceDirectories ++= (`sbt-plugin`.jvm / Compile / unmanagedSourceDirectories).value
   )
 

docs/repo-specific-configuration.md

@@ -32,6 +32,43 @@ You can add `<YOUR_REPO>/.scala-steward.conf` to configure how Scala Steward upd
 #pullRequests.frequency = "0 0 ? * 3" # every thursday on midnight
 pullRequests.frequency = "7 days"
 
+# pullRequests.grouping allows you to specify how Scala Steward should group
+# your updates in order to reduce the number of pull-requests.
+#
+# Updates will be placed in the first group with which they match, starting
+# from the first in the array. Those that do not match any group will follow
+# the default procedure (one PR per update).
+#
+# Each element in the array will have the following schema:
+# 
+#   - name (mandatory): the name of the group, will be used for things like naming the branch
+#   - title (optional): if provided it will be used as the title for the PR
+#   - filter (mandatory): a non-empty list containing the filters to use to know 
+#                         if an update falls into this group.
+#
+# `filter` properties would have this format:
+#   
+#    {
+#       version = "major" | "minor" | "patch" | "pre-release" | "build-metadata",
+#       group = "{group}",
+#       artifact = "{artifact}"
+#    }
+#
+# For more information on the values for the `version` filter visit https://semver.org/
+# 
+# Every field in a `filter` is optional but at least one must be provided.
+#
+# For grouping every update togeher a filter like {group = "*"} can be # provided.
+#
+# Default: []
+pullRequests.grouping = [
+  { name = "patches", "title" = "Patch updates", "filter" = [{"version" = "patch"}] },
+  { name = "minor_major", "title" = "Minor/major updates", "filter" = [{"version" = "minor"}, {"version" = "major"}] },
+  { name = "typelevel", "title" = "Typelevel updates", "filter" = [{"group" = "org.typelevel"}, {"group" = "org.http4s"}] },
+  { name = "my_libraries", "filter" = [{"artifact" = "my-library"}, {"artifact" = "my-other-library", "group" = "my-org"}] },
+  { name = "all", title = "Dependency updates", "filter" = [{"group" = "*"}] }
+]
+
 # pullRequests.includeMatchedLabels allows to control which labels are added to PRs 
 # via a regex check each label is checked against.
 # Defaults to no regex (all labels are added) which is equivalent to ".*".

modules/core/src/main/scala/org/scalasteward/core/data/SemVer.scala

@@ -17,6 +17,7 @@
 package org.scalasteward.core.data
 
 import cats.syntax.all._
+import io.circe.{Codec, Decoder, Encoder}
 import org.scalasteward.core.data.SemVer.Change._
 
 import scala.annotation.tailrec
@@ -42,6 +43,22 @@ object SemVer {
     case object Patch extends Change("patch")
     case object PreRelease extends Change("pre-release")
     case object BuildMetadata extends Change("build-metadata")
+
+    final private val allowed = List(Major, Minor, Patch, PreRelease, BuildMetadata)
+      .map(change => s"`${change.render}`")
+      .mkString(", ")
+
+    implicit val ChangeCodec: Codec[Change] =
+      Codec.from(Decoder[String].emap(from), Encoder[String].contramap(_.render))
+
+    def from(string: String): Either[String, Change] = string match {
+      case Major.`render`         => Right(Major)
+      case Minor.`render`         => Right(Minor)
+      case Patch.`render`         => Right(Patch)
+      case PreRelease.`render`    => Right(PreRelease)
+      case BuildMetadata.`render` => Right(BuildMetadata)
+      case other => Left(s"Invalid value for version change: $other. Allowed values are: $allowed")
+    }
   }
 
   def getChangeSpec(from: SemVer, to: SemVer): Option[Change] =

modules/core/src/main/scala/org/scalasteward/core/data/Update.scala

@@ -19,13 +19,73 @@ package org.scalasteward.core.data
 import cats.Order
 import cats.implicits._
 import io.circe.Codec
+import io.circe.syntax._
 import io.circe.generic.semiauto._
-import org.scalasteward.core.data.Update.{Group, Single}
+import org.scalasteward.core.data.Update.Group
+import org.scalasteward.core.data.Update.Single
+import org.scalasteward.core.repoconfig.PullRequestGroup
 import org.scalasteward.core.util
 import org.scalasteward.core.util.Nel
 import org.scalasteward.core.util.string.MinLengthString
+import io.circe.Decoder
 
-sealed trait Update extends Product with Serializable {
+sealed trait AnUpdate {
+
+  def on[A](update: Update => A, grouped: GroupedUpdate => A): A = this match {
+    case g: GroupedUpdate => grouped(g)
+    case u: Update        => update(u)
+  }
+
+  def show: String
+
+}
+
+object AnUpdate {
+
+  implicit val AnUpdateCodec: Codec[AnUpdate] = Codec.from(
+    Decoder[GroupedUpdate].widen[AnUpdate].or(Decoder[Update].widen[AnUpdate]),
+    _.on(_.asJson, _.asJson)
+  )
+
+}
+
+final case class GroupedUpdate(name: String, title: Option[String], updates: List[Update])
+    extends AnUpdate {
+
+  override def show: String = name
+
+}
+
+object GroupedUpdate {
+
+  /**
+    * Processes the provided updates using the group configuration. Each update will only be present in the
+    * first group it falls into.
+    *
+    * Updates that do not fall into any group will be returned back in the second return parameter.
+    */
+  /**
+    * Processes the provided updates using the group configuration. Each update will only be present in the
+    * first group it falls into.
+    *
+    * Updates that do not fall into any group will be returned back in the second return parameter.
+    */
+  def from(
+      groups: List[PullRequestGroup],
+      updates: List[Update.Single]
+  ): (List[GroupedUpdate], List[Update.Single]) =
+    groups.foldLeft((List.empty[GroupedUpdate], updates)) { case ((grouped, notGrouped), group) =>
+      notGrouped.partition(group.matches) match {
+        case (Nil, rest)     => (grouped, rest)
+        case (matched, rest) => (grouped :+ GroupedUpdate(group.name, group.title, matched), rest)
+      }
+    }
+
+  implicit val GroupedUpdateCodec: Codec[GroupedUpdate] = deriveCodec
+
+}
+
+sealed trait Update extends Product with Serializable with AnUpdate {
   def crossDependencies: Nel[CrossDependency]
   def dependencies: Nel[Dependency]
   def groupId: GroupId
@@ -40,7 +100,7 @@ sealed trait Update extends Product with Serializable {
   final def nextVersion: Version =
     newerVersions.head
 
-  final def show: String = {
+  final override def show: String = {
     val artifacts = this match {
       case s: Single => s.crossDependency.showArtifactNames
       case g: Group  => g.crossDependencies.map(_.showArtifactNames).mkString_("{", ", ", "}")

modules/core/src/main/scala/org/scalasteward/core/data/UpdateData.scala

@@ -23,7 +23,7 @@ import org.scalasteward.core.vcs.data.Repo
 final case class UpdateData(
     repoData: RepoData,
     fork: Repo,
-    update: Update,
+    update: AnUpdate,
     baseBranch: Branch,
     baseSha1: Sha1,
     updateBranch: Branch

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

@@ -17,7 +17,7 @@
 package org.scalasteward.core.git
 
 import cats.syntax.all._
-import org.scalasteward.core.data.Update
+import org.scalasteward.core.data.AnUpdate
 import org.scalasteward.core.update.show
 import org.scalasteward.core.util.Nel
 
@@ -39,17 +39,25 @@ final case class CommitMsg(
 }
 
 object CommitMsg {
-  def replaceVariables(s: String)(update: Update, baseBranch: Option[Branch]): CommitMsg = {
-    val artifactNameValue = show.oneLiner(update)
-    val nextVersionValue = update.nextVersion.value
-    val defaultValue = s"Update $artifactNameValue to $nextVersionValue" +
-      baseBranch.fold("")(branch => s" in ${branch.name}")
-    val title = s
-      .replace("${default}", defaultValue)
-      .replace("${artifactName}", artifactNameValue)
-      .replace("${currentVersion}", update.currentVersion.value)
-      .replace("${nextVersion}", nextVersionValue)
-      .replace("${branchName}", baseBranch.map(_.name).orEmpty)
-    CommitMsg(title = title)
-  }
+  def replaceVariables(s: String)(update: AnUpdate, baseBranch: Option[Branch]): CommitMsg =
+    update.on(
+      u => {
+        val artifactNameValue = show.oneLiner(u)
+        val nextVersionValue = u.nextVersion.value
+        val defaultValue = s"Update $artifactNameValue to $nextVersionValue" +
+          baseBranch.fold("")(branch => s" in ${branch.name}")
+        val title = s
+          .replace("${default}", defaultValue)
+          .replace("${artifactName}", artifactNameValue)
+          .replace("${currentVersion}", u.currentVersion.value)
+          .replace("${nextVersion}", nextVersionValue)
+          .replace("${branchName}", baseBranch.map(_.name).orEmpty)
+        CommitMsg(title = title)
+      },
+      g =>
+        CommitMsg(title =
+          g.title.getOrElse(s"Update for group ${g.name}") +
+            baseBranch.fold("")(branch => s" in ${branch.name}")
+        )
+    )
 }

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

@@ -16,7 +16,7 @@
 
 package org.scalasteward.core
 
-import org.scalasteward.core.data.Update
+import org.scalasteward.core.data.{AnUpdate, GroupedUpdate, Update}
 import org.scalasteward.core.repoconfig.CommitsConfig
 import org.scalasteward.core.vcs.data.Repo
 
@@ -27,9 +27,12 @@ package object git {
 
   val updateBranchPrefix = "update"
 
-  def branchFor(update: Update, baseBranch: Option[Branch]): Branch = {
+  def branchFor(update: AnUpdate, baseBranch: Option[Branch]): Branch = {
     val base = baseBranch.fold("")(branch => s"${branch.name}/")
-    Branch(s"$updateBranchPrefix/$base${update.name}-${update.nextVersion}")
+    update match {
+      case g: GroupedUpdate => Branch(s"$updateBranchPrefix/$base${g.name}")
+      case u: Update        => Branch(s"$updateBranchPrefix/$base${u.name}-${u.nextVersion}")
+    }
   }
 
   def commitMsgFor(