WIP

Author: rtyley

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

@@ -25,6 +25,8 @@ import org.scalasteward.core.util.Nel
 import org.scalasteward.core.coursier.VersionsCache.VersionWithFirstSeen
 import org.scalasteward.core.nurture.UpdatesForGivenEdit
 
+import scala.collection.immutable
+
 case class ArtifactForUpdate(
     crossDependency: CrossDependency,
     newerGroupId: Option[GroupId] = None,
@@ -245,19 +247,23 @@ object Update {
   }
 
   /**
-   * If a set of ApplicableUpdateSet all have the same GroupId, then they could be a Update.ForGroupId()
+   * If a set of ApplicableUpdateSet all have the same GroupId, then they could be an Update.ForGroupId()
    *
    * If there is only one artifact within a ApplicableUpdateSet for a given group id, just create a
    * Update.ForArtifactId
    *
    * Otherwise, create a Grouped()?
    */
-  def groupByGroupId(updates: List[UpdatesForGivenEdit]): List[Single] = {
+  def groupByGroupId(updates: List[UpdatesForGivenEdit]): List[Update] = {
     val groups0 =
       updates.groupByNel(s => (s.commonGroupId, s.commonVersionUpdate))
-    val groups1 = groups0.map { case ((Some(_), Some(versionUpdate)), group) =>
-      if (group.tail.isEmpty) group.head
-      else ForGroupId(group.flatMap(_.artifactUpdates), versionUpdate.nextVersion)
+    val groups1: Iterable[Update] = groups0.map {
+      case ((Some(_), Some(versionUpdate)), updatesWithCommonMavenGroupId) =>
+        val affectedArtifacts = updatesWithCommonMavenGroupId.flatMap(_.artifactsForUpdate)
+        if (affectedArtifacts.size == 1) Update.ForArtifactId(affectedArtifacts.head, updatesWithCommonMavenGroupId.head.nextVersion)
+        else ForGroupId(updatesWithCommonMavenGroupId.flatMap(_.artifactsForUpdate), versionUpdate.nextVersion)
+      case (_, group) =>
+        Update.Grouped("some random name", None, group.flatMap(_.asUpdatesForArtifactId).toList)
     }
     groups1.toList.distinct.sorted
   }
@@ -274,13 +280,21 @@ object Update {
     groups.foldLeft((List.empty[Grouped], updates)) { case ((grouped, notGrouped), group) =>
       notGrouped.partition(group.matches) match {
         case (Nil, rest)     => (grouped, rest)
-        case (matched, rest) => (grouped :+ Grouped(group.name, group.title, matched.flatMap(_.artifactUpdates)), rest)
+        case (matched, rest) => (grouped :+ Grouped(group.name, group.title, matched.flatMap(_.asUpdatesForArtifactId.toList)), rest)
       }
     }
 
   implicit val SingleOrder: Order[Single] =
     Order.by((u: Single) => (u.crossDependencies, u.nextVersion))
 
+  implicit val GroupedOrder: Order[Grouped] =
+    Order.by((u: Grouped) => (u.name, u.asSingleUpdates))
+
+  implicit val UpdateOrder: Order[Update] = Order.by {
+    case g: Grouped => (1, Some(g), None)
+    case s: Single => (2, None, Some(s))
+  }
+
   // Encoder and Decoder instances
 
   // ForArtifactId

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

@@ -38,17 +38,25 @@ import org.typelevel.log4cats.Logger
 
 case class UpdatesForGivenEdit(
     edits: List[Substring.Replacement],
-    artifactUpdates: List[Update.ForArtifactId]
+    artifactsForUpdate: Nel[ArtifactForUpdate],
+    nextVersion: Version
 ) {
   val commonGroupId: Option[GroupId] = {
-    val updatesByGroupId = artifactUpdates.groupBy(_.groupId)
+    val updatesByGroupId = artifactsForUpdate.groupBy(_.groupId)
     Option.when(updatesByGroupId.size == 1)(updatesByGroupId.keys.head)
   }
 
-  val commonVersionUpdate: Option[Version.Update] = {
-    val updatesByVersionUpdate = artifactUpdates.groupBy(_.versionUpdate)
+  val commonCurrentVersion: Option[Version] = {
+    val updatesByVersionUpdate = artifactsForUpdate.groupBy(_.currentVersion)
     Option.when(updatesByVersionUpdate.size == 1)(updatesByVersionUpdate.keys.head)
   }
+
+  val commonVersionUpdate: Option[Version.Update] =
+    commonCurrentVersion.map(Version.Update(_, nextVersion))
+
+  lazy val asUpdatesForArtifactId: Nel[Update.ForArtifactId] = for {
+    artifactForUpdate <- artifactsForUpdate
+  } yield Update.ForArtifactId(artifactForUpdate, nextVersion)
 }
 
 final class NurtureAlg[F[_]](config: ForgeCfg)(implicit
@@ -70,11 +78,13 @@ final class NurtureAlg[F[_]](config: ForgeCfg)(implicit
       baseBranch <- cloneAndSync(data.repo, fork)
       applicableUpdateSets <- updates
         .traverse(update =>
-          editAlg.findUpdateReplacements(fork.repo, data.config, update).map(update -> _)
+          editAlg
+            .findUpdateReplacements(fork.repo, data.config, update)
+            .map(update -> (_, update.nextVersion))
         )
-        .map { x =>
-          x.toList.groupMap(_._2)(_._1).map { case (r, a) =>
-            UpdatesForGivenEdit(r, a)
+        .map {
+          _.toList.groupMap(_._2)(_._1).flatMap { case ((r, nextVersion), a) =>
+            Nel.fromList(a.map(_.artifactForUpdate)).map(UpdatesForGivenEdit(r, _, nextVersion))
           }
         }
 

modules/core/src/main/scala/org/scalasteward/core/repoconfig/PullRequestGroup.scala

@@ -34,7 +34,7 @@ case class PullRequestGroup(
   def matches(update: Update.ForArtifactId): Boolean = filter.exists(_.matches(update))
 
   def matches(updates: UpdatesForGivenEdit): Boolean =
-    filter.exists(f => updates.artifactUpdates.exists(update => f.matches(update)))
+    filter.exists(f => updates.asUpdatesForArtifactId.exists(update => f.matches(update)))
 }
 
 object PullRequestGroup {

modules/core/src/test/scala/org/scalasteward/core/data/GroupedUpdateTest.scala

@@ -4,20 +4,35 @@ import cats.data.NonEmptyList
 import cats.implicits.catsSyntaxOptionId
 import munit.FunSuite
 import org.scalasteward.core.TestSyntax.*
+import org.scalasteward.core.edit.update.data.Substring
+import org.scalasteward.core.edit.update.data.Substring.Position
+import org.scalasteward.core.nurture.UpdatesForGivenEdit
 import org.scalasteward.core.repoconfig.{PullRequestGroup, PullRequestUpdateFilter}
 
 class GroupedUpdateTest extends FunSuite {
-  val updateSingleSpecs2Core: Update.ForArtifactId =
+  def stubReplacementFor(u: Update.ForArtifactId): Substring.Replacement = Substring.Replacement(
+    Position("build.sbt", u.artifactForUpdate.hashCode(), u.currentVersion.value),
+    u.nextVersion.value
+  )
+
+  private def stubEditFor(single: Update.ForArtifactId) = UpdatesForGivenEdit(
+    List(stubReplacementFor(single)),
+    single.artifactsForUpdate,
+    single.nextVersion
+  )
+
+  val updateSingleSpecs2Core = stubEditFor(
     ("org.specs2".g % "specs2-core".a % "3.9.3" %> "3.9.5").single
+  )
 
-  val updateSingleSpecs2Scalacheck: Update.ForArtifactId =
-    ("org.specs2".g % "specs2-scalacheck".a % "3.9.3" %> "3.9.5").single
+  val updateSingleSpecs2Scalacheck =
+    stubEditFor(("org.specs2".g % "specs2-scalacheck".a % "3.9.3" %> "3.9.5").single)
 
-  val updateSingleTypelevelAlgebra: Update.ForArtifactId =
-    ("org.typelevel".g % "algebra".a % "3.9.4" %> "3.9.5").single
+  val updateSingleTypelevelAlgebra =
+    stubEditFor(("org.typelevel".g % "algebra".a % "3.9.4" %> "3.9.5").single)
 
-  val updateSingleCirceCore: Update.ForArtifactId =
-    ("circe".g % "core".a % "1.4.2" %> "1.5.0").single
+  val updateSingleCirceCore =
+    stubEditFor(("circe".g % "core".a % "1.4.2" %> "1.5.0").single)
 
   test(
     "GroupedUpdate.from: Do not group a Update.Single if the groupId does not match the filter"
@@ -76,7 +91,11 @@ class GroupedUpdateTest extends FunSuite {
     assertEquals(
       grouped,
       List(
-        Update.Grouped("typelevel", Some("update typelevel"), List(updateSingleTypelevelAlgebra))
+        Update.Grouped(
+          "typelevel",
+          Some("update typelevel"),
+          updateSingleTypelevelAlgebra.asUpdatesForArtifactId.toList
+        )
       )
     )
     assertEquals(notGrouped, List.empty)
@@ -103,7 +122,9 @@ class GroupedUpdateTest extends FunSuite {
         Update.Grouped(
           "specs2",
           Some("update specs2"),
-          List(updateSingleSpecs2Core, updateSingleSpecs2Scalacheck)
+          List(updateSingleSpecs2Core, updateSingleSpecs2Scalacheck).flatMap(
+            _.asUpdatesForArtifactId.toList
+          )
         )
       )
     )
@@ -143,9 +164,15 @@ class GroupedUpdateTest extends FunSuite {
         Update.Grouped(
           "specs2",
           Some("update specs2"),
-          List(updateSingleSpecs2Core, updateSingleSpecs2Scalacheck)
+          List(updateSingleSpecs2Core, updateSingleSpecs2Scalacheck).flatMap(
+            _.asUpdatesForArtifactId.toList
+          )
         ),
-        Update.Grouped("typelevel", Some("update typelevel"), List(updateSingleTypelevelAlgebra))
+        Update.Grouped(
+          "typelevel",
+          Some("update typelevel"),
+          List(updateSingleTypelevelAlgebra).flatMap(_.asUpdatesForArtifactId.toList)
+        )
       )
     )
     assertEquals(notGrouped, List(updateSingleCirceCore))