119 lines
2.4 KiB
Go
119 lines
2.4 KiB
Go
package linedb
|
|
|
|
import "strings"
|
|
|
|
type stringMatchMode int
|
|
|
|
const (
|
|
stringMatchEqual stringMatchMode = iota
|
|
stringMatchContains
|
|
stringMatchHasPrefix
|
|
stringMatchHasSuffix
|
|
)
|
|
|
|
func matchStringByPattern(value string, pattern string, strictCompare bool) bool {
|
|
mode, lit := parsePercentPattern(pattern)
|
|
|
|
if !strictCompare {
|
|
// For substring checks we use ToLower (close enough to EqualFold intent).
|
|
value = strings.ToLower(value)
|
|
lit = strings.ToLower(lit)
|
|
}
|
|
|
|
switch mode {
|
|
case stringMatchContains:
|
|
return strings.Contains(value, lit)
|
|
case stringMatchHasPrefix:
|
|
return strings.HasPrefix(value, lit)
|
|
case stringMatchHasSuffix:
|
|
return strings.HasSuffix(value, lit)
|
|
default:
|
|
if strictCompare {
|
|
return value == lit
|
|
}
|
|
return strings.EqualFold(value, lit)
|
|
}
|
|
}
|
|
|
|
// parsePercentPattern interprets unescaped % at the start/end of pattern:
|
|
// - %foo% => contains "foo"
|
|
// - foo% => hasPrefix "foo"
|
|
// - %foo => hasSuffix "foo"
|
|
// - foo => equal "foo"
|
|
// Escaping: \% means literal %, \\ means literal \ (only affects escape processing).
|
|
func parsePercentPattern(pattern string) (stringMatchMode, string) {
|
|
if pattern == "" {
|
|
return stringMatchEqual, ""
|
|
}
|
|
|
|
leading := pattern[0] == '%'
|
|
trailing := len(pattern) > 0 && pattern[len(pattern)-1] == '%' && !isEscapedAt(pattern, len(pattern)-1)
|
|
|
|
start := 0
|
|
end := len(pattern)
|
|
if leading {
|
|
start = 1
|
|
}
|
|
if trailing && end > start {
|
|
end--
|
|
}
|
|
lit := unescapePercents(pattern[start:end])
|
|
|
|
switch {
|
|
case leading && trailing:
|
|
return stringMatchContains, lit
|
|
case trailing:
|
|
return stringMatchHasPrefix, lit
|
|
case leading:
|
|
return stringMatchHasSuffix, lit
|
|
default:
|
|
return stringMatchEqual, unescapePercents(pattern)
|
|
}
|
|
}
|
|
|
|
func isEscapedAt(s string, idx int) bool {
|
|
// idx is escaped if preceded by an odd number of backslashes.
|
|
if idx <= 0 || idx >= len(s) {
|
|
return false
|
|
}
|
|
n := 0
|
|
for i := idx - 1; i >= 0 && s[i] == '\\'; i-- {
|
|
n++
|
|
}
|
|
return n%2 == 1
|
|
}
|
|
|
|
func unescapePercents(s string) string {
|
|
if s == "" {
|
|
return ""
|
|
}
|
|
var b strings.Builder
|
|
b.Grow(len(s))
|
|
esc := false
|
|
for i := 0; i < len(s); i++ {
|
|
ch := s[i]
|
|
if esc {
|
|
// Only unescape % and \; keep backslash for other chars.
|
|
if ch == '%' || ch == '\\' {
|
|
b.WriteByte(ch)
|
|
} else {
|
|
b.WriteByte('\\')
|
|
b.WriteByte(ch)
|
|
}
|
|
esc = false
|
|
continue
|
|
}
|
|
if ch == '\\' {
|
|
esc = true
|
|
continue
|
|
}
|
|
b.WriteByte(ch)
|
|
}
|
|
if esc {
|
|
// dangling backslash
|
|
b.WriteByte('\\')
|
|
}
|
|
return b.String()
|
|
}
|
|
|