Update the RIDL error syntax & parser (webrpc#191)

* Remove noisy log in TestSyntaxError()

* Update the RIDL error syntax & parser

error <code> <name> <message> [HTTP <status code>]

Author: VojtechVitek

schema/ridl/error_parser.go

@@ -2,62 +2,103 @@ package ridl
 
 import (
 	"fmt"
+
+	"github.com/pkg/errors"
 )
 
-func parserStateErrorDefinition(et *ErrorNode) parserState {
+// error <code> <name> <message> [HTTP <status code>]
+func parserStateError(p *parser) parserState {
+	// error <code> <name>
+	matches, err := p.match(tokenWord, tokenWhitespace, tokenWord, tokenWhitespace, tokenWord, tokenWhitespace)
+	if err != nil {
+		return p.stateError(err)
+	}
+
+	if matches[0].val != wordError {
+		return p.stateError(errUnexpectedToken)
+	}
+
+	if err := expectNumber(matches[2], matches[2].val); err != nil {
+		return p.stateError(fmt.Errorf("expecting error code to be a number but got '%s'", matches[2].val))
+	}
+
+	return parserStateErrorMessage(&ErrorNode{
+		code: newTokenNode(matches[2]),
+		name: newTokenNode(matches[4]),
+	})
+}
+
+// <message> [HTTP <status code>]
+func parserStateErrorMessage(et *ErrorNode) parserState {
 	return func(p *parser) parserState {
 		var err error
 		tok := p.cursor()
 
+		// message, err := p.expectLiteralValue()
+		// if err != nil {
+		// 	return p.stateError(err)
+		// }
+
 		switch tok.tt {
 
+		// "<message>"
 		case tokenQuote:
 			tok, err = p.expectStringValue()
 			if err != nil {
 				return p.stateError(err)
 			}
 			et.message = newTokenNode(tok)
 
-		case tokenMinusSign:
-			matches, err := p.match(tokenDash, tokenDash, tokenWhitespace, tokenWord)
-			if err != nil {
-				return p.stateError(err)
-			}
-			et.httpStatus = newTokenNode(matches[3])
-
-		case tokenWhitespace, tokenNewLine:
+		// <message>
+		case tokenWord:
+			et.message = newTokenNode(tok)
 			p.next()
 
-		case tokenHash:
-			p.continueUntilEOL()
-
 		default:
+			return p.stateError(errors.Errorf("expected <message> but got %v", tok))
+		}
+
+		return parserStateErrorExplicitStatusCode(et)
+	}
+}
+
+// [HTTP <status code>]
+func parserStateErrorExplicitStatusCode(et *ErrorNode) parserState {
+	return func(p *parser) parserState {
+		// Try to match HTTP
+		matches, err := p.match(tokenWhitespace, tokenWord)
+		if err != nil {
+			if err := p.expectOptionalCommentOrEOL(); err != nil {
+				return p.stateError(err)
+			}
+
 			p.emit(et)
 			return parserDefaultState
+		}
 
+		if err := expectWord(matches[1], "HTTP"); err != nil {
+			p.rewind(1)
+			return p.stateError(fmt.Errorf("expecting optional 'HTTP <status code>' but got '%s'", matches[1].val))
 		}
 
-		return parserStateErrorDefinition(et)
-	}
-}
+		// Match <status code>
+		matches, err = p.match(tokenWhitespace, tokenWord)
+		if err != nil {
+			return p.stateError(fmt.Errorf("expecting '<status code>': %w", err))
+		}
 
-func parserStateError(p *parser) parserState {
-	// error <code> <name> <message> [-- <http status code>]
-	matches, err := p.match(tokenWord, tokenWhitespace, tokenWord, tokenWhitespace, tokenWord, tokenWhitespace)
-	if err != nil {
-		return p.stateError(err)
-	}
+		if err := expectNumber(matches[1], matches[1].val); err != nil {
+			p.rewind(1)
+			return p.stateError(fmt.Errorf("expecting HTTP '<status code>' to be a number but got '%s'", matches[1].val))
+		}
 
-	if matches[0].val != wordError {
-		return p.stateError(errUnexpectedToken)
-	}
+		et.httpStatus = newTokenNode(matches[1])
 
-	if err := expectNumber(matches[2], matches[2].val); err != nil {
-		return p.stateError(fmt.Errorf("expecting error code to be a number but got '%s'", matches[2].val))
-	}
+		if err := p.expectOptionalCommentOrEOL(); err != nil {
+			return p.stateError(err)
+		}
 
-	return parserStateErrorDefinition(&ErrorNode{
-		code: newTokenNode(matches[2]),
-		name: newTokenNode(matches[4]),
-	})
+		p.emit(et)
+		return parserDefaultState
+	}
 }

schema/ridl/parser.go

@@ -391,7 +391,7 @@ func parserStateDeclaration(p *parser) parserState {
 		//   - <value> [<# comment>]
 		return parserStateImport
 	case wordError:
-		// error <code> <name> <message>
+		// error <code> <name> <message> [HTTP <status code>]
 		return parserStateError
 	case wordEnum:
 		// enum <name>: <type>

schema/ridl/parser_test.go

@@ -110,14 +110,52 @@ func TestParserTopLevelDefinitions(t *testing.T) {
 
 func TestParserError(t *testing.T) {
 	p, err := newStringParser(`
-		error 12345 InvalidUsername "username is invalid" -- 401
-		error 45678 Unauthorized    "unauthorized access"
+		error 12345 InvalidUsername "username is invalid" HTTP 401
+		error 12345 InvalidUsername "username is invalid" HTTP 1 # comment
+		error 12345 InvalidUsername InvalidUsername
+		error 12345 InvalidUsername InvalidUsername # comment
+		error 45678 Unauthorized "unauthorized access" HTTP 401
+		error 45678 Unauthorized "unauthorized access" HTTP 401 # comment
+		error 45678 Unauthorized Unauthorized HTTP 401
+		error 45678 Unauthorized Unauthorized HTTP 401 # comment
 	`)
 	assert.NoError(t, err)
 
 	err = p.run()
 	assert.NoError(t, err)
-	assert.Equal(t, 2, len(p.root.Errors()))
+
+	if !assert.Equal(t, 8, len(p.root.Errors())) {
+		for _, e := range p.root.Errors() {
+			t.Logf("%v", e.message)
+		}
+	}
+}
+
+func TestParserErrorInvalid(t *testing.T) {
+	tt := []string{
+		`error`,
+		`error WRONG`,
+		`error 12345`,
+		`error 12345 Unauthorized`, // missing <message>
+		`error 12345 Unauthorized unauthorized access`, // missing quotes for multi-word <message>
+		`error 12345 Unauthorized "unauthorized access" WRONG 401`,
+		`error 12345 Unauthorized "unauthorized access" HTTP STATUS`,
+		`error 12345 Unauthorized "unauthorized access" HTTP 401 EXTRA`,
+	}
+
+	for _, str := range tt {
+		p, err := newStringParser(str)
+		assert.NoError(t, err)
+
+		err = p.run()
+		assert.Error(t, err)
+
+		if !assert.Equal(t, 0, len(p.root.Errors())) {
+			for _, e := range p.root.Errors() {
+				t.Logf("%v", e.message)
+			}
+		}
+	}
 }
 
 func TestParserImport(t *testing.T) {

schema/ridl/syntax_error_test.go

@@ -44,6 +44,5 @@ func TestSyntaxError(t *testing.T) {
 	for i := range syntaxErrors {
 		_, err := parseString(syntaxErrors[i])
 		assert.Error(t, err)
-		t.Logf("%v", err)
 	}
 }