Introduce new mill.api.opt with Opt, OptGroup, Opts and OptSyntax

Author: lefou

core/api/daemon/src/mill/api/daemon/internal/OptsApi.scala

@@ -0,0 +1,14 @@
+package mill.api.daemon.internal
+
+trait OptsApi {
+  def toStringSeq: Seq[String]
+  def value: Seq[OptGroupApi]
+}
+
+trait OptGroupApi {
+  def startsWithArg(prefix: String): Boolean
+}
+
+trait OptApi {
+  def toString(): String
+}

core/api/src/mill/api/opt/Opt.scala

@@ -0,0 +1,82 @@
+package mill.api.opt
+
+import mill.api.daemon.internal.OptApi
+
+import mill.api.JsonFormatters.given
+
+import scala.annotation.targetName
+import scala.language.implicitConversions
+
+type OptTypes = (String | os.Path)
+
+case class Opt private (value: Seq[OptTypes]) extends OptApi {
+  override def toString(): String = value.mkString("")
+
+  def map(conv: OptTypes => OptTypes): Opt = Opt(value.map(conv)*)
+
+  private def startStrings: Seq[String] =
+    value.takeWhile(_.isInstanceOf[String]).collect { case s: String => s }
+
+  def startsWith(prefix: String): Boolean = startStrings.mkString("").startsWith(prefix)
+
+  def mapStartString(rep: String => String): Opt = {
+    val rest = value.dropWhile(_.isInstanceOf[String])
+    Opt((rep(startStrings.mkString("")) +: rest)*)
+  }
+
+  def containsPaths: Boolean = value.exists {
+    case _: os.Path => true
+    case _ => false
+  }
+}
+
+object Opt {
+  @targetName("applyVarArg")
+  def apply(value: OptTypes*): Opt = {
+    // TODO: merge sequential strings
+    new Opt(value.filter {
+      case s: String if s.isEmpty => false
+      case _ => true
+    })
+  }
+
+  /**
+   * Constructs a path from multiple path elements and a separator string.
+   * Can be used to render classpaths.
+   * Each path component will still be handled properly, e.g. mapped according to the current [[MappedPaths]] mapping.
+   */
+  def mkPath(paths: Seq[os.Path], prefix: String = "", sep: String, suffix: String = ""): Opt = {
+    var needSep = false
+    Opt(
+      (
+        Seq(prefix) ++
+          paths.flatMap { path =>
+            if (needSep)
+              Seq(sep, path)
+            else {
+              needSep = true
+              Seq(path)
+            }
+          } ++ Seq(suffix)
+      )*
+    )
+  }
+
+  def mkPlatformPath(paths: Seq[os.Path]): Opt = mkPath(paths, sep = java.io.File.pathSeparator)
+
+  given jsonReadWriter: upickle.ReadWriter[Opt] =
+    upickle.readwriter[Seq[(Option[String], Option[os.Path])]].bimap(
+      _.value.map {
+        case path: os.Path => (None, Some(path))
+        case str: String => (Some(str), None)
+      },
+      seq =>
+        Opt(seq.map {
+          case (Some(str), _) => str
+          case (_, Some(path)) => path
+        }*)
+    )
+
+  given stringToOpt: Conversion[String, Opt] = (value: String) => Opt(value)
+  given osPathToOpt: Conversion[os.Path, Opt] = (value: os.Path) => Opt(value)
+}

core/api/src/mill/api/opt/OptGroup.scala

@@ -0,0 +1,68 @@
+package mill.api.opt
+
+import mill.api.daemon.internal.OptGroupApi
+
+import scala.annotation.targetName
+import scala.language.implicitConversions
+
+/**
+ * A set of options, which are used together
+ */
+case class OptGroup private (value: Seq[Opt]) extends OptGroupApi
+    derives upickle.ReadWriter {
+  override def toString(): String = value.mkString("(", ", ", ")")
+
+//  /**
+//   * Unify multiple options into one option.
+//   * Same as `mkString(" ")`` on a options list of type `Seq[String].
+//   */
+//  def mkOpt(sep: String = " "): Opt = Opt(value*)
+
+  def isEmpty: Boolean = value.isEmpty
+
+  def containsPaths: Boolean = value.exists(_.containsPaths)
+
+  def head: Opt = value.head
+  @deprecated
+  override def startsWithArg(prefix: String): Boolean = internalStartsWith(prefix)
+  @deprecated
+  def startsWithArg(prefix: os.Path): Boolean = internalStartsWith(prefix)
+  @deprecated
+  private inline def internalStartsWith(prefix: (String | os.Path)): Boolean =
+    value.headOption.exists {
+      head =>
+        (head, prefix) match {
+          case (h: String, s: String) => h == s
+          case (h: os.Path, p: os.Path) => h == p
+          case _ => false
+        }
+    }
+}
+
+object OptGroup {
+  @targetName("applyUnion")
+  def apply(value: (Opt | Seq[Opt])*): OptGroup = OptGroup(value.flatMap {
+    case a: Opt => Seq(a)
+    case s: Seq[Opt] => s
+  })
+
+  def when(cond: Boolean)(value: Opt*): OptGroup = if (cond) OptGroup(value*) else OptGroup()
+
+//  given optsToOptGroup: Conversion[(OptTypes, OptTypes), OptGroup] =
+//    (tuple: (OptTypes, OptTypes)) =>
+//      OptGroup(Opt(tuple._1), Opt(tuple._2))
+
+  implicit def StringToOptGroup(s: String): OptGroup = OptGroup(Seq(Opt(s)))
+
+  implicit def OsPathToOptGroup(p: os.Path): OptGroup = OptGroup(Seq(Opt(p)))
+
+  implicit def OptToOptGroup(o: Opt): OptGroup = OptGroup(Seq(o))
+
+  implicit def IterableToOptGroup[T](s: Iterable[T])(using f: T => OptGroup): OptGroup =
+    OptGroup(s.toSeq.flatMap(f(_).value))
+
+  implicit def ArrayToOptGroup[T](s: Array[T])(using f: T => OptGroup): OptGroup =
+    OptGroup(s.flatMap(f(_).value))
+
+}
+

core/api/src/mill/api/opt/OptSyntax.scala

@@ -0,0 +1,19 @@
+package mill.api.opt
+
+import mill.api.daemon.internal.{OptApi, OptGroupApi, OptsApi}
+
+import scala.annotation.targetName
+import scala.language.implicitConversions
+
+implicit class OptSyntax(ctx: StringContext) extends AnyVal {
+  def opt(opts: Any*): Opt = {
+    val vals = ctx.parts.take(opts.length).zip(opts).flatMap { case (p, a) => Seq(p, a) } ++
+      ctx.parts.drop(opts.length)
+
+    val elems: Seq[(String | os.Path)] = vals.flatMap {
+      case path: os.Path => Seq(path)
+      case s => Seq(s.toString).filter(_.nonEmpty)
+    }
+    Opt(elems*)
+  }
+}

core/api/src/mill/api/opt/Opts.scala

@@ -0,0 +1,32 @@
+package mill.api.opt
+
+import mill.api.daemon.internal.OptsApi
+
+import scala.language.implicitConversions
+
+case class Opts private (override val value: OptGroup*) extends OptsApi
+    derives upickle.ReadWriter {
+
+  def toStringSeq: Seq[String] = value.map(_.toString)
+  override def toString(): String = value.mkString("Opts(", ", ", ")")
+
+  def concat(suffix: Opts): Opts = Opts(value ++ suffix.value)
+  @`inline` final def ++(suffix: Opts): Opts = concat(suffix)
+
+  def containsPaths: Boolean = value.exists(_.containsPaths)
+
+  def isEmpty: Boolean = value.isEmpty
+  def filterGroup(pred: OptGroup => Boolean): Opts = Opts(value.filter(pred)*)
+  def mapGroup(f: OptGroup => OptGroup): Opts = Opts(value.map(f)*)
+  def flatMap(f: OptGroup => Seq[OptGroup]): Opts = Opts(value.flatMap(f)*)
+}
+
+object Opts {
+  def apply(value: OptGroup*): Opts = new Opts(value.filter(!_.isEmpty))
+//  @targetName("applyUnion")
+//  def apply(value: (Opt | OptGroup | Seq[Opt])*): Opts = Opts(value.flatMap {
+//    case a: Opt => Seq(OptGroup(a))
+//    case a: OptGroup => Seq(a)
+//    case s: Iterable[Opt] => s.map(OptGroup(_))
+//  })
+}