Method parseEntityStatement

pkg/dsl/parser/parser.go:230–292

parseEntityStatement method parses an ENTITY statement and returns an EntityStatement AST node

()

// parseEntityStatement method parses an ENTITY statement and returns an EntityStatement AST node
func (p *Parser) parseEntityStatement() (*ast.EntityStatement, error) {
	// create a new EntityStatement object and set its Entity field to the currentToken
	stmt := &ast.EntityStatement{Entity: p.currentToken}
	// expect the next token to be an identifier token, and set the EntityStatement's Name field to the identifier's value
	if !p.expectAndNext(token.IDENT) {
		return nil, p.Error()
	}
	stmt.Name = p.currentToken

	// add the entity reference to the Parser's entityReferences map
	err := p.references.AddEntityReference(stmt.Name.Literal)
	if err != nil {
		p.duplicationError(stmt.Name.Literal) // Generate an error message indicating a duplication error
		return nil, p.Error()
	}

	// expect the next token to be a left brace token, indicating the start of the entity's body
	if !p.expectAndNext(token.LCB) {
		return nil, p.Error()
	}

	// loop through the entity's body until a right brace token is encountered
	for !p.currentTokenIs(token.RCB) {
		// if the currentToken is EOF, raise an error and return nil for both the statement and error values
		if p.currentTokenIs(token.EOF) {
			p.currentError(token.RCB)
			return nil, p.Error()
		}
		// based on the currentToken's type, parse a RelationStatement or PermissionStatement and add it to the EntityStatement's corresponding field
		switch p.currentToken.Type {
		case token.RELATION:
			relation, err := p.parseRelationStatement(stmt.Name.Literal)
			if err != nil {
				return nil, p.Error()
			}
			stmt.RelationStatements = append(stmt.RelationStatements, relation)
		case token.ATTRIBUTE:
			attribute, err := p.parseAttributeStatement(stmt.Name.Literal)
			if err != nil {
				return nil, p.Error()
			}
			stmt.AttributeStatements = append(stmt.AttributeStatements, attribute)
		case token.PERMISSION:
			action, err := p.parsePermissionStatement(stmt.Name.Literal)
			if err != nil {
				return nil, p.Error()
			}
			stmt.PermissionStatements = append(stmt.PermissionStatements, action)
		default:
			// if the currentToken is not recognized, check if it is a newline, left brace, or right brace token, and skip it if it is
			if !p.currentTokenIs(token.NEWLINE) && !p.currentTokenIs(token.LCB) && !p.currentTokenIs(token.RCB) {
				// if the currentToken is not recognized and not a newline, left brace, or right brace token, raise an error and return nil for both the statement and error values
				p.currentError(token.RELATION, token.PERMISSION, token.ATTRIBUTE)
				return nil, p.Error()
			}
		}
		// move to the next token in the input string
		p.next()