build.sbt

// Copyright (C) from 2022 The Play Framework Contributors <https://github.com/playframework>, 2011-2021 Lightbend Inc. <https://www.lightbend.com>

import Dependencies._

import sbtcrossproject.CrossPlugin.autoImport.crossProject
import org.scalajs.jsenv.nodejs.NodeJSEnv
import java.util.Properties
import java.io.StringWriter

import com.typesafe.tools.mima.core._

val ScalaTestVersion = "3.2.20"

def parserCombinators(scalaVersion: String) = "org.scala-lang.modules" %% "scala-parser-combinators" % {
  CrossVersion.partialVersion(scalaVersion) match {
    case Some((2, 12)) => "1.1.2"
    case _             => "2.5.0"
  }
}

val previousVersion: Option[String] = Some("2.0.1")

val futureLazyValsJvmSettings = Seq(
  scalacOptions ++= (if (scalaVersion.value.startsWith("3.3.")) Seq("-Yfuture-lazy-vals") else Seq.empty)
)

val mimaSettings = Seq(
  mimaPreviousArtifacts := previousVersion.map(organization.value %% moduleName.value % _).toSet,
  mimaBinaryIssueFilters ++= Seq(
    // Support for [lazy] val
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Template.defs"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.localDef"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.templateDeclaration"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Template.apply"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Template.copy"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Template.copy$default$9"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Template.name"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Template.this"),
    ProblemFilters.exclude[IncompatibleMethTypeProblem]("play.twirl.compiler.TwirlCompiler.templateCode"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Template.copy$default$1"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Template.copy$default$3"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Template.copy$default$4"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TwirlParser.template"),
    ProblemFilters.exclude[MissingTypesProblem]("play.twirl.parser.TreeNodes$Template$"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Template._9"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Template._1"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Template._3"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Template._4"),
    // Chaining a scala block is not always allowed in expressionPart
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.expressionPart"),
    // Remove unused case classes
    ProblemFilters.exclude[MissingClassProblem]("play.twirl.parser.TreeNodes$Params"),
    ProblemFilters.exclude[MissingClassProblem]("play.twirl.parser.TreeNodes$Params$"),
    ProblemFilters.exclude[MissingClassProblem]("play.twirl.parser.TreeNodes$Value"),
    ProblemFilters.exclude[MissingClassProblem]("play.twirl.parser.TreeNodes$Value$"),
    ProblemFilters.exclude[MissingFieldProblem]("play.twirl.parser.TreeNodes.Params"),
    ProblemFilters.exclude[MissingFieldProblem]("play.twirl.parser.TreeNodes.Value"),
    // Allow imports, val, def and subtemplates in body of 'if'/'else if'/'else'
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.compiler.TwirlCompiler.visit"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.block"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TreeNodes#Block.content"),
    ProblemFilters.exclude[IncompatibleMethTypeProblem]("play.twirl.parser.TreeNodes#Block.apply"),
    ProblemFilters.exclude[IncompatibleMethTypeProblem]("play.twirl.parser.TreeNodes#Block.copy"),
    ProblemFilters.exclude[IncompatibleMethTypeProblem]("play.twirl.parser.TreeNodes#Block.this"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Block.copy$default$3"),
    ProblemFilters.exclude[IncompatibleResultTypeProblem]("play.twirl.parser.TreeNodes#Block._3"),
    // Add support for var
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.elseCall"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.elseIfCall"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.ifExpression"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.mixed"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.template"),
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.parser.TwirlParser.templateContent"),
    // Allow word 'format' to be used in template (we use `$twirl__format` in BaseScalaTemplate now to avoid clashes)
    ProblemFilters.exclude[DirectMissingMethodProblem]("play.twirl.api.BaseScalaTemplate.format"),
  )
)

// Customise sbt-dynver's behaviour to make it work with tags which aren't v-prefixed
ThisBuild / dynverVTagPrefix := false

// CI publishes local artifacts in one sbt invocation and consumes them in later sbt/Gradle invocations.
// Keep those invocations on one version even when a dirty dynver timestamp rolls over.
ThisBuild / version ~= (detected => sys.props.getOrElse("project.version", detected))

// Sanity-check: assert that version comes from a tag (e.g. not a too-shallow clone)
// https://github.com/dwijnand/sbt-dynver/#sanity-checking-the-version
Global / onLoad := (Global / onLoad).value.andThen { s =>
  dynverAssertTagVersion.value
  s
}

ThisBuild / javafmtFormatterCompatibleJavaVersion := 17

lazy val twirl = project
  .in(file("."))
  .disablePlugins(MimaPlugin)
  .settings(
    crossScalaVersions := Nil, // workaround so + uses project-defined variants
    publish / skip     := true,
    (Compile / headerSources) ++= Def.uncached(
      ((baseDirectory.value ** ("*.properties" || "*.md" || "*.sbt" || "*.scala.html"))
        --- (baseDirectory.value ** "target" ** "*")
        --- (baseDirectory.value / "compiler" / "version.properties")
        --- (baseDirectory.value ** "gradle-twirl" ** "*") // Gradle Spotless plugin is used
        --- (baseDirectory.value / "docs" ** "*")).get() ++
        (baseDirectory.value / "project" ** "*.scala" --- (baseDirectory.value ** "target" ** "*")).get()
    ),
    addCommandAlias(
      "validateCode",
      List(
        "headerCheckAll",
        "scalafmtSbtCheck",
        "scalafmtCheckAll",
        "javafmtCheckAll",
      ).mkString(";")
    ),
    addCommandAlias(
      "format",
      List(
        "scalafmtSbt",
        "scalafmtAll",
        "javafmtAll",
      ).mkString(";")
    ),
  )
  .aggregate(apiJvm, apiJs, parser, compiler, plugin, mavenPlugin)

lazy val nodeJs = {
  if (System.getProperty("NODE_PATH") != null)
    new NodeJSEnv(NodeJSEnv.Config().withExecutable(System.getProperty("NODE_PATH")))
  else
    new NodeJSEnv()
}

lazy val api = crossProject(JVMPlatform, JSPlatform)
  .in(file("api"))
  .enablePlugins(Common, Playdoc, Omnidoc)
  .configs(Docs)
  .settings(
    scalaVersion       := resolveScalaVersion(sys.props.getOrElse("scala.version", scala33LTSVersion)),
    crossScalaVersions := publishedScalaVersions,
    mimaSettings,
    name  := "twirl-api",
    jsEnv := Def.uncached(nodeJs),
    // hack for GraalVM, see: https://github.com/scala-js/scala-js/issues/3673
    // and https://github.com/playframework/twirl/pull/339
    testFrameworks := List(
      new TestFramework(
        "org.scalatest.tools.Framework",
        "org.scalatest.tools.ScalaTestFramework"
      )
    ),
    libraryDependencies += "org.scala-lang.modules" %% "scala-xml" % "2.5.0",
    libraryDependencies += "org.scalatest"          %% "scalatest" % ScalaTestVersion % Test,
  )
  .jvmSettings(futureLazyValsJvmSettings)

lazy val apiJvm = api.jvm
lazy val apiJs  = api.js

lazy val parser = project
  .in(file("parser"))
  .enablePlugins(Common, Omnidoc)
  .settings(
    scalaVersion       := resolveScalaVersion(sys.props.getOrElse("scala.version", scala33LTSVersion)),
    crossScalaVersions := publishedScalaVersions,
    mimaSettings,
    name := "twirl-parser",
    libraryDependencies += parserCombinators(scalaVersion.value),
    libraryDependencies += "com.github.sbt" % "junit-interface" % "0.13.3"         % Test,
    libraryDependencies += "org.scalatest" %% "scalatest"       % ScalaTestVersion % Test,
  )
  .settings(futureLazyValsJvmSettings)

lazy val compiler = project
  .in(file("compiler"))
  .enablePlugins(Common, Omnidoc, BuildInfoPlugin)
  .settings(
    scalaVersion         := resolveScalaVersion(sys.props.getOrElse("scala.version", scala33LTSVersion)),
    crossScalaVersions   := publishedScalaVersions,
    Test / fork          := true,
    exportJars           := false,
    Test / baseDirectory := (ThisBuild / baseDirectory).value,
    mimaSettings,
    name := "twirl-compiler",
    libraryDependencies ++= {
      CrossVersion.partialVersion(scalaVersion.value) match {
        case Some((2, _)) =>
          // only for scala < 3
          Seq("org.scala-lang" % "scala-compiler" % scalaVersion.value % Test)
        case _ => Seq("org.scala-lang" %% "scala3-compiler" % scalaVersion.value % Test)
      }
    },
    libraryDependencies += parserCombinators(scalaVersion.value),
    libraryDependencies += "org.scalameta" %% "parsers" % "4.17.4",
    run / fork                             := true,
    buildInfoKeys                          := Seq[BuildInfoKey](scalaVersion),
    buildInfoPackage                       := "play.twirl.compiler",
    publishM2                              := publishM2.dependsOn(saveCompilerVersion).value,
    publish                                := publish.dependsOn(saveCompilerVersion).value,
    publishLocal                           := publishLocal.dependsOn(saveCompilerVersion).value
  )
  .settings(futureLazyValsJvmSettings)
  .aggregate(parser)
  .dependsOn(apiJvm % Test, parser % "compile->compile;test->test")

lazy val plugin = project
  .in(file("sbt-twirl"))
  .enablePlugins(SbtPlugin)
  .dependsOn(compiler)
  .settings(
    name         := "sbt-twirl",
    organization := "org.playframework.twirl",
    scalaVersion := scala39LTSVersion,
    // The plugin deliberately consumes the canonical Twirl compiler built with Scala 3.3.
    allowMismatchScala                     := true,
    libraryDependencies += "org.scalatest" %% "scalatest" % ScalaTestVersion % Test,
    crossScalaVersions += scala212Version,
    pluginCrossBuild / sbtVersion := {
      scalaBinaryVersion.value match {
        case "2.12" =>
          "1.13.0"
        case "3" =>
          sbtVersion.value
      }
    },
    Compile / resourceGenerators += generateVersionFile.taskValue,
    scriptedLaunchOpts += version.apply { v => s"-Dproject.version=$v" }.value,
    // Scripted tests run in separate JVMs. Forward both the selected application compiler and
    // the canonical Scala 3 compiler used by Scala-3-only fixtures in the Scala 2 lanes.
    scriptedLaunchOpts += s"-Dscala.version=${resolveScalaVersion(
        sys.props.getOrElse("scripted.scala.version", scala33LTSVersion)
      )}",
    scriptedLaunchOpts += s"-Dscala3.version=$scala33LTSVersion",
    // both `locally`s are to work around sbt/sbt#6161
    scriptedDependencies := {
      locally { val _ = scriptedDependencies.value }
      locally {
        val _ = publishLocal
          .all(
            ScopeFilter(
              inAnyProject
            )
          )
          .value
      }
      ()
    },
    mimaFailOnNoPrevious := false
  )

lazy val mavenPlugin = project
  .in(file("maven-twirl"))
  .enablePlugins(SbtMavenPlugin)
  .dependsOn(compiler)
  .settings(
    name                  := "twirl-maven-plugin",
    scalaVersion          := resolveScalaVersion(sys.props.getOrElse("scala.version", scala33LTSVersion)),
    crossScalaVersions    := publishedScalaVersions,
    mavenPluginGoalPrefix := "twirl",
    mavenLaunchOpts ++= Seq(
      // Uncomment to debug plugin code while Maven scripted test is running
//      "-agentlib:jdwp=transport=dt_socket,address=localhost:62555,suspend=y,server=y",
      version.apply { v => s"-Dplugin.version=$v" }.value,
      scalaVersion.apply { v => s"-Dscala.binaryVersion=${CrossVersion.binaryScalaVersion(v)}" }.value
    ),
    publishM2 := publishM2
      .dependsOn(compiler / publishM2)
      .dependsOn(parser / publishM2)
      .dependsOn(apiJvm / publishM2)
      .value,
    libraryDependencies += "org.codehaus.plexus" % "plexus-utils" % "4.1.0",
    Compile / headerSources ++= Def
      .uncached(
        (baseDirectory.value / "src" / "maven-test" ** ("*.java" || "*.scala" || "*.scala.html") --- (baseDirectory.value ** "target" ** "*"))
          .get()
      ),
    mimaFailOnNoPrevious := false,
  )

// Version file
def generateVersionFile =
  Def.task {
    val version = (apiJvm / Keys.version).value
    val file    = (Compile / resourceManaged).value / "twirl.version.properties"
    val content = s"twirl.api.version=$version"
    IO.write(file, content)
    Seq(file)
  }

def saveCompilerVersion =
  Def.task {
    val props  = new Properties()
    val writer = new StringWriter()
    val file   = baseDirectory.value / "version.properties"
    props.setProperty("twirl.compiler.version", version.value)
    props.store(writer, "")
    IO.write(file, writer.getBuffer.toString)
    Seq(file)
  }