Extended mill init to support an existing Maven project

build.mill

@@ -189,6 +189,14 @@ object Deps {
   val sonatypeCentralClient = ivy"com.lumidion::sonatype-central-client-requests:0.3.0"
   val kotlinVersion = "2.0.21"
   val kotlinCompiler = ivy"org.jetbrains.kotlin:kotlin-compiler:$kotlinVersion"
+  val mavenVersion = "3.9.9"
+  val mavenEmbedder = ivy"org.apache.maven:maven-embedder:$mavenVersion"
+  val mavenResolverVersion = "1.9.22"
+  val mavenResolverConnectorBasic = ivy"org.apache.maven.resolver:maven-resolver-connector-basic:$mavenResolverVersion"
+  val mavenResolverSupplier = ivy"org.apache.maven.resolver:maven-resolver-supplier:$mavenResolverVersion"
+  val mavenResolverTransportFile = ivy"org.apache.maven.resolver:maven-resolver-transport-file:$mavenResolverVersion"
+  val mavenResolverTransportHttp = ivy"org.apache.maven.resolver:maven-resolver-transport-http:$mavenResolverVersion"
+  val mavenResolverTransportWagon = ivy"org.apache.maven.resolver:maven-resolver-transport-wagon:$mavenResolverVersion"
 
   object RuntimeDeps {
     val dokkaVersion = "1.9.20"

integration/feature/init/src/MillInitMavenTests.scala

@@ -0,0 +1,81 @@
+package mill.integration
+
+import mill.testkit.UtestIntegrationTestSuite
+import utest._
+
+object MillInitMavenTests extends UtestIntegrationTestSuite {
+
+  private def downloadExtractTo(workspace: os.Path, zipUrl: String, zipContentDir: String): Unit = {
+    val zipFile = os.temp(requests.get(zipUrl))
+    val contentDir = os.unzip(zipFile, os.temp.dir()) / zipContentDir
+    os.list(contentDir).foreach(os.move.into(_, workspace))
+  }
+
+  def tests: Tests = Tests {
+
+    test("Mill init imports a Maven project") - integrationTest { tester =>
+      import tester._
+
+      downloadExtractTo(
+        workspacePath,
+        // - uses Junit5
+        // - uses --release javac option
+        "https://github.com/fusesource/jansi/archive/refs/tags/jansi-2.4.1.zip",
+        "jansi-jansi-2.4.1"
+      )
+
+      val initRes = eval("init")
+      initRes.isSuccess ==> true
+
+      val resolveRes = eval(("resolve", "_"))
+      Seq(
+        "compile",
+        "test",
+        "publishLocal"
+      ).forall(resolveRes.out.contains) ==> true
+
+      val compileRes = eval("compile")
+      compileRes.isSuccess ==> true
+
+      val testRes = eval("test")
+      testRes.isSuccess ==> true
+      testRes.out.contains(
+        "Test run finished: 0 failed, 1 ignored, 90 total"
+      ) ==> true
+
+      val publishLocalRes = eval("publishLocal")
+      publishLocalRes.isSuccess ==> true
+      publishLocalRes.err.contains( // why is this in err?
+        "Publishing Artifact(FuseSource, Corp.,jansi,2.4.1)") ==> true
+    }
+
+    test("Mill init imports a multi-module Maven project") - integrationTest { tester =>
+      import tester._
+
+      downloadExtractTo(
+        workspacePath,
+        // - uses unsupported test framework
+        // - uses hyphens in module names
+        "https://github.com/avaje/avaje-config/archive/refs/tags/4.0.zip",
+        "avaje-config-4.0"
+      )
+
+      val initRes = eval("init")
+      initRes.isSuccess ==> true
+
+      val resolveRes = eval(("resolve", "_"))
+      resolveRes.isSuccess ==> true
+      Seq(
+        "avaje-config",
+        "avaje-aws-appconfig",
+        "avaje-dynamic-logback"
+      ).forall(resolveRes.out.contains) ==> true
+
+      val compileRes = eval("avaje-config.compile")
+      // probably a JPMS issue but we only care about package task resolution
+      compileRes.err.contains(
+        "src/main/java/module-info.java:5:31: module not found: io.avaje.lang"
+      ) ==> true
+    }
+  }
+}

main/init/package.mill

@@ -4,6 +4,16 @@ import mill._
 import scala.util.matching.Regex
 
 object `package` extends RootModule with build.MillPublishScalaModule {
+
+  def ivyDeps = Agg(
+    build.Deps.mavenEmbedder,
+    build.Deps.mavenResolverConnectorBasic,
+    build.Deps.mavenResolverSupplier,
+    build.Deps.mavenResolverTransportFile,
+    build.Deps.mavenResolverTransportHttp,
+    build.Deps.mavenResolverTransportWagon
+  )
+
   def moduleDeps = Seq(build.main)
 
   override def resources = Task {

main/init/src/mill/init/maven/InitModule.scala

@@ -0,0 +1,41 @@
+package mill.init.maven
+
+import mill.define.{Discover, ExternalModule, TaskModule}
+import mill.{Command, Module, T, Task}
+
+object InitModule extends ExternalModule with InitModule with TaskModule {
+
+  override def defaultCommandName(): String = "init"
+
+  lazy val millDiscover: Discover = Discover[this.type]
+}
+
+/**
+ * Provides a [[InitModule.init task]] to generate Mill build files for an existing Maven project.
+ */
+trait InitModule extends Module {
+
+  /**
+   * Converts a Maven build to Mill automatically.
+   *
+   * @note The conversion may be incomplete, requiring manual edits to generated Mill build file(s).
+   */
+  def init(
+      @mainargs.arg(doc = "build base module (with shared settings) name")
+      baseModule: String = "BaseMavenModule"
+  ): Command[Unit] = Task.Command {
+
+    val buildFiles = codegen(millSourcePath, baseModule, PomReader())
+
+    T.log.info(s"generated ${buildFiles.size} Mill build file(s)")
+
+    buildFiles.foreach {
+      case (source, file) =>
+        T.log.info(s"writing build file $file ...")
+        os.write(file, source)
+    }
+
+    T.log.info(s"converted Maven project to Mill")
+    T.log.info(s"run \"mill resolve _\" to (verify conversion and) list available tasks")
+  }
+}

main/init/src/mill/init/maven/PomReader.scala

@@ -0,0 +1,116 @@
+package mill.init.maven
+
+import org.apache.maven.model.building.*
+import org.apache.maven.model.resolution.{ModelResolver, UnresolvableModelException}
+import org.apache.maven.model.{Dependency, Model, Parent, Repository}
+import org.apache.maven.repository.internal.{ArtifactDescriptorUtils, MavenRepositorySystemUtils}
+import org.eclipse.aether.artifact.DefaultArtifact
+import org.eclipse.aether.repository.{LocalRepository, RemoteRepository}
+import org.eclipse.aether.resolution.{ArtifactRequest, ArtifactResolutionException}
+import org.eclipse.aether.supplier.RepositorySystemSupplier
+import org.eclipse.aether.{RepositorySystem, RepositorySystemSession}
+
+import java.io.File
+import java.util.Properties
+import scala.jdk.CollectionConverters.*
+
+/**
+ * Parses a POM file to generate a [[Model]].
+ *
+ * The implementation is inspired by [[https://github.com/sbt/sbt-pom-reader/ sbt-pom-reader]].
+ */
+private[maven] class PomReader(
+    builder: ModelBuilder,
+    resolver: ModelResolver,
+    systemProperties: Properties
+) {
+
+  /** Returns the effective POM [[Model]] from a `pom.xml` file under `pomDir`. */
+  def apply(pomDir: os.Path): Model =
+    read((pomDir / "pom.xml").toIO)
+
+  /** Returns the effective POM [[Model]] from `pomFile` */
+  def read(pomFile: File): Model = {
+    val request = new DefaultModelBuildingRequest()
+    request.setModelResolver(resolver)
+    request.setSystemProperties(systemProperties)
+    request.setPomFile(pomFile)
+
+    builder.build(request).getEffectiveModel
+  }
+}
+object PomReader {
+
+  def apply(
+      local: LocalRepository = defaultLocalRepository,
+      remotes: Seq[RemoteRepository] = defaultRemoteRepositories,
+      context: String = "",
+      systemProperties: Properties = defaultSystemProperties
+  ): PomReader = {
+    val builder = new DefaultModelBuilderFactory().newInstance()
+    val system = new RepositorySystemSupplier().get()
+    val session = MavenRepositorySystemUtils.newSession()
+    session.setLocalRepositoryManager(system.newLocalRepositoryManager(session, local))
+    new PomReader(builder, resolver(system, session, remotes, context), systemProperties)
+  }
+
+  private def defaultLocalRepository: LocalRepository =
+    new LocalRepository((os.home / ".m2" / "repository").toIO)
+
+  private def defaultRemoteRepositories: Seq[RemoteRepository] =
+    Seq(
+      new RemoteRepository.Builder("central", "default", "https://repo.maven.apache.org/maven2")
+        .build()
+    )
+
+  private def defaultSystemProperties: Properties = {
+    val props = new Properties()
+    sys.env.foreachEntry((k, v) => props.put(s"env.$k", v))
+    sys.props.foreachEntry(props.put)
+    props
+  }
+
+  private def resolver(
+      system: RepositorySystem,
+      session: RepositorySystemSession,
+      remotes: Seq[RemoteRepository],
+      context: String
+  ): ModelResolver =
+    new ModelResolver {
+      private[this] var repositories = remotes
+      override def resolveModel(
+          groupId: String,
+          artifactId: String,
+          version: String
+      ): ModelSource = {
+        val artifact = new DefaultArtifact(groupId, artifactId, "", "pom", version)
+        val request = new ArtifactRequest(artifact, repositories.asJava, context)
+        try {
+          val result = system.resolveArtifact(session, request)
+          new FileModelSource(result.getArtifact.getFile)
+        } catch {
+          case e: ArtifactResolutionException =>
+            throw new UnresolvableModelException(e.getMessage, groupId, artifactId, version, e)
+        }
+      }
+
+      override def resolveModel(parent: Parent): ModelSource =
+        resolveModel(parent.getGroupId, parent.getArtifactId, parent.getVersion)
+
+      override def resolveModel(dependency: Dependency): ModelSource =
+        resolveModel(dependency.getGroupId, dependency.getArtifactId, dependency.getVersion)
+
+      override def addRepository(repository: Repository): Unit =
+        addRepository(repository, replace = false)
+
+      override def addRepository(repository: Repository, replace: Boolean): Unit = {
+        val exists = repositories.exists(_.getId == repository.getId)
+        if (!exists || replace) {
+          repositories = repositories :+ ArtifactDescriptorUtils.toRemoteRepository(repository)
+        }
+      }
+
+      override def newCopy(): ModelResolver =
+        resolver(system, session, repositories, context)
+    }
+}