Make all-libraries and jdk scripted tests pass on both sbt versions

Modernise the two fixtures so they run under both sbt 1.x and sbt 2.x, and
remove the temporary sbt-2.x gating:

- Bump their Scala versions (2.12.10 / 2.13.1 / 2.13.8 -> 2.12.20 / 2.13.16) so
  the sbt 2.x Zinc compiler bridge builds, and scalacheck to 1.18.1.
- all-libraries: the scala-library and scalacheck api doc URLs differ by sbt
  version (autoAPIMappings reads the POM `apiURL` on sbt 1.x — e.g.
  https://www.scala-lang.org/api/<v>/ and https://www.javadoc.io/doc/<...> — while
  on sbt 2.x this plugin's own rules provide http://scala-lang.org/files/archive/
  api/<v>/ and https://javadoc.io/page/<...>). Assert leniently (host + version)
  so one test covers both.
- jdk: the scaladoc output directory is `target/api` on sbt 1.x but
  `target/out/jvm/<...>/api` on sbt 2.x, so the hard-coded `$ exists` / `jgrep`
  path no longer works. Move the file checks into a `checkDoc` task that locates
  the directory via `Compile / doc / target`.

Verified locally (JDK 17): `++2.12.20 test` and `++3.8.4 test` both run all three
scripted tests plus the unit test green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Atry

build.sbt

@@ -52,14 +52,5 @@ scriptedLaunchOpts += s"-Dplugin.version=${version.value}"
 
 (Test / test) := {
   (Test / test).value
-  // The all-libraries and jdk scripted fixtures use very old Scala versions
-  // (whose sbt 2.x compiler bridges don't build) and assert sbt 1.x-specific
-  // behaviour (scaladoc output path, autoAPIMappings URLs). Until those fixtures
-  // are modernised, run only keep-api-url under sbt 2.x; sbt 1.x runs them all.
-  Def.taskDyn {
-    if ((pluginCrossBuild / sbtVersion).value.startsWith("2."))
-      scripted.toTask(" sbt-api-mappings/keep-api-url")
-    else
-      scripted.toTask("")
-  }.value
+  scripted.toTask("").value
 }

src/sbt-test/sbt-api-mappings/all-libraries/build.sbt

@@ -1,6 +1,6 @@
 val check = TaskKey[Unit]("check")
 
-val scalacheckModuleId = "org.scalacheck" %% "scalacheck" % "1.14.3"
+val scalacheckModuleId = "org.scalacheck" %% "scalacheck" % "1.18.1"
 
 // The classpath entry key is a File on sbt 1.x and a HashedVirtualFileRef on
 // sbt 2.x; both render the jar path/name in toString, so look entries up by a
@@ -11,43 +11,50 @@ def findByName(mappings: Map[_, _], jarName: String): Option[String] =
   }
 
 check := {
-  // The expected URL is browsable but not accessible from JRE 8's java.net.HttpURLConnection
-  val expectedScaladocUrl =
-    "https://www.scala-lang.org/api/2.13.1/"
-
-  assert(
-    findByName(
-      (Compile / doc / apiMappings).value,
-      "scala-library"
-    ).contains(expectedScaladocUrl)
-  )
-  assert(
-    findByName(
-      (Test / doc / apiMappings).value,
-      "scala-library"
-    ).contains(expectedScaladocUrl)
-  )
-
+  val compileMappings = (Compile / doc / apiMappings).value
+  val testMappings = (Test / doc / apiMappings).value
+
+  // scala-library should map to a scala-lang.org scaladoc URL for this version.
+  // The exact URL differs by sbt version (autoAPIMappings provides
+  // https://www.scala-lang.org/api/<v>/ on sbt 1.x, while on sbt 2.x this
+  // plugin's ScalaApiMappingRule provides http://scala-lang.org/files/archive/
+  // api/<v>/), so assert leniently.
+  def assertScalaLibrary(mappings: Map[_, _]): Unit =
+    assert(
+      findByName(mappings, "scala-library").exists { url =>
+        url.contains("scala-lang.org") && url.contains(scalaVersion.value)
+      },
+      s"scala-library scaladoc mapping not found in $mappings"
+    )
+  assertScalaLibrary(compileMappings)
+  assertScalaLibrary(testMappings)
+
+  // scalacheck (a Test-only dependency) should map to a javadoc.io URL. As with
+  // scala-library the exact form differs by sbt version (autoAPIMappings reads
+  // https://www.javadoc.io/doc/<...> from the POM on sbt 1.x, while on sbt 2.x
+  // this plugin's JavadocIoApiMappingRule provides https://javadoc.io/page/<...>),
+  // so assert leniently.
   val scalacheckJarName = Artifact.artifactName(
     ScalaVersion(scalaVersion.value, scalaBinaryVersion.value),
     scalacheckModuleId,
     Artifact("scalacheck")
   )
-
-  val expectedUrl =
-    "https://javadoc.io/page/org.scalacheck/scalacheck_2.13/1.14.3/"
   assert(
-    findByName((Test / doc / apiMappings).value, scalacheckJarName)
-      .contains(expectedUrl)
+    findByName(testMappings, scalacheckJarName).exists { url =>
+      url.contains("javadoc.io") && url.contains("scalacheck") &&
+      url.contains("1.18.1")
+    },
+    s"scalacheck javadoc mapping not found in $testMappings"
   )
   assert(
-    findByName((Compile / doc / apiMappings).value, scalacheckJarName).isEmpty
+    findByName(compileMappings, scalacheckJarName).isEmpty,
+    s"scalacheck should not be on the Compile classpath: $compileMappings"
   )
 }
 
-Global / scalaVersion := "2.13.1"
+Global / scalaVersion := "2.13.16"
 
-crossScalaVersions := Seq("2.13.1")
+crossScalaVersions := Seq("2.13.16")
 
 libraryDependencies += scalacheckModuleId % Test
 

src/sbt-test/sbt-api-mappings/jdk/build.sbt

@@ -1,19 +1,13 @@
 val check = TaskKey[Unit]("check")
+val checkDoc = TaskKey[Unit]("checkDoc")
 
 def regexMatches(matcher: scala.util.matching.Regex)(str: String): Boolean = {
   matcher.findFirstIn(str).isDefined
 }
 
-Global / scalaVersion := "2.12.10"
+Global / scalaVersion := "2.12.20"
 
-crossScalaVersions := Seq("2.12.10", "2.13.8")
-
-def javaVersion = VersionNumber(sys.props("java.specification.version"))
-
-def isJava(x: Integer) = javaVersion match {
-  case VersionNumber(Seq(y, _*), _, _) => x == y
-  case _                               => false
-}
+crossScalaVersions := Seq("2.12.20", "2.13.16")
 
 check := {
 
@@ -41,32 +35,27 @@ check := {
   }
 }
 
-val fgrep = InputKey[Unit]("fgrep")
-
-fgrep := {
-  val args: Seq[String] = Def.spaceDelimited().parsed
-
-  val found = IO.readLines(file(args(1))).exists(_.contains(args(0)))
-
-  if (found) {
-    println(s"Found '${args(0)}' in '${args(1)}'")
+// Verify the generated scaladoc, locating the output directory via
+// `Compile / doc / target` rather than a hard-coded path: on sbt 1.x that is
+// `target/api`, but on sbt 2.x it is `target/out/jvm/<...>/api`.
+checkDoc := {
+  val docDir = (Compile / doc / target).value
 
-  } else {
-    sys.error(s"Failed to fgrep '${args(0)}' '${args(1)}'")
+  def requireFile(name: String): File = {
+    val f = docDir / name
+    if (!f.exists) sys.error(s"Expected generated doc file does not exist: $f")
+    f
   }
-}
-
-val jgrep = InputKey[Unit]("jgrep")
 
-jgrep := {
-  val args: Seq[String] = Def.spaceDelimited().parsed
-
-  val found = IO.readLines(file(args(1))).exists(regexMatches(args(0).r)(_))
-
-  if (found) {
-    println(s"Found '${args(0)}' in '${args(1)}'")
+  requireFile("index.html")
+  val aHtml = requireFile("A.html")
 
+  val expect =
+    "https://docs.oracle.com/(?:en/java/)?javase/\\d+/docs/api/(?:java.base/)?java/lang/Throwable.html".r
+  val content = IO.readLines(aHtml)
+  if (content.exists(regexMatches(expect))) {
+    println(s"Found JDK javadoc link in $aHtml")
   } else {
-    sys.error(s"Failed to jgrep '${args(0)}' '${args(1)}'")
+    sys.error(s"Failed to find a JDK javadoc link in $aHtml")
   }
 }

src/sbt-test/sbt-api-mappings/jdk/test

@@ -2,6 +2,4 @@
 > 'set crossPaths := false'
 > +check
 > +doc
-$ exists target/api/index.html
-$ exists target/api/A.html
-> jgrep "https://docs.oracle.com/(?:en/java/)?javase/\\d+/docs/api/(?:java.base/)?java/lang/Throwable.html" "target/api/A.html"
+> +checkDoc