Add export --json option (#1840)

* Add export --json option

* NIT Rename ProjectDescriptor subclasses

* Split Json into scopes

* Add structured output for dependencies, put scalaCompilerPlugins and scalacOptions into scope json

* NIT group defs by return type

Author: MaciejG604

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

@@ -1,19 +1,26 @@
 package scala.cli.commands.export0
 
 import caseapp.*
+import com.github.plokhotnyuk.jsoniter_scala.core.*
+import com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker
+import com.google.gson.{Gson, GsonBuilder}
 import coursier.cache.FileCache
 import coursier.util.{Artifact, Task}
 
+import java.io.{OutputStreamWriter, PrintStream}
+import java.nio.charset.{Charset, StandardCharsets}
+
 import scala.build.EitherCps.{either, value}
 import scala.build.*
 import scala.build.errors.BuildException
 import scala.build.input.Inputs
 import scala.build.internal.{Constants, CustomCodeWrapper}
-import scala.build.options.{BuildOptions, Scope}
+import scala.build.options.{BuildOptions, Platform, Scope}
 import scala.cli.CurrentParams
 import scala.cli.commands.ScalaCommand
 import scala.cli.commands.shared.SharedOptions
 import scala.cli.exportCmd.*
+import scala.util.Using
 
 object Export extends ScalaCommand[ExportOptions] {
   override def scalaSpecificationLevel = SpecificationLevel.RESTRICTED
@@ -53,9 +60,17 @@ object Export extends ScalaCommand[ExportOptions] {
   }
 
   // FIXME Auto-update those
-  def sbtBuildTool(extraSettings: Seq[String], sbtVersion: String, logger: Logger): Sbt =
-    Sbt(sbtVersion, extraSettings, logger)
-  def millBuildTool(cache: FileCache[Task], projectName: Option[String], logger: Logger): Mill = {
+  def sbtProjectDescriptor(
+    extraSettings: Seq[String],
+    sbtVersion: String,
+    logger: Logger
+  ): SbtProjectDescriptor =
+    SbtProjectDescriptor(sbtVersion, extraSettings, logger)
+  def millProjectDescriptor(
+    cache: FileCache[Task],
+    projectName: Option[String],
+    logger: Logger
+  ): MillProjectDescriptor = {
     val launcherArtifacts = Seq(
       os.rel / "mill" -> s"https://github.com/lefou/millw/raw/${Constants.lefouMillwRef}/millw",
       os.rel / "mill.bat" -> s"https://github.com/lefou/millw/raw/${Constants.lefouMillwRef}/millw.bat"
@@ -73,9 +88,12 @@ object Export extends ScalaCommand[ExportOptions] {
     }
     val launchersTask = cache.logger.using(Task.gather.gather(launcherTasks))
     val launchers     = launchersTask.unsafeRun()(cache.ec)
-    Mill(Constants.millVersion, projectName, launchers, logger)
+    MillProjectDescriptor(Constants.millVersion, projectName, launchers, logger)
   }
 
+  def jsonProjectDescriptor(projectName: Option[String], logger: Logger): JsonProjectDescriptor =
+    JsonProjectDescriptor(projectName, logger)
+
   override def sharedOptions(opts: ExportOptions): Option[SharedOptions] = Some(opts.shared)
 
   override def runCommand(options: ExportOptions, args: RemainingArgs, logger: Logger): Unit = {
@@ -84,24 +102,29 @@ object Export extends ScalaCommand[ExportOptions] {
     val output = options.output.getOrElse("dest")
     val dest   = os.Path(output, os.pwd)
     if (os.exists(dest)) {
-      System.err.println(
+      logger.error(
         s"""Error: $dest already exists.
            |To change the destination output directory pass --output path or remove the destination directory first.""".stripMargin
       )
       sys.exit(1)
     }
 
+    val shouldExportToJson = options.json.getOrElse(false)
     val shouldExportToMill = options.mill.getOrElse(false)
     val shouldExportToSbt  = options.sbt.getOrElse(false)
     if (shouldExportToMill && shouldExportToSbt) {
-      System.err.println(
+      logger.error(
         s"Error: Cannot export to both mill and sbt. Please pick one build tool to export."
       )
       sys.exit(1)
     }
 
-    val buildToolName = if (shouldExportToMill) "mill" else "sbt"
-    System.out.println(s"Exporting to a $buildToolName project...")
+    if (!shouldExportToJson) {
+      val buildToolName = if (shouldExportToMill) "mill" else "sbt"
+      logger.message(s"Exporting to a $buildToolName project...")
+    }
+    else
+      logger.message(s"Exporting to JSON...")
 
     val inputs = options.shared.inputs(args.all).orExit(logger)
     CurrentParams.workspaceOpt = Some(inputs.workspace)
@@ -131,7 +154,7 @@ object Export extends ScalaCommand[ExportOptions] {
       svMain <- optionsMain0.scalaOptions.scalaVersion
       svTest <- optionsTest0.scalaOptions.scalaVersion
     } if (svMain != svTest) {
-      System.err.println(
+      logger.error(
         s"""Detected different Scala versions in main and test scopes.
            |Please set the Scala version explicitly in the main and test scope with using directives or pass -S, --scala-version as parameter""".stripMargin
       )
@@ -141,27 +164,30 @@ object Export extends ScalaCommand[ExportOptions] {
     if (
       optionsMain0.scalaOptions.scalaVersion.isEmpty && optionsTest0.scalaOptions.scalaVersion.nonEmpty
     ) {
-      System.err.println(
+      logger.error(
         s"""Detected that the Scala version is only set in test scope.
            |Please set the Scala version explicitly in the main and test scopes with using directives or pass -S, --scala-version as parameter""".stripMargin
       )
       sys.exit(1)
     }
 
     val sbtVersion = options.sbtVersion.getOrElse("1.6.1")
-    def sbtBuildTool0 =
-      sbtBuildTool(options.sbtSetting.map(_.trim).filter(_.nonEmpty), sbtVersion, logger)
 
-    val buildTool =
+    def sbtProjectDescriptor0 =
+      sbtProjectDescriptor(options.sbtSetting.map(_.trim).filter(_.nonEmpty), sbtVersion, logger)
+
+    val projectDescriptor =
       if (shouldExportToMill)
-        millBuildTool(options.shared.coursierCache, options.project, logger)
+        millProjectDescriptor(options.shared.coursierCache, options.project, logger)
+      else if (shouldExportToJson)
+        jsonProjectDescriptor(options.project, logger)
       else // shouldExportToSbt isn't checked, as it's treated as default
-        sbtBuildTool0
+        sbtProjectDescriptor0
 
-    val project = buildTool.`export`(optionsMain0, optionsTest0, sourcesMain, sourcesTest)
+    val project = projectDescriptor.`export`(optionsMain0, optionsTest0, sourcesMain, sourcesTest)
 
     os.makeDir.all(dest)
     project.writeTo(dest)
-    System.out.println(s"Exported to: $dest")
+    logger.message(s"Exported to: $dest")
   }
 }

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

@@ -32,6 +32,9 @@ final case class ExportOptions(
   @Tag(tags.restricted)
   @HelpMessage("Sets the export format to Mill")
     mill: Option[Boolean] = None,
+  @Tag(tags.restricted)
+  @HelpMessage("Sets the export format to Json")
+    json: Option[Boolean] = None,
 
   @Name("setting")
   @Group("Build Tool export options")

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

@@ -0,0 +1,125 @@
+package scala.cli.exportCmd
+
+import com.github.plokhotnyuk.jsoniter_scala.core.{JsonValueCodec, WriterConfig, writeToStream}
+import com.github.plokhotnyuk.jsoniter_scala.macros.{CodecMakerConfig, JsonCodecMaker}
+import coursier.Dependency
+import coursier.util.Artifact
+import dependency.AnyDependency
+
+import java.nio.charset.StandardCharsets
+
+import scala.build.options.ConfigMonoid
+import scala.cli.util.SeqHelpers.*
+import scala.reflect.NameTransformer
+import scala.util.{Properties, Using}
+
+final case class JsonProject(
+  projectName: Option[String] = None,
+  scalaVersion: Option[String] = None,
+  platform: Option[String] = None,
+  jvmVersion: Option[String] = None,
+  scalaJsVersion: Option[String] = None,
+  jsEsVersion: Option[String] = None,
+  scalaNativeVersion: Option[String] = None,
+  mainClass: Option[String] = None,
+  scopes: Map[String, ScopedJsonProject] = Map.empty
+) extends Project {
+
+  def +(other: JsonProject): JsonProject =
+    JsonProject.monoid.orElse(this, other)
+
+  def withScope(scopeName: String, scopedJsonProj: ScopedJsonProject): JsonProject =
+    if (scopedJsonProj.sources.isEmpty)
+      this
+    else
+      this.copy(
+        scopes = this.scopes + (scopeName -> scopedJsonProj)
+      )
+
+  def writeTo(dir: os.Path): Unit = {
+    val config = WriterConfig.withIndentionStep(1)
+
+    Using(os.write.outputStream(dir / "export.json")) {
+      outputStream =>
+        writeToStream(
+          this,
+          outputStream,
+          config
+        )
+    }
+  }
+}
+
+final case class ScopedJsonProject(
+  sources: Seq[String] = Nil,
+  scalacOptions: Seq[String] = Nil,
+  scalaCompilerPlugins: Seq[ExportDependencyFormat] = Nil,
+  dependencies: Seq[ExportDependencyFormat] = Nil,
+  resolvers: Seq[String] = Nil,
+  resourcesDirs: Seq[String] = Nil,
+  customJarsDecls: Seq[String] = Nil
+) {
+
+  def +(other: ScopedJsonProject): ScopedJsonProject =
+    ScopedJsonProject.monoid.orElse(this, other)
+
+  def sorted(using ord: Ordering[String]): ScopedJsonProject =
+    ScopedJsonProject(
+      this.sources.sorted,
+      this.scalacOptions,
+      this.scalaCompilerPlugins.sorted,
+      this.dependencies.sorted,
+      this.resolvers.sorted,
+      this.resourcesDirs.sorted,
+      this.customJarsDecls.sorted
+    )
+}
+
+object ScopedJsonProject {
+  implicit val monoid: ConfigMonoid[ScopedJsonProject]           = ConfigMonoid.derive
+  implicit lazy val jsonCodec: JsonValueCodec[ScopedJsonProject] = JsonCodecMaker.make
+}
+
+object JsonProject {
+  implicit val monoid: ConfigMonoid[JsonProject]           = ConfigMonoid.derive
+  implicit lazy val jsonCodec: JsonValueCodec[JsonProject] = JsonCodecMaker.make
+}
+
+case class ExportDependencyFormat(groupId: String, artifactId: ArtifactId, version: String)
+
+case class ArtifactId(name: String, fullName: String)
+
+object ExportDependencyFormat {
+  def apply(dep: Dependency): ExportDependencyFormat = {
+    val scalaVersionStartIndex = dep.module.name.value.lastIndexOf('_')
+    val shortDepName = if (scalaVersionStartIndex == -1)
+      dep.module.name.value
+    else
+      dep.module.name.value.take(scalaVersionStartIndex)
+    new ExportDependencyFormat(
+      dep.module.organization.value,
+      ArtifactId(shortDepName, dep.module.name.value),
+      dep.version
+    )
+  }
+
+  def apply(
+    dep: AnyDependency,
+    scalaParamsOpt: Option[dependency.ScalaParameters]
+  ): ExportDependencyFormat = {
+    import scala.build.internal.Util.*
+    dep.toCs(scalaParamsOpt)
+      .map(ExportDependencyFormat.apply)
+      .getOrElse(
+        ExportDependencyFormat(
+          dep.module.organization,
+          ArtifactId(dep.module.name, dep.module.name),
+          dep.version
+        )
+      )
+  }
+
+  implicit val ordering: Ordering[ExportDependencyFormat] =
+    Ordering.by(x => x.groupId + x.artifactId.fullName)
+  implicit lazy val jsonCodec: JsonValueCodec[ExportDependencyFormat] = JsonCodecMaker.make
+}