fix: improve std.manifestXmlJsonml empty tags, array/object attrs, and HTML escaping

Motivation:
std.manifestXmlJsonml had several issues:
1. Empty tag names were rejected with an error, while go-jsonnet and jrsonnet
   accept them and produce <></> syntax
2. Array/object attribute values were rejected with an error, while go-jsonnet
   serializes them as JSON strings
3. The empty tag path did not escape HTML entities in attribute values,
   producing inconsistent and potentially invalid XML compared to the non-empty
   tag path which uses scalatags (which escapes automatically)

Modification:
- Added escapeHtmlAttr helper that escapes ", <, >, & and drops invalid XML 1.0
  control characters (below 0x20 except \n, \r, \t) to match scalatags behavior
- Added attrValue helper that converts ujson.Value to its string representation
  for XML attributes, eliminating code duplication between empty and non-empty
  tag paths. Str passes through as-is; Num uses ujson.write for consistent
  formatting; True/False/Null use literals; arrays/objects serialize to JSON
- Added emptyTag helper to render empty tag names with proper attribute escaping
- Changed array/object attribute handling from error to JSON serialization via
  ujson.write (matching go-jsonnet behavior)

Result:
- Empty tag names now produce <></> syntax (aligns with go-jsonnet, jrsonnet)
- Array/object attribute values now serialize as JSON strings instead of
  throwing errors (aligns with go-jsonnet)
- HTML entities are now consistently escaped in both empty and non-empty tag
  paths, producing valid XML 1.0 output (aligns with jrsonnet)
- Code is cleaner with shared attrValue helper eliminating duplication

Test coverage:
22 assertions covering empty tags, array/object attributes, HTML escaping,
numeric/boolean/null attributes, single quotes, nested empty tags, and mixed
children. All tests pass.

Author: He-Pin

sjsonnet/src/sjsonnet/stdlib/ManifestModule.scala

@@ -620,33 +620,65 @@ object ManifestModule extends AbstractFunctionModule {
      */
     builtin("manifestXmlJsonml", "value") { (pos, ev, value: Val) =>
       import scalatags.Text.all.{value => _, _}
+
+      def escapeHtmlAttr(s: String): String = {
+        val sb = new StringBuilder(s.length)
+        var i = 0
+        while (i < s.length) {
+          s(i) match {
+            case '"'                => sb.append("&quot;")
+            case '<'                => sb.append("&lt;")
+            case '>'                => sb.append("&gt;")
+            case '&'                => sb.append("&amp;")
+            case '\n' | '\r' | '\t' => sb.append(s(i))
+            case c if c < ' '       => // drop invalid XML 1.0 control characters
+            case c                  => sb.append(c)
+          }
+          i += 1
+        }
+        sb.toString
+      }
+
+      // Convert ujson.Value to its string representation for XML attributes.
+      // Str passes through as-is; Num uses ujson.write for consistent formatting
+      // (e.g. whole numbers without decimal point); True/False/Null use literals;
+      // arrays/objects serialize to JSON strings (matching go-jsonnet).
+      def attrValue(v: ujson.Value): String = v match {
+        case ujson.Str(str) => str
+        case ujson.Num(n)   => ujson.write(n)
+        case ujson.True     => "true"
+        case ujson.False    => "false"
+        case ujson.Null     => "null"
+        case other          => ujson.write(other)
+      }
+
+      def emptyTag(attrs: Option[ujson.Obj], childrenFrag: Frag): Frag = {
+        val attrStr = attrs match {
+          case Some(obj) =>
+            obj.value.toSeq.map { case (k, v) =>
+              " " + k + "=\"" + escapeHtmlAttr(attrValue(v)) + "\""
+            }.mkString
+          case None => ""
+        }
+        raw("<" + attrStr + ">" + childrenFrag.render + "</>")
+      }
+
       def rec(v: ujson.Value): Frag = {
         v match {
           case ujson.Str(ss)                                                         => ss
           case ujson.Arr(mutable.Seq(ujson.Str(t), attrs: ujson.Obj, children @ _*)) =>
-            tag(t)(
-              // TODO remove the `toSeq` once this is fixed in scala3
-              attrs.value.toSeq.map {
-                case (k, ujson.Str(v)) => attr(k) := v
-
-                // use ujson.write to make sure output number format is same as
-                // google/jsonnet, e.g. whole numbers are printed without the
-                // decimal point and trailing zero
-                case (k, ujson.Num(v)) => attr(k) := ujson.write(v)
-
-                case (k, ujson.True)  => attr(k) := "true"
-                case (k, ujson.False) => attr(k) := "false"
-                case (k, ujson.Null)  => attr(k) := "null"
-
-                case (k, v) =>
-                  Error.fail(
-                    "std.manifestXmlJsonml: unsupported attribute type " + ujsonTypeName(v)
-                  )
-              }.toSeq,
-              children.map(rec)
-            )
+            if (t.isEmpty) emptyTag(Some(attrs), children.map(rec))
+            else
+              tag(t)(
+                // TODO remove the `toSeq` once this is fixed in scala3
+                attrs.value.toSeq.map { case (k, v) =>
+                  attr(k) := attrValue(v)
+                }.toSeq,
+                children.map(rec)
+              )
           case ujson.Arr(mutable.Seq(ujson.Str(t), children @ _*)) =>
-            tag(t)(children.map(rec).toSeq)
+            if (t.isEmpty) emptyTag(None, children.map(rec))
+            else tag(t)(children.map(rec).toSeq)
           case x =>
             Error.fail("std.manifestXmlJsonml: unsupported type " + ujsonTypeName(x))
         }

sjsonnet/test/resources/new_test_suite/manifest_xml_jsonml_empty_tag.jsonnet

@@ -0,0 +1,45 @@
+local empty1 = std.manifestXmlJsonml(["", {}]);
+local empty2 = std.manifestXmlJsonml(["", "hello"]);
+local empty3 = std.manifestXmlJsonml(["", {}, "child1", "child2"]);
+local empty4 = std.manifestXmlJsonml(["", {"id": "x"}, "with attr"]);
+local normal1 = std.manifestXmlJsonml(["div", {}]);
+local normal2 = std.manifestXmlJsonml(["p", "hello"]);
+local normal3 = std.manifestXmlJsonml(["div", {"class": "main"}, "content"]);
+local arrAttr = std.manifestXmlJsonml(["div", {"items": [1,2,3]}]);
+local objAttr = std.manifestXmlJsonml(["div", {"data": {"x": 1}}]);
+local emptyArrAttr = std.manifestXmlJsonml(["", {"items": [1,2,3]}]);
+local emptyObjAttr = std.manifestXmlJsonml(["", {"data": {"x": 1}}]);
+local escapeTest1 = std.manifestXmlJsonml(["div", {"title": "a\"b"}]);
+local escapeTest2 = std.manifestXmlJsonml(["", {"title": "a\"b"}]);
+local escapeTest3 = std.manifestXmlJsonml(["div", {"title": "a<b&c>d"}]);
+local escapeTest4 = std.manifestXmlJsonml(["", {"title": "a<b&c>d"}]);
+local numAttr = std.manifestXmlJsonml(["", {"count": 42}]);
+local boolAttr = std.manifestXmlJsonml(["", {"flag": true}]);
+local nullAttr = std.manifestXmlJsonml(["", {"val": null}]);
+local singleQuote = std.manifestXmlJsonml(["", {"title": "it's"}]);
+local singleQuoteNormal = std.manifestXmlJsonml(["div", {"title": "it's"}]);
+local nestedEmpty = std.manifestXmlJsonml(["", {}, ["", {}, "inner"]]);
+local mixedChildren = std.manifestXmlJsonml(["", {}, ["div", {}, "a"], ["p", "b"]]);
+
+empty1 == "<></>" &&
+empty2 == "<>hello</>" &&
+empty3 == "<>child1child2</>" &&
+empty4 == '< id="x">with attr</>' &&
+normal1 == "<div></div>" &&
+normal2 == "<p>hello</p>" &&
+normal3 == '<div class="main">content</div>' &&
+arrAttr == '<div items="[1,2,3]"></div>' &&
+objAttr == '<div data="{&quot;x&quot;:1}"></div>' &&
+emptyArrAttr == '< items="[1,2,3]"></>' &&
+emptyObjAttr == '< data="{&quot;x&quot;:1}"></>' &&
+escapeTest1 == '<div title="a&quot;b"></div>' &&
+escapeTest2 == '< title="a&quot;b"></>' &&
+escapeTest3 == '<div title="a&lt;b&amp;c&gt;d"></div>' &&
+escapeTest4 == '< title="a&lt;b&amp;c&gt;d"></>' &&
+numAttr == '< count="42"></>' &&
+boolAttr == '< flag="true"></>' &&
+nullAttr == '< val="null"></>' &&
+singleQuote == "< title=\"it's\"></>" &&
+singleQuoteNormal == "<div title=\"it's\"></div>" &&
+nestedEmpty == "<><>inner</></>" &&
+mixedChildren == "<><div>a</div><p>b</p></>"

sjsonnet/test/resources/new_test_suite/manifest_xml_jsonml_empty_tag.jsonnet.golden

@@ -0,0 +1 @@
+true