snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/pkg/slice/ints.go

@@ -0,0 +1,42 @@
+package slice
+
+import (
+	"bytes"
+	"strconv"
+)
+
+type (
+	// UInt64s represents slice of uint64 with some extra powers:
+	//  - encodes (JSON) uint64s as strings
+	UInt64s []uint64
+)
+
+func HasUint64(ss []uint64, s uint64) bool {
+	for _, value := range ss {
+		if value == s {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (uu UInt64s) MarshalJSON() ([]byte, error) {
+	var (
+		buf = bytes.Buffer{}
+	)
+
+	buf.WriteByte('[')
+	for i, u := range uu {
+		if i > 0 {
+			buf.WriteByte(',')
+		}
+
+		buf.WriteByte('"')
+		buf.WriteString(strconv.FormatUint(u, 10))
+		buf.WriteByte('"')
+	}
+	buf.WriteByte(']')
+
+	return buf.Bytes(), nil
+}

server/pkg/slice/ints_test.go

@@ -0,0 +1,77 @@
+package slice
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestHasUint64(t *testing.T) {
+	cases := []struct {
+		name string
+		ss   []uint64
+		s    uint64
+		o    bool
+	}{
+		{
+			"empty",
+			[]uint64{},
+			42,
+			false,
+		},
+		{
+			"has not",
+			[]uint64{42},
+			12345,
+			false,
+		},
+		{
+			"has",
+			[]uint64{42},
+			42,
+			true,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			ok := HasUint64(c.ss, c.s)
+			assert.EqualValues(t, ok, c.o)
+		})
+	}
+}
+
+func TestUInt64s_MarshalJSON(t *testing.T) {
+	cases := []struct {
+		name string
+		ii   UInt64s
+		json string
+	}{
+		{
+			"empty",
+			UInt64s{},
+			`[]`,
+		},
+		{
+			"one",
+			UInt64s{285372959844073660},
+			`["285372959844073660"]`,
+		},
+		{
+			"two",
+			UInt64s{285372959844073660, 285372959844073661},
+			`["285372959844073660","285372959844073661"]`,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var (
+				req         = require.New(t)
+				result, err = json.Marshal(c.ii)
+			)
+
+			req.NoError(err)
+			req.Equal(string(result), c.json)
+		})
+	}
+}

server/pkg/slice/keys.go

@@ -0,0 +1,26 @@
+package slice
+
+import (
+	"reflect"
+	"sort"
+
+	"github.com/spf13/cast"
+)
+
+// Keys returns sorted map keys
+//
+// If input is not a map it will return an empty slice
+func Keys(m interface{}) (kk []string) {
+	v := reflect.ValueOf(m)
+	if v.Kind() == reflect.Map {
+		kk = make([]string, 0, v.Len())
+		for _, kval := range v.MapKeys() {
+			if k := cast.ToString(kval.Interface()); k != "" {
+				kk = append(kk, k)
+			}
+		}
+	}
+
+	sort.Strings(kk)
+	return
+}

server/pkg/slice/keys_test.go

@@ -0,0 +1,52 @@
+package slice
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestKeys(t *testing.T) {
+	var (
+		cases = []struct {
+			name string
+			in   interface{}
+			out  string
+		}{
+			{
+				in: map[string]interface{}{"b": nil, "c": nil, "d": nil, "a": nil},
+				// warning! false booleans will not be set and that is ok!
+				out: "a,b,c,d",
+			},
+			{
+				in: map[int]interface{}{4: nil, 2: nil, 3: nil, 1: nil},
+				// warning! false booleans will not be set and that is ok!
+				out: "1,2,3,4",
+			},
+			{
+				in:  nil,
+				out: "",
+			},
+			{
+				in:  42,
+				out: "",
+			},
+		}
+	)
+
+	for _, c := range cases {
+		if c.name == "" && c.in != nil {
+			c.name = fmt.Sprintf("%T", c.in)
+		}
+
+		t.Run(c.name, func(t *testing.T) {
+			var (
+				req = require.New(t)
+			)
+
+			req.EqualValues(c.out, strings.Join(Keys(c.in), ","))
+		})
+	}
+}

server/pkg/slice/strings.go

@@ -0,0 +1,89 @@
+package slice
+
+func ContainsAny[C comparable](haystack []C, needles ...C) bool {
+	for _, h := range haystack {
+		for _, n := range needles {
+			if h == n {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func ContainsAll[C comparable](haystack []C, needles ...C) bool {
+	var matches = 0
+	for _, h := range haystack {
+		for _, n := range needles {
+			if h == n {
+				matches++
+			}
+		}
+	}
+
+	return len(needles) == matches
+}
+
+func IntersectStrings(a []string, b []string) []string {
+	var (
+		out = make([]string, 0, len(a)+len(b))
+		ah  = ToStringBoolMap(a)
+	)
+
+	for i := 0; i < len(b); i++ {
+		if ah[b[i]] {
+			out = append(out, b[i])
+		}
+	}
+
+	return out
+}
+
+func ToStringBoolMap(s []string) (h map[string]bool) {
+	h = make(map[string]bool)
+	for i := 0; i < len(s); i++ {
+		h[s[i]] = true
+	}
+
+	return
+}
+
+func ToUint64BoolMap(u []uint64) (h map[uint64]bool) {
+	h = make(map[uint64]bool)
+	for i := 0; i < len(u); i++ {
+		h[u[i]] = true
+	}
+
+	return
+}
+
+// @todo replace with ContainsAny
+func HasString(ss []string, s string) bool {
+	for i := range ss {
+		if ss[i] == s {
+			return true
+		}
+	}
+
+	return false
+}
+
+// RemoveString removes one or more strings form the input slice
+func PluckString(ss []string, ff ...string) (o []string) {
+	if len(ff) == 0 {
+		return ss
+	}
+
+	f := ToStringBoolMap(ff)
+	o = make([]string, 0, len(ss))
+
+	for _, s := range ss {
+		if !f[s] {
+			// remove from the list
+			o = append(o, s)
+		}
+	}
+
+	return o
+}

server/pkg/slice/strings_test.go

@@ -0,0 +1,152 @@
+package slice
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestIntersectStrings(t *testing.T) {
+	cases := []struct {
+		name string
+		a    []string
+		b    []string
+		c    []string
+	}{
+		{
+			"empty",
+			[]string{},
+			[]string{},
+			[]string{},
+		},
+		{
+			"none",
+			[]string{"a"},
+			[]string{"b"},
+			[]string{},
+		},
+		{
+			"some",
+			[]string{"a", "b"},
+			[]string{"a", "c"},
+			[]string{"a"},
+		},
+		{
+			"all",
+			[]string{"a", "b"},
+			[]string{"a", "b"},
+			[]string{"a", "b"},
+		},
+		{
+			"dups",
+			[]string{"a", "b", "b", "b"},
+			[]string{"a", "b"},
+			[]string{"a", "b"},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.EqualValues(t, IntersectStrings(c.a, c.b), c.c)
+		})
+	}
+}
+
+func TestToStringBoolMap(t *testing.T) {
+	cases := []struct {
+		name string
+		i    []string
+		o    map[string]bool
+	}{
+		{
+			"empty",
+			[]string{},
+			map[string]bool{},
+		},
+		{
+			"some",
+			[]string{"a"},
+			map[string]bool{"a": true},
+		},
+		{
+			"many",
+			[]string{"a", "b", "c", "c", "d"},
+			map[string]bool{"a": true, "b": true, "c": true, "d": true},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.EqualValues(t, ToStringBoolMap(c.i), c.o)
+		})
+	}
+}
+
+func TestHasString(t *testing.T) {
+	cases := []struct {
+		name string
+		ss   []string
+		s    string
+		o    bool
+	}{
+		{
+			"empty",
+			[]string{},
+			"a",
+			false,
+		},
+		{
+			"has not",
+			[]string{"a"},
+			"b",
+			false,
+		},
+		{
+			"has",
+			[]string{"a"},
+			"a",
+			true,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.EqualValues(t, HasString(c.ss, c.s), c.o)
+		})
+	}
+}
+
+func TestPluckStrung(t *testing.T) {
+	cases := []struct {
+		name string
+		ss   []string
+		ff   []string
+		o    []string
+	}{
+		{
+			"empty",
+			[]string{},
+			[]string{},
+			[]string{},
+		},
+		{
+			"some",
+			[]string{"a", "b"},
+			[]string{"a"},
+			[]string{"b"},
+		},
+		{
+			"all",
+			[]string{"a", "b"},
+			[]string{"a", "b"},
+			[]string{},
+		},
+		{
+			"not there",
+			[]string{"a"},
+			[]string{"b"},
+			[]string{"a"},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.EqualValues(t, PluckString(c.ss, c.ff...), c.o)
+		})
+	}
+}