netdata/netdata

// SPDX-License-Identifier: GPL-3.0-or-later

package matcher

import (
    "errors"
    "fmt"
    "regexp"
)

type (
    // Matcher is an interface that wraps MatchString method.
    Matcher interface {
        // Match performs match against given []byte
        Match(b []byte) bool
        // MatchString performs match against given string
        MatchString(string) bool
    }

    // Format matcher format
    Format string
)

const (
    // FmtString is a string match format.
    FmtString Format = "string"
    // FmtGlob is a glob match format.
    FmtGlob Format = "glob"
    // FmtRegExp is a regex match format.
    FmtRegExp Format = "regexp"
    // FmtSimplePattern is a simple pattern match format
    // https://docs.netdata.cloud/libnetdata/simple_pattern/
    FmtSimplePattern Format = "simple_patterns"

    // Separator is a separator between match format and expression.
    Separator = ":"
)

const (
    symString = "="
    symGlob   = "*"
    symRegExp = "~"
)

var (
    reShortSyntax = regexp.MustCompile(`(?s)^(!)?(.)\s*(.*)$`)
    reLongSyntax  = regexp.MustCompile(`(?s)^(!)?([^:]+):(.*)$`)

    errNotShortSyntax = errors.New("not short syntax")
)

// Must is a helper that wraps a call to a function returning (Matcher, error) and panics if the error is non-nil.
// It is intended for use in variable initializations such as
//
//    var m = matcher.Must(matcher.New(matcher.FmtString, "hello world"))
func Must(m Matcher, err error) Matcher {
    if err != nil {
        panic(err)
    }
    return m
}

// New create a matcher
func New(format Format, expr string) (Matcher, error) {
    switch format {
    case FmtString:
        return NewStringMatcher(expr, true, true)
    case FmtGlob:
        return NewGlobMatcher(expr)
    case FmtRegExp:
        return NewRegExpMatcher(expr)
    case FmtSimplePattern:
        return NewSimplePatternsMatcher(expr)
    default:
        return nil, fmt.Errorf("unsupported matcher format: '%s'", format)
    }
}

// Parse parses line and returns appropriate matcher based on matched format.
//
// Short Syntax
//
//    <line>      ::= [ <not> ] <format> <space> <expr>
//    <not>       ::= '!'
//                      negative expression
//    <format>    ::= [ '=', '~', '*' ]
//                      '=' means string match
//                      '~' means regexp match
//                      '*' means glob match
//    <space>     ::= { ' ' | '\t' | '\n' | '\n' | '\r' }
//    <expr>      ::= any string
//
// Long Syntax
//
//    <line>      ::= [ <not> ] <format> <separator> <expr>
//    <format>    ::= [ 'string' | 'glob' | 'regexp' | 'simple_patterns' ]
//    <not>       ::= '!'
//                      negative expression
//    <separator> ::= ':'
//    <expr>      ::= any string
func Parse(line string) (Matcher, error) {
    matcher, err := parseShortFormat(line)
    if err == nil {
        return matcher, nil
    }
    return parseLongSyntax(line)
}

func parseShortFormat(line string) (Matcher, error) {
    m := reShortSyntax.FindStringSubmatch(line)
    if m == nil {
        return nil, errNotShortSyntax
    }
    var format Format
    switch m[2] {
    case symString:
        format = FmtString
    case symGlob:
        format = FmtGlob
    case symRegExp:
        format = FmtRegExp
    default:
        return nil, fmt.Errorf("invalid short syntax: unknown symbol '%s'", m[2])
    }
    expr := m[3]
    matcher, err := New(format, expr)
    if err != nil {
        return nil, err
    }
    if m[1] != "" {
        matcher = Not(matcher)
    }
    return matcher, nil
}

func parseLongSyntax(line string) (Matcher, error) {
    m := reLongSyntax.FindStringSubmatch(line)
    if m == nil {
        return nil, fmt.Errorf("invalid syntax")
    }
    matcher, err := New(Format(m[2]), m[3])
    if err != nil {
        return nil, err
    }
    if m[1] != "" {
        matcher = Not(matcher)
    }
    return matcher, nil
}