From 85efc87879d596cd519d56bc3e5b1bce3ca4f858 Mon Sep 17 00:00:00 2001 From: Kamil Podsiadlo Date: Thu, 31 Mar 2022 12:28:15 +0200 Subject: [PATCH 1/4] feat: generate JVM environment requests --- .../sbt/internal/bsp/JvmEnvironmentItem.scala | 48 +++++++++++++++++++ .../bsp/JvmRunEnvironmentParams.scala | 40 ++++++++++++++++ .../bsp/JvmRunEnvironmentResult.scala | 40 ++++++++++++++++ .../bsp/JvmTestEnvironmentParams.scala | 40 ++++++++++++++++ .../bsp/JvmTestEnvironmentResult.scala | 40 ++++++++++++++++ .../sbt/internal/bsp/codec/JsonProtocol.scala | 5 ++ .../bsp/codec/JvmEnvironmentItemFormats.scala | 35 ++++++++++++++ .../JvmRunEnvironmentParamsFormats.scala | 29 +++++++++++ .../JvmRunEnvironmentResultFormats.scala | 29 +++++++++++ .../JvmTestEnvironmentParamsFormats.scala | 29 +++++++++++ .../JvmTestEnvironmentResultFormats.scala | 29 +++++++++++ protocol/src/main/contraband/bsp.contra | 31 ++++++++++++ 12 files changed, 395 insertions(+) create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JvmEnvironmentItem.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentParams.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentResult.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentParams.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentResult.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmEnvironmentItemFormats.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentParamsFormats.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentResultFormats.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentParamsFormats.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentResultFormats.scala diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmEnvironmentItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmEnvironmentItem.scala new file mode 100644 index 000000000..6e3d6b895 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmEnvironmentItem.scala @@ -0,0 +1,48 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +final class JvmEnvironmentItem private ( + val target: sbt.internal.bsp.BuildTargetIdentifier, + val classpath: Vector[java.net.URI], + val jvmOptions: Vector[String], + val workingDirectory: String, + val environmentVariables: scala.collection.immutable.Map[String, String]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JvmEnvironmentItem => (this.target == x.target) && (this.classpath == x.classpath) && (this.jvmOptions == x.jvmOptions) && (this.workingDirectory == x.workingDirectory) && (this.environmentVariables == x.environmentVariables) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmEnvironmentItem".##) + target.##) + classpath.##) + jvmOptions.##) + workingDirectory.##) + environmentVariables.##) + } + override def toString: String = { + "JvmEnvironmentItem(" + target + ", " + classpath + ", " + jvmOptions + ", " + workingDirectory + ", " + environmentVariables + ")" + } + private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, classpath: Vector[java.net.URI] = classpath, jvmOptions: Vector[String] = jvmOptions, workingDirectory: String = workingDirectory, environmentVariables: scala.collection.immutable.Map[String, String] = environmentVariables): JvmEnvironmentItem = { + new JvmEnvironmentItem(target, classpath, jvmOptions, workingDirectory, environmentVariables) + } + def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): JvmEnvironmentItem = { + copy(target = target) + } + def withClasspath(classpath: Vector[java.net.URI]): JvmEnvironmentItem = { + copy(classpath = classpath) + } + def withJvmOptions(jvmOptions: Vector[String]): JvmEnvironmentItem = { + copy(jvmOptions = jvmOptions) + } + def withWorkingDirectory(workingDirectory: String): JvmEnvironmentItem = { + copy(workingDirectory = workingDirectory) + } + def withEnvironmentVariables(environmentVariables: scala.collection.immutable.Map[String, String]): JvmEnvironmentItem = { + copy(environmentVariables = environmentVariables) + } +} +object JvmEnvironmentItem { + + def apply(target: sbt.internal.bsp.BuildTargetIdentifier, classpath: Vector[java.net.URI], jvmOptions: Vector[String], workingDirectory: String, environmentVariables: scala.collection.immutable.Map[String, String]): JvmEnvironmentItem = new JvmEnvironmentItem(target, classpath, jvmOptions, workingDirectory, environmentVariables) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentParams.scala new file mode 100644 index 000000000..f96b6a26e --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentParams.scala @@ -0,0 +1,40 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +final class JvmRunEnvironmentParams private ( + val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], + val originId: Option[String]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JvmRunEnvironmentParams => (this.targets == x.targets) && (this.originId == x.originId) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmRunEnvironmentParams".##) + targets.##) + originId.##) + } + override def toString: String = { + "JvmRunEnvironmentParams(" + targets + ", " + originId + ")" + } + private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId): JvmRunEnvironmentParams = { + new JvmRunEnvironmentParams(targets, originId) + } + def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): JvmRunEnvironmentParams = { + copy(targets = targets) + } + def withOriginId(originId: Option[String]): JvmRunEnvironmentParams = { + copy(originId = originId) + } + def withOriginId(originId: String): JvmRunEnvironmentParams = { + copy(originId = Option(originId)) + } +} +object JvmRunEnvironmentParams { + + def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String]): JvmRunEnvironmentParams = new JvmRunEnvironmentParams(targets, originId) + def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String): JvmRunEnvironmentParams = new JvmRunEnvironmentParams(targets, Option(originId)) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentResult.scala new file mode 100644 index 000000000..47ebb14ea --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmRunEnvironmentResult.scala @@ -0,0 +1,40 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +final class JvmRunEnvironmentResult private ( + val items: Vector[sbt.internal.bsp.JvmEnvironmentItem], + val originId: Option[String]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JvmRunEnvironmentResult => (this.items == x.items) && (this.originId == x.originId) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmRunEnvironmentResult".##) + items.##) + originId.##) + } + override def toString: String = { + "JvmRunEnvironmentResult(" + items + ", " + originId + ")" + } + private[this] def copy(items: Vector[sbt.internal.bsp.JvmEnvironmentItem] = items, originId: Option[String] = originId): JvmRunEnvironmentResult = { + new JvmRunEnvironmentResult(items, originId) + } + def withItems(items: Vector[sbt.internal.bsp.JvmEnvironmentItem]): JvmRunEnvironmentResult = { + copy(items = items) + } + def withOriginId(originId: Option[String]): JvmRunEnvironmentResult = { + copy(originId = originId) + } + def withOriginId(originId: String): JvmRunEnvironmentResult = { + copy(originId = Option(originId)) + } +} +object JvmRunEnvironmentResult { + + def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: Option[String]): JvmRunEnvironmentResult = new JvmRunEnvironmentResult(items, originId) + def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: String): JvmRunEnvironmentResult = new JvmRunEnvironmentResult(items, Option(originId)) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentParams.scala new file mode 100644 index 000000000..dd49a1474 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentParams.scala @@ -0,0 +1,40 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +final class JvmTestEnvironmentParams private ( + val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], + val originId: Option[String]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JvmTestEnvironmentParams => (this.targets == x.targets) && (this.originId == x.originId) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmTestEnvironmentParams".##) + targets.##) + originId.##) + } + override def toString: String = { + "JvmTestEnvironmentParams(" + targets + ", " + originId + ")" + } + private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId): JvmTestEnvironmentParams = { + new JvmTestEnvironmentParams(targets, originId) + } + def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): JvmTestEnvironmentParams = { + copy(targets = targets) + } + def withOriginId(originId: Option[String]): JvmTestEnvironmentParams = { + copy(originId = originId) + } + def withOriginId(originId: String): JvmTestEnvironmentParams = { + copy(originId = Option(originId)) + } +} +object JvmTestEnvironmentParams { + + def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String]): JvmTestEnvironmentParams = new JvmTestEnvironmentParams(targets, originId) + def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String): JvmTestEnvironmentParams = new JvmTestEnvironmentParams(targets, Option(originId)) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentResult.scala new file mode 100644 index 000000000..54fd64253 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JvmTestEnvironmentResult.scala @@ -0,0 +1,40 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +final class JvmTestEnvironmentResult private ( + val items: Vector[sbt.internal.bsp.JvmEnvironmentItem], + val originId: Option[String]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JvmTestEnvironmentResult => (this.items == x.items) && (this.originId == x.originId) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "sbt.internal.bsp.JvmTestEnvironmentResult".##) + items.##) + originId.##) + } + override def toString: String = { + "JvmTestEnvironmentResult(" + items + ", " + originId + ")" + } + private[this] def copy(items: Vector[sbt.internal.bsp.JvmEnvironmentItem] = items, originId: Option[String] = originId): JvmTestEnvironmentResult = { + new JvmTestEnvironmentResult(items, originId) + } + def withItems(items: Vector[sbt.internal.bsp.JvmEnvironmentItem]): JvmTestEnvironmentResult = { + copy(items = items) + } + def withOriginId(originId: Option[String]): JvmTestEnvironmentResult = { + copy(originId = originId) + } + def withOriginId(originId: String): JvmTestEnvironmentResult = { + copy(originId = Option(originId)) + } +} +object JvmTestEnvironmentResult { + + def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: Option[String]): JvmTestEnvironmentResult = new JvmTestEnvironmentResult(items, originId) + def apply(items: Vector[sbt.internal.bsp.JvmEnvironmentItem], originId: String): JvmTestEnvironmentResult = new JvmTestEnvironmentResult(items, Option(originId)) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala index c55580da2..7d26ae037 100644 --- a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala @@ -63,4 +63,9 @@ trait JsonProtocol extends sjsonnew.BasicJsonProtocol with sbt.internal.bsp.codec.ResourcesParamsFormats with sbt.internal.bsp.codec.ResourcesItemFormats with sbt.internal.bsp.codec.ResourcesResultFormats + with sbt.internal.bsp.codec.JvmEnvironmentItemFormats + with sbt.internal.bsp.codec.JvmTestEnvironmentParamsFormats + with sbt.internal.bsp.codec.JvmTestEnvironmentResultFormats + with sbt.internal.bsp.codec.JvmRunEnvironmentParamsFormats + with sbt.internal.bsp.codec.JvmRunEnvironmentResultFormats object JsonProtocol extends JsonProtocol \ No newline at end of file diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmEnvironmentItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmEnvironmentItemFormats.scala new file mode 100644 index 000000000..c1ecd6ee1 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmEnvironmentItemFormats.scala @@ -0,0 +1,35 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JvmEnvironmentItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JvmEnvironmentItemFormat: JsonFormat[sbt.internal.bsp.JvmEnvironmentItem] = new JsonFormat[sbt.internal.bsp.JvmEnvironmentItem] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmEnvironmentItem = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target") + val classpath = unbuilder.readField[Vector[java.net.URI]]("classpath") + val jvmOptions = unbuilder.readField[Vector[String]]("jvmOptions") + val workingDirectory = unbuilder.readField[String]("workingDirectory") + val environmentVariables = unbuilder.readField[scala.collection.immutable.Map[String, String]]("environmentVariables") + unbuilder.endObject() + sbt.internal.bsp.JvmEnvironmentItem(target, classpath, jvmOptions, workingDirectory, environmentVariables) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JvmEnvironmentItem, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("target", obj.target) + builder.addField("classpath", obj.classpath) + builder.addField("jvmOptions", obj.jvmOptions) + builder.addField("workingDirectory", obj.workingDirectory) + builder.addField("environmentVariables", obj.environmentVariables) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentParamsFormats.scala new file mode 100644 index 000000000..b1c5ce3e4 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentParamsFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JvmRunEnvironmentParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JvmRunEnvironmentParamsFormat: JsonFormat[sbt.internal.bsp.JvmRunEnvironmentParams] = new JsonFormat[sbt.internal.bsp.JvmRunEnvironmentParams] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmRunEnvironmentParams = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets") + val originId = unbuilder.readField[Option[String]]("originId") + unbuilder.endObject() + sbt.internal.bsp.JvmRunEnvironmentParams(targets, originId) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JvmRunEnvironmentParams, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("targets", obj.targets) + builder.addField("originId", obj.originId) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentResultFormats.scala new file mode 100644 index 000000000..6a9d40a5e --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmRunEnvironmentResultFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JvmRunEnvironmentResultFormats { self: sbt.internal.bsp.codec.JvmEnvironmentItemFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JvmRunEnvironmentResultFormat: JsonFormat[sbt.internal.bsp.JvmRunEnvironmentResult] = new JsonFormat[sbt.internal.bsp.JvmRunEnvironmentResult] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmRunEnvironmentResult = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val items = unbuilder.readField[Vector[sbt.internal.bsp.JvmEnvironmentItem]]("items") + val originId = unbuilder.readField[Option[String]]("originId") + unbuilder.endObject() + sbt.internal.bsp.JvmRunEnvironmentResult(items, originId) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JvmRunEnvironmentResult, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("items", obj.items) + builder.addField("originId", obj.originId) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentParamsFormats.scala new file mode 100644 index 000000000..b02e289f2 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentParamsFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JvmTestEnvironmentParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JvmTestEnvironmentParamsFormat: JsonFormat[sbt.internal.bsp.JvmTestEnvironmentParams] = new JsonFormat[sbt.internal.bsp.JvmTestEnvironmentParams] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmTestEnvironmentParams = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets") + val originId = unbuilder.readField[Option[String]]("originId") + unbuilder.endObject() + sbt.internal.bsp.JvmTestEnvironmentParams(targets, originId) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JvmTestEnvironmentParams, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("targets", obj.targets) + builder.addField("originId", obj.originId) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentResultFormats.scala new file mode 100644 index 000000000..cd9c9d297 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JvmTestEnvironmentResultFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JvmTestEnvironmentResultFormats { self: sbt.internal.bsp.codec.JvmEnvironmentItemFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JvmTestEnvironmentResultFormat: JsonFormat[sbt.internal.bsp.JvmTestEnvironmentResult] = new JsonFormat[sbt.internal.bsp.JvmTestEnvironmentResult] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JvmTestEnvironmentResult = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val items = unbuilder.readField[Vector[sbt.internal.bsp.JvmEnvironmentItem]]("items") + val originId = unbuilder.readField[Option[String]]("originId") + unbuilder.endObject() + sbt.internal.bsp.JvmTestEnvironmentResult(items, originId) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JvmTestEnvironmentResult, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("items", obj.items) + builder.addField("originId", obj.originId) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband/bsp.contra b/protocol/src/main/contraband/bsp.contra index 62438cff0..bc20a52e9 100644 --- a/protocol/src/main/contraband/bsp.contra +++ b/protocol/src/main/contraband/bsp.contra @@ -696,3 +696,34 @@ type ResourcesItem { ## List of resource files. resources: [java.net.URI] } + + +# JVM Environment requests + +type JvmEnvironmentItem { + target: sbt.internal.bsp.BuildTargetIdentifier! + classpath: [java.net.URI]! + jvmOptions: [String]! + workingDirectory: String! + environmentVariables: StringStringMap! +} + +type JvmTestEnvironmentParams { + targets: [sbt.internal.bsp.BuildTargetIdentifier]! + originId: String +} + +type JvmTestEnvironmentResult{ + items: [sbt.internal.bsp.JvmEnvironmentItem]! + originId: String +} + +type JvmRunEnvironmentParams { + targets: [sbt.internal.bsp.BuildTargetIdentifier]! + originId: String +} + +type JvmRunEnvironmentResult{ + items: [sbt.internal.bsp.JvmEnvironmentItem]! + originId: String +} \ No newline at end of file From ad4113caebc7e8486443d0e06ea10be2c80faba6 Mon Sep 17 00:00:00 2001 From: Kamil Podsiadlo Date: Thu, 31 Mar 2022 23:26:41 +0200 Subject: [PATCH 2/4] feat: implement BSP's JVM environment requests --- main/src/main/scala/sbt/Keys.scala | 6 ++ .../internal/server/BuildServerProtocol.scala | 67 +++++++++++++++++++ 2 files changed, 73 insertions(+) diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index a4fee0b85..68332cd13 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -398,6 +398,7 @@ object Keys { val usePipelining = settingKey[Boolean]("Use subproject pipelining for compilation.").withRank(BSetting) val exportPipelining = settingKey[Boolean]("Product early output so downstream subprojects can do pipelining.").withRank(BSetting) + // BSP keys val bspConfig = taskKey[Unit]("Create or update the BSP connection files").withRank(DSetting) val bspEnabled = SettingKey[Boolean](BasicKeys.bspEnabled) val bspSbtEnabled = settingKey[Boolean]("Should BSP export meta-targets for the SBT build itself?") @@ -420,6 +421,11 @@ object Keys { val bspBuildTargetCleanCache = inputKey[Unit]("Corresponds to buildTarget/cleanCache request").withRank(DTask) val bspBuildTargetScalacOptions = inputKey[Unit]("").withRank(DTask) val bspBuildTargetScalacOptionsItem = taskKey[ScalacOptionsItem]("").withRank(DTask) + + val bspBuildTargetJVMRunEnvironment = inputKey[Unit]("Corresponds to the buildTarget/jvmRunEnvironment request").withRank(DTask) + val bspBuildTargetJVMTestEnvironment = inputKey[Unit]("Corresponds to the buildTarget/jvmTestEnvironment request").withRank(DTask) + val bspBuildTargetJvmEnvironmentItem = taskKey[JvmEnvironmentItem]("Computes JVM environment item").withRank(DTask) + val bspScalaTestClasses = inputKey[Unit]("Corresponds to buildTarget/scalaTestClasses request").withRank(DTask) val bspScalaTestClassesItem = taskKey[Seq[ScalaTestClassesItem]]("").withRank(DTask) val bspScalaMainClasses = inputKey[Unit]("Corresponds to buildTarget/scalaMainClasses request").withRank(DTask) diff --git a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala index 1cfae2054..78ffa74f5 100644 --- a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala +++ b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala @@ -315,6 +315,31 @@ object BuildServerProtocol { bspBuildTargetCompileItem := bspCompileTask.value, bspBuildTargetRun := bspRunTask.evaluated, bspBuildTargetScalacOptionsItem := scalacOptionsTask.value, + bspBuildTargetJVMRunEnvironment := Def.inputTaskDyn { + val s = state.value + val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) + val workspace = bspFullWorkspace.value.filter(targets) + val filter = ScopeFilter.in(workspace.scopes.values.toList) + Def.task { + val items = bspBuildTargetJvmEnvironmentItem.result.all(filter).value + val successfulItems = anyOrThrow(items) + val result = JvmRunEnvironmentResult(successfulItems.toVector, None) + s.respondEvent(result) + } + }.evaluated, + bspBuildTargetJVMTestEnvironment := Def.inputTaskDyn { + val s = state.value + val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) + val workspace = bspFullWorkspace.value.filter(targets) + val filter = ScopeFilter.in(workspace.scopes.values.toList) + Def.task { + val items = bspBuildTargetJvmEnvironmentItem.result.all(filter).value + val successfulItems = anyOrThrow(items) + val result = JvmTestEnvironmentResult(successfulItems.toVector, None) + s.respondEvent(result) + } + }.evaluated, + bspBuildTargetJvmEnvironmentItem := jvmEnvironmentItem().value, bspInternalDependencyConfigurations := internalDependencyConfigurationsSetting.value, bspScalaTestClassesItem := scalaTestClassesTask.value, bspScalaMainClassesItem := scalaMainClassesTask.value, @@ -344,6 +369,8 @@ object BuildServerProtocol { final val Run = "buildTarget/run" final val CleanCache = "buildTarget/cleanCache" final val ScalacOptions = "buildTarget/scalacOptions" + final val JvmRunEnvironment = "buildTarget/jvmRunEnvironment" + final val JvmTestEnvironment = "buildTarget/jvmTestEnvironment" final val ScalaTestClasses = "buildTarget/scalaTestClasses" final val ScalaMainClasses = "buildTarget/scalaMainClasses" final val Exit = "build/exit" @@ -443,6 +470,18 @@ object BuildServerProtocol { val command = Keys.bspBuildTargetScalacOptions.key val _ = callback.appendExec(s"$command $targets", Some(r.id)) + case r if r.method == Method.JvmRunEnvironment => + val param = Converter.fromJson[JvmRunEnvironmentParams](json(r)).get + val targets = param.targets.map(_.uri).mkString(" ") + val command = Keys.bspBuildTargetJVMRunEnvironment.key + val _ = callback.appendExec(s"$command $targets", Some(r.id)) + + case r if r.method == Method.JvmTestEnvironment => + val param = Converter.fromJson[JvmTestEnvironmentParams](json(r)).get + val targets = param.targets.map(_.uri).mkString(" ") + val command = Keys.bspBuildTargetJVMTestEnvironment.key + val _ = callback.appendExec(s"$command $targets", Some(r.id)) + case r if r.method == Method.ScalaTestClasses => val param = Converter.fromJson[ScalaTestClassesParams](json(r)).get val targets = param.targets.map(_.uri).mkString(" ") @@ -648,6 +687,33 @@ object BuildServerProtocol { ) } + private def jvmEnvironmentItem(): Initialize[Task[JvmEnvironmentItem]] = Def.taskDyn { + val target = Keys.bspTargetIdentifier.value + val baseDir = Keys.baseDirectory.value.toURI().toString() + val jvmOptions = Keys.javaOptions.value.toVector + val env = envVars.value + val externalDependencyClasspath = Keys.externalDependencyClasspath.value + + val internalDependencyClasspath = for { + (ref, configs) <- bspInternalDependencyConfigurations.value + config <- configs + } yield ref / config / Keys.classDirectory + + Def.task { + val classpath = + internalDependencyClasspath.join.value.distinct ++ + externalDependencyClasspath.map(_.data) + + JvmEnvironmentItem( + target, + classpath.map(_.toURI).toVector, + jvmOptions, + baseDir, + env + ) + } + } + private def scalacOptionsTask: Def.Initialize[Task[ScalacOptionsItem]] = Def.taskDyn { val target = Keys.bspTargetIdentifier.value val scalacOptions = Keys.scalacOptions.value @@ -878,6 +944,7 @@ object BuildServerProtocol { } } + // here private def scalaMainClassesTask: Initialize[Task[ScalaMainClassesItem]] = Def.task { val jvmOptions = Keys.javaOptions.value.toVector val mainClasses = Keys.discoveredMainClasses.value.map( From 6eb911ad15aa3c21d633fd2be079baaf78e57069 Mon Sep 17 00:00:00 2001 From: Kamil Podsiadlo Date: Tue, 5 Apr 2022 12:20:40 +0200 Subject: [PATCH 3/4] refactor: simplify JVm environment requests refactor: extract common logic to the `bspInputTask` --- .../internal/server/BuildServerProtocol.scala | 146 +++++++----------- 1 file changed, 54 insertions(+), 92 deletions(-) diff --git a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala index 78ffa74f5..2c7989ce2 100644 --- a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala +++ b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala @@ -119,11 +119,7 @@ object BuildServerProtocol { } }.value, // https://github.com/build-server-protocol/build-server-protocol/blob/master/docs/specification.md#build-target-sources-request - bspBuildTargetSources := Def.inputTaskDyn { - val s = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspBuildTargetSources := bspInputTask { (state, _, workspace, filter) => // run the worker task concurrently Def.task { val items = bspBuildTargetSourcesItem.result.all(filter).value @@ -147,64 +143,48 @@ object BuildServerProtocol { } val successfulItems = anyOrThrow(items ++ buildItems) val result = SourcesResult(successfulItems.toVector) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, bspBuildTargetSources / aggregate := false, - bspBuildTargetResources := Def.inputTaskDyn { - val s = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - workspace.warnIfBuildsNonEmpty(Method.Resources, s.log) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspBuildTargetResources := bspInputTask { (state, _, workspace, filter) => + workspace.warnIfBuildsNonEmpty(Method.Resources, state.log) // run the worker task concurrently Def.task { val items = bspBuildTargetResourcesItem.result.all(filter).value val successfulItems = anyOrThrow(items) val result = ResourcesResult(successfulItems.toVector) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, bspBuildTargetResources / aggregate := false, - bspBuildTargetDependencySources := Def.inputTaskDyn { - val s = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspBuildTargetDependencySources := bspInputTask { (state, _, workspace, filter) => // run the worker task concurrently Def.task { import sbt.internal.bsp.codec.JsonProtocol._ val items = bspBuildTargetDependencySourcesItem.result.all(filter).value val successfulItems = anyOrThrow(items) val result = DependencySourcesResult(successfulItems.toVector) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, bspBuildTargetDependencySources / aggregate := false, - bspBuildTargetCompile := Def.inputTaskDyn { - val s: State = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - workspace.warnIfBuildsNonEmpty(Method.Compile, s.log) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspBuildTargetCompile := bspInputTask { (state, _, workspace, filter) => + workspace.warnIfBuildsNonEmpty(Method.Compile, state.log) Def.task { val statusCodes = Keys.bspBuildTargetCompileItem.result.all(filter).value val aggregatedStatusCode = allOrThrow(statusCodes) match { case Seq() => StatusCode.Success case codes => codes.max } - s.respondEvent(BspCompileResult(None, aggregatedStatusCode)) + state.respondEvent(BspCompileResult(None, aggregatedStatusCode)) } }.evaluated, bspBuildTargetCompile / aggregate := false, bspBuildTargetTest := bspTestTask.evaluated, bspBuildTargetTest / aggregate := false, - bspBuildTargetCleanCache := Def.inputTaskDyn { - val s: State = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - workspace.warnIfBuildsNonEmpty(Method.CleanCache, s.log) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspBuildTargetCleanCache := bspInputTask { (state, targets, workspace, filter) => + workspace.warnIfBuildsNonEmpty(Method.CleanCache, state.log) Def.task { val results = Keys.clean.result.all(filter).value val successes = anyOrThrow(results).size @@ -214,18 +194,12 @@ object BuildServerProtocol { // checking that the executed results plus this entry is equal to the total number of targets. // When rebuilding a single module, the root build isn't sent, just the requested targets. val cleaned = successes + workspace.builds.size == targets.size - s.respondEvent(CleanCacheResult(None, cleaned)) + state.respondEvent(CleanCacheResult(None, cleaned)) } }.evaluated, bspBuildTargetCleanCache / aggregate := false, - bspBuildTargetScalacOptions := Def.inputTaskDyn { - val s = state.value - - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) + bspBuildTargetScalacOptions := bspInputTask { (state, _, workspace, filter) => val builds = workspace.builds - - val filter = ScopeFilter.in(workspace.scopes.values.toList) Def.task { val items = bspBuildTargetScalacOptionsItem.result.all(filter).value val appProvider = appConfiguration.value.provider() @@ -246,34 +220,26 @@ object BuildServerProtocol { } val successfulItems = anyOrThrow(items ++ buildItems) val result = ScalacOptionsResult(successfulItems.toVector) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, bspBuildTargetScalacOptions / aggregate := false, - bspScalaTestClasses := Def.inputTaskDyn { - val s = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - workspace.warnIfBuildsNonEmpty(Method.ScalaTestClasses, s.log) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspScalaTestClasses := bspInputTask { (state, _, workspace, filter) => + workspace.warnIfBuildsNonEmpty(Method.ScalaTestClasses, state.log) Def.task { val items = bspScalaTestClassesItem.result.all(filter).value val successfulItems = anyOrThrow(items).flatten.toVector val result = ScalaTestClassesResult(successfulItems.toVector, None) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, - bspScalaMainClasses := Def.inputTaskDyn { - val s = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - workspace.warnIfBuildsNonEmpty(Method.ScalaMainClasses, s.log) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspScalaMainClasses := bspInputTask { (state, _, workspace, filter) => + workspace.warnIfBuildsNonEmpty(Method.ScalaMainClasses, state.log) Def.task { val items = bspScalaMainClassesItem.result.all(filter).value val successfulItems = anyOrThrow(items) val result = ScalaMainClassesResult(successfulItems.toVector, None) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, bspScalaMainClasses / aggregate := false @@ -315,28 +281,20 @@ object BuildServerProtocol { bspBuildTargetCompileItem := bspCompileTask.value, bspBuildTargetRun := bspRunTask.evaluated, bspBuildTargetScalacOptionsItem := scalacOptionsTask.value, - bspBuildTargetJVMRunEnvironment := Def.inputTaskDyn { - val s = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspBuildTargetJVMRunEnvironment := bspInputTask { (state, _, _, filter) => Def.task { val items = bspBuildTargetJvmEnvironmentItem.result.all(filter).value val successfulItems = anyOrThrow(items) val result = JvmRunEnvironmentResult(successfulItems.toVector, None) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, - bspBuildTargetJVMTestEnvironment := Def.inputTaskDyn { - val s = state.value - val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) - val workspace = bspFullWorkspace.value.filter(targets) - val filter = ScopeFilter.in(workspace.scopes.values.toList) + bspBuildTargetJVMTestEnvironment := bspInputTask { (state, _, _, filter) => Def.task { val items = bspBuildTargetJvmEnvironmentItem.result.all(filter).value val successfulItems = anyOrThrow(items) val result = JvmTestEnvironmentResult(successfulItems.toVector, None) - s.respondEvent(result) + state.respondEvent(result) } }.evaluated, bspBuildTargetJvmEnvironmentItem := jvmEnvironmentItem().value, @@ -687,31 +645,36 @@ object BuildServerProtocol { ) } - private def jvmEnvironmentItem(): Initialize[Task[JvmEnvironmentItem]] = Def.taskDyn { - val target = Keys.bspTargetIdentifier.value - val baseDir = Keys.baseDirectory.value.toURI().toString() - val jvmOptions = Keys.javaOptions.value.toVector - val env = envVars.value - val externalDependencyClasspath = Keys.externalDependencyClasspath.value - - val internalDependencyClasspath = for { - (ref, configs) <- bspInternalDependencyConfigurations.value - config <- configs - } yield ref / config / Keys.classDirectory - - Def.task { - val classpath = - internalDependencyClasspath.join.value.distinct ++ - externalDependencyClasspath.map(_.data) - - JvmEnvironmentItem( - target, - classpath.map(_.toURI).toVector, - jvmOptions, - baseDir, - env - ) + private def bspInputTask[T]( + taskImpl: ( + State, + Seq[BuildTargetIdentifier], + BspFullWorkspace, + ScopeFilter + ) => Def.Initialize[Task[T]] + ): Def.Initialize[InputTask[T]] = + Def.inputTaskDyn { + val s = state.value + val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri))) + val workspace: BspFullWorkspace = bspFullWorkspace.value.filter(targets) + val filter = ScopeFilter.in(workspace.scopes.values.toList) + taskImpl(s, targets, workspace, filter) } + + private def jvmEnvironmentItem(): Initialize[Task[JvmEnvironmentItem]] = Def.task { + val target = Keys.bspTargetIdentifier.value + val classpath = Keys.fullClasspath.value.map(_.data.toURI).toVector + val jvmOptions = Keys.javaOptions.value.toVector + val baseDir = Keys.baseDirectory.value.toURI().toString() + val env = envVars.value + + JvmEnvironmentItem( + target, + classpath, + jvmOptions, + baseDir, + env + ) } private def scalacOptionsTask: Def.Initialize[Task[ScalacOptionsItem]] = Def.taskDyn { @@ -944,7 +907,6 @@ object BuildServerProtocol { } } - // here private def scalaMainClassesTask: Initialize[Task[ScalaMainClassesItem]] = Def.task { val jvmOptions = Keys.javaOptions.value.toVector val mainClasses = Keys.discoveredMainClasses.value.map( From f16412c3dd5df52cb53a6e3642894ce04673ded6 Mon Sep 17 00:00:00 2001 From: Kamil Podsiadlo Date: Tue, 5 Apr 2022 19:29:00 +0200 Subject: [PATCH 4/4] tests: run&test environment requests --- .../src/server-test/buildserver/build.sbt | 8 +++- .../test/scala/testpkg/BuildServerTest.scala | 45 ++++++++++++++++++- 2 files changed, 51 insertions(+), 2 deletions(-) diff --git a/server-test/src/server-test/buildserver/build.sbt b/server-test/src/server-test/buildserver/build.sbt index 52691a0a5..9d2de35fc 100644 --- a/server-test/src/server-test/buildserver/build.sbt +++ b/server-test/src/server-test/buildserver/build.sbt @@ -1,10 +1,16 @@ -ThisBuild / scalaVersion := "2.13.1" +ThisBuild / scalaVersion := "2.13.8" Global / serverLog / logLevel := Level.Debug lazy val runAndTest = project.in(file("run-and-test")) .settings( + libraryDependencies += "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-core" % "2.13.11", libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.8" % "test", + Compile / javaOptions := Vector("Xmx256M"), + Compile / envVars := Map("KEY" -> "VALUE"), + + Test / javaOptions := Vector("Xmx512M"), + Test / envVars := Map("KEY_TEST" -> "VALUE_TEST"), ) .dependsOn(util) diff --git a/server-test/src/test/scala/testpkg/BuildServerTest.scala b/server-test/src/test/scala/testpkg/BuildServerTest.scala index a6d900a16..817b0e6ad 100644 --- a/server-test/src/test/scala/testpkg/BuildServerTest.scala +++ b/server-test/src/test/scala/testpkg/BuildServerTest.scala @@ -157,7 +157,7 @@ object BuildServerTest extends AbstractServerTest { assert(processing("buildTarget/scalacOptions")) assert(svr.waitForString(10.seconds) { s => (s contains """"id":"40"""") && - (s contains "scala-library-2.13.1.jar") + (s contains "scala-library-2.13.8.jar") }) } @@ -311,6 +311,49 @@ object BuildServerTest extends AbstractServerTest { }) } + test("buildTarget/jvmRunEnvironment") { _ => + val buildTarget = buildTargetUri("runAndTest", "Compile") + svr.sendJsonRpc( + s"""|{ "jsonrpc": "2.0", + | "id": "97", + | "method": "buildTarget/jvmRunEnvironment", + | "params": { "targets": [{ "uri": "$buildTarget" }] } + |}""".stripMargin + ) + assert(processing("buildTarget/jvmRunEnvironment")) + assert { + svr.waitForString(10.seconds) { s => + (s contains """"id":"97"""") && + (s contains "jsoniter-scala-core_2.13-2.13.11.jar") && // compile dependency + (s contains "\"jvmOptions\":[\"Xmx256M\"]") && + (s contains "\"environmentVariables\":{\"KEY\":\"VALUE\"}") && + (s contains "/buildserver/run-and-test/") // working directory + } + } + } + + test("buildTarget/jvmTestEnvironment") { _ => + val buildTarget = buildTargetUri("runAndTest", "Test") + svr.sendJsonRpc( + s"""|{ "jsonrpc": "2.0", + | "id": "98", + | "method": "buildTarget/jvmTestEnvironment", + | "params": { "targets": [{ "uri": "$buildTarget" }] } + |}""".stripMargin + ) + assert(processing("buildTarget/jvmTestEnvironment")) + assert { + svr.waitForString(10.seconds) { s => + (s contains """"id":"98"""") && + // test depends on compile so it has dependencies from both + (s contains "jsoniter-scala-core_2.13-2.13.11.jar") && // compile dependency + (s contains "scalatest_2.13-3.0.8.jar") && // test dependency + (s contains "\"jvmOptions\":[\"Xmx512M\"]") && + (s contains "\"environmentVariables\":{\"KEY_TEST\":\"VALUE_TEST\"}") + } + } + } + test("buildTarget/scalaTestClasses") { _ => val buildTarget = buildTargetUri("runAndTest", "Test") val badBuildTarget = buildTargetUri("badBuildTarget", "Test")