unpackRequest

Author: fc

build.sbt

@@ -1,18 +1,18 @@
 name := "vscode-scala"
 
 
-scalaVersion in ThisBuild := "2.11.11"
+scalaVersion in ThisBuild := "2.12.3"
 
 publishMavenStyle := true
 publishArtifact in Test := false
 pomIncludeRepository := { _ => false }
 
 lazy val commonSettings = Seq(
   organization := "com.github.dragos",
-  version := "0.1.4-SNAPSHOT",
+  version := "0.1.7-SNAPSHOT",
   resolvers += "dhpcs at bintray" at "https://dl.bintray.com/dhpcs/maven",
   libraryDependencies ++= Seq(
-    "org.scalatest" %% "scalatest" % "2.2.6" % "test"
+    "org.scalatest" %% "scalatest" % "3.0.1" % "test"
   ),
   publishTo := {
     val nexus = "https://oss.sonatype.org/"
@@ -27,8 +27,8 @@ lazy val languageserver = project.
   settings(commonSettings).
   settings(
     libraryDependencies ++= Seq(
-      "com.dhpcs" %% "play-json-rpc" % "1.3.0",
-      "com.typesafe.scala-logging" %% "scala-logging" % "3.4.0",
+      "com.dhpcs" %% "scala-json-rpc" % "2.0.0",
+      "com.typesafe.scala-logging" %% "scala-logging" % "3.7.2",
       "org.slf4j" % "slf4j-api" % "1.7.21",
       "ch.qos.logback" %  "logback-classic" % "1.1.7",
       "org.codehaus.groovy" % "groovy" % "2.4.0"
@@ -63,7 +63,7 @@ lazy val `ensime-lsp` = project.
   settings(
     resolvers += Resolver.sonatypeRepo("snapshots"),
     libraryDependencies ++= Seq(
-      "org.ensime" %% "core" % "2.0.0-M3"
+      "org.ensime" %% "core" % "2.0.0-M4"
     ),
     pomExtra in Global := {
       <url>https://github.com/dragos/dragos-vscode-scala/</url>

ensime-lsp/src/main/scala/org/github/dragos/vscode/EnsimeLanguageServer.scala

@@ -18,7 +18,10 @@ import org.ensime.config.EnsimeConfigProtocol
 import org.ensime.core._
 import org.ensime.util.file._
 import org.ensime.util.path._
-
+import org.ensime.config._
+import org.ensime.config.richconfig._
+import org.ensime.core.Canon
+import com.typesafe.config._
 import akka.actor.ActorRef
 import akka.actor.ActorSystem
 import akka.actor.Props
@@ -37,7 +40,7 @@ import java.nio.charset.Charset
 import langserver.core.MessageReader
 
 class EnsimeLanguageServer(in: InputStream, out: OutputStream) extends LanguageServer(in, out) {
-  private val system = ActorSystem("ENSIME")
+  private var system:ActorSystem = _
   private var fileStore: TempFileStore = _
 
   // Ensime root actor
@@ -80,29 +83,48 @@ class EnsimeLanguageServer(in: InputStream, out: OutputStream) extends LanguageS
     )
   }
 
+  def loadConfig(ensimeFile:File): Config = {
+    val config = s"""ensime.config = "${ensimeFile.toString}" """
+    val fallback = ConfigFactory.parseString(config)
+    ConfigFactory.load().withFallback(fallback)
+  }  
+
   private def initializeEnsime(rootPath: String): Try[EnsimeConfig] = {
     val ensimeFile = new File(s"$rootPath/.ensime")
 
     val configT = Try {
-      EnsimeConfigProtocol.parse(ensimeFile.toPath.readString()(MessageReader.Utf8Charset))
+      val config = loadConfig(ensimeFile)
+      system = ActorSystem("ENSIME", config)
+      val serverConfig: EnsimeServerConfig = parseServerConfig(config)
+      val ensimeConfig = EnsimeConfigProtocol.parse(serverConfig.config.file.readString()(MessageReader.Utf8Charset))
+      Canon.config = ensimeConfig
+      Canon.serverConfig = serverConfig      
+      (ensimeConfig, serverConfig)
     }
 
+    configT.recover{case e => logger.error(s"initializeEnsime Error: ${e.getMessage}"); e.printStackTrace}
+
     configT match {
       case Failure(e) =>
         if (ensimeFile.exists)
           connection.showMessage(MessageType.Error, s"Error parsing .ensime: ${e.getMessage}")
         else
           connection.showMessage(MessageType.Error, s"No .ensime file in directory. Run `sbt ensimeConfig` to create one.")
-      case Success(config) =>
+      case Success((config, serverConfig)) =>
         //showMessage(MessageType.Info, s"Using configuration: $ensimeFile")
         logger.info(s"Using configuration: $config")
-        fileStore = new TempFileStore(config.cacheDir.toString)
-        ensimeActor = system.actorOf(Props(classOf[EnsimeActor], this, config), "server")
-
-        // we don't give a damn about them, but Ensime expects it
+        val t = Try{
+          fileStore = new TempFileStore(config.cacheDir.file.toString)
+          ensimeActor = system.actorOf(Props(classOf[EnsimeActor], this, config, serverConfig), "server")
+        }
+        t.recover{case e => 
+          logger.error(s"initializeEnsime: ${e.getMessage}"); e.printStackTrace
+          connection.showMessage(MessageType.Error, s"Error creating storage: ${e.getMessage}")
+        }
+          // we don't give a damn about them, but Ensime expects it
         ensimeActor ! ConnectionInfoReq
     }
-    configT
+    configT.map(_._1)
   }
 
   override def onChangeWatchedFiles(changes: Seq[FileEvent]): Unit = changes match {
@@ -194,7 +216,7 @@ class EnsimeLanguageServer(in: InputStream, out: OutputStream) extends LanguageS
     res.map(f => CompletionList(false, Await.result(f, 5 seconds))) getOrElse CompletionList(false, Nil)
   }
 
-  override def gotoDefinitionRequest(textDocument: TextDocumentIdentifier, position: Position): Seq[Location] = {
+  override def gotoDefinitionRequest(textDocument: TextDocumentIdentifier, position: Position): LocationSeq = {
     import scala.concurrent.ExecutionContext.Implicits._
     logger.info(s"Got goto definition request at (${position.line}, ${position.character}).")
 
@@ -230,7 +252,8 @@ class EnsimeLanguageServer(in: InputStream, out: OutputStream) extends LanguageS
       }
     }
 
-    res.map { f =>  Await.result(f, 5 seconds) } getOrElse Seq.empty[Location]
+    val r = (res.map { f =>  Await.result(f, 5 seconds) } getOrElse Seq.empty[Location])
+    LocationSeq(r)
   }
 
   override def hoverRequest(textDocument: TextDocumentIdentifier, position: Position): Hover = {

ensime-lsp/src/main/scala/org/github/dragos/vscode/Main.scala

@@ -10,6 +10,7 @@ object Main extends LazyLogging {
     val cwd = System.getProperty("vscode.workspace")
     logger.info(s"Starting server in $cwd")
     logger.info(s"Classpath: ${Properties.javaClassPath}")
+    logger.info(s"LogLevel: ${Option(System.getProperty("vscode.logLevel")).getOrElse("")}")
 
     val server = new EnsimeLanguageServer(System.in, System.out)
 
@@ -25,6 +26,19 @@ object Main extends LazyLogging {
       System.setOut(origOut)
     }
 
+    logger.underlying match {
+      case logbackLogger:ch.qos.logback.classic.Logger => 
+        val logLevel = Option(System.getProperty("vscode.logLevel"))
+        logLevel match{
+          case Some("ERROR") => logbackLogger.setLevel(ch.qos.logback.classic.Level.ERROR)
+          case Some("INFO") => logbackLogger.setLevel(ch.qos.logback.classic.Level.INFO)
+          case Some("DEBUG") => logbackLogger.setLevel(ch.qos.logback.classic.Level.DEBUG)
+          case Some("WARN") => logbackLogger.setLevel(ch.qos.logback.classic.Level.WARN)
+          case _ =>
+        }
+      case _ =>
+    }
+
     // make sure we actually exit
     System.exit(0)
   }

ensime-lsp/src/main/scala/org/github/dragos/vscode/ensime/EnsimeActor.scala

@@ -2,6 +2,7 @@ package org.github.dragos.vscode.ensime
 
 import akka.actor._
 import org.ensime.api.EnsimeConfig
+import org.ensime.api.EnsimeServerConfig
 import org.github.dragos.vscode.EnsimeLanguageServer
 import langserver.messages.MessageType
 import com.typesafe.scalalogging.LazyLogging
@@ -12,7 +13,7 @@ import scala.concurrent.duration._
  *
  * It catches `ActorInitializationError` and tries to restart it.
  */
-class EnsimeActor(langServer: EnsimeLanguageServer, config: EnsimeConfig) extends Actor with LazyLogging {
+class EnsimeActor(langServer: EnsimeLanguageServer, config: EnsimeConfig, ensimeServerConfig:EnsimeServerConfig) extends Actor with LazyLogging {
 
   private var project: ActorRef = _
 
@@ -32,10 +33,10 @@ class EnsimeActor(langServer: EnsimeLanguageServer, config: EnsimeConfig) extend
         // trying to catch this elusive ActorInitializationException by creating this actor as late
         // as possible. Still, it looks like the supervisor strategy does not get this crash
         logger.info("Starting problematic actor now")
-        project = context.actorOf(Props(new EnsimeProjectServer(langServer, config)), "ensimeProject")
+        project = context.actorOf(Props(new EnsimeProjectServer(langServer, config, ensimeServerConfig)), "ensimeProject")
         logger.info(s"Created: $project")
       }
-
+      
       project forward message
   }
 }

ensime-lsp/src/main/scala/org/github/dragos/vscode/ensime/EnsimeProjectServer.scala

@@ -7,7 +7,7 @@ import org.ensime.api._
 import org.ensime.api.EnsimeConfig
 import org.ensime.core.Broadcaster
 import org.ensime.core.Project
-
+import org.ensime.api.EnsimeServerConfig
 import com.typesafe.scalalogging.LazyLogging
 
 import akka.actor.Actor
@@ -19,7 +19,9 @@ import langserver.messages.MessageType
 import org.github.dragos.vscode.EnsimeLanguageServer
 import akka.actor.TypedActor.PostStop
 
-class EnsimeProjectServer(langServer: EnsimeLanguageServer, implicit val config: EnsimeConfig) extends Actor with LazyLogging {
+class EnsimeProjectServer(langServer: EnsimeLanguageServer, 
+                          implicit val config: EnsimeConfig, 
+                          implicit val ensimeServerConfig:EnsimeServerConfig) extends Actor with LazyLogging {
   implicit val timeout: Timeout = Timeout(10 seconds)
 
   val broadcaster = context.actorOf(Broadcaster(), "broadcaster")

languageserver/src/main/scala/langserver/core/Connection.scala

@@ -17,7 +17,7 @@ import com.typesafe.scalalogging.LazyLogging
 import langserver.messages._
 import langserver.types._
 import play.api.libs.json._
-
+import com.dhpcs.jsonrpc.JsonRpcMessage._
 /**
  * A connection that reads and writes Language Server Protocol messages.
  *
@@ -92,9 +92,10 @@ class Connection(inStream: InputStream, outStream: OutputStream)(val commandHand
 
             case Right(message) => message match {
               case notification: JsonRpcNotificationMessage =>
-                Notification.read(notification).fold {
+                Option(Notification.read(notification)).fold(
                   logger.error(s"No notification type exists with method=${notification.method}")
-                }(_.fold({ errors => logger.error(s"Invalid Notification: $errors") },
+                )(_.fold(
+                  errors => logger.error(s"Invalid Notification: $errors"),
                   notifySubscribers))
 
               case request: JsonRpcRequestMessage =>
@@ -111,55 +112,67 @@ class Connection(inStream: InputStream, outStream: OutputStream)(val commandHand
               case m =>
                 logger.error(s"Received unknown message: $m")
             }
+            case m => logger.error(s"Received unknown message: $m")
           }
       }
     } while (!streamClosed)
   }
 
-  private def readJsonRpcMessage(jsonString: String): Either[JsonRpcResponseError, JsonRpcMessage] = {
+  private def readJsonRpcMessage(jsonString: String): Either[JsonRpcResponseErrorMessage, JsonRpcMessage] = {
     logger.debug(s"Received $jsonString")
     Try(Json.parse(jsonString)) match {
       case Failure(exception) =>
-        Left(JsonRpcResponseError.parseError(exception))
+        Left(JsonRpcResponseErrorMessage.parseError(exception,NoCorrelationId))
 
       case Success(json) =>
         Json.fromJson[JsonRpcMessage](json).fold({ errors =>
-          Left(JsonRpcResponseError.invalidRequest(errors))
+          Left(JsonRpcResponseErrorMessage.invalidRequest(JsError(errors),NoCorrelationId))
         }, Right(_))
     }
   }
 
-  private def readCommand(jsonString: String): (Option[Either[String, BigDecimal]], Either[JsonRpcResponseError, ServerCommand]) =
+  private def readCommand(jsonString: String): (Option[CorrelationId], Either[JsonRpcResponseErrorMessage, ServerCommand]) =
     Try(Json.parse(jsonString)) match {
       case Failure(exception) =>
-        None -> Left(JsonRpcResponseError.parseError(exception))
+        None -> Left(JsonRpcResponseErrorMessage.parseError(exception,NoCorrelationId ))
 
       case Success(json) =>
         Json.fromJson[JsonRpcRequestMessage](json).fold(
-          errors => None -> Left(JsonRpcResponseError.invalidRequest(errors)),
+          errors => None -> Left(JsonRpcResponseErrorMessage.invalidRequest(JsError(errors),NoCorrelationId)),
 
           jsonRpcRequestMessage =>
-            ServerCommand.read(jsonRpcRequestMessage)
-              .fold[(Option[Either[String, BigDecimal]], Either[JsonRpcResponseError, ServerCommand])](
-                jsonRpcRequestMessage.id -> Left(JsonRpcResponseError.methodNotFound(jsonRpcRequestMessage.method)))(commandJsResult => commandJsResult.fold(
-                  errors => jsonRpcRequestMessage.id -> Left(JsonRpcResponseError.invalidParams(errors)),
-                  command => jsonRpcRequestMessage.id -> Right(command))))
+            Option(ServerCommand.read(jsonRpcRequestMessage))
+              .fold[(Option[CorrelationId], Either[JsonRpcResponseErrorMessage, ServerCommand])](
+                Some(jsonRpcRequestMessage.id) -> Left(JsonRpcResponseErrorMessage.methodNotFound(jsonRpcRequestMessage.method,jsonRpcRequestMessage.id )))(commandJsResult => commandJsResult.fold(
+                  errors => Some(jsonRpcRequestMessage.id) -> Left(JsonRpcResponseErrorMessage.invalidParams(JsError(errors),jsonRpcRequestMessage.id)),
+                  command => Some(jsonRpcRequestMessage.id) -> Right(command))))
 
     }
 
-  private def unpackRequest(request: JsonRpcRequestMessage): (Option[Either[String, BigDecimal]], Either[JsonRpcResponseError, ServerCommand]) = {
-    ServerCommand.read(request)
-      .fold[(Option[Either[String, BigDecimal]], Either[JsonRpcResponseError, ServerCommand])](
-
-        request.id -> Left(
-          JsonRpcResponseError.methodNotFound(request.method)))(commandJsResult => commandJsResult.fold(
-          errors => request.id -> Left(JsonRpcResponseError.invalidParams(errors)),
-          command => request.id -> Right(command)))
+  private def unpackRequest(request: JsonRpcRequestMessage): (Option[CorrelationId], Either[JsonRpcResponseErrorMessage, ServerCommand]) = {
+    Option(ServerCommand.read(request))
+      .fold[(Option[CorrelationId], Either[JsonRpcResponseErrorMessage, ServerCommand])](
+        Some(request.id) -> Left(JsonRpcResponseErrorMessage.methodNotFound(request.method,request.id )))(
+          commandJsResult => commandJsResult.fold(errors => 
+            Some(request.id) -> Left(JsonRpcResponseErrorMessage.invalidParams(JsError(errors),request.id )),
+            command => Some(request.id) -> Right(command)))
+            
   }
 
-  private def handleCommand(method: String, id: Either[String, BigDecimal], command: ServerCommand) = {
+  private def handleCommand(method: String, id: CorrelationId, command: ServerCommand) = {
     Future(commandHandler(method, command)).map { result =>
-      msgWriter.write(ResultResponse.write(Right(result), Some(id)))
+      logger.info("Result:"+result)
+      val r = Try{
+        result match {
+          case ls:LocationSeq => JsonRpcResponseSuccessMessage(Json.toJson(ls.locs), id) //Special case, new play-json-rcp can not deal with Seq of JsValue
+          case r => ResultResponse.write(r, id)
+        }
+      }
+      r.recover{case e => logger.error("ResultResponse.write:"+result); e.printStackTrace }
+      r.foreach{rJson => 
+        logger.info("Result json:"+r)
+        msgWriter.write(rJson)
+      }
     }
   }
 }

languageserver/src/main/scala/langserver/core/LanguageServer.scala

@@ -84,8 +84,8 @@ class LanguageServer(inStream: InputStream, outStream: OutputStream) extends Laz
 
   }
 
-  def gotoDefinitionRequest(textDocument: TextDocumentIdentifier, position: Position): Seq[Location] = {
-    Seq.empty[Location]
+  def gotoDefinitionRequest(textDocument: TextDocumentIdentifier, position: Position): LocationSeq = {
+    LocationSeq(Seq.empty[Location])
   }
 
   def hoverRequest(textDocument: TextDocumentIdentifier, position: Position): Hover = {

languageserver/src/main/scala/langserver/core/Main.scala

@@ -1,12 +1,16 @@
 package langserver.core
 
 import com.typesafe.scalalogging.LazyLogging
+import scala.util.Try
 
 object Main extends LazyLogging {
   def main(args: Array[String]): Unit = {
     logger.info(s"Starting server in ${System.getenv("PWD")}")
 
-    val server = new LanguageServer(System.in, System.out)
-    server.start()
+    val server = Try {
+      val s = new LanguageServer(System.in, System.out)
+      s.start()
+    }
+    server.recover{case e => {logger.error(e.getMessage); e.printStackTrace} }
   }
 }

languageserver/src/main/scala/langserver/messages/Commands.scala

@@ -142,9 +142,9 @@ case class InitializeResult(capabilities: ServerCapabilities) extends ResultResp
 
 case class Shutdown() extends ServerCommand
 object Shutdown {
-  implicit val format: Format[Shutdown] = Format(
+  implicit val format: Format[Shutdown] = OFormat(
     Reads(jsValue => JsSuccess(Shutdown())),
-    Writes(s => Json.obj()))
+    OWrites[Shutdown](s => Json.obj()))
 }
 
 case class ShutdownResult(dummy: Int) extends ResultResponse
@@ -248,13 +248,18 @@ object Notification extends NotificationCompanion[Notification] {
 
 case class DocumentSymbolResult(params: Seq[SymbolInformation]) extends ResultResponse
 
+case class LocationSeq(locs: Seq[Location]) extends ResultResponse
+
 object ResultResponse extends ResponseCompanion[Any] {
   import JsonRpcUtils._
 
+  implicit val positionParamsFormat = Json.format[Location]
+
   override val ResponseFormats = Message.MessageFormats(
     "initialize" -> Json.format[InitializeResult],
     "textDocument/completion" -> Json.format[CompletionList],
-    "textDocument/definition" -> implicitly[Format[Seq[Location]]],
+    "textDocument/definition" -> Json.format[LocationSeq],
+    //"textDocument/definition" -> implicitly[Format[Seq[Location]]], //Runtime exception with latest play-json-rcp
     "textDocument/hover" -> Json.format[Hover],
     "textDocument/documentSymbol" -> valueFormat(DocumentSymbolResult)(_.params),
     "shutdown" -> Json.format[ShutdownResult])

languageserver/src/main/scala/langserver/utils/JsonRpcUtils.scala

@@ -34,8 +34,8 @@ object JsonRpcUtils {
    *         )
    * }}}
    */
-   def valueFormat[A, B: Format](apply: B => A)(unapply: A => B): Format[A] = new Format[A] {
+   def valueFormat[A, B: Format](apply: B => A)(unapply: A => B): OFormat[A] = new OFormat[A] {
     override def reads(json: JsValue) = Reads.of[B].reads(json).map(apply(_))
-    override def writes(o: A) = Writes.of[B].writes(unapply(o))
+    override def writes(o: A) = Writes.of[B].writes(unapply(o)).as[JsObject]
   }
 }