Use in-house json printer rather then jackson

Author: romanowski

project/Build.scala

@@ -1563,7 +1563,6 @@ object Build {
             "com.vladsch.flexmark" % "flexmark-ext-yaml-front-matter" % flexmarkVersion,
             "nl.big-o" % "liqp" % "0.6.7",
             "org.jsoup" % "jsoup" % "1.13.1", // Needed to process .html files for static site
-            "args4j" % "args4j" % "2.33",
             Dependencies.`jackson-dataformat-yaml`,
 
             "com.novocode" % "junit-interface" % "0.11" % "test",

scala3doc/src/dotty/dokka/JSON.scala

@@ -0,0 +1,55 @@
+package dotty.dokka
+
+import scala.annotation.tailrec
+
+opaque type JSON = String
+
+def jsonList(elems: Seq[JSON]): JSON = elems.mkString("[", ",\n", "]")
+
+def jsonObject(fields: (String, JSON)*): JSON =
+  fields.map{ case (k, v) => quoteStr(k)+":"+v}.mkString("{", ",", "}")
+
+
+def quoteStr(str: String) = s""""$str""""
+
+// based on Spray Json
+def jsonString(s: String): JSON =
+    def requiresEncoding(c: Char): Boolean =
+      // from RFC 4627
+      // unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
+      c match
+        case '"'  => true
+        case '\\' => true
+        case c    => c < 0x20
+
+    val sb = new StringBuilder
+    @tailrec def firstToBeEncoded(ix: Int = 0): Int =
+      if (ix == s.length) -1 else if (requiresEncoding(s.charAt(ix))) ix else firstToBeEncoded(ix + 1)
+
+    sb.append('"')
+    firstToBeEncoded() match
+      case -1 ⇒ sb.append(s)
+      case first =>
+        // sb.append(s, 0, first) for "abc", 0, 2 produce "(abc,0,2)" rather then "ab" as in Java
+        sb.append(s.substring(0, first))
+        @tailrec def append(ix: Int): Unit =
+          if (ix < s.length) {
+            s.charAt(ix) match
+              case c if !requiresEncoding(c) => sb.append(c)
+              case '"' => sb.append("\\\"")
+              case '\\' => sb.append("\\\\")
+              case '\b' => sb.append("\\b")
+              case '\f' => sb.append("\\f")
+              case '\n' => sb.append("\\n")
+              case '\r' => sb.append("\\r")
+              case '\t' => sb.append("\\t")
+              case x if x <= 0xF => sb.append("\\u000").append(Integer.toHexString(x))
+              case x if x <= 0xFF => sb.append("\\u00").append(Integer.toHexString(x))
+              case x if x <= 0xFFF => sb.append("\\u0").append(Integer.toHexString(x))
+              case x => sb.append("\\u").append(Integer.toHexString(x))
+
+            append(ix + 1)
+          }
+        append(first)
+
+    sb.append('"').toString

scala3doc/src/dotty/renderers/Resources.scala

@@ -14,7 +14,6 @@ import java.nio.file.Path
 import java.nio.file.Files
 import java.io.File
 import dotty.dokka.translators.FilterAttributes
-import com.fasterxml.jackson.databind.ObjectMapper
 
 enum Resource(val path: String):
   case Text(override val path: String, content: String) extends Resource(path)
@@ -24,10 +23,9 @@ enum Resource(val path: String):
 
 trait Resources(using ctx: DocContext) extends Locations, Writer:
   private def dynamicJsData =
-    // If data at any point will become more complex we should use a proper mapping
-    val data: Map[String, Map[String, String]] =
-      Map("filterDefaults" -> FilterAttributes.defaultValues)
-    val str = new ObjectMapper().writeValueAsString(data.transform((_, v) => v.asJava).asJava)
+    val str = jsonObject("filterDefaults" -> jsonObject(
+      FilterAttributes.defaultValues.toSeq.map { case  (n, v) => n -> jsonString(v) }:_*
+    ))
     Resource.Text("scripts/data.js", s"var scala3DocData = $str")
 
   private def scala3docVersionFile = Resource.Text("scala3doc.version", BuildInfo.version)
@@ -87,17 +85,6 @@ trait Resources(using ctx: DocContext) extends Locations, Writer:
   val searchDataPath = "scripts/searchData.js"
   val memberResourcesPaths = Seq(searchDataPath) ++ memberResources.map(_.path)
 
-  case class PageEntry(
-    dri: DRI,
-    name: String,
-    text: String,
-    descr: String,
-  ):
-    // for jackson
-    def getL: String = absolutePath(dri)
-    def getN: String = name
-    def getT: String = text
-    def getD: String = descr
 
   def searchData(pages: Seq[Page]) =
     def flattenToText(signature: Signature): String =
@@ -106,28 +93,34 @@ trait Resources(using ctx: DocContext) extends Locations, Writer:
         case s: String => s
       }.mkString
 
-    def processPage(page: Page): Seq[PageEntry] =
+    def mkEntry(dri: DRI, name: String, text: String, descr: String) = jsonObject(
+        "l" -> jsonString(absolutePath(dri)),
+        "n" -> jsonString(name),
+        "t" -> jsonString(text),
+        "d" -> jsonString(descr)
+      )
+
+    def processPage(page: Page): Seq[JSON] =
       val res =  page.content match
         case m: Member =>
           val descr = m.dri.asFileLocation
-          def processMember(member: Member): Seq[PageEntry] =
+          def processMember(member: Member): Seq[JSON] =
             val signatureBuilder = ScalaSignatureProvider.rawSignature(member, InlineSignatureBuilder()).asInstanceOf[InlineSignatureBuilder]
             val sig = Signature(member.kind.name, " ") ++ Seq(Link(member.name, member.dri)) ++ signatureBuilder.names.reverse
-            val entry = PageEntry(member.dri, member.name, flattenToText(sig), descr)
+            val entry = mkEntry(member.dri, member.name, flattenToText(sig), descr)
             val children = member
                 .membersBy(m => m.kind != dotty.dokka.model.api.Kind.Package && !m.kind.isInstanceOf[Classlike])
                 .filter(m => m.origin == Origin.RegularlyDefined && m.inheritedFrom.isEmpty)
             Seq(entry) ++ children.flatMap(processMember)
 
           processMember(m)
         case _ =>
-          Seq(PageEntry(page.link.dri, page.link.name, page.link.name, ""))
+          Seq(mkEntry(page.link.dri, page.link.name, page.link.name, ""))
 
       res ++ page.children.flatMap(processPage)
 
-    val entries = pages.flatMap(processPage).toArray
-    val entriesText = new ObjectMapper().writeValueAsString(entries)
-    Resource.Text(searchDataPath, s"pages = $entriesText;")
+    val entries = pages.flatMap(processPage)
+    Resource.Text(searchDataPath, s"pages = ${jsonList(entries)};")
 
 
   def allResources(pages: Seq[Page]): Seq[Resource] = memberResources ++ Seq(

scala3doc/test/dotty/dokka/JSONTest.scala

@@ -0,0 +1,10 @@
+package dotty.dokka
+
+import org.junit.Test
+import org.junit.Assert._
+
+class JSONTest:
+  @Test
+  def testStrings =
+    assertEquals(quoteStr("""ala"""), jsonString("""ala"""))
+    assertEquals(quoteStr("""\""""), jsonString("""""""))