Get everything compiling with VersionWithFirstSeen

# Conflicts:
#	modules/core/src/main/scala/org/scalasteward/core/data/Update.scala
#	modules/core/src/main/scala/org/scalasteward/core/update/FilterAlg.scala

Author: emdash-ie

modules/benchmark/src/main/scala/org/scalasteward/benchmark/UpdatesConfigBenchmark.scala

@@ -21,6 +21,7 @@ import org.openjdk.jmh.annotations.{Benchmark, BenchmarkMode, Mode, OutputTimeUn
 import org.scalasteward.core.data.*
 import org.scalasteward.core.repoconfig.{UpdatePattern, UpdatesConfig, VersionPattern}
 import org.scalasteward.core.util.Nel
+import org.scalasteward.core.coursier.VersionsCache.VersionWithFirstSeen
 
 @BenchmarkMode(Array(Mode.AverageTime))
 class UpdatesConfigBenchmark {
@@ -32,7 +33,7 @@ class UpdatesConfigBenchmark {
     val dependency = CrossDependency(Dependency(groupId, ArtifactId("artifact"), Version("1.0.0")))
     val newerVersions = Nel
       .of("2.0.0", "2.1.0", "2.1.1", "2.2.0", "3.0.0", "3.1.0", "3.2.1", "3.3.3", "4.0", "5.0")
-      .map(Version.apply)
+      .map(v => VersionWithFirstSeen(Version(v), None))
     val update = Update.ForArtifactId(dependency, newerVersions)
 
     UpdatesConfig().keep(update)

modules/core/src/main/scala/org/scalasteward/core/buildtool/sbt/SbtAlg.scala

@@ -129,7 +129,7 @@ final class SbtAlg[F[_]](defaultResolvers: List[Resolver], ignoreOptsFiles: Bool
   private def latestSbtScalafixVersion: F[Option[Version]] =
     versionsCache
       .getVersions(Scope(sbtScalafixDependency, defaultResolvers), None)
-      .map(_.lastOption)
+      .map(_.lastOption.map(_.version))
 
   private def runBuildMigration(buildRoot: BuildRoot, migration: ScalafixMigration): F[Unit] =
     for {

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

@@ -84,7 +84,7 @@ object Update {
 
   final case class ForArtifactId(
       crossDependency: CrossDependency,
-      newerVersions: Nel[VersionWithFirstSeen],
+      newerVersionsWithFirstSeen: Nel[VersionWithFirstSeen],
       newerGroupId: Option[GroupId] = None,
       newerArtifactId: Option[String] = None
   ) extends Single {
@@ -109,6 +109,8 @@ object Update {
     override def currentVersion: Version =
       crossDependency.head.version
 
+    val newerVersions: Nel[Version] = newerVersionsWithFirstSeen.map(_.version)
+
     def artifactId: ArtifactId =
       crossDependency.head.artifactId
   }
@@ -216,7 +218,12 @@ object Update {
           newerGroupId: Option[GroupId],
           newerArtifactId: Option[String]
       ) =>
-        ForArtifactId(crossDependency, newerVersions, newerGroupId, newerArtifactId)
+        ForArtifactId(
+          crossDependency,
+          newerVersions.map(VersionWithFirstSeen(_, None)),
+          newerGroupId,
+          newerArtifactId
+        )
     }
 
   private val forArtifactIdDecoderV2 =

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

@@ -19,7 +19,7 @@ package org.scalasteward.core.repoconfig
 import cats.syntax.all.*
 import io.circe.Codec
 import io.circe.generic.semiauto.*
-import org.scalasteward.core.data.{GroupId, Update, Version}
+import org.scalasteward.core.data.{GroupId, Update}
 import org.scalasteward.core.coursier.VersionsCache.VersionWithFirstSeen
 
 final case class UpdatePattern(
@@ -44,8 +44,10 @@ object UpdatePattern {
   ): MatchResult = {
     val byGroupId = patterns.filter(_.groupId === update.groupId)
     val byArtifactId = byGroupId.filter(_.artifactId.forall(_ === update.artifactId.name))
-    val filteredVersions = update.newerVersions.filter(newVersion =>
-      (byArtifactId.exists(_.version.forall(_.matches(newVersion.value))) && versionPredicate(
+    val filteredVersions = update.newerVersionsWithFirstSeen.filter(newVersion =>
+      (byArtifactId.exists(
+        _.version.forall(_.matches(newVersion.version.value))
+      ) && versionPredicate(
         newVersion
       ))
         === include

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

@@ -77,7 +77,7 @@ final case class UpdatesConfig(
   private def isAllowed(update: Update.ForArtifactId): FilterResult = {
     val m = UpdatePattern.findMatch(allowOrDefault, update, include = true)
     if (m.filteredVersions.nonEmpty)
-      Right(update.copy(newerVersions = Nel.fromListUnsafe(m.filteredVersions)))
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.fromListUnsafe(m.filteredVersions)))
     else if (allowOrDefault.isEmpty)
       Right(update)
     else Left(NotAllowedByConfig(update))
@@ -86,7 +86,7 @@ final case class UpdatesConfig(
   private def isPinned(update: Update.ForArtifactId): FilterResult = {
     val m = UpdatePattern.findMatch(pinOrDefault, update, include = true)
     if (m.filteredVersions.nonEmpty)
-      Right(update.copy(newerVersions = Nel.fromListUnsafe(m.filteredVersions)))
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.fromListUnsafe(m.filteredVersions)))
     else if (m.byArtifactId.isEmpty)
       Right(update)
     else Left(VersionPinnedByConfig(update))
@@ -95,7 +95,7 @@ final case class UpdatesConfig(
   private def isIgnored(update: Update.ForArtifactId): FilterResult = {
     val m = UpdatePattern.findMatch(ignoreOrDefault, update, include = false)
     if (m.filteredVersions.nonEmpty)
-      Right(update.copy(newerVersions = Nel.fromListUnsafe(m.filteredVersions)))
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.fromListUnsafe(m.filteredVersions)))
     else
       Left(IgnoredByConfig(update))
   }

modules/core/src/main/scala/org/scalasteward/core/update/FilterAlg.scala

@@ -79,9 +79,10 @@ object FilterAlg {
         // already on Scala Next
         Right(update)
       } else {
-        val filteredVersions = update.newerVersions.filterNot(_ >= scalaNextMinVersion)
+        val filteredVersions =
+          update.newerVersionsWithFirstSeen.filterNot(v => v.version >= scalaNextMinVersion)
         if (filteredVersions.nonEmpty)
-          Right(update.copy(newerVersions = Nel.fromListUnsafe(filteredVersions)))
+          Right(update.copy(newerVersionsWithFirstSeen = Nel.fromListUnsafe(filteredVersions)))
         else
           Left(IgnoreScalaNext(update))
       }
@@ -113,7 +114,7 @@ object FilterAlg {
     val allowPreReleases = repoConfig.updatesOrDefault.preRelease(update).isRight
 
     update.currentVersion.selectNext(newerVersions, allowPreReleases) match {
-      case Some(next) => Right(update.copy(newerVersions = Nel.of(next)))
+      case Some(next) => Right(update.copy(newerVersionsWithFirstSeen = Nel.of(next)))
       case None       => Left(NoSuitableNextVersion(update))
     }
   }

modules/core/src/main/scala/org/scalasteward/core/update/UpdateAlg.scala

@@ -82,9 +82,9 @@ final class UpdateAlg[F[_]](implicit
   private def findNewerVersions(
       dependency: Scope[Dependency],
       maxAge: Option[FiniteDuration]
-  ): OptionT[F, Nel[Version]] =
+  ): OptionT[F, Nel[VersionsCache.VersionWithFirstSeen]] =
     OptionT(versionsCache.getVersions(dependency, maxAge).map { versions =>
-      Nel.fromList(versions.filter(_ > dependency.value.version))
+      Nel.fromList(versions.filter(v => v.version > dependency.value.version))
     })
 }
 

modules/core/src/test/scala/org/scalasteward/core/TestSyntax.scala

@@ -3,6 +3,7 @@ package org.scalasteward.core
 import org.scalasteward.core.data.*
 import org.scalasteward.core.data.Resolver.IvyRepository
 import org.scalasteward.core.util.Nel
+import org.scalasteward.core.coursier.VersionsCache.VersionWithFirstSeen
 
 object TestSyntax {
   val sbtPluginReleases: IvyRepository = {
@@ -19,6 +20,7 @@ object TestSyntax {
     def g: GroupId = GroupId(self)
     def a: ArtifactId = ArtifactId(self)
     def v: Version = Version(self)
+    def vfs: VersionWithFirstSeen = VersionWithFirstSeen(Version(self), None)
   }
 
   implicit class StringTupleOps(private val self: (String, String)) extends AnyVal {
@@ -76,29 +78,29 @@ object TestSyntax {
       private val self: (Dependency, String)
   ) extends AnyVal {
     def single: Update.ForArtifactId =
-      Update.ForArtifactId(CrossDependency(self._1), Nel.of(self._2.v))
+      Update.ForArtifactId(CrossDependency(self._1), Nel.of(self._2.vfs))
   }
 
   implicit class DependencyAndNewerVersionsOps(
       private val self: (Dependency, Nel[String])
   ) extends AnyVal {
     def single: Update.ForArtifactId =
-      Update.ForArtifactId(CrossDependency(self._1), self._2.map(_.v))
+      Update.ForArtifactId(CrossDependency(self._1), self._2.map(_.vfs))
   }
 
   implicit class DependenciesAndNextVersionOps(
       private val self: (Nel[Dependency], String)
   ) extends AnyVal {
     def single: Update.ForArtifactId =
-      Update.ForArtifactId(CrossDependency(self._1), Nel.of(self._2.v))
+      Update.ForArtifactId(CrossDependency(self._1), Nel.of(self._2.vfs))
   }
 
   implicit class GroupIdAndArtifactIdsAndVersionAndNextVersionOps(
       private val self: (GroupId, Nel[ArtifactId], String, String)
   ) extends AnyVal {
     def single: Update.ForArtifactId = {
       val crossDependency = CrossDependency(self._2.map(aId => Dependency(self._1, aId, self._3.v)))
-      Update.ForArtifactId(crossDependency, Nel.of(self._4.v))
+      Update.ForArtifactId(crossDependency, Nel.of(self._4.vfs))
     }
 
     def group: Update.ForGroupId = {

modules/core/src/test/scala/org/scalasteward/core/nurture/PullRequestRepositoryTest.scala

@@ -81,7 +81,7 @@ class PullRequestRepositoryTest extends FunSuite {
 
   test("getObsoleteOpenPullRequests for single update") {
     val data = openPRFor(portableScala)
-    val nextUpdate = portableScala.copy(newerVersions = Nel.of("1.0.1".v))
+    val nextUpdate = portableScala.copy(newerVersionsWithFirstSeen = Nel.of("1.0.1".vfs))
 
     val (emptyResult, result, closedResult) =
       executeOnTestRepo(expectedStoreOps = Seq("read", "write", "write")) { repo =>

modules/core/src/test/scala/org/scalasteward/core/update/FilterAlgTest.scala

@@ -28,20 +28,26 @@ class FilterAlgTest extends FunSuite {
 
   test("localFilter: update without bad version") {
     val update = ("com.jsuereth".g % "sbt-pgp".a % "1.1.0" %> Nel.of("1.1.2", "2.0.0")).single
-    assertEquals(localFilter(update, config), Right(update.copy(newerVersions = Nel.of("1.1.2".v))))
+    assertEquals(
+      localFilter(update, config),
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.of("1.1.2".vfs)))
+    )
   }
 
   test("localFilter: update with bad version") {
     val update = ("com.jsuereth".g % "sbt-pgp".a % "1.1.2-1" %> Nel.of("1.1.2", "2.0.0")).single
-    assertEquals(localFilter(update, config), Right(update.copy(newerVersions = Nel.of("2.0.0".v))))
+    assertEquals(
+      localFilter(update, config),
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.of("2.0.0".vfs)))
+    )
   }
 
   test("localFilter: update with bad version 2") {
     val update = ("net.sourceforge.plantuml".g % "plantuml".a % "1.2019.11" %>
       Nel.of("7726", "8020", "2017.09", "1.2019.12")).single
     assertEquals(
       localFilter(update, config),
-      Right(update.copy(newerVersions = Nel.of("1.2019.12".v)))
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.of("1.2019.12".vfs)))
     )
   }
 
@@ -58,7 +64,7 @@ class FilterAlgTest extends FunSuite {
       config.updatesOrDefault.copy(allowPreReleases = allowedPreReleases.some).some
     )
 
-    val expected = Right(update.copy(newerVersions = Nel.of("2.0.1-M3".v)))
+    val expected = Right(update.copy(newerVersionsWithFirstSeen = Nel.of("2.0.1-M3".vfs)))
     assertEquals(localFilter(update, configWithAllowed), expected)
   }
 
@@ -111,7 +117,7 @@ class FilterAlgTest extends FunSuite {
         ).some
       ).some
     )
-    val expected = Right(update.copy(newerVersions = Nel.of("2.13.7".v)))
+    val expected = Right(update.copy(newerVersionsWithFirstSeen = Nel.of("2.13.7".vfs)))
     assertEquals(localFilter(update, config), expected)
   }
 
@@ -214,7 +220,10 @@ class FilterAlgTest extends FunSuite {
     )
 
     val filtered = localFilter(update, config)
-    assertEquals(filtered, Right(update.copy(newerVersions = Nel.of("7.3.0.jre8".v))))
+    assertEquals(
+      filtered,
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.of("7.3.0.jre8".vfs)))
+    )
   }
 
   test("ignore update via config updates.ignore using suffix") {
@@ -234,7 +243,10 @@ class FilterAlgTest extends FunSuite {
     )
 
     val filtered = localFilter(update, config)
-    assertEquals(filtered, Right(update.copy(newerVersions = Nel.of("7.3.0.jre8".v))))
+    assertEquals(
+      filtered,
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.of("7.3.0.jre8".vfs)))
+    )
   }
 
   test("ignore update via config updates.pin using prefix and suffix") {
@@ -263,7 +275,7 @@ class FilterAlgTest extends FunSuite {
       """updates.ignore = [ { groupId = "sqlserver", version = { contains = "feature" } } ]"""
     )
     val obtained = repoConfig.flatMap(localFilter(update, _).leftMap(_.show))
-    assertEquals(obtained, Right(update.copy(newerVersions = Nel.of("7.3.0".v))))
+    assertEquals(obtained, Right(update.copy(newerVersionsWithFirstSeen = Nel.of("7.3.0".vfs))))
   }
 
   test("isDependencyConfigurationIgnored: false") {
@@ -287,7 +299,10 @@ class FilterAlgTest extends FunSuite {
         "3.3.3",
         "3.4.0"
       )).single
-    assertEquals(scalaLTSFilter(update), Right(update.copy(newerVersions = Nel.of("3.3.3".v))))
+    assertEquals(
+      scalaLTSFilter(update),
+      Right(update.copy(newerVersionsWithFirstSeen = Nel.of("3.3.3".vfs)))
+    )
   }
 
   test("scalaLTSFilter: Next") {