Method Compile

pkg/dsl/compiler/compiler.go:34–74

Compile compiles the schema into a list of entity definitions. Returns a slice of EntityDefinition pointers and an error, if any.

()

// Compile compiles the schema into a list of entity definitions.
// Returns a slice of EntityDefinition pointers and an error, if any.
func (t *Compiler) Compile() ([]*base.EntityDefinition, []*base.RuleDefinition, error) {
	// If withoutReferenceValidation is not set to true, validate the schema for reference errors.
	if t.withReferenceValidation {
		err := t.schema.Validate()
		if err != nil {
			return nil, nil, err
		}
	}

	// Create an empty slice to hold the entity definitions.
	entities := make([]*base.EntityDefinition, 0, len(t.schema.Statements))
	rules := make([]*base.RuleDefinition, 0, len(t.schema.Statements))

	// Loop through each statement in the schema.
	for _, statement := range t.schema.Statements {
		switch v := statement.(type) { // Check statement type
		case *ast.EntityStatement:
			// Compile the EntityStatement into an EntityDefinition.
			entityDef, err := t.compileEntity(v) // Compile entity
			if err != nil {
				return nil, nil, err
			}

			// Append the EntityDefinition to the slice of entity definitions.
			entities = append(entities, entityDef)
		case *ast.RuleStatement:
			// Compile the RuleStatement into a RuleDefinition.
			ruleDef, err := t.compileRule(v) // Compile rule
			if err != nil {
				return nil, nil, err
			}

			// Append the RuleDefinition to the slice of rule definitions.
			rules = append(rules, ruleDef)
		default:
			return nil, nil, errors.New("invalid statement")
		}
	}

	return entities, rules, nil
}

// compile - compiles an EntityStatement into an EntityDefinition
func (t *Compiler) compileEntity(sc *ast.EntityStatement) (*base.EntityDefinition, error) {