fix edge cases for pathIter, test for pathIter

Author: brian-gavin

cache.go

@@ -45,26 +45,32 @@ func (c *cache) registerConverter(value interface{}, converterFunc Converter) {
 //	var it pathIter
 //	for key, ok := it.start(path); ok; key, ok = it.advance() {}
 type pathIter struct {
-	rest string
+	rest      string
+	lastFound bool
 }
 
 // start initializes the iteration, and returns the first key.
 func (p *pathIter) start(path string) (string, bool) {
-	return p.next(path)
+	// init the iter for the first call to next, so that the first call will either
+	// cut on "." and return the "before", or it will return path if it does not contain
+	// ".".
+	p.rest = path
+	p.lastFound = true
+	return p.next()
 }
 
 // advance advances the iteration to the next key.
 func (p *pathIter) advance() (string, bool) {
-	return p.next(p.rest)
+	return p.next()
 }
 
-// next should only be used by (*pathIter).start and (*pathIter).advance. it will cut path,
+// next should only be used by (*pathIter).start and (*pathIter).advance. it will cut p.rest,
 // and return the "before", storing the "after" for the subsequent call.
-// if path does not contain "." and is non-empty, it will return (path, true), storing "".
-// if path is empty, it will return ("", false). this means the end of iteration.
-func (p *pathIter) next(path string) (key string, ok bool) {
-	key, p.rest, _ = strings.Cut(path, ".")
-	ok = key != ""
+func (p *pathIter) next() (key string, ok bool) {
+	var found bool
+	key, p.rest, found = strings.Cut(p.rest, ".")
+	ok = found || p.lastFound
+	p.lastFound = found
 	return key, ok
 }
 

decoder_test.go

@@ -2566,3 +2566,29 @@ func BenchmarkSliceOfStruct(b *testing.B) {
 		_ = d.Decode(in, v)
 	}
 }
+
+func TestPathIter(t *testing.T) {
+	testcases := []string{
+		"a",
+		"a.b",
+		".b.",
+		".",
+		"..",
+		"",
+	}
+	for _, tc := range testcases {
+		t.Run(tc, func(t *testing.T) {
+			var (
+				it      pathIter
+				split   = strings.Split(tc, ".")
+				collect = make([]string, 0, len(split))
+			)
+			for k, ok := it.start(tc); ok; k, ok = it.advance() {
+				collect = append(collect, k)
+			}
+			if !reflect.DeepEqual(split, collect) {
+				t.Fatalf("expected: %q | got: %q", split, collect)
+			}
+		})
+	}
+}