Merge pull request #40 from yoheimuta/support-option

feat: Support oneof options

Author: yoheimuta

Makefile

@@ -19,7 +19,7 @@ test/lint:
 	# checks the error the compiler can't find.
 	go vet ./...
 	# checks shadowed variables.
-	go vet -shadow ./...
+	go vet -vettool=$(which shadow) ./...
 	# checks not to ignore the error.
 	errcheck ./...
 	# checks unused global variables and constants.

parser/oneof.go

@@ -44,6 +44,8 @@ type Oneof struct {
 	OneofFields []*OneofField
 	OneofName   string
 
+	Options []*Option
+
 	// Comments are the optional ones placed at the beginning.
 	Comments []*Comment
 	// InlineComment is the optional one placed at the ending.
@@ -68,6 +70,9 @@ func (o *Oneof) Accept(v Visitor) {
 	for _, field := range o.OneofFields {
 		field.Accept(v)
 	}
+	for _, option := range o.Options {
+		option.Accept(v)
+	}
 	for _, comment := range o.Comments {
 		comment.Accept(v)
 	}
@@ -101,6 +106,7 @@ func (p *Parser) ParseOneof() (*Oneof, error) {
 	inlineLeftCurly := p.parseInlineComment()
 
 	var oneofFields []*OneofField
+	var options []*Option
 	for {
 		comments := p.ParseComments()
 
@@ -109,13 +115,27 @@ func (p *Parser) ParseOneof() (*Oneof, error) {
 			continue
 		}
 
-		oneofField, err := p.parseOneofField()
-		if err != nil {
-			return nil, err
+		p.lex.NextKeyword()
+		token := p.lex.Token
+		p.lex.UnNext()
+		if p.permissive && token == scanner.TOPTION {
+			// accept an option. See https://github.com/yoheimuta/go-protoparser/issues/39.
+			option, err := p.ParseOption()
+			if err != nil {
+				return nil, err
+			}
+			option.Comments = comments
+			p.MaybeScanInlineComment(option)
+			options = append(options, option)
+		} else {
+			oneofField, err := p.parseOneofField()
+			if err != nil {
+				return nil, err
+			}
+			oneofField.Comments = comments
+			p.MaybeScanInlineComment(oneofField)
+			oneofFields = append(oneofFields, oneofField)
 		}
-		oneofField.Comments = comments
-		p.MaybeScanInlineComment(oneofField)
-		oneofFields = append(oneofFields, oneofField)
 
 		p.lex.Next()
 		if p.lex.Token == scanner.TRIGHTCURLY {
@@ -137,6 +157,7 @@ func (p *Parser) ParseOneof() (*Oneof, error) {
 	return &Oneof{
 		OneofFields:                  oneofFields,
 		OneofName:                    oneofName,
+		Options:                      options,
 		InlineCommentBehindLeftCurly: inlineLeftCurly,
 		Meta:                         meta.NewMetaWithLastPos(startPos, lastPos),
 	}, nil

parser/oneof_test.go

@@ -367,6 +367,101 @@ func TestParser_ParseOneof(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "accept options. See https://github.com/yoheimuta/go-protoparser/issues/39",
+			input: `oneof something {
+  option (validator.oneof) = {required: true};
+  uint32 three_int = 5 [(validator.field) = {int_gt: 20}];
+  uint32 four_int = 6 [(validator.field) = {int_gt: 100}];
+  string five_regex = 7 [(validator.field) = {regex: "^[a-z]{2,5}$"}];
+}
+`,
+			permissive: true,
+			wantOneof: &parser.Oneof{
+				OneofFields: []*parser.OneofField{
+					{
+						Type:        "uint32",
+						FieldName:   "three_int",
+						FieldNumber: "5",
+						FieldOptions: []*parser.FieldOption{
+							{
+								OptionName: "(validator.field)",
+								Constant:   "{int_gt:20}",
+							},
+						},
+						Meta: meta.Meta{
+							Pos: meta.Position{
+								Offset: 67,
+								Line:   3,
+								Column: 3,
+							},
+						},
+					},
+					{
+						Type:        "uint32",
+						FieldName:   "four_int",
+						FieldNumber: "6",
+						FieldOptions: []*parser.FieldOption{
+							{
+								OptionName: "(validator.field)",
+								Constant:   "{int_gt:100}",
+							},
+						},
+						Meta: meta.Meta{
+							Pos: meta.Position{
+								Offset: 126,
+								Line:   4,
+								Column: 3,
+							},
+						},
+					},
+					{
+						Type:        "string",
+						FieldName:   "five_regex",
+						FieldNumber: "7",
+						FieldOptions: []*parser.FieldOption{
+							{
+								OptionName: "(validator.field)",
+								Constant:   "{regex:\"^[a-z]{2,5}$\"}",
+							},
+						},
+						Meta: meta.Meta{
+							Pos: meta.Position{
+								Offset: 185,
+								Line:   5,
+								Column: 3,
+							},
+						},
+					},
+				},
+				Options: []*parser.Option{
+					{
+						OptionName: "(validator.oneof)",
+						Constant:   "{required:true}",
+						Meta: meta.Meta{
+							Pos: meta.Position{
+								Offset: 20,
+								Line:   2,
+								Column: 3,
+							},
+						},
+					},
+				},
+				OneofName: "something",
+				Meta: meta.Meta{
+					Pos: meta.Position{
+						Offset: 0,
+						Line:   1,
+						Column: 1,
+					},
+					LastPos: meta.Position{
+						Offset: 254,
+						Line:   6,
+						Column: 1,
+					},
+				},
+			},
+		},
 	}
 
 	for _, test := range tests {