build.mill

//| mvnDeps:
//| - com.goyeau::mill-scalafix::0.6.0

import mill._
import mill.scalalib._
import mill.scalalib.Assembly
import mill.scalalib.publish._
import mill.javalib.NativeImageModule
import mill.javalib.SonatypeCentralPublishModule
import mill.util.Jvm
import com.goyeau.mill.scalafix.ScalafixModule

trait CommonScalaModule extends ScalaModule with ScalafixModule {
  def scalaVersion = "3.9.0"
  def javacOptions = Seq("--release", "17")
  def scalacOptions = Seq(
    "-deprecation",
    "-feature",
    "-Werror",
    "-Wunused:all",
    "-Wvalue-discard",
    "-Wnonunit-statement",
    "-Wimplausible-patterns",
    "-Wshadow:all",
    "-Wsafe-init",
    "-Wrecurse-with-default",
    "-Wenum-comment-discard",
    "-WunstableInlineAccessors",
    "-Wwrong-arrow",
    "-Winfer-union"
  )
}

def cellarVersion: T[String] = Task.Input {
  sys.env.getOrElse("CELLAR_VERSION", "0.1.0-SNAPSHOT").stripPrefix("v")
}

trait CellarPublishModule extends CommonScalaModule with SonatypeCentralPublishModule {
  def publishVersion = cellarVersion()

  override def docJar: T[PathRef] = Task {
    val docs = Task.dest / "docs"
    os.makeDir.all(docs)
    PathRef(Jvm.createJar(Task.dest / "out.jar", Seq(docs)))
  }
}

def cellarPom(desc: String) = PomSettings(
  description    = desc,
  organization   = "org.virtuslab",
  url            = "https://github.com/VirtusLab/cellar",
  licenses       = Seq(License.`MPL-2.0`),
  versionControl = VersionControl.github("VirtusLab", "cellar"),
  developers     = Seq(Developer("rochala", "Jakub Rochala", "https://github.com/rochala"))
)

object lib extends CellarPublishModule {
  def artifactName   = "cellar-lib"
  def pomSettings    = cellarPom("Programmatic access to JVM dependency APIs (Scala 3, Scala 2, Java)")

  def mvnDeps = Seq(
    mvn"org.typelevel::cats-effect:3.7.1",
    mvn"co.fs2::fs2-io:3.13.0",
    mvn"io.get-coursier:interface:1.0.29-M4",
    mvn"ch.epfl.scala::tasty-query:1.9.0",
    mvn"org.scala-lang:scala3-tasty-inspector_3:3.9.0",
    mvn"com.github.pureconfig::pureconfig-core:0.17.10",
    mvn"org.typelevel::log4cats-core:2.8.0",
    mvn"org.typelevel::otel4s-core-trace:1.1.0"
  )


  object test extends ScalaTests with TestModule.Munit {
    // Every test class boots its own tasty-query Context; one forked JVM per class saturates
    // the whole machine and starts failing under load, so run them in a single JVM.
    def testParallelism = false
    def mvnDeps = super.mvnDeps() ++ Seq(
      mvn"org.scalameta::munit:1.3.5",
      mvn"org.typelevel::munit-cats-effect:2.2.0"
    )
    def forkArgs = Task {
      // Publish fixtures to ~/.m2 before running tests
      fixtureJava.publishM2LocalCached()
      fixtureScala2.publishM2LocalCached()
      fixtureScala3.publishM2LocalCached()
      val millAbsPath = (lib.moduleDir / os.up / "mill").toString
      Seq(
        s"-Dcellar.test.millBinary=$millAbsPath",
        s"-Dcellar.test.localM2=${os.home / ".m2" / "repository"}",
        s"-Dcellar.test.fixtureJavaGroup=cellar.test",
        s"-Dcellar.test.fixtureJavaArtifact=cellar-fixture-java",
        s"-Dcellar.test.fixtureJavaVersion=0.1.0-SNAPSHOT",
        s"-Dcellar.test.fixtureScala2Group=cellar.test",
        s"-Dcellar.test.fixtureScala2Artifact=cellar-fixture-scala2_2.13",
        s"-Dcellar.test.fixtureScala2Version=0.1.0-SNAPSHOT",
        s"-Dcellar.test.fixtureScala3Group=cellar.test",
        s"-Dcellar.test.fixtureScala3Artifact=cellar-fixture-scala3_3",
        s"-Dcellar.test.fixtureScala3Version=0.1.0-SNAPSHOT"
      )
    }
  }
}

object profilingRuntime extends CellarPublishModule {
  def artifactName   = "cellar-profiling-runtime"
  def pomSettings    = cellarPom("Cellar profiling and tracing runtime (Pyroscope + OTLP)")

  def mvnDeps = Seq(
    mvn"org.typelevel::otel4s-sdk-trace:0.19.2",
    mvn"org.typelevel::otel4s-sdk-exporter:0.19.2",
    mvn"io.pyroscope:agent:2.9.1"
  )

  object test extends ScalaTests with TestModule.Munit {
    def mvnDeps = super.mvnDeps() ++ Seq(
      mvn"org.scalameta::munit:1.3.5",
      mvn"org.typelevel::munit-cats-effect:2.2.0"
    )
  }
}

object cli extends CellarPublishModule with NativeImageModule {
  def moduleDeps  = Seq(lib, profilingRuntime)
  def mainClass   = Some("cellar.cli.CellarApp")

  def artifactName   = "cellar-cli"
  def pomSettings    = cellarPom("Cellar command-line interface — JVM dependency API explorer")

  // Only consumed in native-image mode (JRT filesystem is unreliable there —
  // graal#10013), so kept off `resources` to avoid bloating the published lib JAR.
  def bundledJreJar: T[PathRef] = Task {
    import java.net.URI
    import java.nio.file.{Files, FileSystems}
    import java.util.jar.{JarEntry, JarOutputStream}
    import scala.jdk.CollectionConverters.*

    val dest = Task.dest / "jre.bin"
    val fs   = FileSystems.getFileSystem(URI.create("jrt:/"))
    val jos  = new JarOutputStream(java.io.FileOutputStream(dest.toIO))
    val seen = scala.collection.mutable.Set[String]()

    Files.list(fs.getPath("modules")).iterator().asScala.toList.foreach { modPath =>
      Files.walk(modPath).iterator().asScala
        .filterNot(Files.isDirectory(_))
        .foreach { p =>
          val name = p.getFileName.toString
          if (name.endsWith(".class") || name.endsWith(".tasty")) && name != "module-info.class" then
            val rel       = modPath.relativize(p)
            val entryName = (0 until rel.getNameCount).map(i => rel.getName(i).toString).mkString("/")
            if !seen(entryName) then
              seen += entryName
              jos.putNextEntry(new JarEntry(entryName))
              jos.write(Files.readAllBytes(p))
              jos.closeEntry()
        }
    }
    jos.close()
    PathRef(Task.dest)
  }

  override def nativeImageClasspath = Task {
    super.nativeImageClasspath() ++ Seq(bundledJreJar())
  }

  def generatedSources = Task {
    val dir = Task.dest
    val safeVersion = cellarVersion().replace("\\", "\\\\").replace("\"", "\\\"").replaceAll("[\r\n]", "")
    os.write(
      dir / "BuildInfo.scala",
      s"""package cellar.cli
         |private[cli] object BuildInfo:
         |  val version = "${safeVersion}"
         |""".stripMargin
    )
    super.generatedSources() ++ Seq(PathRef(dir))
  }

  def jvmVersion = "graalvm-community:23.0.2"

  // No `-H:+AllowJRTFileSystem`: with the jrt provider present, the image carries the *build*
  // machine's `java.home` baked into `jdk.internal.jrtfs.SystemImage`, so opening `jrt:/` on any
  // other machine throws `InternalError: NoSuchFileException .../lib/modules`. dotc's
  // `JrtClassPath` only recovers from `ProviderNotFoundException`/`FileSystemNotFoundException`,
  // so the docstring inspector died and dotc printed a crash report over cellar's stdout. Without
  // the provider the lookup raises `ProviderNotFoundException`, which dotc handles. Nothing in the
  // native binary needs jrt: `JreClasspath` reads the bundled `jre.bin` there instead.
  def nativeImageOptions = Seq(
    "--no-fallback",
    "--enable-url-protocols=http,https",
    "-H:+ReportExceptionStackTraces"
  )

  def mvnDeps = Seq(
    mvn"com.monovore::decline:2.6.2",
    mvn"com.monovore::decline-effect:2.6.2",
    mvn"org.slf4j:slf4j-nop:2.0.18"
  )
  def assemblyRules = Seq(
    Assembly.Rule.Append("META-INF/services/.*"),
    Assembly.Rule.Append("reference.conf"),
    Assembly.Rule.ExcludePattern("META-INF/.*\\.SF"),
    Assembly.Rule.ExcludePattern("META-INF/.*\\.DSA"),
    Assembly.Rule.ExcludePattern("META-INF/.*\\.RSA"),
    Assembly.Rule.ExcludePattern("module-info.class"),
    Assembly.Rule.ExcludePattern("jre.bin")
  ) ++ Assembly.defaultRules

  object test extends ScalaTests with TestModule.Munit {
    def mvnDeps = super.mvnDeps() ++ Seq(
      mvn"org.scalameta::munit:1.3.5",
      mvn"org.typelevel::munit-cats-effect:2.2.0"
    )
  }
}

/** Publish all three fixture artifacts to ~/.m2. */
def publishFixtures() = Task.Command {
  fixtureJava.publishM2Local()()
  fixtureScala2.publishM2Local()()
  fixtureScala3.publishM2Local()()
}

def fixturePom(desc: String) = PomSettings(
  description = desc,
  organization = "cellar.test",
  url = "https://github.com/example/cellar",
  licenses = Seq(License.`Apache-2.0`),
  versionControl = VersionControl.github("example", "cellar"),
  developers = Seq(
    Developer("test-dev", "Test Developer", "https://github.com/test-dev")
  )
)

object fixtureJava extends JavaModule with PublishModule {
  def javacOptions = Seq("--release", "17")
  def publishVersion = "0.1.0-SNAPSHOT"
  def artifactName   = "cellar-fixture-java"
  def pomSettings    = fixturePom("Cellar Java test fixture")
}

object fixtureScala2 extends ScalaModule with PublishModule {
  def scalaVersion   = "2.13.16"
  def javacOptions   = Seq("--release", "17")
  def publishVersion = "0.1.0-SNAPSHOT"
  def artifactName   = "cellar-fixture-scala2"
  def pomSettings    = fixturePom("Cellar Scala 2.13 test fixture")
}

object fixtureScala3 extends CommonScalaModule with PublishModule {
  def publishVersion = "0.1.0-SNAPSHOT"
  def artifactName   = "cellar-fixture-scala3"
  def pomSettings    = fixturePom("Cellar Scala 3 test fixture")
}