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

Update contraband sources 

In 8bfae66b9d I upgraded contraband but
not all of the sources were regenerated because I didn't run clean
before recompiling.
This commit is contained in:
Ethan Atkins 2019-12-12 11:33:53 -08:00
parent cba7442618
commit aecdc44909
49 changed files with 196 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/LogOptionFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.util.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait LogOptionFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val LogOptionFormat: JsonFormat[sbt.internal.util.LogOption] = new JsonFormat[sbt.internal.util.LogOption] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.LogOption = {
jsOpt match {
case Some(js) =>
unbuilder.readString(js) match {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.LogOption = {
__jsOpt match {
case Some(__js) =>
unbuilder.readString(__js) match {
case "Always" => sbt.internal.util.LogOption.Always
case "Never" => sbt.internal.util.LogOption.Never
case "Auto" => sbt.internal.util.LogOption.Auto

8
internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.util.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ProgressEventFormats { self: sbt.internal.util.codec.ProgressItemFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val ProgressEventFormat: JsonFormat[sbt.internal.util.ProgressEvent] = new JsonFormat[sbt.internal.util.ProgressEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.ProgressEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.ProgressEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val level = unbuilder.readField[String]("level")
val items = unbuilder.readField[Vector[sbt.internal.util.ProgressItem]]("items")
val lastTaskCount = unbuilder.readField[Option[Int]]("lastTaskCount")

8
internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressItemFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.util.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ProgressItemFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ProgressItemFormat: JsonFormat[sbt.internal.util.ProgressItem] = new JsonFormat[sbt.internal.util.ProgressItem] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.ProgressItem = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.ProgressItem = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val name = unbuilder.readField[String]("name")
val elapsedMicros = unbuilder.readField[Long]("elapsedMicros")
unbuilder.endObject()

8
internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/StringEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.util.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait StringEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val StringEventFormat: JsonFormat[sbt.internal.util.StringEvent] = new JsonFormat[sbt.internal.util.StringEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.StringEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.StringEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val level = unbuilder.readField[String]("level")
val message = unbuilder.readField[String]("message")
val channelName = unbuilder.readField[Option[String]]("channelName")

8
internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/SuccessEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.util.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait SuccessEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val SuccessEventFormat: JsonFormat[sbt.internal.util.SuccessEvent] = new JsonFormat[sbt.internal.util.SuccessEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.SuccessEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.SuccessEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val message = unbuilder.readField[String]("message")
unbuilder.endObject()
sbt.internal.util.SuccessEvent(message)

8
internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/TraceEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.util.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TraceEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val TraceEventFormat: JsonFormat[sbt.internal.util.TraceEvent] = new JsonFormat[sbt.internal.util.TraceEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.TraceEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.TraceEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val level = unbuilder.readField[String]("level")
val message = unbuilder.readField[Throwable]("message")
val channelName = unbuilder.readField[Option[String]]("channelName")

8
main-command/src/main/contraband-scala/CommandSourceFormats.scala generated
View File

@ -6,10 +6,10 @@
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait CommandSourceFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val CommandSourceFormat: JsonFormat[sbt.CommandSource] = new JsonFormat[sbt.CommandSource] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.CommandSource = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.CommandSource = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val channelName = unbuilder.readField[String]("channelName")
unbuilder.endObject()
sbt.CommandSource(channelName)

8
main-command/src/main/contraband-scala/ConnectionTypeFormats.scala generated
View File

@ -6,10 +6,10 @@
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ConnectionTypeFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ConnectionTypeFormat: JsonFormat[sbt.ConnectionType] = new JsonFormat[sbt.ConnectionType] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.ConnectionType = {
jsOpt match {
case Some(js) =>
unbuilder.readString(js) match {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.ConnectionType = {
__jsOpt match {
case Some(__js) =>
unbuilder.readString(__js) match {
case "Local" => sbt.ConnectionType.Local
case "Tcp" => sbt.ConnectionType.Tcp
}

8
main-command/src/main/contraband-scala/ExecFormats.scala generated
View File

@ -6,10 +6,10 @@
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ExecFormats { self: CommandSourceFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val ExecFormat: JsonFormat[sbt.Exec] = new JsonFormat[sbt.Exec] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.Exec = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.Exec = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val commandLine = unbuilder.readField[String]("commandLine")
val execId = unbuilder.readField[Option[String]]("execId")
val source = unbuilder.readField[Option[sbt.CommandSource]]("source")

8
main-command/src/main/contraband-scala/ServerAuthenticationFormats.scala generated
View File

@ -6,10 +6,10 @@
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ServerAuthenticationFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ServerAuthenticationFormat: JsonFormat[sbt.ServerAuthentication] = new JsonFormat[sbt.ServerAuthentication] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.ServerAuthentication = {
jsOpt match {
case Some(js) =>
unbuilder.readString(js) match {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.ServerAuthentication = {
__jsOpt match {
case Some(__js) =>
unbuilder.readString(__js) match {
case "Token" => sbt.ServerAuthentication.Token
}
case None =>

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/CancelRequestParamsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait CancelRequestParamsFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val CancelRequestParamsFormat: JsonFormat[sbt.internal.langserver.CancelRequestParams] = new JsonFormat[sbt.internal.langserver.CancelRequestParams] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.CancelRequestParams = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.CancelRequestParams = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val id = unbuilder.readField[String]("id")
unbuilder.endObject()
sbt.internal.langserver.CancelRequestParams(id)

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ClientCapabilitiesFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ClientCapabilitiesFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ClientCapabilitiesFormat: JsonFormat[sbt.internal.langserver.ClientCapabilities] = new JsonFormat[sbt.internal.langserver.ClientCapabilities] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.ClientCapabilities = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.ClientCapabilities = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
unbuilder.endObject()
sbt.internal.langserver.ClientCapabilities()

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/DiagnosticFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait DiagnosticFormats { self: sbt.internal.langserver.codec.RangeFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val DiagnosticFormat: JsonFormat[sbt.internal.langserver.Diagnostic] = new JsonFormat[sbt.internal.langserver.Diagnostic] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Diagnostic = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Diagnostic = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val range = unbuilder.readField[sbt.internal.langserver.Range]("range")
val severity = unbuilder.readField[Option[Long]]("severity")
val code = unbuilder.readField[Option[String]]("code")

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeParamsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait InitializeParamsFormats { self: sbt.internal.util.codec.JValueFormats with sbt.internal.langserver.codec.ClientCapabilitiesFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val InitializeParamsFormat: JsonFormat[sbt.internal.langserver.InitializeParams] = new JsonFormat[sbt.internal.langserver.InitializeParams] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.InitializeParams = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.InitializeParams = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val processId = unbuilder.readField[Option[Long]]("processId")
val rootPath = unbuilder.readField[Option[String]]("rootPath")
val rootUri = unbuilder.readField[Option[String]]("rootUri")

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeResultFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait InitializeResultFormats { self: sbt.internal.langserver.codec.ServerCapabilitiesFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val InitializeResultFormat: JsonFormat[sbt.internal.langserver.InitializeResult] = new JsonFormat[sbt.internal.langserver.InitializeResult] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.InitializeResult = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.InitializeResult = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val capabilities = unbuilder.readField[sbt.internal.langserver.ServerCapabilities]("capabilities")
unbuilder.endObject()
sbt.internal.langserver.InitializeResult(capabilities)

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LocationFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait LocationFormats { self: sbt.internal.langserver.codec.RangeFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val LocationFormat: JsonFormat[sbt.internal.langserver.Location] = new JsonFormat[sbt.internal.langserver.Location] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Location = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Location = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val uri = unbuilder.readField[String]("uri")
val range = unbuilder.readField[sbt.internal.langserver.Range]("range")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LogMessageParamsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait LogMessageParamsFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val LogMessageParamsFormat: JsonFormat[sbt.internal.langserver.LogMessageParams] = new JsonFormat[sbt.internal.langserver.LogMessageParams] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.LogMessageParams = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.LogMessageParams = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val `type` = unbuilder.readField[Long]("type")
val message = unbuilder.readField[String]("message")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PositionFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val PositionFormat: JsonFormat[sbt.internal.langserver.Position] = new JsonFormat[sbt.internal.langserver.Position] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Position = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Position = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val line = unbuilder.readField[Long]("line")
val character = unbuilder.readField[Long]("character")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PublishDiagnosticsParamsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait PublishDiagnosticsParamsFormats { self: sbt.internal.langserver.codec.DiagnosticFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val PublishDiagnosticsParamsFormat: JsonFormat[sbt.internal.langserver.PublishDiagnosticsParams] = new JsonFormat[sbt.internal.langserver.PublishDiagnosticsParams] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.PublishDiagnosticsParams = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.PublishDiagnosticsParams = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val uri = unbuilder.readField[String]("uri")
val diagnostics = unbuilder.readField[Vector[sbt.internal.langserver.Diagnostic]]("diagnostics")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/RangeFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait RangeFormats { self: sbt.internal.langserver.codec.PositionFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val RangeFormat: JsonFormat[sbt.internal.langserver.Range] = new JsonFormat[sbt.internal.langserver.Range] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Range = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Range = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val start = unbuilder.readField[sbt.internal.langserver.Position]("start")
val end = unbuilder.readField[sbt.internal.langserver.Position]("end")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SaveOptionsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait SaveOptionsFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val SaveOptionsFormat: JsonFormat[sbt.internal.langserver.SaveOptions] = new JsonFormat[sbt.internal.langserver.SaveOptions] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.SaveOptions = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.SaveOptions = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val includeText = unbuilder.readField[Option[Boolean]]("includeText")
unbuilder.endObject()
sbt.internal.langserver.SaveOptions(includeText)

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SbtExecParamsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait SbtExecParamsFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val SbtExecParamsFormat: JsonFormat[sbt.internal.langserver.SbtExecParams] = new JsonFormat[sbt.internal.langserver.SbtExecParams] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.SbtExecParams = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.SbtExecParams = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val commandLine = unbuilder.readField[String]("commandLine")
unbuilder.endObject()
sbt.internal.langserver.SbtExecParams(commandLine)

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ServerCapabilitiesFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ServerCapabilitiesFormats { self: sbt.internal.langserver.codec.TextDocumentSyncOptionsFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val ServerCapabilitiesFormat: JsonFormat[sbt.internal.langserver.ServerCapabilities] = new JsonFormat[sbt.internal.langserver.ServerCapabilities] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.ServerCapabilities = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.ServerCapabilities = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val textDocumentSync = unbuilder.readField[Option[sbt.internal.langserver.TextDocumentSyncOptions]]("textDocumentSync")
val hoverProvider = unbuilder.readField[Option[Boolean]]("hoverProvider")
val definitionProvider = unbuilder.readField[Option[Boolean]]("definitionProvider")

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentIdentifierFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TextDocumentIdentifierFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val TextDocumentIdentifierFormat: JsonFormat[sbt.internal.langserver.TextDocumentIdentifier] = new JsonFormat[sbt.internal.langserver.TextDocumentIdentifier] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentIdentifier = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentIdentifier = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val uri = unbuilder.readField[String]("uri")
unbuilder.endObject()
sbt.internal.langserver.TextDocumentIdentifier(uri)

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentPositionParamsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TextDocumentPositionParamsFormats { self: sbt.internal.langserver.codec.TextDocumentIdentifierFormats with sbt.internal.langserver.codec.PositionFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val TextDocumentPositionParamsFormat: JsonFormat[sbt.internal.langserver.TextDocumentPositionParams] = new JsonFormat[sbt.internal.langserver.TextDocumentPositionParams] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentPositionParams = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentPositionParams = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val textDocument = unbuilder.readField[sbt.internal.langserver.TextDocumentIdentifier]("textDocument")
val position = unbuilder.readField[sbt.internal.langserver.Position]("position")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentSyncOptionsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.langserver.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TextDocumentSyncOptionsFormats { self: sbt.internal.langserver.codec.SaveOptionsFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val TextDocumentSyncOptionsFormat: JsonFormat[sbt.internal.langserver.TextDocumentSyncOptions] = new JsonFormat[sbt.internal.langserver.TextDocumentSyncOptions] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentSyncOptions = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentSyncOptions = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val openClose = unbuilder.readField[Option[Boolean]]("openClose")
val change = unbuilder.readField[Option[Long]]("change")
val willSave = unbuilder.readField[Option[Boolean]]("willSave")

8
protocol/src/main/contraband-scala/sbt/internal/protocol/codec/InitializeOptionFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait InitializeOptionFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val InitializeOptionFormat: JsonFormat[sbt.internal.protocol.InitializeOption] = new JsonFormat[sbt.internal.protocol.InitializeOption] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.InitializeOption = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.InitializeOption = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val token = unbuilder.readField[Option[String]]("token")
unbuilder.endObject()
sbt.internal.protocol.InitializeOption(token)

8
protocol/src/main/contraband-scala/sbt/internal/protocol/codec/PortFileFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait PortFileFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val PortFileFormat: JsonFormat[sbt.internal.protocol.PortFile] = new JsonFormat[sbt.internal.protocol.PortFile] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.PortFile = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.PortFile = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val uri = unbuilder.readField[String]("uri")
val tokenfilePath = unbuilder.readField[Option[String]]("tokenfilePath")
val tokenfileUri = unbuilder.readField[Option[String]]("tokenfileUri")

8
protocol/src/main/contraband-scala/sbt/internal/protocol/codec/TokenFileFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.internal.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TokenFileFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val TokenFileFormat: JsonFormat[sbt.internal.protocol.TokenFile] = new JsonFormat[sbt.internal.protocol.TokenFile] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.TokenFile = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.TokenFile = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val uri = unbuilder.readField[String]("uri")
val token = unbuilder.readField[String]("token")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/protocol/codec/ChannelAcceptedEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ChannelAcceptedEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ChannelAcceptedEventFormat: JsonFormat[sbt.protocol.ChannelAcceptedEvent] = new JsonFormat[sbt.protocol.ChannelAcceptedEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ChannelAcceptedEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ChannelAcceptedEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val channelName = unbuilder.readField[String]("channelName")
unbuilder.endObject()
sbt.protocol.ChannelAcceptedEvent(channelName)

8
protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionParamsFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait CompletionParamsFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val CompletionParamsFormat: JsonFormat[sbt.protocol.CompletionParams] = new JsonFormat[sbt.protocol.CompletionParams] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.CompletionParams = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.CompletionParams = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val query = unbuilder.readField[String]("query")
unbuilder.endObject()
sbt.protocol.CompletionParams(query)

8
protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionResponseFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait CompletionResponseFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val CompletionResponseFormat: JsonFormat[sbt.protocol.CompletionResponse] = new JsonFormat[sbt.protocol.CompletionResponse] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.CompletionResponse = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.CompletionResponse = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val items = unbuilder.readField[Vector[String]]("items")
unbuilder.endObject()
sbt.protocol.CompletionResponse(items)

8
protocol/src/main/contraband-scala/sbt/protocol/codec/ExecCommandFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ExecCommandFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ExecCommandFormat: JsonFormat[sbt.protocol.ExecCommand] = new JsonFormat[sbt.protocol.ExecCommand] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecCommand = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecCommand = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val commandLine = unbuilder.readField[String]("commandLine")
val execId = unbuilder.readField[Option[String]]("execId")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/protocol/codec/ExecStatusEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ExecStatusEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ExecStatusEventFormat: JsonFormat[sbt.protocol.ExecStatusEvent] = new JsonFormat[sbt.protocol.ExecStatusEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecStatusEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecStatusEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val status = unbuilder.readField[String]("status")
val channelName = unbuilder.readField[Option[String]]("channelName")
val execId = unbuilder.readField[Option[String]]("execId")

8
protocol/src/main/contraband-scala/sbt/protocol/codec/ExecutionEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ExecutionEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val ExecutionEventFormat: JsonFormat[sbt.protocol.ExecutionEvent] = new JsonFormat[sbt.protocol.ExecutionEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecutionEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecutionEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val success = unbuilder.readField[String]("success")
val commandLine = unbuilder.readField[String]("commandLine")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/protocol/codec/InitCommandFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait InitCommandFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val InitCommandFormat: JsonFormat[sbt.protocol.InitCommand] = new JsonFormat[sbt.protocol.InitCommand] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.InitCommand = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.InitCommand = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val token = unbuilder.readField[Option[String]]("token")
val execId = unbuilder.readField[Option[String]]("execId")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/protocol/codec/LogEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait LogEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val LogEventFormat: JsonFormat[sbt.protocol.LogEvent] = new JsonFormat[sbt.protocol.LogEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.LogEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.LogEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val level = unbuilder.readField[String]("level")
val message = unbuilder.readField[String]("message")
unbuilder.endObject()

8
protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFailureFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait SettingQueryFailureFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val SettingQueryFailureFormat: JsonFormat[sbt.protocol.SettingQueryFailure] = new JsonFormat[sbt.protocol.SettingQueryFailure] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQueryFailure = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQueryFailure = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val message = unbuilder.readField[String]("message")
unbuilder.endObject()
sbt.protocol.SettingQueryFailure(message)

8
protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait SettingQueryFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val SettingQueryFormat: JsonFormat[sbt.protocol.SettingQuery] = new JsonFormat[sbt.protocol.SettingQuery] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQuery = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQuery = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val setting = unbuilder.readField[String]("setting")
unbuilder.endObject()
sbt.protocol.SettingQuery(setting)

8
protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQuerySuccessFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait SettingQuerySuccessFormats { self: sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val SettingQuerySuccessFormat: JsonFormat[sbt.protocol.SettingQuerySuccess] = new JsonFormat[sbt.protocol.SettingQuerySuccess] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQuerySuccess = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQuerySuccess = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val value = unbuilder.readField[sjsonnew.shaded.scalajson.ast.unsafe.JValue]("value")
val contentType = unbuilder.readField[String]("contentType")
unbuilder.endObject()

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupErrorEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait EndTestGroupErrorEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val EndTestGroupErrorEventFormat: JsonFormat[sbt.protocol.testing.EndTestGroupErrorEvent] = new JsonFormat[sbt.protocol.testing.EndTestGroupErrorEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.EndTestGroupErrorEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.EndTestGroupErrorEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val name = unbuilder.readField[String]("name")
val error = unbuilder.readField[String]("error")
unbuilder.endObject()

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait EndTestGroupEventFormats { self: sbt.protocol.testing.codec.TestResultFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val EndTestGroupEventFormat: JsonFormat[sbt.protocol.testing.EndTestGroupEvent] = new JsonFormat[sbt.protocol.testing.EndTestGroupEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.EndTestGroupEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.EndTestGroupEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val name = unbuilder.readField[String]("name")
val result = unbuilder.readField[sbt.protocol.testing.TestResult]("result")
unbuilder.endObject()

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/StartTestGroupEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait StartTestGroupEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val StartTestGroupEventFormat: JsonFormat[sbt.protocol.testing.StartTestGroupEvent] = new JsonFormat[sbt.protocol.testing.StartTestGroupEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.StartTestGroupEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.StartTestGroupEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val name = unbuilder.readField[String]("name")
unbuilder.endObject()
sbt.protocol.testing.StartTestGroupEvent(name)

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestCompleteEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TestCompleteEventFormats { self: sbt.protocol.testing.codec.TestResultFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val TestCompleteEventFormat: JsonFormat[sbt.protocol.testing.TestCompleteEvent] = new JsonFormat[sbt.protocol.testing.TestCompleteEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestCompleteEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestCompleteEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val result = unbuilder.readField[sbt.protocol.testing.TestResult]("result")
unbuilder.endObject()
sbt.protocol.testing.TestCompleteEvent(result)

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestInitEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TestInitEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val TestInitEventFormat: JsonFormat[sbt.protocol.testing.TestInitEvent] = new JsonFormat[sbt.protocol.testing.TestInitEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestInitEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestInitEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
unbuilder.endObject()
sbt.protocol.testing.TestInitEvent()

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemDetailFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TestItemDetailFormats { self: sbt.internal.testing.StatusFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val TestItemDetailFormat: JsonFormat[sbt.protocol.testing.TestItemDetail] = new JsonFormat[sbt.protocol.testing.TestItemDetail] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestItemDetail = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestItemDetail = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val fullyQualifiedName = unbuilder.readField[String]("fullyQualifiedName")
val status = unbuilder.readField[sbt.testing.Status]("status")
val duration = unbuilder.readField[Option[Long]]("duration")

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TestItemEventFormats { self: sbt.protocol.testing.codec.TestResultFormats with sbt.protocol.testing.codec.TestItemDetailFormats with sjsonnew.BasicJsonProtocol =>
implicit lazy val TestItemEventFormat: JsonFormat[sbt.protocol.testing.TestItemEvent] = new JsonFormat[sbt.protocol.testing.TestItemEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestItemEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestItemEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val result = unbuilder.readField[Option[sbt.protocol.testing.TestResult]]("result")
val detail = unbuilder.readField[Vector[sbt.protocol.testing.TestItemDetail]]("detail")
unbuilder.endObject()

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestResultFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TestResultFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val TestResultFormat: JsonFormat[sbt.protocol.testing.TestResult] = new JsonFormat[sbt.protocol.testing.TestResult] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestResult = {
jsOpt match {
case Some(js) =>
unbuilder.readString(js) match {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestResult = {
__jsOpt match {
case Some(__js) =>
unbuilder.readString(__js) match {
case "Passed" => sbt.protocol.testing.TestResult.Passed
case "Failed" => sbt.protocol.testing.TestResult.Failed
case "Error" => sbt.protocol.testing.TestResult.Error

8
testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestStringEventFormats.scala generated
View File

@ -7,10 +7,10 @@ package sbt.protocol.testing.codec
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait TestStringEventFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val TestStringEventFormat: JsonFormat[sbt.protocol.testing.TestStringEvent] = new JsonFormat[sbt.protocol.testing.TestStringEvent] {
override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestStringEvent = {
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestStringEvent = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val value = unbuilder.readField[String]("value")
unbuilder.endObject()
sbt.protocol.testing.TestStringEvent(value)