Feedback

Signed-off-by: George Robinson <[email protected]>

Author: grobinson-grafana

matchers/parse/lexer.go

@@ -104,11 +104,11 @@ func (e UnterminatedError) Error() string {
 type Lexer struct {
 	input  string
 	err    error
-	start  int // the offset of the current token
-	pos    int // the position of the cursor in the input
-	width  int // the width of the last rune
-	column int // the column offset of the current token
-	cols   int // the number of columns (runes) decoded from the input
+	start  int // The offset of the current token.
+	pos    int // The position of the cursor in the input.
+	width  int // The width of the last rune.
+	column int // The column offset of the current token.
+	cols   int // The number of columns (runes) decoded from the input.
 }
 
 func NewLexer(input string) Lexer {
@@ -123,7 +123,7 @@ func (l *Lexer) Peek() (Token, error) {
 	width := l.width
 	column := l.column
 	cols := l.cols
-	// Do not reset l.err because we can return it on the next call to Scan()
+	// Do not reset l.err because we can return it on the next call to Scan().
 	defer func() {
 		l.start = start
 		l.pos = pos
@@ -137,12 +137,12 @@ func (l *Lexer) Peek() (Token, error) {
 func (l *Lexer) Scan() (Token, error) {
 	tok := Token{}
 
-	// Do not attempt to emit more tokens if the input is invalid
+	// Do not attempt to emit more tokens if the input is invalid.
 	if l.err != nil {
 		return tok, l.err
 	}
 
-	// Iterate over each rune in the input and either emit a token or an error
+	// Iterate over each rune in the input and either emit a token or an error.
 	for r := l.next(); r != eof; r = l.next() {
 		switch {
 		case r == '{':
@@ -198,11 +198,11 @@ func (l *Lexer) scanOperator() (Token, error) {
 		return Token{}, err
 	}
 
-	// Rewind because we need to know if the rune was an '!' or an '='
+	// Rewind because we need to know if the rune was an '!' or an '='.
 	l.rewind()
 
 	// If the first rune is an '!' then it must be followed with either an
-	// '=' or '~' to not match a string or regex
+	// '=' or '~' to not match a string or regex.
 	if l.accept("!") {
 		if err := l.expect("=~"); err != nil {
 			return Token{}, err
@@ -211,7 +211,7 @@ func (l *Lexer) scanOperator() (Token, error) {
 	}
 
 	// If the first rune is an '=' then it can be followed with an optional
-	// '~' to match a regex
+	// '~' to match a regex.
 	l.accept("=")
 	l.accept("~")
 	return l.emit(TokenOperator), nil

matchers/parse/lexer_test.go

@@ -39,7 +39,7 @@ func TestLexer_Scan(t *testing.T) {
 			},
 		}},
 	}, {
-		name:  "open brace with space",
+		name:  "open brace with leading space",
 		input: " {",
 		expected: []Token{{
 			Kind:  TokenOpenBrace,
@@ -65,8 +65,8 @@ func TestLexer_Scan(t *testing.T) {
 			},
 		}},
 	}, {
-		name:  "close brace with space",
-		input: "}",
+		name:  "close brace with leading space",
+		input: " }",
 		expected: []Token{{
 			Kind:  TokenCloseBrace,
 			Value: "}",

matchers/parse/parse.go

@@ -139,7 +139,7 @@ func (p *Parser) parse() (labels.Matchers, error) {
 type parseFn func(l *Lexer) (parseFn, error)
 
 func (p *Parser) parseOpenParen(l *Lexer) (parseFn, error) {
-	// Can start with an optional open brace
+	// Can start with an optional open brace.
 	hasOpenParen, err := p.accept(l.Peek, TokenOpenBrace)
 	if err != nil {
 		if errors.Is(err, ErrEOF) {
@@ -149,14 +149,14 @@ func (p *Parser) parseOpenParen(l *Lexer) (parseFn, error) {
 	}
 	if hasOpenParen {
 		// If the token was an open brace it must be scanned so the token
-		// following it can be peeked
+		// following it can be peeked.
 		if _, err = l.Scan(); err != nil {
 			panic("Unexpected error scanning open brace")
 		}
 	}
 	p.hasOpenParen = hasOpenParen
 	// If the next token is a close brace there are no matchers in the input
-	// and we can just parse the close brace
+	// and we can just parse the close brace.
 	if hasCloseParen, err := p.accept(l.Peek, TokenCloseBrace); err != nil {
 		return nil, fmt.Errorf("%s: %w", err, ErrNoCloseBrace)
 	} else if hasCloseParen {
@@ -167,12 +167,12 @@ func (p *Parser) parseOpenParen(l *Lexer) (parseFn, error) {
 
 func (p *Parser) parseCloseParen(l *Lexer) (parseFn, error) {
 	if p.hasOpenParen {
-		// If there was an open brace there must be a matching close brace
+		// If there was an open brace there must be a matching close brace.
 		if _, err := p.expect(l.Scan, TokenCloseBrace); err != nil {
 			return nil, fmt.Errorf("%s: %w", err, ErrNoCloseBrace)
 		}
 	} else {
-		// If there was no open brace there must not be a close brace either
+		// If there was no open brace there must not be a close brace either.
 		if _, err := p.expect(l.Peek, TokenCloseBrace); err == nil {
 			return nil, fmt.Errorf("0:%d: }: %w", len(p.input), ErrNoOpenBrace)
 		}
@@ -185,7 +185,7 @@ func (p *Parser) parseComma(l *Lexer) (parseFn, error) {
 		return nil, fmt.Errorf("%s: %s", err, "expected a comma")
 	}
 	// The token after the comma can be another matcher, a close brace or the
-	// end of input
+	// end of input.
 	tok, err := p.expect(l.Peek, TokenCloseBrace, TokenIdent, TokenQuoted)
 	if err != nil {
 		if errors.Is(err, ErrEOF) {
@@ -219,13 +219,13 @@ func (p *Parser) parseLabelMatcher(l *Lexer) (parseFn, error) {
 
 	// The next token is the label name. This can either be an ident which
 	// accepts just [a-zA-Z_] or a quoted which accepts all UTF-8 characters
-	// in double quotes
+	// in double quotes.
 	if tok, err = p.expect(l.Scan, TokenIdent, TokenQuoted); err != nil {
 		return nil, fmt.Errorf("%s: %w", err, ErrNoLabelName)
 	}
 	labelName = tok.Value
 
-	// The next token is the operator such as '=', '!=', '=~' and '!~'
+	// The next token is the operator such as '=', '!=', '=~' and '!~'.
 	if tok, err = p.expect(l.Scan, TokenOperator); err != nil {
 		return nil, fmt.Errorf("%s: %s", err, ErrNoOperator)
 	}
@@ -235,7 +235,7 @@ func (p *Parser) parseLabelMatcher(l *Lexer) (parseFn, error) {
 
 	// The next token is the label value. This too can either be an ident
 	// which accepts just [a-zA-Z_] or a quoted which accepts all UTF-8
-	// characters in double quotes
+	// characters in double quotes.
 	if tok, err = p.expect(l.Scan, TokenIdent, TokenQuoted); err != nil {
 		return nil, fmt.Errorf("%s: %s", err, ErrNoLabelValue)
 	}
@@ -261,7 +261,7 @@ func (p *Parser) parseLabelMatcherEnd(l *Lexer) (parseFn, error) {
 	tok, err := p.expect(l.Peek, TokenComma, TokenCloseBrace)
 	if err != nil {
 		// If this is the end of input we still need to check if the optional
-		// open brace has a matching close brace
+		// open brace has a matching close brace.
 		if errors.Is(err, ErrEOF) {
 			return p.parseCloseParen, nil
 		}

matchers/parse/token.go

@@ -63,8 +63,8 @@ func IsNone(t Token) bool {
 }
 
 type Position struct {
-	OffsetStart int // The start position in the input
-	OffsetEnd   int // The end position in the input
-	ColumnStart int // The column number
-	ColumnEnd   int // The end of the column
+	OffsetStart int // The start position in the input.
+	OffsetEnd   int // The end position in the input.
+	ColumnStart int // The column number.
+	ColumnEnd   int // The end of the column.
 }