luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix BSP

This commit is contained in:
Eugene Yokota 2022-09-19 15:50:58 -04:00
parent fe0de6ca30
commit 98302d7a13
1 changed files with 83 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala
View File

@ -752,101 +752,96 @@ object BuildServerProtocol {
} }
} }
private val jsonParser: Parser[Try[JValue]] = (Parsers.any *).map(_.mkString) private val jsonParser: Parser[JValue] = (Parsers.any *).map(_.mkString)
.map(JsonParser.parseFromString) .map(JsonParser.parseUnsafe)
private def bspRunTask: Def.Initialize[InputTask[Unit]] = Def.inputTaskDyn { private def bspRunTask: Def.Initialize[InputTask[Unit]] =
val runParams = jsonParser Def.input((s: State) => jsonParser).flatMapTask { json =>
.map(_.flatMap(json => Converter.fromJson[RunParams](json))) val runParams = Converter.fromJson[RunParams](json).get
.parsed val defaultClass = Keys.mainClass.value
.get val defaultJvmOptions = Keys.javaOptions.value
val defaultClass = Keys.mainClass.value
val defaultJvmOptions = Keys.javaOptions.value
val mainClass = runParams.dataKind match { val mainClass = runParams.dataKind match {
case Some("scala-main-class") => case Some("scala-main-class") =>
val data = runParams.data.getOrElse(JNull) val data = runParams.data.getOrElse(JNull)
Converter.fromJson[ScalaMainClass](data) match { Converter.fromJson[ScalaMainClass](data) match {
case Failure(e) => case Failure(e) =>
throw LangServerError( throw LangServerError(
ErrorCodes.ParseError, ErrorCodes.ParseError,
e.getMessage e.getMessage
) )
case Success(value) => case Success(value) =>
value.withEnvironmentVariables( value.withEnvironmentVariables(
envVars.value.map { case (k, v) => s"$k=$v" }.toVector ++ value.environmentVariables envVars.value.map { case (k, v) => s"$k=$v" }.toVector ++ value.environmentVariables
) )
}
case Some(dataKind) =>
throw LangServerError(
ErrorCodes.InvalidParams,
s"Unexpected data of kind '$dataKind', 'scala-main-class' is expected"
)
case None =>
ScalaMainClass(
defaultClass.getOrElse(
throw LangServerError(
ErrorCodes.InvalidParams,
"No default main class is defined"
)
),
runParams.arguments,
defaultJvmOptions.toVector,
envVars.value.map { case (k, v) => s"$k=$v" }.toVector
)
}
runMainClassTask(mainClass, runParams.originId)
}
private def bspTestTask: Def.Initialize[InputTask[Unit]] = Def.inputTaskDyn {
val testParams = jsonParser
.map(_.flatMap(json => Converter.fromJson[TestParams](json)))
.parsed
.get
val workspace = bspFullWorkspace.value
val resultTask: Def.Initialize[Task[Result[Seq[Unit]]]] = testParams.dataKind match {
case Some("scala-test") =>
val data = testParams.data.getOrElse(JNull)
val items = Converter.fromJson[ScalaTestParams](data) match {
case Failure(e) =>
throw LangServerError(ErrorCodes.ParseError, e.getMessage)
case Success(value) => value.testClasses
}
val testTasks: Seq[Def.Initialize[Task[Unit]]] = items.map { item =>
val scope = workspace.scopes(item.target)
item.classes.toList match {
case Nil => Def.task(())
case classes =>
(scope / testOnly).toTask(" " + classes.mkString(" "))
} }
}
testTasks.joinWith(ts => TaskExtra.joinTasks(ts).join).result
case Some(dataKind) => case Some(dataKind) =>
throw LangServerError( throw LangServerError(
ErrorCodes.InvalidParams, ErrorCodes.InvalidParams,
s"Unexpected data of kind '$dataKind', 'scala-main-class' is expected" s"Unexpected data of kind '$dataKind', 'scala-main-class' is expected"
) )
case None => case None =>
// run allTests in testParams.targets ScalaMainClass(
val filter = ScopeFilter.in(testParams.targets.map(workspace.scopes)) defaultClass.getOrElse(
test.all(filter).result throw LangServerError(
} ErrorCodes.InvalidParams,
"No default main class is defined"
Def.task { )
val state = Keys.state.value ),
val statusCode = resultTask.value match { runParams.arguments,
case Value(_) => StatusCode.Success defaultJvmOptions.toVector,
case Inc(_) => StatusCode.Error envVars.value.map { case (k, v) => s"$k=$v" }.toVector
)
}
runMainClassTask(mainClass, runParams.originId)
}
private def bspTestTask: Def.Initialize[InputTask[Unit]] =
Def.input((s: State) => jsonParser).flatMapTask { json =>
val testParams = Converter.fromJson[TestParams](json).get
val workspace = bspFullWorkspace.value
val resultTask: Def.Initialize[Task[Result[Seq[Unit]]]] = testParams.dataKind match {
case Some("scala-test") =>
val data = testParams.data.getOrElse(JNull)
val items = Converter.fromJson[ScalaTestParams](data) match {
case Failure(e) =>
throw LangServerError(ErrorCodes.ParseError, e.getMessage)
case Success(value) => value.testClasses
}
val testTasks: Seq[Def.Initialize[Task[Unit]]] = items.map { item =>
val scope = workspace.scopes(item.target)
item.classes.toList match {
case Nil => Def.task(())
case classes =>
(scope / testOnly).toTask(" " + classes.mkString(" "))
}
}
testTasks.joinWith(ts => TaskExtra.joinTasks(ts).join).result
case Some(dataKind) =>
throw LangServerError(
ErrorCodes.InvalidParams,
s"Unexpected data of kind '$dataKind', 'scala-main-class' is expected"
)
case None =>
// run allTests in testParams.targets
val filter = ScopeFilter.in(testParams.targets.map(workspace.scopes))
test.all(filter).result
}
Def.task {
val state = Keys.state.value
val statusCode = resultTask.value match {
case Value(_) => StatusCode.Success
case Inc(_) => StatusCode.Error
}
val _ = state.respondEvent(TestResult(testParams.originId, statusCode))
} }
val _ = state.respondEvent(TestResult(testParams.originId, statusCode))
} }
}
private def runMainClassTask(mainClass: ScalaMainClass, originId: Option[String]) = Def.task { private def runMainClassTask(mainClass: ScalaMainClass, originId: Option[String]) = Def.task {
val state = Keys.state.value val state = Keys.state.value