Merge pull request #1157 from nyaruka/more_generics

Convert `StringSet` functions to be generic

contactql/inspect.go

@@ -69,8 +69,8 @@ func Inspect(query *ContactQuery) *Inspection {
 	allowAsGroup := !(attributes[AttributeID] || attributes[AttributeStatus] || attributes[AttributeGroup] || attributes[AttributeFlow] || attributes[AttributeHistory])
 
 	return &Inspection{
-		Attributes:   utils.StringSetKeys(attributes),
-		Schemes:      utils.StringSetKeys(schemes),
+		Attributes:   utils.SortedKeys(attributes),
+		Schemes:      utils.SortedKeys(schemes),
 		Fields:       fieldRefs,
 		Groups:       groupRefs,
 		AllowAsGroup: allowAsGroup,

flows/definition/flow.go

@@ -268,7 +268,7 @@ func (f *flow) extract() ([]flows.ExtractedTemplate, []flows.ExtractedReference,
 		})
 	}
 
-	return templates, assetRefs, utils.StringSetKeys(parentRefs)
+	return templates, assetRefs, utils.SortedKeys(parentRefs)
 }
 
 // extracts all result specs

flows/translation/flows.go

@@ -73,7 +73,7 @@ func ExtractFromFlows(initialComment string, translationsLanguage envs.Language,
 }
 
 func findLocalizedText(translationsLanguage envs.Language, excludeProperties []string, sources []flows.Flow) []*localizedText {
-	exclude := utils.StringSet(excludeProperties)
+	exclude := utils.Set(excludeProperties)
 	extracted := make([]*localizedText, 0)
 
 	for _, flow := range sources {

utils/misc.go

@@ -4,6 +4,8 @@ import (
 	"reflect"
 
 	"golang.org/x/exp/constraints"
+	"golang.org/x/exp/maps"
+	"golang.org/x/exp/slices"
 )
 
 // IsNil returns whether the given object is nil or an interface to a nil
@@ -39,6 +41,22 @@ func Min[T constraints.Ordered](x, y T) T {
 	return y
 }
 
+// Set converts a slice to a set (a K > bool map)
+func Set[K constraints.Ordered](s []K) map[K]bool {
+	m := make(map[K]bool, len(s))
+	for _, v := range s {
+		m[v] = true
+	}
+	return m
+}
+
+// SortedKeys returns the keys of a set in lexical order
+func SortedKeys[K constraints.Ordered](m map[K]bool) []K {
+	keys := maps.Keys(m)
+	slices.Sort(keys)
+	return keys
+}
+
 // Typed is an interface of objects that are marshalled as typed envelopes
 type Typed interface {
 	Type() string

utils/misc_test.go

@@ -30,6 +30,18 @@ func TestMin(t *testing.T) {
 	assert.Equal(t, uint16(0), utils.Min(uint16(0), uint16(1)))
 }
 
+func TestSortedKeys(t *testing.T) {
+	assert.Equal(t, []string{}, utils.SortedKeys(map[string]bool{}))
+	assert.Equal(t, []string{"a", "x", "y"}, utils.SortedKeys(map[string]bool{"x": true, "y": true, "a": true}))
+	assert.Equal(t, []int{3, 5, 6}, utils.SortedKeys(map[int]bool{6: true, 3: true, 5: true}))
+}
+
+func TestSet(t *testing.T) {
+	assert.Equal(t, map[string]bool{}, utils.Set[string](nil))
+	assert.Equal(t, map[string]bool{}, utils.Set([]string{}))
+	assert.Equal(t, map[string]bool{"x": true, "y": true, "a": true}, utils.Set([]string{"a", "x", "y"}))
+}
+
 func TestReadTypeFromJSON(t *testing.T) {
 	_, err := utils.ReadTypeFromJSON([]byte(`{}`))
 	assert.EqualError(t, err, "field 'type' is required")

utils/text.go

@@ -2,7 +2,6 @@ package utils
 
 import (
 	"regexp"
-	"sort"
 	"strings"
 
 	"github.com/blevesearch/segment"
@@ -83,25 +82,6 @@ func StringSliceContains(slice []string, str string, caseSensitive bool) bool {
 	return false
 }
 
-// StringSet converts a slice of strings to a set (a string > bool map)
-func StringSet(s []string) map[string]bool {
-	m := make(map[string]bool, len(s))
-	for _, v := range s {
-		m[v] = true
-	}
-	return m
-}
-
-// StringSetKeys returns the keys of string set in lexical order
-func StringSetKeys(m map[string]bool) []string {
-	vals := make([]string, 0, len(m))
-	for v := range m {
-		vals = append(vals, v)
-	}
-	sort.Strings(vals)
-	return vals
-}
-
 // Indent indents each non-empty line in the given string
 func Indent(s string, prefix string) string {
 	output := strings.Builder{}

utils/text_test.go

@@ -148,14 +148,3 @@ func TestIndent(t *testing.T) {
 	assert.Equal(t, "  x\n\n  y", utils.Indent("x\n\ny", "  "))
 	assert.Equal(t, ">>>x", utils.Indent("x", ">>>"))
 }
-
-func TestStringSet(t *testing.T) {
-	assert.Equal(t, map[string]bool{}, utils.StringSet(nil))
-	assert.Equal(t, map[string]bool{}, utils.StringSet([]string{}))
-	assert.Equal(t, map[string]bool{"x": true, "y": true, "a": true}, utils.StringSet([]string{"a", "x", "y"}))
-}
-
-func TestStringSetKeys(t *testing.T) {
-	assert.Equal(t, []string{}, utils.StringSetKeys(map[string]bool{}))
-	assert.Equal(t, []string{"a", "x", "y"}, utils.StringSetKeys(map[string]bool{"x": true, "y": true, "a": true}))
-}