Remove JSON, already provided by Jackson

3 files changed, 1 insertions, 134 deletions

diff --git a/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala b/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala
index ba7edb4b6..b675cabb6 100644
--- a/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala
@@ -6,7 +6,6 @@ import core.ContextDottydoc
 import dotc.core.Contexts._
 import dotc.{ Compiler, Driver }
 import model.Package
-import model.json._
 import dotc.config._
 import dotc.core.Comments.ContextDoc
 import staticsite.Site
@@ -40,29 +39,15 @@ class DocDriver extends Driver {
     ctx.docbase.packages
   }
 
-  def compiledDocsJava(args: Array[String]): JMap[String, Package] = {
-    scala.collection.JavaConverters.mapAsJavaMapConverter(compiledDocs(args)).asJava
-  }
-
-  def indexToJson(index: collection.Map[String, Package]): String =
-    index.json
-
-  def indexToJsonJava(index: JMap[String, Package]): String = {
-    import scala.collection.JavaConverters._
-    indexToJson(index.asScala)
-  }
-
   override def main(args: Array[String]): Unit = {
     implicit val (filesToDocument, ctx) = setup(args, initCtx.fresh)
     val reporter = doCompile(newCompiler(ctx), filesToDocument)(ctx)
-
-    val docs = ctx.docbase.packages
     val siteRoot = new java.io.File(ctx.settings.siteRoot.value)
 
     if (!siteRoot.exists || !siteRoot.isDirectory)
       ctx.error(s"Site root does not exist: $siteRoot")
     else {
-      Site(siteRoot, ctx.settings.projectName.value, docs)
+      Site(siteRoot, ctx.settings.projectName.value, ctx.docbase.packages)
         .generateApiDocs()
         .copyStaticFiles()
         .generateHtmlFiles()
diff --git a/doc-tool/src/dotty/tools/dottydoc/model/json.scala b/doc-tool/src/dotty/tools/dottydoc/model/json.scala
deleted file mode 100644
index 766f0c147..000000000
--- a/doc-tool/src/dotty/tools/dottydoc/model/json.scala
+++ /dev/null
@@ -1,94 +0,0 @@
-package dotty.tools.dottydoc
-package model
-
-import comment._
-import references._
-
-/** This object provides a protocol for serializing the package AST to JSON
- *
- *  TODO: It might be a good ideat to represent the JSON better than just
- *  serializing a big string-blob in the future.
- */
-object json {
-  implicit class JsonString(val str: String) extends AnyVal {
-    def json: String = {
-      val cleanedString = str
-        .replaceAll("\\\\","\\\\\\\\")
-        .replaceAll("\\\"", "\\\\\"")
-        .replaceAll("\n", "\\\\n")
-
-      s""""$cleanedString""""
-    }
-  }
-
-  implicit class JsonBoolean(val boo: Boolean) extends AnyVal {
-    def json: String = if (boo) "true" else "false"
-  }
-
-  implicit class JsonComment(val cmt: Comment) extends AnyVal {
-    def json: String =
-      s"""{"body":${cmt.body.json},"short":${cmt.short.json},"authors":${cmt.authors.map(_.json).mkString("[",",","]")},"see":${cmt.see.map(_.json).mkString("[",",","]")},${cmt.result.map(res => s""""result":${res.json},""").getOrElse("")}"throws":${cmt.throws.map { case (k, v) => s"${k.json}:${v.json}" }.mkString("{",",","}")},"valueParams":${cmt.valueParams.map { case (k, v) => s"${k.json}:${v.json}"}.mkString("{",",","}")},"typeParams":${cmt.typeParams.map { case (k, v) => s"${k.json}:${v.json}"}.mkString("{",",","}")},${cmt.version.map(x => s""""version":${x.json},""").getOrElse("")}${cmt.since.map(x => s""""since":${x.json},""").getOrElse("")}"todo":${cmt.todo.map(_.json).mkString("[",",","]")},${cmt.deprecated.map(x => s""""deprecated":${x.json},""").getOrElse("")}"note":${cmt.note.map(_.json).mkString("[",",","]")},"example":${cmt.example.map(_.json).mkString("[",",","]")},${cmt.constructor.map(x => s""""constructor":${x.json},""").getOrElse("")}${cmt.group.map(x => s""""group":${x.json},""").getOrElse("")}"groupDesc":${cmt.groupDesc.map { case (k, v) => s"${k.json}:${v.json}"}.mkString("{",",","}")},"groupNames":${cmt.groupNames.map { case (k, v) => s"${k.json}:${v.json}"}.mkString("{",",","}")},"groupPrio":${cmt.groupPrio.map { case (k, v) => s"${k.json}:${v.json}"}.mkString("{",",","}")},"hideImplicitConversions":${cmt.hideImplicitConversions.map(_.json).mkString("[",",","]")}}"""
-  }
-
-  implicit class LinkJson(val link: MaterializableLink) extends AnyVal {
-    def json: String = {
-      val (secondTitle, secondValue, kind) = link match {
-        case ul: UnsetLink => ("query".json, ul.query.json, "UnsetLink".json)
-        case ml: MaterializedLink => ("target".json, ml.target.json, "MaterializedLink".json)
-        case nl: NoLink => ("target".json, nl.target.json, "NoLink".json)
-      }
-      s"""{"title":${link.title.json},$secondTitle:${secondValue},"kind":$kind}"""
-    }
-  }
-
-  implicit class ParamListJson(val plist: ParamList) extends AnyVal {
-    def json: String =
-      s"""{"list":${plist.list.map(_.json).mkString("[",",","]")},"isImplicit":${plist.isImplicit.json}}"""
-  }
-
-  private def refToJson(ref: Reference): String = ref match {
-    case ref: TypeReference =>
-      s"""{"title":${ref.title.json},"tpeLink":${ref.tpeLink.json},"paramLinks":${ref.paramLinks.map(_.json).mkString("[",",","]")},"kind":"TypeReference"}"""
-    case ref: AndTypeReference =>
-      s"""{"left":${refToJson(ref.left)},"right":${refToJson(ref.right)},"kind":"AndTypeReference"}"""
-    case ref: OrTypeReference =>
-      s"""{"left":${refToJson(ref.left)},"right":${refToJson(ref.right)},"kind":"OrTypeReference"}"""
-    case ref: BoundsReference =>
-      s"""{"low":${refToJson(ref.low)},"high":${refToJson(ref.high)},"kind":"BoundsReference"}"""
-    case ref: NamedReference =>
-      s"""{"title":${ref.title.json},"ref":${refToJson(ref.ref)},"isByName":${ref.isByName.json},"isRepeated":${ref.isRepeated.json},"kind":"NamedReference"}"""
-    case ref: ConstantReference =>
-      s"""{"title":${ref.title.json},"kind": "ConstantReference"}"""
-    case ref: FunctionReference =>
-      s"""{"args":${ref.args.map(refToJson).mkString("[",",","]")},"returnValue":${refToJson(ref.returnValue)},"kind": "FunctionReference"}"""
-    case ref: TupleReference =>
-      s"""{"args":${ref.args.map(refToJson).mkString("[",",","]")},"kind": "TupleReference"}"""
-    case EmptyReference => ???
-  }
-  implicit class ReferenceJson(val ref: Reference) extends AnyVal { def json: String = refToJson(ref) }
-
-  private def entToJson(ent: Entity): String = ent match {
-    case ent: Package =>
-      s"""{"name":${ent.name.json},"members":${ent.members.map(_.json).mkString("[",",","]")},"path":${ent.path.map(_.json).mkString("[",",","]")},${ent.comment.map(_.json).fold("")(cmt => s""""comment":$cmt,""")}"kind":"package"}"""
-    case ent: Class =>
-      s"""{"name":${ent.name.json},"members":${ent.members.map(_.json).mkString("[",",","]")},"modifiers":${ent.modifiers.map(_.json).mkString("[",",","]")},"path":${ent.path.map(_.json).mkString("[",",","]")},"typeParams":${ent.typeParams.map(_.json).mkString("[",",","]")},"constructors":${ent.constructors.map(xs => xs.map(_.json).mkString("[",",","]")).mkString("[",",","]")},"superTypes":${ent.superTypes.map(_.json).mkString("[",",","]")},${ent.comment.map(_.json).fold("")(cmt => s""""comment":$cmt,""")}"kind":"class"}"""
-    case ent: CaseClass =>
-      s"""{"name":${ent.name.json},"members":${ent.members.map(_.json).mkString("[",",","]")},"modifiers":${ent.modifiers.map(_.json).mkString("[",",","]")},"path":${ent.path.map(_.json).mkString("[",",","]")},"typeParams":${ent.typeParams.map(_.json).mkString("[",",","]")},"constructors":${ent.constructors.map(xs => xs.map(_.json).mkString("[",",","]")).mkString("[",",","]")},"superTypes":${ent.superTypes.map(_.json).mkString("[",",","]")},${ent.comment.map(_.json).fold("")(cmt => s""""comment":$cmt,""")}"kind":"case class"}"""
-    case ent: Trait =>
-      s"""{"name":${ent.name.json},"members":${ent.members.map(_.json).mkString("[",",","]")},"modifiers":${ent.modifiers.map(_.json).mkString("[",",","]")},"path":${ent.path.map(_.json).mkString("[",",","]")},"typeParams":${ent.typeParams.map(_.json).mkString("[",",","]")},"traitParams":${ent.traitParams.map(_.json).mkString("[",",","]")},"superTypes":${ent.superTypes.map(_.json).mkString("[",",","]")},${ent.comment.map(_.json).fold("")(cmt => s""""comment":$cmt,""")}"kind":"trait"}"""
-    case ent: Object =>
-      s"""{"name":${ent.name.json},"members":${ent.members.map(_.json).mkString("[",",","]")},"modifiers":${ent.modifiers.map(_.json).mkString("[",",","]")},"path":${ent.path.map(_.json).mkString("[",",","]")},"superTypes":${ent.superTypes.map(_.json).mkString("[",",","]")},${ent.comment.map(_.json).fold("")(cmt => s""""comment":$cmt,""")}"kind":"object"}"""
-    case ent: Def =>
-      s"""{"name":${ent.name.json},"modifiers":${ent.modifiers.map(_.json).mkString("[",",","]")},"path":${ent.path.map(_.json).mkString("[",",","]")},"returnValue":${ent.returnValue.json},"typeParams":${ent.typeParams.map(_.json).mkString("[",",","]")},"paramLists":${ent.paramLists.map(_.json).mkString("[",",","]")},${ent.comment.map(_.json).fold("")(cmt => s""""comment":$cmt,""")}${ent.implicitlyAddedFrom.fold("")(ref => s""""implicitlyAddedFrom":${ref.json},""")}"kind":"def"}"""
-    case ent: Val =>
-      s"""{"name":${ent.name.json},"modifiers":${ent.modifiers.map(_.json).mkString("[",",","]")},"path":${ent.path.map(_.json).mkString("[",",","]")},"returnValue":${ent.returnValue.json},${ent.comment.map(_.json).fold("")(cmt => s""""comment":$cmt,""")}${ent.implicitlyAddedFrom.fold("")(ref => s""""implicitlyAddedFrom":${ref.json},""")}"kind":"val"}"""
-  }
-  implicit class EntityJson(val ent: Entity) extends AnyVal { def json: String = entToJson(ent) }
-  implicit class PackageJson(val pack: Package) extends AnyVal { def json: String = (pack: Entity).json }
-
-  implicit class PackMapJson(val packs: collection.Map[String, Package]) extends AnyVal {
-    def json: String = packs
-      .map { case (k, v) => s"${k.json}: ${v.json}" }
-      .mkString("{",",","}")
-  }
-}
diff --git a/doc-tool/test/ConstructorTest.scala b/doc-tool/test/ConstructorTest.scala
index d82115cd0..b61c5911d 100644
--- a/doc-tool/test/ConstructorTest.scala
+++ b/doc-tool/test/ConstructorTest.scala
@@ -184,28 +184,4 @@ class Constructors extends DottyDocTest {
       }
     }
   }
-
-  @Test def testJson = {
-    val actualSource =
-      """
-      |package scala
-      |
-      |trait Trait(val main: String)
-      |class Class(val main: String)
-      |case class CaseClass(main: String)
-      """.stripMargin
-
-    val source = new SourceFile ("JsonTest.scala", actualSource)
-
-    checkSources(source :: Nil) { packages =>
-      packages("scala") match {
-        case PackageImpl(_, _, _, List(cc: CaseClass, _, cls: Class, trt: Trait), _, _, _, _) =>
-          import model.json._
-          lazy val incorrectJson = s"The json generated for:\n$actualSource\n\nIs not correct"
-          assert(cc.json.contains(s""""constructors":[[{"list":[{"title":"main""""), incorrectJson)
-          assert(cls.json.contains(s""""constructors":[[{"list":[{"title":"main""""), incorrectJson)
-          assert(trt.json.contains(s""""traitParams":[{"list":[{"title":"main""""), incorrectJson)
-      }
-    }
-  }
 }