fix(selectors): more permissive with slice "from" underflow

traversal/selector/matcher.go

@@ -32,6 +32,24 @@ type Slice struct {
 	To   int64
 }
 
+func sliceBounds(from, to, length int64) (bool, int64, int64) {
+	if to < 0 {
+		to = length + to
+	} else if length < to {
+		to = length
+	}
+	if from < 0 {
+		from = length + from
+		if from < 0 {
+			from = 0
+		}
+	}
+	if from > to || from >= length {
+		return false, 0, 0
+	}
+	return true, from, to
+}
+
 func (s Slice) Slice(n datamodel.Node) (datamodel.Node, error) {
 	var from, to int64
 	switch n.Kind() {
@@ -41,24 +59,11 @@ func (s Slice) Slice(n datamodel.Node) (datamodel.Node, error) {
 			return nil, err
 		}
 
-		to = s.To
-		from = s.From
-		length := int64(len(str))
-
-		if to < 0 {
-			to = length + to
-		} else if length < to {
-			to = length
-		}
-		if from < 0 {
-			from = length + from
-		} else if length < from {
-			from = length
-		}
-		if from < 0 || to < 0 || from > to || from >= length {
+		var match bool
+		match, from, to = sliceBounds(s.From, s.To, int64(len(str)))
+		if !match {
 			return nil, nil
 		}
-
 		return basicnode.NewString(str[from:to]), nil
 	case datamodel.Kind_Bytes:
 		to = s.To
@@ -91,21 +96,11 @@ func (s Slice) Slice(n datamodel.Node) (datamodel.Node, error) {
 			length = int64(len(bytes))
 		}
 
-		if to < 0 {
-			to = length + to
-		} else if length < to {
-			to = length
-		}
-		if from < 0 {
-			from = length + from
-		} else if length < from {
-			from = length
-		}
-
-		if from < 0 || to < 0 || from > to || from >= length {
+		var match bool
+		match, from, to = sliceBounds(from, to, length)
+		if !match {
 			return nil, nil
 		}
-
 		if rdr != nil {
 			sr := io.NewSectionReader(&readerat{rdr, 0}, from, to-from)
 			return basicnode.NewBytesFromReader(sr), nil

traversal/selector/matcher_test.go

@@ -3,6 +3,7 @@ package selector_test
 import (
 	"fmt"
 	"math"
+	"regexp"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
@@ -78,9 +79,11 @@ func TestSubsetMatch(t *testing.T) {
 		{-int64(len(expectedString)), math.MaxInt64, expectedString, true},
 		{math.MaxInt64 - 1, math.MaxInt64, "", false},
 		{int64(len(expectedString)), math.MaxInt64, "", false},
-		{-1000, -100, "", false},
-		{-1, -2, "", false},
-		{-1, -1, "", true}, // matches empty node
+		{-1, -2, "", false},                 // To < From, no match
+		{-1, -1, "", true},                  // To==From, match zero bytes
+		{-1000, -100, "", false},            // From undeflow, adjusted to 0, To underflow, not adjusted, To < From, no match
+		{-100, -1000, "", false},            // From undeflow, adjusted to 0, To underflow, adjusted to 0, To < From, no match
+		{-1000, 1000, expectedString, true}, // From undeflow, adjusted to 0, To overflow, adjusted to len, match all
 	} {
 		for _, variant := range nodes {
 			t.Run(fmt.Sprintf("%s[%d:%d]", variant.name, tc.from, tc.to), func(t *testing.T) {
@@ -123,4 +126,15 @@ func TestSubsetMatch(t *testing.T) {
 			})
 		}
 	}
+
+	// when both are positive, we can validate ranges up-front
+	t.Run("invalid range", func(t *testing.T) {
+		selNode, err := mkRangeSelector(1000, 100)
+		qt.Assert(t, err, qt.IsNil)
+		re, err := regexp.Compile("from.*less than or equal to.*to")
+		qt.Assert(t, err, qt.IsNil)
+		ss, err := selector.ParseSelector(selNode)
+		qt.Assert(t, ss, qt.IsNil)
+		qt.Assert(t, err, qt.ErrorMatches, re)
+	})
 }