fix: align format numeric edge cases with Python rules

Motivation:
Jsonnet documents std.format and the % string operator as following Python-style formatting rules. sjsonnet diverged on several numeric edge cases: floating-point formats did not preserve the IEEE -0.0 sign bit, dynamic * width/precision accepted fractional values via truncation, and %g exponent selection was sensitive to floating-point log10 roundoff.

Modification:
Normalize dynamic * width and precision through a shared Python-style integer conversion path, including negative width and negative precision handling. Preserve -0.0 signs for floating-point conversions, keep integral conversions unchanged, and stabilize %g exponent calculation around powers of ten. Add focused regression coverage for negative zero, dynamic * width/precision, fractional * errors, and %g boundary values.

Result:
sjsonnet follows the official std.format Python-style contract for these numeric formatting edge cases. The PR is format-only and no longer includes unrelated manifestXmlJsonml changes.

References:
https://jsonnet.org/ref/stdlib.html#std-format

Author: He-Pin

sjsonnet/src/sjsonnet/Format.scala

@@ -1,10 +1,11 @@
 package sjsonnet
 
 /**
- * Minimal re-implementation of Python's `%` formatting logic, since Jsonnet's `%` formatter is
- * basically "do whatever python does", with a link to:
+ * Minimal re-implementation of Python's `%` formatting logic. Jsonnet documents `std.format` and
+ * the `%` operator as following Python formatting rules:
  *
- *   - https://docs.python.org/2/library/stdtypes.html#string-formatting
+ *   - https://jsonnet.org/ref/stdlib.html#std-format
+ *   - https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting
  *
  * Parses the formatted strings into a sequence of literal strings separated by `%` interpolations
  * modelled as structured [[Format.FormatSpec]]s, and use those to decide how to inteprolate the
@@ -93,12 +94,28 @@ object Format {
       conversion == 's' && !hasWidth && !hasPrecision &&
       (flags & SimpleStringDisqualifierFlags) == 0
 
-    def withStarWidth(newWidth: Int): FormatSpec =
-      new FormatSpec((bits & ~(NumberMask << WidthShift)) | (encodeNumber(newWidth) << WidthShift))
+    // Jsonnet documents std.format as Python-style formatting. Python treats a negative
+    // dynamic width as left adjustment with the absolute width.
+    def withStarWidth(newWidth: Int): FormatSpec = {
+      val normalizedWidth =
+        if (newWidth < 0) {
+          if (newWidth == Int.MinValue)
+            throw new Exception("Format width/precision is too large: " + newWidth)
+          -newWidth
+        } else newWidth
+      val normalizedFlags = if (newWidth < 0) flags | LeftAdjustedFlag else flags
+      new FormatSpec(
+        (bits & ~(NumberMask << WidthShift) & ~(FlagsMask << FlagsShift)) |
+        (normalizedFlags.toLong << FlagsShift) |
+        (encodeNumber(normalizedWidth) << WidthShift)
+      )
+    }
 
+    // Python treats a negative dynamic precision as zero; %g later maps precision 0 to 1.
     def withStarPrecision(newPrecision: Int): FormatSpec =
       new FormatSpec(
-        (bits & ~(NumberMask << PrecisionShift)) | (encodeNumber(newPrecision) << PrecisionShift)
+        (bits & ~(NumberMask << PrecisionShift)) |
+        (encodeNumber(math.max(newPrecision, 0)) << PrecisionShift)
       )
 
     def withStarValues(newWidth: Int, newPrecision: Int): FormatSpec =
@@ -645,7 +662,7 @@ object Format {
                       )
                     }
                     i += 1
-                    formatted = formatted.withStarWidth(width.asInt)
+                    formatted = withStarWidth(formatted, width, idx)
                     valuesArr.value(i)
                   case (false, true) =>
                     val precision = valuesArr.value(i)
@@ -655,7 +672,7 @@ object Format {
                       )
                     }
                     i += 1
-                    formatted = formatted.withStarPrecision(precision.asInt)
+                    formatted = withStarPrecision(formatted, precision, idx)
                     valuesArr.value(i)
                   case (true, true) =>
                     val width = valuesArr.value(i)
@@ -672,7 +689,8 @@ object Format {
                       )
                     }
                     i += 1
-                    formatted = formatted.withStarValues(width.asInt, precision.asInt)
+                    formatted =
+                      withStarPrecision(withStarWidth(formatted, width, idx), precision, idx)
                     valuesArr.value(i)
                 }
             } else {
@@ -984,14 +1002,47 @@ object Format {
     case _            => false
   }
 
+  private def withStarWidth(formatted: FormatSpec, width: Val, idx: Int): FormatSpec =
+    try formatted.withStarWidth(starInteger(width, "width", idx))
+    catch {
+      case e: Error     => throw e
+      case e: Exception =>
+        Error.fail(e.getMessage)
+    }
+
+  private def withStarPrecision(formatted: FormatSpec, precision: Val, idx: Int): FormatSpec =
+    try formatted.withStarPrecision(starInteger(precision, "precision", idx))
+    catch {
+      case e: Error     => throw e
+      case e: Exception =>
+        Error.fail(e.getMessage)
+    }
+
+  private def starInteger(value: Val, name: String, idx: Int): Int =
+    value match {
+      case n: Val.Num =>
+        val d = n.asDouble
+        // Jsonnet has one number type, so Python's "integer required for *" rule maps to
+        // finite whole-number values. Fractional star arguments must not be rounded.
+        if (!d.isWhole || !d.isValidInt)
+          Error.fail("* %s at position %d requires an integer".format(name, idx))
+        d.toInt
+      case _ =>
+        Error.fail("* %s at position %d requires an integer".format(name, idx))
+    }
+
+  // std.format follows Python's % formatting. Jsonnet numbers have IEEE double semantics, so
+  // floating-point formats preserve the sign bit of -0.0 even though -0.0 == 0.0.
+  private def isNegative(s: Double): Boolean = s < 0 || (s == 0.0 && 1.0 / s < 0)
+
   private def formatInteger(formatted: FormatSpec, s: Double): String = {
     formatIntegralRadix(formatted, s, 10, _ => "")
   }
 
   private def formatFloat(formatted: FormatSpec, s: Double): String = {
     widen(
       formatted,
-      if (s < 0) "-" else "",
+      if (isNegative(s)) "-" else "",
       "",
       sjsonnet.DecimalFormat
         .format(
@@ -1002,7 +1053,7 @@ object Format {
           math.abs(s)
         ),
       numeric = true,
-      signedConversion = s >= 0
+      signedConversion = !isNegative(s)
     )
 
   }
@@ -1055,10 +1106,10 @@ object Format {
     if (s == 0) 0
     else {
       val abs = math.abs(s)
-      val rawExponent = math.floor(math.log10(abs)).toInt
+      val rawExponent = math.floor(math.log10(abs) + 1e-10).toInt
       val scale = math.pow(10, rawExponent - precision + 1)
       val rounded = Math.round(abs / scale) * scale
-      if (rounded == 0) 0 else math.floor(math.log10(rounded)).toInt
+      if (rounded == 0) 0 else math.floor(math.log10(rounded) + 1e-10).toInt
     }
   }
 
@@ -1069,7 +1120,7 @@ object Format {
     if (exponent < -4 || exponent >= precision) {
       widen(
         formatted,
-        if (s < 0) "-" else "",
+        if (isNegative(s)) "-" else "",
         "",
         sjsonnet.DecimalFormat
           .format(
@@ -1080,13 +1131,13 @@ object Format {
             math.abs(s)
           ),
         numeric = true,
-        signedConversion = s >= 0
+        signedConversion = !isNegative(s)
       )
     } else {
-      val fractionalPrecision = math.max(0, precision - exponent - 1)
+      val fractionalPrecision = math.max(0, precision - 1 - exponent)
       widen(
         formatted,
-        if (s < 0) "-" else "",
+        if (isNegative(s)) "-" else "",
         "",
         sjsonnet.DecimalFormat
           .format(
@@ -1097,7 +1148,7 @@ object Format {
             math.abs(s)
           ),
         numeric = true,
-        signedConversion = s >= 0
+        signedConversion = !isNegative(s)
       )
     }
 
@@ -1106,7 +1157,7 @@ object Format {
   private def formatExponent(formatted: FormatSpec, s: Double): String = {
     widen(
       formatted,
-      if (s < 0) "-" else "",
+      if (isNegative(s)) "-" else "",
       "",
       sjsonnet.DecimalFormat
         .format(
@@ -1117,7 +1168,7 @@ object Format {
           math.abs(s)
         ),
       numeric = true,
-      signedConversion = s >= 0
+      signedConversion = !isNegative(s)
     )
   }
 

sjsonnet/test/resources/new_test_suite/error.format_fractional_star_precision.jsonnet

@@ -0,0 +1 @@
+"%.*g" % [2.7, 1.23456]

sjsonnet/test/resources/new_test_suite/error.format_fractional_star_precision.jsonnet.golden

@@ -0,0 +1 @@
+sjsonnet.Error: [std.format] * precision at position 0 requires an integer

sjsonnet/test/resources/new_test_suite/error.format_fractional_star_width.jsonnet

@@ -0,0 +1 @@
+"%*g" % [3.7, 1]

sjsonnet/test/resources/new_test_suite/error.format_fractional_star_width.jsonnet.golden

@@ -0,0 +1 @@
+sjsonnet.Error: [std.format] * width at position 0 requires an integer

sjsonnet/test/resources/new_test_suite/format_g_precision_fix.jsonnet

@@ -0,0 +1,57 @@
+// Tests for %g and %#g format fixes
+// Verifies floating-point precision fixes in roundedGenericExponent and formatGeneric
+
+// Basic %g tests with various exponents
+std.assertEqual('%g' % 0.1, '0.1') &&
+std.assertEqual('%g' % 0.0001, '0.0001') &&
+std.assertEqual('%g' % 1.0, '1') &&
+std.assertEqual('%g' % 100.0, '100') &&
+std.assertEqual('%g' % 1234567.0, '1.23457e+06') &&
+
+// %#g tests (alternate flag preserves trailing zeros)
+std.assertEqual('%#g' % 0.1, '0.100000') &&
+std.assertEqual('%#g' % 0.0001, '0.000100000') &&
+std.assertEqual('%#g' % 1.0, '1.00000') &&
+std.assertEqual('%#g' % 100.0, '100.000') &&
+std.assertEqual('%#g' % 1234567.0, '1.23457e+06') &&
+
+// Precision-specific tests
+std.assertEqual('%.3g' % 0.0001, '0.0001') &&
+std.assertEqual('%.3g' % 123.456, '123') &&
+std.assertEqual('%.10g' % 0.1, '0.1') &&
+
+// Zero handling
+std.assertEqual('%g' % 0.0, '0') &&
+std.assertEqual('%#g' % 0.0, '0.00000') &&
+
+// Negative values
+std.assertEqual('%g' % -0.1, '-0.1') &&
+std.assertEqual('%#g' % -0.1, '-0.100000') &&
+
+// Very small exponents
+std.assertEqual('%g' % 0.00001, '1e-05') &&
+std.assertEqual('%#g' % 0.00001, '1.00000e-05') &&
+
+// Precision 0 (treated as precision 1)
+std.assertEqual('%.0g' % 0.0, '0') &&
+std.assertEqual('%.0g' % 1.0, '1') &&
+std.assertEqual('%.0g' % 0.1, '0.1') &&
+std.assertEqual('%#.0g' % 1.0, '1.') &&
+
+// Star width/precision follows Python-style integer semantics
+std.assertEqual('%*g' % [10, 1.0], '         1') &&
+std.assertEqual('%*g' % [10, 0.1], '       0.1') &&
+std.assertEqual('%*g' % [4, 1.0], '   1') &&
+std.assertEqual('%*g' % [-4, 1.0], '1   ') &&
+std.assertEqual('%.*g' % [3, 1.23456], '1.23') &&
+std.assertEqual('%.*g' % [-3, 1.23456], '1') &&
+std.assertEqual('%*.*g' % [6, 3, 1.23456], '  1.23') &&
+std.assertEqual('%*.*g' % [-6, 3, 1.23456], '1.23  ') &&
+
+// Regression tests: values close to powers of 10
+std.assertEqual('%g' % 99.9999, '99.9999') &&
+std.assertEqual('%g' % 9.99999, '9.99999') &&
+std.assertEqual('%g' % 999.999, '999.999') &&
+std.assertEqual('%g' % 0.999999, '0.999999') &&
+
+true

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

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

sjsonnet/test/resources/new_test_suite/format_zero_sign_flags.jsonnet

@@ -7,4 +7,14 @@ std.assertEqual("%+E" % 0.0, "+0.000000E+00") &&
 std.assertEqual("%+g" % 0.0, "+0") &&
 std.assertEqual("%+G" % 0.0, "+0") &&
 std.assertEqual("%+010f" % 0.0, "+00.000000") &&
-std.assertEqual("%+f" % (-0.0), "+0.000000")
+std.assertEqual("%+f" % (-0.0), "-0.000000") &&
+std.assertEqual("%f" % (-0.0), "-0.000000") &&
+std.assertEqual("%e" % (-0.0), "-0.000000e+00") &&
+std.assertEqual("%E" % (-0.0), "-0.000000E+00") &&
+std.assertEqual("%g" % (-0.0), "-0") &&
+std.assertEqual("%G" % (-0.0), "-0") &&
+std.assertEqual("% f" % (-0.0), "-0.000000") &&
+std.assertEqual("%010f" % (-0.0), "-00.000000") &&
+std.assertEqual("%d" % (-0.0), "0") &&
+std.assertEqual("%o" % (-0.0), "0") &&
+std.assertEqual("%x" % (-0.0), "0")