Add support for Scala-CLI

api/src/main/scala/com.olegych.scastie.api/ApiModels.scala

@@ -2,10 +2,10 @@ package com.olegych.scastie.api
 
 import play.api.libs.json._
 
-case object SbtPing
-case object SbtPong
+case object RunnerPing
+case object RunnerPong
 
-case class SbtRunnerConnect(hostname: String, port: Int)
+case class RunnerConnect(hostname: String, port: Int)
 case object ActorConnected
 
 object SnippetSummary {
@@ -127,7 +127,9 @@ case class ScalaDependency(
   override def toString: String = target.renderSbt(this)
 }
 
-case class ScastieMetalsOptions(dependencies: Set[ScalaDependency], scalaTarget: ScalaTarget)
+// Note: adding a code parameter is for the metals-runner
+// so it can parse dependencies and give support for it :)
+case class ScastieMetalsOptions(dependencies: Set[ScalaDependency], scalaTarget: ScalaTarget, code: Option[String] = None)
 
 object ScastieMetalsOptions {
   implicit val scastieMetalsOptions: OFormat[ScastieMetalsOptions] = Json.format[ScastieMetalsOptions]
@@ -141,6 +143,8 @@ sealed trait FailureType {
 
 case class NoResult(msg: String) extends FailureType
 case class PresentationCompilerFailure(msg: String) extends FailureType
+case class InvalidScalaVersion(msg: String) extends FailureType
+
 
 object FailureType {
   implicit val failureTypeFormat: OFormat[FailureType] = Json.format[FailureType]
@@ -158,6 +162,10 @@ object ScastieOffsetParams {
   implicit val scastieOffsetParams: OFormat[ScastieOffsetParams] = Json.format[ScastieOffsetParams]
 }
 
+object InvalidScalaVersion {
+  implicit val InvalidScalaVersionFormat: OFormat[InvalidScalaVersion] = Json.format[InvalidScalaVersion]
+}
+
 case class LSPRequestDTO(options: ScastieMetalsOptions, offsetParams: ScastieOffsetParams)
 case class CompletionInfoRequest(options: ScastieMetalsOptions, completionItem: CompletionItemDTO)
 

api/src/main/scala/com.olegych.scastie.api/ScalaTarget.scala

@@ -76,6 +76,7 @@ object ScalaTarget {
           formatNative.writes(native) ++ JsObject(Seq("tpe" -> JsString("Native")))
         case dotty: Scala3 =>
           formatScala3.writes(dotty) ++ JsObject(Seq("tpe" -> JsString("Scala3")))
+        case scli: ScalaCli => JsObject(Seq("tpe" -> JsString("ScalaCli")))
       }
     }
 
@@ -91,6 +92,7 @@ object ScalaTarget {
                 case "Typelevel"        => formatTypelevel.reads(json)
                 case "Native"           => formatNative.reads(json)
                 case "Scala3" | "Dotty" => formatScala3.reads(json)
+                case "ScalaCli"         => JsSuccess(ScalaCli())
                 case _                  => JsError(Seq())
               }
             case _ => JsError(Seq())
@@ -109,6 +111,29 @@ object ScalaTarget {
     )
   )
 
+  def fromScalaVersion(version: String): Option[ScalaTarget] = {
+    if (version.startsWith("3")) {
+      if (version == "3")
+        Some(ScalaTarget.Scala3(BuildInfo.latest3))
+      else 
+        Some(ScalaTarget.Scala3(version))
+    } else if (version.startsWith("2")) {
+      if (version == "2")
+        Some(ScalaTarget.Jvm(BuildInfo.latest213))
+      else if (version == "2.13") 
+        Some(ScalaTarget.Jvm(BuildInfo.latest213))
+      else if (version == "2.12")
+        Some(ScalaTarget.Jvm(BuildInfo.latest212))
+      else if (version == "2.11")
+        Some(ScalaTarget.Jvm(BuildInfo.latest211))
+      else if (version == "2.10")
+        Some(ScalaTarget.Jvm(BuildInfo.latest210))
+      else
+        Some(ScalaTarget.Jvm(version))
+    } else
+      None
+  }
+
   object Jvm {
     def default: ScalaTarget = ScalaTarget.Jvm(scalaVersion = BuildInfo.latest213)
   }
@@ -299,4 +324,37 @@ object ScalaTarget {
     override def toString: String =
       s"Scala $scalaVersion"
   }
+
+  object ScalaCli {
+    def default: ScalaTarget = ScalaCli()
+
+    def defaultCode: String =
+      """|// Hello!
+         |// Scastie is compatible with Scala CLI! You can use
+         |// directives: https://scala-cli.virtuslab.org/docs/guides/using-directives/
+         |
+         |println("Hi Scala CLI <3")
+      """.stripMargin
+  }
+
+  case class ScalaCli(scalaBinaryVersion0: String = "") extends ScalaTarget {
+    override def binaryScalaVersion: String = scalaBinaryVersion0
+
+    override def scalaVersion: String = ""
+
+    override def targetType: ScalaTargetType = ScalaTargetType.ScalaCli
+
+    override def scaladexRequest: Map[String,String] = 
+      Map("target" -> "JVM")
+
+    override def renderSbt(lib: ScalaDependency): String = "// Non-applicable"
+
+    override def sbtConfig: String = "// Non-applicable"
+
+    override def sbtPluginsConfig: String = "// Non-applicable"
+
+    override def sbtRunCommand(worksheetMode: Boolean): String = ???
+
+    override def toString: String = "Scala-CLI"
+  }
 }

api/src/main/scala/com.olegych.scastie.api/ScalaTargetType.scala

@@ -15,6 +15,7 @@ object ScalaTargetType {
       case "JS"        => Some(JS)
       case "NATIVE"    => Some(Native)
       case "TYPELEVEL" => Some(Typelevel)
+      case "SCALACLI"  => Some(ScalaCli)
       case _           => None
     }
   }
@@ -30,7 +31,8 @@ object ScalaTargetType {
         Scala3,
         JS,
         Native,
-        Typelevel
+        Typelevel,
+        ScalaCli
       ).map(v => (v.toString, v)).toMap
 
     def reads(json: JsValue): JsResult[ScalaTargetType] = {
@@ -65,4 +67,8 @@ object ScalaTargetType {
   case object Typelevel extends ScalaTargetType {
     def defaultScalaTarget: ScalaTarget = ScalaTarget.Typelevel.default
   }
+
+  case object ScalaCli extends ScalaTargetType {
+    def defaultScalaTarget: ScalaTarget = ScalaTarget.ScalaCli.default
+  }
 }

api/src/main/scala/com.olegych.scastie.api/ScliState.scala

@@ -0,0 +1,40 @@
+package com.olegych.scastie.api
+
+import play.api.libs.json._
+
+sealed trait ScliState extends ServerState
+object ScliState {
+  case object Unknown extends ScliState {
+    override def toString: String = "Unknown"
+    def isReady: Boolean = true
+  }
+
+  case object Disconnected extends ScliState {
+    override def toString: String = "Disconnected"
+    def isReady: Boolean = false
+  }
+
+  implicit object ScliStateFormat extends Format[ScliState] {
+    def writes(state: ScliState): JsValue = {
+      JsString(state.toString)
+    }
+
+    private val values =
+      List(
+        Unknown,
+        Disconnected
+      ).map(v => (v.toString, v)).toMap
+
+    def reads(json: JsValue): JsResult[ScliState] = {
+      json match {
+        case JsString(tpe) => {
+          values.get(tpe) match {
+            case Some(v) => JsSuccess(v)
+            case _       => JsError(Seq())
+          }
+        }
+        case _ => JsError(Seq())
+      }
+    }
+  }
+}

balancer/src/main/resources/reference.conf

@@ -3,9 +3,13 @@ com.olegych.scastie.balancer {
   snippets-dir = ./target/snippets/
   old-snippets-dir = ./target/old-snippets/
 
-  remote-hostname = "127.0.0.1"
+  remote-sbt-hostname = "127.0.0.1"
   remote-sbt-ports-start = 5150
   remote-sbt-ports-size = 1
+
+  remote-scli-hostname = "127.0.0.1"
+  remote-scli-ports-start = 5250
+  remote-scli-ports-size = 1
 }
 
 akka.actor.warn-about-java-serializer-usage = false

balancer/src/main/scala/com.olegych.scastie.balancer/BaseDispatcher.scala

@@ -0,0 +1,72 @@
+package com.olegych.scastie.balancer
+
+import com.typesafe.config.Config
+import akka.actor.ActorSelection
+import com.olegych.scastie.api.ActorConnected
+import akka.actor.ActorLogging
+import akka.actor.Actor
+import akka.actor.ActorRef
+import scala.concurrent.Future
+import akka.pattern.ask
+import akka.util.Timeout
+import scala.concurrent.duration._
+import com.olegych.scastie.api.RunnerPing
+
+abstract class BaseDispatcher[R, S](config: Config) extends Actor with ActorLogging {
+  case class SocketAddress(host: String, port: Int)
+
+  import context._
+
+  private def getRemoteActorsPath(
+    key: String,
+    runnerName: String,
+    actorName: String
+  ): Map[SocketAddress, String] = {
+    val host = config.getString(s"remote-$key-hostname")
+    val portStart = config.getInt(s"remote-$key-ports-start")
+    val portSize = config.getInt(s"remote-$key-ports-size")
+    (0 until portSize).map(_ + portStart)
+      .map(port => {
+        val addr = SocketAddress(host, port)
+        (addr, getRemoteActorPath(runnerName, addr, actorName))
+      })
+      .toMap
+  }
+
+  def getRemoteActorPath(
+    runnerName: String,
+    runnerAddress: SocketAddress,
+    actorName: String
+  ) = s"akka://$runnerName@${runnerAddress.host}:${runnerAddress.port}/user/$actorName"
+
+  def connectRunner(path: String): ActorSelection = {
+    val selection = context.actorSelection(path)
+    selection ! ActorConnected
+    selection
+  }
+
+  def getRemoteServers(
+    key: String,
+    runnerName: String,
+    actorName: String
+    ): Map[SocketAddress, ActorSelection] = {
+      getRemoteActorsPath(key, runnerName, actorName).map {
+        case (address, url) => (address, connectRunner(url))
+      }
+    }
+
+  def ping(servers: List[ActorSelection]): Future[List[Boolean]] = {
+    implicit val timeout: Timeout = Timeout(10.seconds)
+    val futures = servers.map { s =>
+        (s ? RunnerPing).map { _ =>
+          log.info(s"pinged $s")
+          true
+        }.recover { e => 
+          log.error(e, s"could not ping $s")
+          false
+        }
+      }
+    Future.sequence(futures)
+  }
+
+}