[performance] bump codeberg.org/gruf/go-kv to v2 (#4341)

updates our codeberg.org/gruf/go-kv log key-value formatting library to latest version, which comes with some maaaaaaajor speed boosts in the form of:
- very minimal reflect.Value{} usage
- caching prepared formatting functions per type

~~still a work-in-progress until i make a release tag on the go-kv repository, which itself is waiting on published benchmark results in the README and finishing writing some code comments~~

benchmarks so far show this to be ~3x faster than the "fmt" stdlib package on average, when run across a wide variety (106 different types) of test cases, while still creating more visually friendly log output and actually recursing down nested struct ptrs

Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4341
Co-authored-by: kim <grufwub@gmail.com>
Co-committed-by: kim <grufwub@gmail.com>

1 files changed, 130 insertions, 0 deletions

diff --git a/vendor/codeberg.org/gruf/go-kv/v2/format/map.go b/vendor/codeberg.org/gruf/go-kv/v2/format/map.go
new file mode 100644
index 000000000..038fb74ac
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-kv/v2/format/map.go
@@ -0,0 +1,130 @@
+package format
+
+import "unsafe"
+
+// iterMapType returns a FormatFunc capable of iterating
+// and formatting the given map type currently in typenode{}.
+// note this will fetch sub-FormatFuncs for key / value types.
+func (fmt *Formatter) iterMapType(t typenode) FormatFunc {
+
+	// Key / value types.
+	key := t.rtype.Key()
+	elem := t.rtype.Elem()
+
+	// Get nested k / v typenodes with appropriate flags.
+	flagsKey := reflect_map_key_flags(key)
+	flagsVal := reflect_map_elem_flags(elem)
+	kt := t.next(t.rtype.Key(), flagsKey)
+	vt := t.next(t.rtype.Elem(), flagsVal)
+
+	// Get key format func.
+	kfn := fmt.loadOrGet(kt)
+	if kfn == nil {
+		panic("unreachable")
+	}
+
+	// Get value format func.
+	vfn := fmt.loadOrGet(vt)
+	if vfn == nil {
+		panic("unreachable")
+	}
+
+	// Final map type.
+	rtype := t.rtype
+	flags := t.flags
+
+	// Map type string with ptrs / refs.
+	typestrPtrs := t.typestr_with_ptrs()
+	typestrRefs := t.typestr_with_refs()
+
+	if !t.needs_typestr() {
+		return func(s *State) {
+			if s.P == nil || *(*unsafe.Pointer)(s.P) == nil {
+				// Append nil.
+				appendNil(s)
+				return
+			}
+
+			// Build reflect value, and then a map iter.
+			v := build_reflect_value(rtype, s.P, flags)
+			i := map_iter(v)
+
+			// Prepend object brace.
+			s.B = append(s.B, '{')
+
+			// Before len.
+			l := len(s.B)
+
+			for i.Next() {
+				// Pass to key fn.
+				s.P = map_key(i)
+				kfn(s)
+
+				// Add key seperator.
+				s.B = append(s.B, '=')
+
+				// Pass to elem fn.
+				s.P = map_elem(i)
+				vfn(s)
+
+				// Add comma pair seperator.
+				s.B = append(s.B, ',', ' ')
+			}
+
+			if len(s.B) != l {
+				// Drop final ", ".
+				s.B = s.B[:len(s.B)-2]
+			}
+
+			// Append object brace.
+			s.B = append(s.B, '}')
+		}
+	}
+
+	return func(s *State) {
+		if s.P == nil || *(*unsafe.Pointer)(s.P) == nil {
+			// Append nil value with type.
+			appendNilType(s, typestrPtrs)
+			return
+		}
+
+		// Build reflect value, and then a map iter.
+		v := build_reflect_value(rtype, s.P, flags)
+		i := map_iter(v)
+
+		// Include type info.
+		if s.A.WithType() {
+			s.B = append(s.B, typestrRefs...)
+		}
+
+		// Prepend object brace.
+		s.B = append(s.B, '{')
+
+		// Before len.
+		l := len(s.B)
+
+		for i.Next() {
+			// Pass to key fn.
+			s.P = map_key(i)
+			kfn(s)
+
+			// Add key seperator.
+			s.B = append(s.B, '=')
+
+			// Pass to elem fn.
+			s.P = map_elem(i)
+			vfn(s)
+
+			// Add comma pair seperator.
+			s.B = append(s.B, ',', ' ')
+		}
+
+		if len(s.B) != l {
+			// Drop final ", ".
+			s.B = s.B[:len(s.B)-2]
+		}
+
+		// Append object brace.
+		s.B = append(s.B, '}')
+	}
+}