func NewRestriction()

in confgenerator/filter/internal/ast/ast.go [341:397]
51 lines of code
13 McCabe index (conditional complexity)

func NewRestriction(lhs, operator, rhs Attrib) (*Restriction, error) {
	var r Restriction
	switch operator := operator.(type) {
	case string:
		r.Operator = operator
	case *token.Token:
		r.Operator = string(operator.Lit)
	default:
		return nil, fmt.Errorf("unknown operator: %v", operator)
	}
	switch lhs := lhs.(type) {
	case Target:
		// Eager validation
		if err := lhs.checkValidCharacters(); err != nil {
			// TODO: Unnecessary, but preserved until we drop fluent-bit.
			return nil, err
		}

		_, err := lhs.RecordAccessor()
		if err != nil {
			_, err := lhs.OTTLAccessor()
			if err != nil {
				return nil, err
			}
		}
		r.LHS = lhs
	default:
		return nil, fmt.Errorf("unknown lhs: %v", lhs)
	}
	switch rhs := rhs.(type) {
	case nil:
	case Target:
		// BNF parses values as Target, even if they are singular
		if len(rhs) != 1 {
			return nil, fmt.Errorf("unexpected rhs: %v", rhs)
		}
		// Perform the appropriate unquoting depending on what operator is being used.
		switch r.Operator {
		case "=~", "!~":
			rhs := rhs[0]
			// Regular expressions must be string, not text, and we need to preserve the original escaped text for the regex engine.
			if rhs[0] != byte('"') || rhs[len(rhs)-1] != byte('"') {
				return nil, fmt.Errorf("regular expressions must begin and end with '\"', token %q", rhs)
			}
			r.RHS = rhs[1 : len(rhs)-1]
		default:
			rhs, err := UnquoteTextOrString(rhs[0])
			if err != nil {
				return nil, err
			}
			r.RHS = rhs
		}
	default:
		return nil, fmt.Errorf("unknown rhs: %v", rhs)
	}
	return &r, nil
}