Add engine.Quote with JSON quoting standard

Author: antonmedv

internal/engine/quote.go

@@ -0,0 +1,64 @@
+package engine
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf16"
+	"unicode/utf8"
+)
+
+func Quote(s string) string {
+	var err error
+	var b strings.Builder
+	b.WriteByte('"')
+
+	for i := 0; i < len(s); {
+		r, width := utf8.DecodeRuneInString(s[i:])
+
+		switch r {
+		case '"':
+			b.WriteString(`\"`)
+		case '\\':
+			b.WriteString(`\\`)
+		case '\b':
+			b.WriteString(`\b`)
+		case '\f':
+			b.WriteString(`\f`)
+		case '\n':
+			b.WriteString(`\n`)
+		case '\r':
+			b.WriteString(`\r`)
+		case '\t':
+			b.WriteString(`\t`)
+		default:
+			if r < 0x20 || r == 0x7F {
+				// Control characters must be escaped as \uXXXX
+				_, err = fmt.Fprintf(&b, `\u%04x`, r)
+				if err != nil {
+					panic(err)
+				}
+			} else if r > 0xFFFF {
+				// Characters outside BMP need UTF-16 surrogate pairs
+				r1, r2 := utf16.EncodeRune(r)
+				_, err = fmt.Fprintf(&b, `\u%04x\u%04x`, r1, r2)
+				if err != nil {
+					panic(err)
+				}
+			} else if r == utf8.RuneError && width == 1 {
+				// Invalid UTF-8 sequence - escape the byte
+				_, err = fmt.Fprintf(&b, `\u%04x`, s[i])
+				if err != nil {
+					panic(err)
+				}
+			} else {
+				// Regular character - write as-is
+				b.WriteRune(r)
+			}
+		}
+
+		i += width
+	}
+
+	b.WriteByte('"')
+	return b.String()
+}

internal/engine/quote_test.go

@@ -0,0 +1,113 @@
+package engine_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/antonmedv/fx/internal/engine"
+)
+
+func TestQuote_BasicASCII(t *testing.T) {
+	assert.Equal(t, "\"hello\"", engine.Quote("hello"))
+	assert.Equal(t, "\"\"", engine.Quote(""))
+	assert.Equal(t, "\"Hello, world!\"", engine.Quote("Hello, world!"))
+}
+
+func TestQuote_EscapesSpecialCharacters(t *testing.T) {
+	// Quotes and backslashes
+	assert.Equal(t, "\"\\\"\"", engine.Quote("\""))
+	assert.Equal(t, "\"\\\\\"", engine.Quote("\\"))
+
+	// Common escapes
+	assert.Equal(t, "\"\\b\"", engine.Quote("\b"))
+	assert.Equal(t, "\"\\f\"", engine.Quote("\f"))
+	assert.Equal(t, "\"\\n\"", engine.Quote("\n"))
+	assert.Equal(t, "\"\\r\"", engine.Quote("\r"))
+	assert.Equal(t, "\"\\t\"", engine.Quote("\t"))
+}
+
+func TestQuote_ControlCharactersAndDEL(t *testing.T) {
+	// 0x00 .. 0x1F should be \uXXXX
+	for b := 0; b < 0x20; b++ {
+		s := string([]byte{byte(b)})
+		q := engine.Quote(s)
+		expected := "\"\\u" + hex4Lower(b) + "\""
+		// For those with dedicated escapes, engine.Quote uses short escapes; both are valid.
+		// We'll accept either short escape or \uXXXX for those particular bytes.
+		switch b {
+		case '\b':
+			assert.Equal(t, "\"\\b\"", q)
+		case '\f':
+			assert.Equal(t, "\"\\f\"", q)
+		case '\n':
+			assert.Equal(t, "\"\\n\"", q)
+		case '\r':
+			assert.Equal(t, "\"\\r\"", q)
+		case '\t':
+			assert.Equal(t, "\"\\t\"", q)
+		default:
+			assert.Equal(t, expected, q, "byte %d", b)
+		}
+	}
+	// 0x7F DEL
+	assert.Equal(t, "\"\\u007f\"", engine.Quote(string([]byte{0x7F})))
+}
+
+func TestQuote_BMP_CharactersAsIs(t *testing.T) {
+	// Latin-1 supplement, Cyrillic, CJK BMP characters should appear as-is
+	assert.Equal(t, "\"café\"", engine.Quote("café"))     // U+00E9
+	assert.Equal(t, "\"Привет\"", engine.Quote("Привет")) // Cyrillic
+	assert.Equal(t, "\"漢字\"", engine.Quote("漢字"))         // CJK
+}
+
+func TestQuote_NonBMP_SurrogatePairs(t *testing.T) {
+	// Rocket U+1F680 -> \ud83d\ude80
+	assert.Equal(t, "\"\\ud83d\\ude80\"", engine.Quote("🚀"))
+	// Musical symbol G clef U+1D11E -> \ud834\udd1e
+	assert.Equal(t, "\"\\ud834\\udd1e\"", engine.Quote("𝄞"))
+}
+
+func TestQuote_InvalidUTF8BytesAreEscaped(t *testing.T) {
+	// Construct a string with invalid UTF-8 byte 0xFF and 0xC0 (overlong lead)
+	s := string([]byte{'A', 0xFF, 'B', 0xC0, 'C'})
+	got := engine.Quote(s)
+	// Expect bytes to be escaped as \u00xx in lowercase hex
+	want := "\"A\\u00ffB\\u00c0C\""
+	assert.Equal(t, want, got)
+}
+
+func TestQuote_MixedContent(t *testing.T) {
+	s := "Line1\n\t\"Quote\" and backslash \\ and DEL:" + string([]byte{0x7F}) + " and emoji 🚀"
+	got := engine.Quote(s)
+	// Validate it is a valid JSON string and round-trips to the same value
+	var v string
+	err := json.Unmarshal([]byte(got), &v)
+	assert.NoError(t, err)
+	assert.Equal(t, s, v)
+}
+
+func TestQuote_JSONRoundTrip_ValidUTF8(t *testing.T) {
+	inputs := []string{
+		"", "simple", "line\nfeed", "tab\tchar", "quote \" here", "backslash \\",
+		"café", "Привет", "漢字", "emoji 🚀", "mix: \b\f\n\r\t and \u007F:" + string([]byte{0x7F}),
+	}
+	for _, s := range inputs {
+		q := engine.Quote(s)
+		var v string
+		err := json.Unmarshal([]byte(q), &v)
+		assert.NoError(t, err, "failed to unmarshal: %q", q)
+		assert.Equal(t, s, v)
+	}
+}
+
+// hex4Lower returns a 4-digit lowercase hex for a small non-negative integer (< 65536)
+func hex4Lower(n int) string {
+	const hexdigits = "0123456789abcdef"
+	b0 := hexdigits[(n>>12)&0xF]
+	b1 := hexdigits[(n>>8)&0xF]
+	b2 := hexdigits[(n>>4)&0xF]
+	b3 := hexdigits[n&0xF]
+	return string([]byte{b0, b1, b2, b3})
+}

internal/engine/stringify.go

@@ -5,7 +5,6 @@ import (
 	"math"
 	"math/big"
 	"reflect"
-	"strconv"
 	"strings"
 	"time"
 
@@ -28,7 +27,7 @@ func Stringify(value goja.Value, vm *goja.Runtime, depth int) string {
 		return bi.String()
 	case timeTimeType:
 		t := value.Export().(time.Time)
-		quoted := strconv.Quote(t.String())
+		quoted := Quote(t.String())
 		return quoted
 	}
 
@@ -53,7 +52,7 @@ func Stringify(value goja.Value, vm *goja.Runtime, depth int) string {
 		return value.String()
 
 	case reflect.String:
-		return strconv.Quote(value.String())
+		return Quote(value.String())
 
 	case reflect.Map:
 		obj := value.ToObject(vm)
@@ -72,7 +71,7 @@ func Stringify(value goja.Value, vm *goja.Runtime, depth int) string {
 
 		for i, key := range keys {
 			out.WriteString(identKey)
-			out.WriteString(strconv.Quote(key))
+			out.WriteString(Quote(key))
 			out.WriteString(":")
 			out.WriteString(" ")
 			out.WriteString(Stringify(obj.Get(key), vm, depth+1))