remove unused packages
This commit is contained in:
parent
a65c341690
commit
2c8c81a24b
GPG Key ID:
40482A264AAEC85F
@ -1,349 +0,0 @@
|
|||||||
// Copyright 2023 The Go Authors. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package glob
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"strings"
|
|
||||||
"unicode/utf8"
|
|
||||||
)
|
|
||||||
|
|
||||||
// A Glob is an LSP-compliant glob pattern, as defined by the spec:
|
|
||||||
// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#documentFilter
|
|
||||||
//
|
|
||||||
// NOTE: this implementation is currently only intended for testing. In order
|
|
||||||
// to make it production ready, we'd need to:
|
|
||||||
// - verify it against the VS Code implementation
|
|
||||||
// - add more tests
|
|
||||||
// - microbenchmark, likely avoiding the element interface
|
|
||||||
// - resolve the question of what is meant by "character". If it's a UTF-16
|
|
||||||
// code (as we suspect) it'll be a bit more work.
|
|
||||||
//
|
|
||||||
// Quoting from the spec:
|
|
||||||
// Glob patterns can have the following syntax:
|
|
||||||
// - `*` to match one or more characters in a path segment
|
|
||||||
// - `?` to match on one character in a path segment
|
|
||||||
// - `**` to match any number of path segments, including none
|
|
||||||
// - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}`
|
|
||||||
// matches all TypeScript and JavaScript files)
|
|
||||||
// - `[]` to declare a range of characters to match in a path segment
|
|
||||||
// (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
|
|
||||||
// - `[!...]` to negate a range of characters to match in a path segment
|
|
||||||
// (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but
|
|
||||||
// not `example.0`)
|
|
||||||
//
|
|
||||||
// Expanding on this:
|
|
||||||
// - '/' matches one or more literal slashes.
|
|
||||||
// - any other character matches itself literally.
|
|
||||||
type Glob struct {
|
|
||||||
elems []element // pattern elements
|
|
||||||
}
|
|
||||||
|
|
||||||
// Parse builds a Glob for the given pattern, returning an error if the pattern
|
|
||||||
// is invalid.
|
|
||||||
func Parse(pattern string) (*Glob, error) {
|
|
||||||
g, _, err := parse(pattern, false)
|
|
||||||
return g, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func parse(pattern string, nested bool) (*Glob, string, error) {
|
|
||||||
g := new(Glob)
|
|
||||||
for len(pattern) > 0 {
|
|
||||||
switch pattern[0] {
|
|
||||||
case '/':
|
|
||||||
pattern = pattern[1:]
|
|
||||||
g.elems = append(g.elems, slash{})
|
|
||||||
|
|
||||||
case '*':
|
|
||||||
if len(pattern) > 1 && pattern[1] == '*' {
|
|
||||||
if (len(g.elems) > 0 && g.elems[len(g.elems)-1] != slash{}) || (len(pattern) > 2 && pattern[2] != '/') {
|
|
||||||
return nil, "", errors.New("** may only be adjacent to '/'")
|
|
||||||
}
|
|
||||||
pattern = pattern[2:]
|
|
||||||
g.elems = append(g.elems, starStar{})
|
|
||||||
break
|
|
||||||
}
|
|
||||||
pattern = pattern[1:]
|
|
||||||
g.elems = append(g.elems, star{})
|
|
||||||
|
|
||||||
case '?':
|
|
||||||
pattern = pattern[1:]
|
|
||||||
g.elems = append(g.elems, anyChar{})
|
|
||||||
|
|
||||||
case '{':
|
|
||||||
var gs group
|
|
||||||
for pattern[0] != '}' {
|
|
||||||
pattern = pattern[1:]
|
|
||||||
groupG, pat, err := parse(pattern, true)
|
|
||||||
if err != nil {
|
|
||||||
return nil, "", err
|
|
||||||
}
|
|
||||||
if len(pat) == 0 {
|
|
||||||
return nil, "", errors.New("unmatched '{'")
|
|
||||||
}
|
|
||||||
pattern = pat
|
|
||||||
gs = append(gs, groupG)
|
|
||||||
}
|
|
||||||
pattern = pattern[1:]
|
|
||||||
g.elems = append(g.elems, gs)
|
|
||||||
|
|
||||||
case '}', ',':
|
|
||||||
if nested {
|
|
||||||
return g, pattern, nil
|
|
||||||
}
|
|
||||||
pattern = g.parseLiteral(pattern, false)
|
|
||||||
|
|
||||||
case '[':
|
|
||||||
pattern = pattern[1:]
|
|
||||||
if len(pattern) == 0 {
|
|
||||||
return nil, "", errBadRange
|
|
||||||
}
|
|
||||||
negate := false
|
|
||||||
if pattern[0] == '!' {
|
|
||||||
pattern = pattern[1:]
|
|
||||||
negate = true
|
|
||||||
}
|
|
||||||
low, sz, err := readRangeRune(pattern)
|
|
||||||
if err != nil {
|
|
||||||
return nil, "", err
|
|
||||||
}
|
|
||||||
pattern = pattern[sz:]
|
|
||||||
if len(pattern) == 0 || pattern[0] != '-' {
|
|
||||||
return nil, "", errBadRange
|
|
||||||
}
|
|
||||||
pattern = pattern[1:]
|
|
||||||
high, sz, err := readRangeRune(pattern)
|
|
||||||
if err != nil {
|
|
||||||
return nil, "", err
|
|
||||||
}
|
|
||||||
pattern = pattern[sz:]
|
|
||||||
if len(pattern) == 0 || pattern[0] != ']' {
|
|
||||||
return nil, "", errBadRange
|
|
||||||
}
|
|
||||||
pattern = pattern[1:]
|
|
||||||
g.elems = append(g.elems, charRange{negate, low, high})
|
|
||||||
|
|
||||||
default:
|
|
||||||
pattern = g.parseLiteral(pattern, nested)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return g, "", nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// helper for decoding a rune in range elements, e.g. [a-z]
|
|
||||||
func readRangeRune(input string) (rune, int, error) {
|
|
||||||
r, sz := utf8.DecodeRuneInString(input)
|
|
||||||
var err error
|
|
||||||
if r == utf8.RuneError {
|
|
||||||
// See the documentation for DecodeRuneInString.
|
|
||||||
switch sz {
|
|
||||||
case 0:
|
|
||||||
err = errBadRange
|
|
||||||
case 1:
|
|
||||||
err = errInvalidUTF8
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return r, sz, err
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
errBadRange = errors.New("'[' patterns must be of the form [x-y]")
|
|
||||||
errInvalidUTF8 = errors.New("invalid UTF-8 encoding")
|
|
||||||
)
|
|
||||||
|
|
||||||
func (g *Glob) parseLiteral(pattern string, nested bool) string {
|
|
||||||
var specialChars string
|
|
||||||
if nested {
|
|
||||||
specialChars = "*?{[/},"
|
|
||||||
} else {
|
|
||||||
specialChars = "*?{[/"
|
|
||||||
}
|
|
||||||
end := strings.IndexAny(pattern, specialChars)
|
|
||||||
if end == -1 {
|
|
||||||
end = len(pattern)
|
|
||||||
}
|
|
||||||
g.elems = append(g.elems, literal(pattern[:end]))
|
|
||||||
return pattern[end:]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (g *Glob) String() string {
|
|
||||||
var b strings.Builder
|
|
||||||
for _, e := range g.elems {
|
|
||||||
fmt.Fprint(&b, e)
|
|
||||||
}
|
|
||||||
return b.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
// element holds a glob pattern element, as defined below.
|
|
||||||
type element fmt.Stringer
|
|
||||||
|
|
||||||
// element types.
|
|
||||||
type (
|
|
||||||
slash struct{} // One or more '/' separators
|
|
||||||
literal string // string literal, not containing /, *, ?, {}, or []
|
|
||||||
star struct{} // *
|
|
||||||
anyChar struct{} // ?
|
|
||||||
starStar struct{} // **
|
|
||||||
group []*Glob // {foo, bar, ...} grouping
|
|
||||||
charRange struct { // [a-z] character range
|
|
||||||
negate bool
|
|
||||||
low, high rune
|
|
||||||
}
|
|
||||||
)
|
|
||||||
|
|
||||||
func (s slash) String() string { return "/" }
|
|
||||||
func (l literal) String() string { return string(l) }
|
|
||||||
func (s star) String() string { return "*" }
|
|
||||||
func (a anyChar) String() string { return "?" }
|
|
||||||
func (s starStar) String() string { return "**" }
|
|
||||||
func (g group) String() string {
|
|
||||||
var parts []string
|
|
||||||
for _, g := range g {
|
|
||||||
parts = append(parts, g.String())
|
|
||||||
}
|
|
||||||
return "{" + strings.Join(parts, ",") + "}"
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r charRange) String() string {
|
|
||||||
return "[" + string(r.low) + "-" + string(r.high) + "]"
|
|
||||||
}
|
|
||||||
|
|
||||||
// Match reports whether the input string matches the glob pattern.
|
|
||||||
func (g *Glob) Match(input string) bool {
|
|
||||||
return match(g.elems, input)
|
|
||||||
}
|
|
||||||
|
|
||||||
func match(elems []element, input string) (ok bool) {
|
|
||||||
var elem interface{}
|
|
||||||
for len(elems) > 0 {
|
|
||||||
elem, elems = elems[0], elems[1:]
|
|
||||||
switch elem := elem.(type) {
|
|
||||||
case slash:
|
|
||||||
if len(input) == 0 || input[0] != '/' {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
for input[0] == '/' {
|
|
||||||
input = input[1:]
|
|
||||||
}
|
|
||||||
|
|
||||||
case starStar:
|
|
||||||
// Special cases:
|
|
||||||
// - **/a matches "a"
|
|
||||||
// - **/ matches everything
|
|
||||||
//
|
|
||||||
// Note that if ** is followed by anything, it must be '/' (this is
|
|
||||||
// enforced by Parse).
|
|
||||||
if len(elems) > 0 {
|
|
||||||
elems = elems[1:]
|
|
||||||
}
|
|
||||||
|
|
||||||
// A trailing ** matches anything.
|
|
||||||
if len(elems) == 0 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Backtracking: advance pattern segments until the remaining pattern
|
|
||||||
// elements match.
|
|
||||||
for len(input) != 0 {
|
|
||||||
if match(elems, input) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
_, input = split(input)
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
|
|
||||||
case literal:
|
|
||||||
if !strings.HasPrefix(input, string(elem)) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
input = input[len(elem):]
|
|
||||||
|
|
||||||
case star:
|
|
||||||
var segInput string
|
|
||||||
segInput, input = split(input)
|
|
||||||
|
|
||||||
elemEnd := len(elems)
|
|
||||||
for i, e := range elems {
|
|
||||||
if e == (slash{}) {
|
|
||||||
elemEnd = i
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
segElems := elems[:elemEnd]
|
|
||||||
elems = elems[elemEnd:]
|
|
||||||
|
|
||||||
// A trailing * matches the entire segment.
|
|
||||||
if len(segElems) == 0 {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
|
|
||||||
// Backtracking: advance characters until remaining subpattern elements
|
|
||||||
// match.
|
|
||||||
matched := false
|
|
||||||
for i := range segInput {
|
|
||||||
if match(segElems, segInput[i:]) {
|
|
||||||
matched = true
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if !matched {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
case anyChar:
|
|
||||||
if len(input) == 0 || input[0] == '/' {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
input = input[1:]
|
|
||||||
|
|
||||||
case group:
|
|
||||||
// Append remaining pattern elements to each group member looking for a
|
|
||||||
// match.
|
|
||||||
var branch []element
|
|
||||||
for _, m := range elem {
|
|
||||||
branch = branch[:0]
|
|
||||||
branch = append(branch, m.elems...)
|
|
||||||
branch = append(branch, elems...)
|
|
||||||
if match(branch, input) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
|
|
||||||
case charRange:
|
|
||||||
if len(input) == 0 || input[0] == '/' {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
c, sz := utf8.DecodeRuneInString(input)
|
|
||||||
if c < elem.low || c > elem.high {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
input = input[sz:]
|
|
||||||
|
|
||||||
default:
|
|
||||||
panic(fmt.Sprintf("segment type %T not implemented", elem))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return len(input) == 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// split returns the portion before and after the first slash
|
|
||||||
// (or sequence of consecutive slashes). If there is no slash
|
|
||||||
// it returns (input, nil).
|
|
||||||
func split(input string) (first, rest string) {
|
|
||||||
i := strings.IndexByte(input, '/')
|
|
||||||
if i < 0 {
|
|
||||||
return input, ""
|
|
||||||
}
|
|
||||||
first = input[:i]
|
|
||||||
for j := i; j < len(input); j++ {
|
|
||||||
if input[j] != '/' {
|
|
||||||
return first, input[j:]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return first, ""
|
|
||||||
}
|
|
||||||
Loading…
x
Reference in New Issue
Block a user