feat(sidekick): RFC 6570 "+" support (#3538)

Add support for the "+" operator defined as part of RFC-6570 level 2
templates.

Part of #2820

Author: brianquinlan

internal/sidekick/api/model.go

@@ -668,6 +668,9 @@ type PathSegment struct {
 type PathVariable struct {
 	FieldPath []string
 	Segments  []string
+	// Allow characters defined as `reserved` by RFC-6570 1.5 to pass through without
+	// percent encoding. See RFC-6570 1.2 for examples.
+	AllowReserved bool
 }
 
 // PathMatch is a single wildcard match in a path.
@@ -729,6 +732,12 @@ func (v *PathVariable) WithMatch() *PathVariable {
 	return v
 }
 
+// WithAllowReserved marks the variable as allowing reserved characters to remain unescaped.
+func (v *PathVariable) WithAllowReserved() *PathVariable {
+	v.AllowReserved = true
+	return v
+}
+
 // NewPathSegment creates a new path segment.
 func NewPathSegment() *PathSegment {
 	return &PathSegment{}

internal/sidekick/api/model_test.go

@@ -201,6 +201,7 @@ func TestPathTemplateBuilder(t *testing.T) {
 		WithVariable(NewPathVariable("parent", "child").
 			WithLiteral("projects").
 			WithMatch().
+			WithAllowReserved().
 			WithLiteral("locations").
 			WithMatchRecursive()).
 		WithVariableNamed("v2", "field").
@@ -214,8 +215,9 @@ func TestPathTemplateBuilder(t *testing.T) {
 			},
 			{
 				Variable: &PathVariable{
-					FieldPath: []string{"parent", "child"},
-					Segments:  []string{"projects", "*", "locations", "**"},
+					FieldPath:     []string{"parent", "child"},
+					Segments:      []string{"projects", "*", "locations", "**"},
+					AllowReserved: true,
 				},
 			},
 			{

internal/sidekick/parser/discovery/uritemplate.go

@@ -29,7 +29,7 @@ const (
 )
 
 var (
-	identifierRe = regexp.MustCompile("[A-Za-z][A-Za-z0-9_]*")
+	identifierRe = regexp.MustCompile("^[A-Za-z][A-Za-z0-9_]*$")
 )
 
 // ParseUriTemplate parses a [RFC 6570] URI template as an `api.PathTemplate`.
@@ -73,25 +73,40 @@ func parseExpression(input string) (*api.PathSegment, int, error) {
 		return nil, 0, fmt.Errorf("missing `{` character in expression %q", input)
 	}
 	tail := input[1:]
-	if strings.IndexAny(tail, "+#") == 0 {
-		return nil, 0, fmt.Errorf("level 2 expressions unsupported input=%q", input)
+	end := strings.IndexRune(tail, endExpression)
+	if end == -1 {
+		return nil, 0, fmt.Errorf("missing `}` character at the end of the expression %q", input)
+	}
+	tail = tail[:end]
+	if tail == "" {
+		return nil, 0, fmt.Errorf("empty expression %q", input)
 	}
+
 	if strings.IndexAny(tail, "./?&") == 0 {
 		return nil, 0, fmt.Errorf("level 3 expressions unsupported input=%q", input)
 	}
 	if strings.IndexAny(tail, "=,!@|") == 0 {
 		return nil, 0, fmt.Errorf("reserved character on expression %q", input)
 	}
-	match := identifierRe.FindStringIndex(tail)
-	if match[0] != 0 {
-		return nil, 0, fmt.Errorf("no identifier found on expression %q", input)
+
+	allowReserved := false
+	switch tail[0] {
+	case '+':
+		allowReserved = true
+		tail = tail[1:]
+	case '#':
+		return nil, 0, fmt.Errorf("level 2 fragment expressions unsupported input=%q", input)
 	}
-	id := tail[0:match[1]]
-	tail = tail[match[1]:]
-	if tail == "" || tail[0] != endExpression {
-		return nil, 0, fmt.Errorf("missing `}` character at the end of the expression %q", input)
+
+	match := identifierRe.MatchString(tail)
+	if !match {
+		return nil, 0, fmt.Errorf("invalid varname found on expression %q", input)
+	}
+	variable := api.NewPathVariable(tail).WithMatch()
+	if allowReserved {
+		variable.WithAllowReserved()
 	}
-	return &api.PathSegment{Variable: api.NewPathVariable(id).WithMatch()}, match[1] + 2, nil
+	return &api.PathSegment{Variable: variable}, end + 2, nil
 }
 
 // parseLiteral() extracts a literal value from `input`.

internal/sidekick/parser/discovery/uritemplate_test.go

@@ -43,6 +43,10 @@ func TestParseUriTemplateSuccess(t *testing.T) {
 			WithVariableNamed("zone").
 			WithVariableNamed("parentName").
 			WithLiteral("reservationSubBlocks")},
+		{"v1/{+parent}/externalAccountKeys", api.NewPathTemplate().
+			WithLiteral("v1").
+			WithVariable(api.NewPathVariable("parent").WithAllowReserved().WithMatch()).
+			WithLiteral("externalAccountKeys")},
 	} {
 		got, err := ParseUriTemplate(test.input)
 		if err != nil {
@@ -59,7 +63,6 @@ func TestParseUriTemplateError(t *testing.T) {
 	for _, test := range []struct {
 		input string
 	}{
-		{"v1/{+parent}/externalAccountKeys"},
 		{"a/b/c/"},
 		{"a/b/c|"},
 		{"a/b/{c}|"},
@@ -101,11 +104,16 @@ func TestParseExpression(t *testing.T) {
 
 func TestParseExpressionError(t *testing.T) {
 	for _, input := range []string{
-		"", "(a)",
-		"{+a}", "{#a}",
+		"",
+		"{}",
+		"{+}",
+		"{#}",
+		"(a)",
+		"{#a}",
 		"{.a}", "{/a}", "{?a}", "{&a}",
 		"{=a}", "{,a}", "{!a}", "{@a}", "{|a}",
-		"{a,b}", "{_abc}", "{0abc}", "{ab"} {
+		"{a,b}", "{_abc}", "{0abc}", "{ab", "{abc/}",
+		"{+abc", "{+abc/}"} {
 		if gotSegment, gotWidth, err := parseExpression(input); err == nil {
 			t.Errorf("expected a parsing error with input=%s, gotSegment=%v, gotWidth=%v", input, gotSegment, gotWidth)
 		}