Accept dependencies via using directives too

Author: alexarchambault

.scalafmt.conf

@@ -22,6 +22,6 @@ fileOverride {
 }
 project.excludeFilters = [
   ".metals"
-  "examples/scala-3" # Scala 3 scripts not supported yet
+  "examples" # Scala 3 scripts and using directives not supported yet
   "out"
 ]

build.sc

@@ -88,6 +88,9 @@ object `generate-reference-doc` extends SbtModule {
   def moduleDeps = Seq(
     cli
   )
+  def repositories = super.repositories ++ Seq(
+    coursier.Repositories.sonatype("snapshots")
+  )
   def ivyDeps = Agg(
     Deps.caseApp,
     Deps.munit
@@ -115,6 +118,9 @@ class Build(val crossScalaVersion: String)
     `test-runner`(),
     `tasty-lib`()
   )
+  def repositories = super.repositories ++ Seq(
+    coursier.Repositories.sonatype("snapshots")
+  )
   def ivyDeps = super.ivyDeps() ++ Agg(
     Deps.asm,
     Deps.bloopConfig,
@@ -134,7 +140,8 @@ class Build(val crossScalaVersion: String)
     Deps.scalametaTrees,
     Deps.scalaparse,
     Deps.shapeless,
-    Deps.swoval
+    Deps.swoval,
+    Deps.usingDirectives
   )
 
   private def vcsState = {
@@ -229,6 +236,9 @@ trait Cli extends SbtModule with CliLaunchers with ScalaCliPublishModule with Fo
     build(Scala.defaultInternal),
     `test-runner`(Scala.defaultInternal)
   )
+  def repositories = super.repositories ++ Seq(
+    coursier.Repositories.sonatype("snapshots")
+  )
   def ivyDeps = super.ivyDeps() ++ Agg(
     Deps.caseApp,
     Deps.coursierLauncher,

examples/utest/MyTests.scala

@@ -1,4 +1,6 @@
-import $ivy.`com.lihaoyi::utest::0.7.10`, utest._
+@using lib "com.lihaoyi::utest::0.7.10"
+
+import utest._
 
 object MyTests extends TestSuite {
   val tests = Tests {

modules/build/src/main/scala/scala/build/preprocessing/DirectivesOutputStreamReporter.scala

@@ -0,0 +1,37 @@
+package scala.build.preprocessing
+
+import com.virtuslab.using_directives.custom.utils.Position
+import com.virtuslab.using_directives.reporter.Reporter
+
+import java.io.PrintStream
+
+class DirectivesOutputStreamReporter(out: PrintStream) extends Reporter {
+
+  private var errorCount = 0
+
+  private def msgWithPos(pos: Position, msg: String): String =
+    s"${pos.getLine}:${pos.getColumn}:\n$msg"
+
+  private def errorMessage(msg: String): String = {
+    errorCount += 1
+    s"ERROR: $msg"
+  }
+  private def warningMessage(msg: String): String =
+    s"WARNING: $msg"
+
+  override def error(msg: String): Unit =
+    out.println(errorMessage(msg))
+  override def error(position: Position, msg: String): Unit =
+    out.println(msgWithPos(position, errorMessage(msg)))
+  override def warning(msg: String): Unit =
+    out.println(warningMessage(msg))
+  override def warning(position: Position, msg: String): Unit =
+    out.println(msgWithPos(position, warningMessage(msg)))
+
+  override def hasErrors(): Boolean =
+    errorCount != 0
+
+  override def reset(): Unit = {
+    errorCount = 0
+  }
+}

modules/build/src/main/scala/scala/build/preprocessing/DirectivesProcessor.scala

@@ -0,0 +1,104 @@
+package scala.build.preprocessing
+
+import com.virtuslab.using_directives.custom.model.{Path, Value}
+import dependency.AnyDependency
+import dependency.parser.DependencyParser
+
+import scala.build.options.{BuildOptions, ClassPathOptions, ScalaOptions}
+import scala.collection.JavaConverters._
+
+object DirectivesProcessor {
+
+  private val processors = Map(
+    "lib" -> (processLib _)
+  )
+
+  private def processLib(value: Any): BuildOptions = {
+
+    val extraDependencies = Some(value)
+      .collect {
+        case list: java.util.List[_] =>
+          list
+            .asScala
+            .map {
+              case v: Value[_] => v.get()
+            }
+            .collect {
+              case s: String => s
+            }
+            .toVector
+        case s: String =>
+          Vector(s)
+      }
+      .map { deps =>
+        // Really necessary? (might already be handled by the coursier-dependency library)
+        val deps0 = deps.map(_.filter(!_.isSpaceChar))
+
+        deps0.map(parseDependency)
+      }
+      .getOrElse(Vector.empty)
+
+    BuildOptions(
+      classPathOptions = ClassPathOptions(
+        extraDependencies = extraDependencies
+      )
+    )
+  }
+
+  private def processScala(value: Any): BuildOptions = {
+
+    val versions = Some(value)
+      .toList
+      .collect {
+        case list: java.util.List[_] =>
+          list.asScala.collect { case v: String => v }.toList
+        case v: String =>
+          List(v)
+      }
+      .flatten
+      .map(_.filter(!_.isSpaceChar))
+      .filter(_.nonEmpty)
+      .distinct
+
+    versions match {
+      case Nil => BuildOptions()
+      case v :: Nil =>
+        BuildOptions(
+          scalaOptions = ScalaOptions(
+            scalaVersion = Some(v)
+          )
+        )
+      case _ =>
+        val highest = versions.maxBy(coursier.core.Version(_))
+        BuildOptions(
+          scalaOptions = ScalaOptions(
+            scalaVersion = Some(highest)
+          )
+        )
+    }
+  }
+
+  def process(directives: Map[Path, Value[_]]): BuildOptions = {
+
+    val values = directives.map {
+      case (k, v) =>
+        k.getPath.asScala.mkString(".") -> (v.get: Any)
+    }
+
+    values
+      .iterator
+      .flatMap {
+        case (k, v) =>
+          processors.get(k).iterator.map { f =>
+            f(v)
+          }
+      }
+      .foldLeft(BuildOptions())(_ orElse _)
+  }
+
+  private def parseDependency(str: String): AnyDependency =
+    DependencyParser.parse(str) match {
+      case Left(msg)  => sys.error(s"Malformed dependency '$str': $msg")
+      case Right(dep) => dep
+    }
+}

modules/build/src/main/scala/scala/build/preprocessing/ScalaPreprocessor.scala

@@ -1,5 +1,9 @@
 package scala.build.preprocessing
 
+import com.virtuslab.using_directives.{Context, UsingDirectivesProcessor}
+import com.virtuslab.using_directives.config.Settings
+import com.virtuslab.using_directives.custom.model.Path
+import com.virtuslab.using_directives.reporter.ConsoleReporter
 import dependency.AnyDependency
 import dependency.parser.DependencyParser
 
@@ -8,6 +12,7 @@ import java.nio.charset.StandardCharsets
 import scala.build.{Inputs, Os, Sources}
 import scala.build.internal.AmmUtil
 import scala.build.options.{BuildOptions, ClassPathOptions}
+import scala.collection.JavaConverters._
 
 case object ScalaPreprocessor extends Preprocessor {
   def preprocess(input: Inputs.SingleElement): Option[Seq[PreprocessedSource]] =
@@ -50,12 +55,6 @@ case object ScalaPreprocessor extends Preprocessor {
         None
     }
 
-  private def parseDependency(str: String): AnyDependency =
-    DependencyParser.parse(str) match {
-      case Left(msg)  => sys.error(s"Malformed dependency '$str': $msg")
-      case Right(dep) => dep
-    }
-
   def process(path: os.Path): Option[(BuildOptions, String)] = {
     val printablePath =
       if (path.startsWith(Os.pwd)) path.relativeTo(Os.pwd).toString
@@ -65,6 +64,65 @@ case object ScalaPreprocessor extends Preprocessor {
   }
   def process(content: String, printablePath: String): Option[(BuildOptions, String)] = {
 
+    val afterUsing = processUsing(content, printablePath)
+    val afterProcessImports = processSpecialImports(
+      afterUsing.map(_._2).getOrElse(content),
+      printablePath
+    )
+
+    if (afterUsing.isEmpty && afterProcessImports.isEmpty) None
+    else {
+      val allOptions    = afterUsing.map(_._1).toSeq ++ afterProcessImports.map(_._1).toSeq
+      val summedOptions = allOptions.foldLeft(BuildOptions())(_ orElse _)
+      val lastContent = afterProcessImports
+        .map(_._2)
+        .orElse(afterUsing.map(_._2))
+        .getOrElse(content)
+      Some((summedOptions, lastContent))
+    }
+  }
+
+  private def processUsing(
+    content: String,
+    printablePath: String
+  ): Option[(BuildOptions, String)] = {
+
+    val processor = {
+      val reporter = new DirectivesOutputStreamReporter(System.err) // TODO Get that via a logger
+      val settings = new Settings
+      val context  = new Context(reporter, settings)
+      new UsingDirectivesProcessor(context)
+    }
+
+    val contentChars = content.toCharArray
+    val directives   = processor.extract(contentChars)
+
+    val updatedOptions = DirectivesProcessor.process(directives.getFlattenedMap.asScala.toMap)
+
+    val codeOffset = directives.getCodeOffset()
+
+    val updatedContentOpt =
+      if (codeOffset > 0)
+        Some {
+          val headerBytes = contentChars
+            .iterator
+            .take(codeOffset)
+            .map(c => if (c.isControl) c else ' ')
+            .toArray
+          val mainBytes = contentChars.drop(codeOffset)
+          new String(headerBytes ++ mainBytes)
+        }
+      else None
+
+    if (updatedContentOpt.isEmpty) None
+    else Some((updatedOptions, updatedContentOpt.getOrElse(content)))
+  }
+
+  private def processSpecialImports(
+    content: String,
+    printablePath: String
+  ): Option[(BuildOptions, String)] = {
+
     import fastparse._
     import scalaparse._
     import scala.build.internal.ScalaParse._
@@ -128,10 +186,16 @@ case object ScalaPreprocessor extends Preprocessor {
       val deps    = dependencyTrees.map(_.prefix.drop(1).mkString("."))
       val options = BuildOptions(
         classPathOptions = ClassPathOptions(
-          extraDependencies = deps.map(ScalaPreprocessor.parseDependency)
+          extraDependencies = deps.map(parseDependency)
         )
       )
       Some((options, newCode))
     }
   }
+
+  private def parseDependency(str: String): AnyDependency =
+    DependencyParser.parse(str) match {
+      case Left(msg)  => sys.error(s"Malformed dependency '$str': $msg")
+      case Right(dep) => dep
+    }
 }