initial implementation

LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024 Nicolás Parada
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

README.md

@@ -0,0 +1,39 @@
+[![Go Reference](https://pkg.go.dev/badge/github.com/nicolasparada/go-ordered-map.svg)](https://pkg.go.dev/github.com/nicolasparada/go-ordered-map)
+
+# Golang Ordered Map
+
+Golang Ordered Map is a `map` data structure that maintains the order of the keys.
+It also supports JSON and YAML marshalling.
+
+## Installation
+
+```bash
+go get github.com/nicolasparada/go-ordered-map
+```
+
+## Usage
+
+```go
+package main
+
+import (
+	orderedmap "github.com/nicolasparada/go-ordered-map"
+)
+
+func main() {
+	data := []byte(`{ "name": "John", "age": 30, "active": true }`)
+
+	var unordered map[string]any{}
+	if err := json.Unmarshal(data, &unordered); err != nil {
+		panic(err)
+	}
+
+	var ordered orderedmap.OrderedMap[string, any]
+	if err := json.Unmarshal(data, &ordered); err != nil {
+		panic(err)
+	}
+
+	json.NewEncoder(os.Stdout).Encode(unordered) // will print in undefined order
+	json.NewEncoder(os.Stdout).Encode(ordered) // will always print: {"name":"John","age":30,"active":true}
+}
+```

go.mod

@@ -0,0 +1,13 @@
+module github.com/nicolasparada/go-ordered-map
+
+go 1.22.0
+
+require (
+	github.com/alecthomas/assert/v2 v2.5.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	github.com/alecthomas/repr v0.3.0 // indirect
+	github.com/hexops/gotextdiff v1.0.3 // indirect
+)

go.sum

@@ -0,0 +1,10 @@
+github.com/alecthomas/assert/v2 v2.5.0 h1:OJKYg53BQx06/bMRBSPDCO49CbCDNiUQXwdoNrt6x5w=
+github.com/alecthomas/assert/v2 v2.5.0/go.mod h1:fw5suVxB+wfYJ3291t0hRTqtGzFYdSwstnRQdaQx2DM=
+github.com/alecthomas/repr v0.3.0 h1:NeYzUPfjjlqHY4KtzgKJiWd6sVq2eNUPTi34PiFGjY8=
+github.com/alecthomas/repr v0.3.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

json.go

@@ -0,0 +1,131 @@
+package orderedmap
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+)
+
+// MarshalJSON implements json.Marshaler interface
+// to marshall a sorted list of key-value pairs into an object.
+func (o OrderedMap[K, V]) MarshalJSON() ([]byte, error) {
+	if o == nil {
+		return []byte(`null`), nil
+	}
+
+	if len(o) == 0 {
+		return []byte(`{}`), nil
+	}
+
+	var buf bytes.Buffer
+	if err := buf.WriteByte('{'); err != nil {
+		return nil, err
+	}
+
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	for i, p := range o {
+		if i != 0 {
+			if err := buf.WriteByte(','); err != nil {
+				return nil, err
+			}
+		}
+
+		if err := enc.Encode(p.Key); err != nil {
+			return nil, err
+		}
+
+		if err := buf.WriteByte(':'); err != nil {
+			return nil, err
+		}
+
+		if err := enc.Encode(p.Val); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := buf.WriteByte('}'); err != nil {
+		return nil, err
+	}
+
+	return bytes.TrimRight(buf.Bytes(), "\n"), nil
+}
+
+// UnmarshalJSON implements json.Unmarshaler interface
+// to unmarshal an object into a sorted list of key-value pairs.
+func (o *OrderedMap[K, V]) UnmarshalJSON(data []byte) error {
+	var m map[K]V
+	err := json.Unmarshal(data, &m)
+	if err != nil {
+		return err
+	}
+
+	dec := json.NewDecoder(bytes.NewReader(data))
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	if t != json.Delim('{') {
+		return errors.New("expected start of object")
+	}
+
+	for {
+		t, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		if t == json.Delim('}') {
+			break
+		}
+
+		key, ok := t.(K)
+		if !ok {
+			return fmt.Errorf("expected object key to be %T, got %T", key, t)
+		}
+
+		*o = append(*o, Pair[K, V]{
+			Key: key,
+			Val: m[key],
+		})
+
+		// ignored value
+		if err := skipJSONValue(dec); err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
+
+			return err
+		}
+	}
+
+	return nil
+}
+
+var errJSONEnd = errors.New("invalid end of json array or object")
+
+func skipJSONValue(dec *json.Decoder) error {
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	switch t {
+	case json.Delim('['), json.Delim('{'):
+		for {
+			if err := skipJSONValue(dec); err != nil {
+				if errors.Is(err, errJSONEnd) {
+					break
+				}
+				return err
+			}
+		}
+	case json.Delim(']'), json.Delim('}'):
+		return errJSONEnd
+	}
+
+	return nil
+}

json_test.go

@@ -0,0 +1,36 @@
+package orderedmap
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/alecthomas/assert/v2"
+)
+
+func TestOrderedMap_MarshalJSON(t *testing.T) {
+	now := time.Now().UTC().Truncate(time.Second)
+	got, err := json.Marshal(OrderedMap[string, any]{
+		{"name", "John"},
+		{"age", 30},
+		{"active", true},
+		{"last_access_time", now},
+	})
+	assert.NoError(t, err)
+	assert.Equal(t, `{"name":"John","age":30,"active":true,"last_access_time":"`+now.Format(time.RFC3339Nano)+`"}`, string(got))
+}
+
+func TestOrderedMap_UnmarshalJSON(t *testing.T) {
+	now := time.Now().UTC().Truncate(time.Second)
+	nowStr := now.Format(time.RFC3339Nano)
+	var got OrderedMap[string, any]
+	err := json.Unmarshal([]byte(`{"name":"John","age":30,"active":true,"last_access_time":"`+nowStr+`"}`), &got)
+	assert.NoError(t, err)
+
+	assert.Equal(t, OrderedMap[string, any]{
+		{"name", "John"},
+		{"age", float64(30)}, // json always unmarshals numbers as float64
+		{"active", true},
+		{"last_access_time", nowStr}, // json doesn't detect time.Time
+	}, got)
+}

ordered_map.go

@@ -0,0 +1,92 @@
+package orderedmap
+
+type OrderedMap[K comparable, V any] []Pair[K, V]
+
+type Pair[K comparable, V any] struct {
+	Key K
+	Val V
+}
+
+func New[K comparable, V any]() OrderedMap[K, V] {
+	return OrderedMap[K, V]{}
+}
+
+func (m OrderedMap[K, V]) Has(key K) bool {
+	_, ok := m.Get(key)
+	return ok
+}
+
+func (m OrderedMap[K, V]) Get(key K) (V, bool) {
+	for _, p := range m {
+		if p.Key == key {
+			return p.Val, true
+		}
+	}
+	var zero V
+	return zero, false
+}
+
+func (m *OrderedMap[K, V]) Set(key K, val V) {
+	if m == nil {
+		*m = OrderedMap[K, V]{}
+	}
+
+	for i, p := range *m {
+		if p.Key == key {
+			(*m)[i].Val = val
+			return
+		}
+	}
+	*m = append(*m, Pair[K, V]{key, val})
+}
+
+func (m *OrderedMap[K, V]) Delete(key K) {
+	if m == nil || len(*m) == 0 {
+		return
+	}
+
+	for i, p := range *m {
+		if p.Key == key {
+			*m = append((*m)[:i], (*m)[i+1:]...)
+			return
+		}
+	}
+}
+
+func (m OrderedMap[K, V]) Keys() []K {
+	if m == nil {
+		return nil
+	}
+	keys := make([]K, len(m))
+	for i, p := range m {
+		keys[i] = p.Key
+	}
+	return keys
+}
+
+func (m OrderedMap[K, V]) Values() []V {
+	if m == nil {
+		return nil
+	}
+	values := make([]V, len(m))
+	for i, p := range m {
+		values[i] = p.Val
+	}
+	return values
+}
+
+func (m *OrderedMap[K, V]) Clear() {
+	if m == nil || len(*m) == 0 {
+		return
+	}
+
+	*m = []Pair[K, V]{}
+}
+
+func (m OrderedMap[K, V]) Copy() OrderedMap[K, V] {
+	if m == nil {
+		return nil
+	}
+
+	return append([]Pair[K, V]{}, m...)
+}