Add support for exporting to a Maven project

build.sc

@@ -491,6 +491,9 @@ trait Core extends ScalaCliCrossSbtModule
          |  def giter8Organization = "${Deps.giter8.dep.module.organization.value}"
          |  def giter8Name = "${Deps.giter8.dep.module.name.value}"
          |  def giter8Version = "${Deps.giter8.dep.version}"
+         |
+         |  def mavenVersion = "3.8.1"
+         |  def mavenScalaCompilerPluginVersion = "4.9.1"
          |}
          |""".stripMargin
     if (!os.isFile(dest) || os.read(dest) != code)

modules/cli/src/main/scala/scala/cli/commands/export0/Export.scala

@@ -79,6 +79,15 @@ object Export extends ScalaCommand[ExportOptions] {
     logger: Logger
   ): SbtProjectDescriptor =
     SbtProjectDescriptor(sbtVersion, extraSettings, logger)
+
+  def mavenProjectDescriptor(
+    mavenPluginVersion: String,
+    mavenScalaPluginVersion: String,
+    extraSettings: Seq[String],
+    logger: Logger
+  ): MavenProjectDescriptor =
+    MavenProjectDescriptor(mavenPluginVersion, mavenScalaPluginVersion, extraSettings, logger)
+
   def millProjectDescriptor(
     cache: FileCache[Task],
     projectName: Option[String],
@@ -129,17 +138,22 @@ object Export extends ScalaCommand[ExportOptions] {
       sys.exit(1)
     }
 
-    val shouldExportToMill = options.mill.getOrElse(false)
-    val shouldExportToSbt  = options.sbt.getOrElse(false)
-    if (shouldExportToMill && shouldExportToSbt) {
+    val shouldExportToMill  = options.mill.getOrElse(false)
+    val shouldExportToSbt   = options.sbt.getOrElse(false)
+    val shouldExportToMaven = options.maven.getOrElse(false)
+
+    val exportOptions = List(shouldExportToMill, shouldExportToSbt, shouldExportToMaven)
+
+    if (exportOptions.count(identity) > 1) {
       logger.error(
         s"Error: Cannot export to both mill and sbt. Please pick one build tool to export."
       )
       sys.exit(1)
     }
 
     if (!shouldExportToJson) {
-      val buildToolName = if (shouldExportToMill) "mill" else "sbt"
+      val buildToolName =
+        if (shouldExportToMill) "mill" else if (shouldExportToMaven) "maven" else "sbt"
       logger.message(s"Exporting to a $buildToolName project...")
     }
     else if (!shouldExportJsonToStdout)
@@ -211,14 +225,24 @@ object Export extends ScalaCommand[ExportOptions] {
       project.print(System.out)
     }
     else {
-      val sbtVersion = options.sbtVersion.getOrElse("1.10.1")
+      val sbtVersion                  = options.sbtVersion.getOrElse("1.10.1")
+      val defaultMavenCompilerVersion = options.mvnVersion.getOrElse(Constants.mavenVersion)
+      val defaultScalaMavenCompilerVersion =
+        options.mvnScalaVersion.getOrElse(Constants.mavenScalaCompilerPluginVersion)
 
       def sbtProjectDescriptor0 =
         sbtProjectDescriptor(options.sbtSetting.map(_.trim).filter(_.nonEmpty), sbtVersion, logger)
 
       val projectDescriptor =
         if (shouldExportToMill)
           millProjectDescriptor(options.shared.coursierCache, options.project, logger)
+        else if (shouldExportToMaven)
+          mavenProjectDescriptor(
+            defaultMavenCompilerVersion,
+            defaultScalaMavenCompilerVersion,
+            Nil,
+            logger
+          ) // todo: do we need extraSettings?
         else if (shouldExportToJson)
           jsonProjectDescriptor(options.project, inputs.workspace, logger)
         else // shouldExportToSbt isn't checked, as it's treated as default

modules/cli/src/main/scala/scala/cli/commands/export0/ExportOptions.scala

@@ -27,6 +27,12 @@ final case class ExportOptions(
   @HelpMessage("Sets the export format to SBT")
     sbt: Option[Boolean] = None,
   @Group(HelpGroup.BuildToolExport.toString)
+  @Tag(tags.experimental)
+  @Tag(tags.inShortHelp)
+  @HelpMessage("Sets the export format to Maven")
+  @Name("mvn")
+    maven: Option[Boolean] = None,
+  @Group(HelpGroup.BuildToolExport.toString)
   @Tag(tags.restricted)
   @Tag(tags.inShortHelp)
   @HelpMessage("Sets the export format to Mill")
@@ -50,6 +56,14 @@ final case class ExportOptions(
   @Tag(tags.restricted)
   @HelpMessage("Version of SBT to be used for the export")
     sbtVersion: Option[String] = None,
+  @Group(HelpGroup.BuildToolExport.toString)
+  @Tag(tags.experimental)
+  @HelpMessage("Version of Maven Compiler Plugin to be used for the export")
+    mvnVersion: Option[String] = None,
+  @Group(HelpGroup.BuildToolExport.toString)
+  @Tag(tags.experimental)
+  @HelpMessage("Version of Maven Scala Plugin to be used for the export")
+  mvnScalaVersion: Option[String] = None,
   @Name("o")
   @Group(HelpGroup.BuildToolExport.toString)
   @Tag(tags.restricted)

modules/cli/src/main/scala/scala/cli/exportCmd/MavenProject.scala

@@ -0,0 +1,146 @@
+package scala.cli.exportCmd
+
+import os.RelPath
+
+import java.nio.charset.StandardCharsets
+
+import scala.build.options.{ConfigMonoid, Scope}
+import scala.xml.{Elem, NodeSeq, PrettyPrinter, XML}
+
+final case class MavenProject(
+  groupId: Option[String] = None,
+  artifactId: Option[String] = None,
+  version: Option[String] = None,
+  plugins: Seq[MavenPlugin] = Nil,
+  imports: Seq[String] = Nil,
+  settings: Seq[Seq[String]] = Nil,
+  dependencies: Seq[MavenLibraryDependency] = Nil,
+  mainSources: Seq[(os.SubPath, String, Array[Byte])] = Nil,
+  testSources: Seq[(os.SubPath, String, Array[Byte])] = Nil,
+  resourceDirectories: Seq[String] = Nil
+  // properties: Seq[(String, String)] = Nil // using Seq[Tuple] since derive was failing for Map
+) extends Project {
+
+  def +(other: MavenProject): MavenProject =
+    MavenProject.monoid.orElse(this, other)
+
+  def writeTo(dir: os.Path): Unit = {
+
+    val nl      = System.lineSeparator()
+    val charset = StandardCharsets.UTF_8
+
+    val buildMavenContent = MavenModel(
+      "4.0.0",
+      groupId.getOrElse("groupId"),
+      artifactId.getOrElse("artifactId"),
+      version.getOrElse("0.1-SNAPSHOT"),
+      dependencies,
+      plugins,
+      resourceDirectories
+      // properties
+    )
+
+    val prettyPrinter = new PrettyPrinter(width = 80, step = 2)
+    val formattedXml  = prettyPrinter.format(buildMavenContent.toXml)
+
+    os.write(
+      dir / "pom.xml",
+      formattedXml.getBytes(charset)
+    )
+
+    for ((path, language, content) <- mainSources) {
+      val path0 = dir / "src" / "main" / language / path
+      os.write(path0, content, createFolders = true)
+    }
+    for ((path, language, content) <- testSources) {
+      val path0 = dir / "src" / "test" / language / path
+      os.write(path0, content, createFolders = true)
+    }
+
+  }
+}
+
+object MavenProject {
+  implicit val monoid: ConfigMonoid[MavenProject] = ConfigMonoid.derive
+}
+
+final case class MavenModel(
+  model: String,
+  groupId: String,
+  artifactId: String,
+  version: String,
+  dependencies: Seq[MavenLibraryDependency],
+  plugins: Seq[MavenPlugin],
+  resourceDirectories: Seq[String]
+  // properties: Seq[(String, String)] //todo: bring back only if it is needed
+) {
+
+  private def resourceNodes: NodeSeq =
+    if (resourceDirectories.isEmpty)
+      NodeSeq.Empty
+    else {
+      val resourceNodes = resourceDirectories.map { path =>
+        <resource>
+          <directory>
+            {path}
+          </directory>
+        </resource>
+      }
+      <resources>
+        {resourceNodes}
+      </resources>
+    }
+
+  def toXml: Elem =
+    <project>
+      <modelVersion>{model}</modelVersion>
+      <groupId>{groupId}</groupId>
+      <artifactId>{artifactId}</artifactId>
+      <version>{version}</version>
+
+      <dependencies>
+        {dependencies.map(_.toXml)}
+      </dependencies>
+      <build>
+        {resourceNodes}
+        <plugins>
+          {plugins.map(_.toXml)}
+        </plugins>
+      </build>
+    </project>
+}
+
+final case class MavenLibraryDependency(
+  groupId: String,
+  artifactId: String,
+  version: String,
+  scope: Option[String] = None
+) {
+
+  private val scopeParam = scope.fold(scala.xml.Null)(s => <scope>{s}</scope>)
+
+  def toXml: Elem =
+    <dependency>
+      <groupId>{groupId}</groupId>
+      <artifactId>{artifactId}</artifactId>
+      <version>{version}</version>
+      {scopeParam}
+    </dependency>
+}
+
+final case class MavenPlugin(
+  groupId: String,
+  artifactId: String,
+  version: String,
+  jdk: String,
+  additionalNode: Elem
+) {
+
+  def toXml: Elem =
+    <plugin>
+      <groupId>{groupId}</groupId>
+      <artifactId>{artifactId}</artifactId>
+      <version>{version}</version>
+      {additionalNode}
+    </plugin>
+}