build.mill

//| mill-version: 1.1.3
//| mvnDeps:
//| - com.github.lolgab::mill-mima::0.2.1

import com.github.lolgab.mill.mima.*
import mill.*
import mill.api.BuildCtx
import mill.scalajslib.*
import mill.scalalib.*
import mill.scalalib.publish.*
import mill.util.VcsVersion

import java.io.File

object DepVersions {
  def mdoc = "2.3.6"
  def scala213 = "2.13.18"
  def scalaJs = "1.20.2"

  def scala = Seq(scala213, "2.12.21")
}

object Deps {
  def macroParadise = mvn"org.scalamacros:::paradise:2.1.1"
  def pprint = mvn"com.lihaoyi::pprint::0.9.6"
  def utest = mvn"com.lihaoyi::utest::0.8.9"
}

trait VersionsMima extends Mima with PublishModule {
  def mimaPreviousVersions: T[Seq[String]] = Task.Input {
    val current = os.proc("git", "describe", "--tags", "--match", "v*")
      .call(cwd = BuildCtx.workspaceRoot)
      .out.trim()
    val cutOff = coursier.version.Version("0.4.0")
    os.proc("git", "tag", "-l")
      .call(cwd = BuildCtx.workspaceRoot)
      .out.lines()
      .filter(_ != current)
      .filter(_.startsWith("v"))
      .map(_.stripPrefix("v"))
      .map(coursier.version.Version(_))
      .filter(_ > cutOff)
      .sorted
      .map(_.repr)
  }
  // required if mimaPreviousVersions is empty
  def mimaPreviousArtifacts = Task {
    val versions = mimaPreviousVersions().distinct
    mill.api.Result.Success(
      versions.map(version =>
        mvn"${pomSettings().organization}:${artifactId()}:$version"
      )
    )
  }
}

trait VersionsPublishModule extends PublishModule with VersionsMima {
  def pomSettings = PomSettings(
    description = artifactName(),
    organization = "io.get-coursier",
    url = "https://github.com/coursier/versions",
    licenses = Seq(License.`Apache-2.0`),
    versionControl = VersionControl.github("coursier", "versions"),
    developers = Seq(
      Developer("alexarchambault", "Alex Archambault","https://github.com/alexarchambault")
    )
  )

  def publishVersion = Task {
    val state = VcsVersion.vcsState()
    if (state.commitsSinceLastTag > 0) {
      val versionOrEmpty = state.lastTag
        .filter(_ != "latest")
        .map(_.stripPrefix("v"))
        .flatMap { tag =>
          val idx = tag.lastIndexOf(".")
          if (idx >= 0)
            Some(tag.take(idx + 1) + (tag.drop(idx + 1).takeWhile(_.isDigit).toInt + 1).toString + "-SNAPSHOT")
          else None
        }
        .getOrElse("0.0.1-SNAPSHOT")
      Some(versionOrEmpty)
        .filter(_.nonEmpty)
        .getOrElse(state.format())
    } else
      state
        .lastTag
        .getOrElse(state.format())
        .stripPrefix("v")
  }
}

trait Versions extends Cross.Module[String] with ScalaModule with VersionsPublishModule {
  def artifactName = "versions"
  def scalaVersion = crossValue
  def scalacPluginMvnDeps = Task {
    val sv = scalaVersion()
    val scala212Plugins =
      if (sv.startsWith("2.12.")) Seq(Deps.macroParadise)
      else Nil
    super.scalacPluginMvnDeps() ++ scala212Plugins
  }
  def scalacOptions = Task {
    val sv = scalaVersion()
    val scala213Opts =
      if (sv.startsWith("2.13.")) Seq("-Ymacro-annotations")
      else Nil
    super.scalacOptions() ++ scala213Opts ++ Seq(
      "-deprecation",
      "--release",
      "8"
    )
  }
  def sources = Task {
    super.sources() ++ Seq(versions.shared.sources())
  }

  def compileMvnDeps = Seq(
    mvn"io.github.alexarchambault::data-class:0.2.7"
  )

  def mimaBinaryIssueFilters = super.mimaBinaryIssueFilters() ++ Seq(
    // Additional abstract method on *sealed* trait
    ProblemFilter.exclude[ReversedMissingMethodProblem]("coursier.version.VersionCompatibility.minimumCompatibleVersion")
  )
}

trait VersionsJvm extends Versions {

  object test extends ScalaTests {
    def mvnDeps = super.mvnDeps() ++ Seq(
      Deps.pprint,
      Deps.utest
    )
    def testFramework = "utest.runner.Framework"
    def sources = Task {
      super.sources() ++ Seq(versions.shared.testSources())
    }
  }
}

trait VersionsJs extends Versions with ScalaJSModule {
  def scalaJSVersion = DepVersions.scalaJs

  object test extends ScalaJSTests {
    def mvnDeps = super.mvnDeps() ++ Seq(
      Deps.pprint,
      Deps.utest
    )
    def testFramework = "utest.runner.Framework"
    def sources = Task {
      super.sources() ++ Seq(versions.shared.testSources())
    }
  }
}

object versions extends Module {
  object shared extends Module {
    def sources = Task.Source("src")
    def testSources = Task.Source("test/src")
  }
  object jvm extends Cross[VersionsJvm](DepVersions.scala)
  object js extends Cross[VersionsJs](DepVersions.scala)
}


def readme = Task.Source("README.md")

private def mdocScalaVersion = DepVersions.scala213
def mdoc(args: String*) = Task.Command {
  val readme0 = readme().path
  val dest = Task.dest / "README.md"
  val cp = (versions.jvm(mdocScalaVersion).runClasspath() :+ versions.jvm(mdocScalaVersion).jar())
    .map(_.path)
    .filter(os.exists(_))
    .filter(!os.isDir(_))
  val cmd = Seq("cs", "launch", s"mdoc:${DepVersions.mdoc}", "--scala", mdocScalaVersion)
  val mdocArgs = Seq(
    "--in", readme0.toString,
    "--out", dest.toString,
    "--classpath", cp.mkString(File.pathSeparator)
  )
  os.proc(cmd, "--", mdocArgs, args).call(
    cwd = BuildCtx.workspaceRoot,
    stdin = os.Inherit,
    stdout = os.Inherit,
    stderr = os.Inherit
  )
}