Add utility functions to access args

Author: jpbetz

v2/codetags/types.go

@@ -41,6 +41,29 @@ type Tag struct {
 	ValueType ValueType
 }
 
+// PositionalArg returns the positional argument. If there is no positional
+// argument, it returns false.
+func (t Tag) PositionalArg() (Arg, bool) {
+	if len(t.Args) == 0 || len(t.Args[0].Name) > 0 {
+		return Arg{}, false
+	}
+	return t.Args[0], true
+}
+
+// NamedArg returns the named argument. If o named argument is found, it returns
+// false. Always returns false for empty name; use PositionalArg instead.
+func (t Tag) NamedArg(name string) (Arg, bool) {
+	if len(name) == 0 {
+		return Arg{}, false
+	}
+	for _, arg := range t.Args {
+		if arg.Name == name {
+			return arg, true
+		}
+	}
+	return Arg{}, false
+}
+
 // String returns the canonical string representation of the tag.
 // All strings are represented in double quotes. Spacing is normalized.
 func (t Tag) String() string {

v2/codetags/types_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package codetags
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -197,3 +198,134 @@ func TestTypedTagString(t *testing.T) {
 		})
 	}
 }
+
+func TestTagArgAccessors(t *testing.T) {
+	strPtr := func(s string) *string { return &s }
+
+	tests := []struct {
+		name           string
+		tag            Tag
+		argName        *string
+		wantPositional *Arg
+		wantNamed      *Arg
+		found          bool
+	}{
+		{
+			name: "found positional arg",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{
+					{Value: "value1", Type: ArgTypeInt},
+				},
+			},
+			wantPositional: &Arg{Value: "value1", Type: ArgTypeInt},
+			found:          true,
+		},
+		{
+			name: "not found positional arg, no args",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{},
+			},
+			found: false,
+		},
+		{
+			name: "not found positional arg, only named args",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{
+					{Name: "arg1", Value: "value1", Type: ArgTypeInt},
+					{Name: "arg1", Value: "value2", Type: ArgTypeString},
+				},
+			},
+			found: false,
+		},
+
+		{
+			name: "found named arg, first",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{
+					{Name: "arg1", Value: "value1", Type: ArgTypeString},
+					{Name: "arg2", Value: "value2", Type: ArgTypeString},
+					{Name: "arg3", Value: "value3", Type: ArgTypeString},
+				},
+			},
+			argName:   strPtr("arg1"),
+			wantNamed: &Arg{Name: "arg1", Value: "value1", Type: ArgTypeString},
+			found:     true,
+		},
+		{
+			name: "found named arg, second",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{
+					{Name: "arg1", Value: "value1", Type: ArgTypeString},
+					{Name: "arg2", Value: "value2", Type: ArgTypeString},
+					{Name: "arg3", Value: "value3", Type: ArgTypeString},
+				},
+			},
+			argName:   strPtr("arg3"),
+			wantNamed: &Arg{Name: "arg3", Value: "value3", Type: ArgTypeString},
+			found:     true,
+		},
+		{
+			name: "not found named arg, no args",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{},
+			},
+			argName: strPtr("arg1"),
+			found:   false,
+		},
+		{
+			name: "not found named arg, not in args",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{
+					{Name: "arg1", Value: "value1", Type: ArgTypeString},
+					{Name: "arg2", Value: "value2", Type: ArgTypeString},
+					{Name: "arg3", Value: "value3", Type: ArgTypeString},
+				},
+			},
+			argName: strPtr("arg4"),
+			found:   false,
+		},
+		{
+			name: "not found named arg, only positional args",
+			tag: Tag{
+				Name: "tag",
+				Args: []Arg{
+					{Value: "value1", Type: ArgTypeString},
+				},
+			},
+			argName: strPtr(""),
+			found:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.wantPositional != nil {
+				got, ok := tt.tag.PositionalArg()
+				if ok != tt.found {
+					t.Fatalf("got: %v, want: %v", ok, tt.found)
+				}
+				if !reflect.DeepEqual(got, *tt.wantPositional) {
+					t.Fatalf("got: %v, want: %v", got, tt.wantPositional)
+				}
+			}
+			if tt.argName != nil {
+				got, ok := tt.tag.NamedArg(*tt.argName)
+				if ok != tt.found {
+					t.Fatalf("got: %v, want: %v", ok, tt.found)
+				}
+				if tt.wantNamed != nil {
+					if !reflect.DeepEqual(got, *tt.wantNamed) {
+						t.Fatalf("got: %v, want: %v", got, tt.wantNamed)
+					}
+				}
+			}
+		})
+	}
+}