Add Map.SetEscapeHTML()

jsonmap.go

@@ -9,14 +9,16 @@ package jsonmap
 type Map struct {
 	elements    map[Key]*Element
 	first, last *Element
+	escapeHTML  bool
 }
 
 // New returns a new map. O(1) time.
 //
 //	m := jsonmap.New()
 func New() *Map {
 	return &Map{
-		elements: make(map[Key]*Element),
+		elements:   make(map[Key]*Element),
+		escapeHTML: true,
 	}
 }
 
@@ -156,3 +158,11 @@ func (m *Map) GetElement(key Key) *Element {
 	}
 	return nil
 }
+
+// SetEscapeHTML sets whether HTML characters should be escaped when marshaling to JSON.
+// This setting is propagated to nested maps and arrays when unmarshaling from JSON.
+// Set to true by default.
+// O(1) time.
+func (m *Map) SetEscapeHTML(escape bool) {
+	m.escapeHTML = escape
+}

marshal.go

@@ -13,6 +13,7 @@ func (m *Map) MarshalJSON() ([]byte, error) {
 	var buf bytes.Buffer
 	buf.WriteByte('{')
 	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(m.escapeHTML)
 	for i, key := range m.Keys() {
 		if i > 0 {
 			buf.WriteByte(',')

test/json_test.go

@@ -1,6 +1,7 @@
 package test_test
 
 import (
+	"bytes"
 	"encoding/json"
 	"strings"
 	"testing"
@@ -85,3 +86,74 @@ func verifyPlainJSON(t *testing.T, m IMapShort) {
 	assert.False(t, ok)
 	assert.Equal(t, v, nil)
 }
+
+func encodeJSON(v any, escapeHTML bool) (string, error) {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(escapeHTML)
+	err := enc.Encode(v)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes.TrimRight(buf.Bytes(), "\n")), nil
+}
+
+func TestHTMLEscaping(t *testing.T) {
+	const rawJSON = `{"range":">1.0.0 && <2.0.0"}`
+	const escapedJSON = `{"range":"\u003e1.0.0 \u0026\u0026 \u003c2.0.0"}`
+	const nestedRawJSON = `{"name":"test","deps":{"a":">1.0","b":"<2.0 & >=1.5"},"tags":["<root>","&"]}`
+	const nestedArrayJSON = `{"name":"test","list":[{"op":">="},{"op":"<="}]}`
+
+	t.Run("DefaultMarshal", func(t *testing.T) {
+		m := jsonmap.New()
+		err := json.Unmarshal([]byte(rawJSON), m)
+		assert.NoError(t, err)
+
+		data, err := json.Marshal(m)
+		assert.NoError(t, err)
+		assert.Equal(t, string(data), escapedJSON)
+	})
+
+	t.Run("DefaultEncode", func(t *testing.T) {
+		m := jsonmap.New()
+		err := json.Unmarshal([]byte(rawJSON), m)
+		assert.NoError(t, err)
+
+		data, err := encodeJSON(m, true)
+		assert.NoError(t, err)
+		assert.Equal(t, data, escapedJSON)
+	})
+
+	t.Run("EncodeNoEscape", func(t *testing.T) {
+		m := jsonmap.New()
+		m.SetEscapeHTML(false)
+		err := json.Unmarshal([]byte(rawJSON), m)
+		assert.NoError(t, err)
+
+		data, err := encodeJSON(m, false)
+		assert.NoError(t, err)
+		assert.Equal(t, data, rawJSON)
+	})
+
+	t.Run("EncodeNoEscapeNested", func(t *testing.T) {
+		m := jsonmap.New()
+		m.SetEscapeHTML(false)
+		err := json.Unmarshal([]byte(nestedRawJSON), m)
+		assert.NoError(t, err)
+
+		data, err := encodeJSON(m, false)
+		assert.NoError(t, err)
+		assert.Equal(t, data, nestedRawJSON)
+	})
+
+	t.Run("EncodeNoEscapeNestedArray", func(t *testing.T) {
+		m := jsonmap.New()
+		m.SetEscapeHTML(false)
+		err := json.Unmarshal([]byte(nestedArrayJSON), m)
+		assert.NoError(t, err)
+
+		data, err := encodeJSON(m, false)
+		assert.NoError(t, err)
+		assert.Equal(t, data, nestedArrayJSON)
+	})
+}

unmarshal.go

@@ -53,14 +53,15 @@ func decodeMap(d *json.Decoder, m *Map) error {
 
 		case json.Delim('{'):
 			m2 := New()
+			m2.SetEscapeHTML(m.escapeHTML)
 			err = decodeMap(d, m2)
 			if err != nil {
 				return err
 			}
 			m.Push(key, m2)
 
 		case json.Delim('['):
-			a, err := decodeArray(d)
+			a, err := decodeArray(d, m.escapeHTML)
 			if err != nil {
 				return err
 			}
@@ -72,7 +73,7 @@ func decodeMap(d *json.Decoder, m *Map) error {
 	}
 }
 
-func decodeArray(d *json.Decoder) ([]any, error) {
+func decodeArray(d *json.Decoder, escapeHTML bool) ([]any, error) {
 	a := make([]any, 0)
 	for {
 		tok, err := d.Token()
@@ -87,14 +88,15 @@ func decodeArray(d *json.Decoder) ([]any, error) {
 
 		case json.Delim('{'):
 			m := New()
+			m.SetEscapeHTML(escapeHTML)
 			err = decodeMap(d, m)
 			if err != nil {
 				return a, err
 			}
 			a = append(a, m)
 
 		case json.Delim('['):
-			a2, err := decodeArray(d)
+			a2, err := decodeArray(d, escapeHTML)
 			if err != nil {
 				return a, err
 			}