Fallback on reflection to select from slice & map

Turns out to be more straightforward than I expected to support
selecting values not just from `[]any` and `map[string]any` but from any
type of slice or string-keyed map, thanks to the `reflect` package.

Leave the branches for `[]any` and `map[string]any` in place to avoid
the overhead of reflection, but then use reflection if the value is any
other type of slice or map. Resolves #26.

Author: theory

CHANGELOG.md

@@ -9,6 +9,14 @@ All notable changes to this project will be documented in this file. It uses the
 
 ## [v0.11.1] — Unreleased
 
+### ⚡ Improvements
+
+*   Added support for selecting values from any type of slice or map, not just
+    `[]any` or `map[string]any`. Internally it still prefers `[]any` and
+    `map[string]any`, to optimize for values decoded by encoding/json, but it
+    now falls back on reflection to detect any other kind of slice or
+    string-keyed map. Thanks to @ndsboy for the prompt (#26).
+
 ### ⬆️ Dependency Updates
 
 *   Upgraded to `golangci-lint` v2.11.1 and made suggested slice allocation

path_example_test.go

@@ -115,7 +115,7 @@ func ExampleLocatedNodeList() {
 
 func ExampleLocatedNodeList_Deduplicate() {
 	// Load some JSON.
-	pallet := map[string]any{"colors": []any{"red", "blue"}}
+	pallet := map[string]any{"colors": []string{"red", "blue"}}
 
 	// Parse a JSONPath and select from the input.
 	p := jsonpath.MustParse("$.colors[0, 1, 1, 0]")
@@ -133,7 +133,7 @@ func ExampleLocatedNodeList_Deduplicate() {
 
 func ExampleLocatedNodeList_Sort() {
 	// Load some JSON.
-	pallet := map[string]any{"colors": []any{"red", "blue", "green"}}
+	pallet := map[string]any{"colors": []string{"red", "blue", "green"}}
 
 	// Parse a JSONPath and select from the input.
 	p := jsonpath.MustParse("$.colors[2, 0, 1]")
@@ -166,7 +166,7 @@ func ExampleLocatedNodeList_Sort() {
 
 func ExampleLocatedNodeList_Clone() {
 	// Load some JSON.
-	items := []any{1, 2, 3, 4, 5}
+	items := []int{1, 2, 3, 4, 5}
 
 	// Parse a JSONPath and select from the input.
 	p := jsonpath.MustParse("$[2, 0, 1, 0, 1]")
@@ -259,9 +259,9 @@ func ExampleWithRegistry() {
 
 	// Do any of these arrays start with 6?
 	input := []any{
-		[]any{1, 2, 3, 4, 5},
-		[]any{6, 7, 8, 9},
-		[]any{4, 8, 12},
+		[]int{1, 2, 3, 4, 5},
+		[]int{6, 7, 8, 9},
+		[]int{4, 8, 12},
 	}
 	nodes := path.Select(input)
 	fmt.Printf("%v\n", nodes)

registry/funcs.go

@@ -3,6 +3,7 @@ package registry
 import (
 	"errors"
 	"fmt"
+	"reflect"
 	"regexp"
 	"regexp/syntax"
 	"unicode/utf8"
@@ -50,7 +51,13 @@ func lengthFunc(jv []spec.PathValue) spec.PathValue {
 	case map[string]any:
 		return spec.Value(len(v))
 	default:
-		return nil
+		val := reflect.ValueOf(v)
+		switch val.Kind() {
+		case reflect.Slice, reflect.Map:
+			return spec.Value(val.Len())
+		default:
+			return nil
+		}
 	}
 }
 

spec/query.go

@@ -1,6 +1,8 @@
 package spec
 
-import "strings"
+import (
+	"strings"
+)
 
 // PathQuery represents a JSONPath query. Interfaces implemented:
 //   - [Selector]

spec/query_test.go

@@ -288,6 +288,34 @@ func TestQueryObject(t *testing.T) {
 			exp:     []any{},
 			loc:     []*LocatedNode{},
 		},
+		{
+			test:    "string_map",
+			resType: FuncValue,
+			input:   map[string]string{"x": "hi", "y": "y"},
+			segs:    []*Segment{Child(Name("x"))},
+			exp:     []any{"hi"},
+			loc: []*LocatedNode{
+				{Path: Normalized(Name("x")), Node: "hi"},
+			},
+		},
+		{
+			test:    "int_map",
+			resType: FuncValue,
+			input:   map[string]int{"x": 42, "y": 99},
+			segs:    []*Segment{Child(Name("x"))},
+			exp:     []any{42},
+			loc: []*LocatedNode{
+				{Path: Normalized(Name("x")), Node: 42},
+			},
+		},
+		{
+			test:    "int_keyed_map",
+			resType: FuncValue,
+			input:   map[int]string{42: "hi", 99: "y"},
+			segs:    []*Segment{Child(Name("42"))},
+			exp:     []any{},
+			loc:     []*LocatedNode{},
+		},
 	} {
 		t.Run(tc.test, func(t *testing.T) {
 			t.Parallel()
@@ -631,6 +659,22 @@ func TestQueryArray(t *testing.T) {
 				{Path: Normalized(Index(0), Name("x"), Index(1)), Node: 2},
 			},
 		},
+		{
+			test:    "string_slice_index",
+			resType: FuncValue,
+			segs:    []*Segment{Child(Index(0))},
+			input:   []string{"x", "y"},
+			exp:     []any{"x"},
+			loc:     []*LocatedNode{{Path: Normalized(Index(0)), Node: "x"}},
+		},
+		{
+			test:    "int_slice_index",
+			resType: FuncValue,
+			segs:    []*Segment{Child(Index(1))},
+			input:   []int{0, 42},
+			exp:     []any{42},
+			loc:     []*LocatedNode{{Path: Normalized(Index(1)), Node: 42}},
+		},
 	} {
 		t.Run(tc.test, func(t *testing.T) {
 			t.Parallel()
@@ -1101,6 +1145,26 @@ func TestQuerySlice(t *testing.T) {
 				{Path: Normalized(Index(0), Index(1)), Node: 42},
 			},
 		},
+		{
+			test:  "string_slice",
+			segs:  []*Segment{Child(Slice())},
+			input: []string{"x", "y"},
+			exp:   []any{"x", "y"},
+			loc: []*LocatedNode{
+				{Path: Normalized(Index(0)), Node: "x"},
+				{Path: Normalized(Index(1)), Node: "y"},
+			},
+		},
+		{
+			test:  "int_slice",
+			segs:  []*Segment{Child(Slice())},
+			input: []int{42, 99},
+			exp:   []any{42, 99},
+			loc: []*LocatedNode{
+				{Path: Normalized(Index(0)), Node: 42},
+				{Path: Normalized(Index(1)), Node: 99},
+			},
+		},
 	} {
 		t.Run(tc.test, func(t *testing.T) {
 			t.Parallel()

spec/segment.go

@@ -1,6 +1,7 @@
 package spec
 
 import (
+	"reflect"
 	"strings"
 )
 
@@ -94,6 +95,20 @@ func (s *Segment) descend(current, root any) []any {
 		for _, v := range val {
 			ret = append(ret, s.Select(v, root)...)
 		}
+	default:
+		value := reflect.ValueOf(current)
+		switch value.Kind() {
+		case reflect.Slice:
+			for i := range value.Len() {
+				ret = append(ret, s.Select(value.Index(i).Interface(), root)...)
+			}
+		case reflect.Map:
+			for _, k := range value.MapKeys() {
+				ret = append(ret, s.Select(value.MapIndex(k).Interface(), root)...)
+			}
+		default:
+			return nil
+		}
 	}
 	return ret
 }
@@ -111,6 +126,24 @@ func (s *Segment) descendLocated(current, root any, parent NormalizedPath) []*Lo
 		for k, v := range val {
 			ret = append(ret, s.SelectLocated(v, root, append(parent, Name(k)))...)
 		}
+	default:
+		value := reflect.ValueOf(current)
+		switch value.Kind() {
+		case reflect.Slice:
+			for i := range value.Len() {
+				ret = append(ret, s.SelectLocated(
+					value.Index(i).Interface(), root, append(parent, Index(i)),
+				)...)
+			}
+		case reflect.Map:
+			for _, k := range value.MapKeys() {
+				ret = append(ret, s.SelectLocated(
+					value.MapIndex(k).Interface(), root, append(parent, Name(k.String())),
+				)...)
+			}
+		default:
+			return nil
+		}
 	}
 	return ret
 }