lib/ignore: Replace lib/fnmatch with github.com/gobwas/glob

Because it's literally ten times faster:



	benchmark                  old ns/op     new ns/op     delta

	BenchmarkMatch-8           13842         1200          -91.33%

	BenchmarkMatchCached-8     139           147           +5.76%



	benchmark                  old allocs     new allocs     delta

	BenchmarkMatch-8           0              0              +0.00%

	BenchmarkMatchCached-8     0              0              +0.00%



	benchmark                  old bytes     new bytes     delta

	BenchmarkMatch-8           12            0             -100.00%

	BenchmarkMatchCached-8     0             0             +0.00%

vendor/github.com/gobwas/glob/compiler.go

@@ -0,0 +1,682 @@
+package glob
+
+// TODO use constructor with all matchers, and to their structs private
+// TODO glue multiple Text nodes (like after QuoteMeta)
+
+import (
+	"fmt"
+	"github.com/gobwas/glob/match"
+	"github.com/gobwas/glob/runes"
+	"reflect"
+)
+
+func optimize(matcher match.Matcher) match.Matcher {
+	switch m := matcher.(type) {
+
+	case match.Any:
+		if len(m.Separators) == 0 {
+			return match.NewSuper()
+		}
+
+	case match.AnyOf:
+		if len(m.Matchers) == 1 {
+			return m.Matchers[0]
+		}
+
+		return m
+
+	case match.List:
+		if m.Not == false && len(m.List) == 1 {
+			return match.NewText(string(m.List))
+		}
+
+		return m
+
+	case match.BTree:
+		m.Left = optimize(m.Left)
+		m.Right = optimize(m.Right)
+
+		r, ok := m.Value.(match.Text)
+		if !ok {
+			return m
+		}
+
+		leftNil := m.Left == nil
+		rightNil := m.Right == nil
+
+		if leftNil && rightNil {
+			return match.NewText(r.Str)
+		}
+
+		_, leftSuper := m.Left.(match.Super)
+		lp, leftPrefix := m.Left.(match.Prefix)
+
+		_, rightSuper := m.Right.(match.Super)
+		rs, rightSuffix := m.Right.(match.Suffix)
+
+		if leftSuper && rightSuper {
+			return match.NewContains(r.Str, false)
+		}
+
+		if leftSuper && rightNil {
+			return match.NewSuffix(r.Str)
+		}
+
+		if rightSuper && leftNil {
+			return match.NewPrefix(r.Str)
+		}
+
+		if leftNil && rightSuffix {
+			return match.NewPrefixSuffix(r.Str, rs.Suffix)
+		}
+
+		if rightNil && leftPrefix {
+			return match.NewPrefixSuffix(lp.Prefix, r.Str)
+		}
+
+		return m
+	}
+
+	return matcher
+}
+
+func glueMatchers(matchers []match.Matcher) match.Matcher {
+	var (
+		glued  []match.Matcher
+		winner match.Matcher
+	)
+	maxLen := -1
+
+	if m := glueAsEvery(matchers); m != nil {
+		glued = append(glued, m)
+		return m
+	}
+
+	if m := glueAsRow(matchers); m != nil {
+		glued = append(glued, m)
+		return m
+	}
+
+	for _, g := range glued {
+		if l := g.Len(); l > maxLen {
+			maxLen = l
+			winner = g
+		}
+	}
+
+	return winner
+}
+
+func glueAsRow(matchers []match.Matcher) match.Matcher {
+	if len(matchers) <= 1 {
+		return nil
+	}
+
+	var (
+		c []match.Matcher
+		l int
+	)
+	for _, matcher := range matchers {
+		if ml := matcher.Len(); ml == -1 {
+			return nil
+		} else {
+			c = append(c, matcher)
+			l += ml
+		}
+	}
+
+	return match.NewRow(l, c...)
+}
+
+func glueAsEvery(matchers []match.Matcher) match.Matcher {
+	if len(matchers) <= 1 {
+		return nil
+	}
+
+	var (
+		hasAny    bool
+		hasSuper  bool
+		hasSingle bool
+		min       int
+		separator []rune
+	)
+
+	for i, matcher := range matchers {
+		var sep []rune
+
+		switch m := matcher.(type) {
+		case match.Super:
+			sep = []rune{}
+			hasSuper = true
+
+		case match.Any:
+			sep = m.Separators
+			hasAny = true
+
+		case match.Single:
+			sep = m.Separators
+			hasSingle = true
+			min++
+
+		case match.List:
+			if !m.Not {
+				return nil
+			}
+			sep = m.List
+			hasSingle = true
+			min++
+
+		default:
+			return nil
+		}
+
+		// initialize
+		if i == 0 {
+			separator = sep
+		}
+
+		if runes.Equal(sep, separator) {
+			continue
+		}
+
+		return nil
+	}
+
+	if hasSuper && !hasAny && !hasSingle {
+		return match.NewSuper()
+	}
+
+	if hasAny && !hasSuper && !hasSingle {
+		return match.NewAny(separator)
+	}
+
+	if (hasAny || hasSuper) && min > 0 && len(separator) == 0 {
+		return match.NewMin(min)
+	}
+
+	every := match.NewEveryOf()
+
+	if min > 0 {
+		every.Add(match.NewMin(min))
+
+		if !hasAny && !hasSuper {
+			every.Add(match.NewMax(min))
+		}
+	}
+
+	if len(separator) > 0 {
+		every.Add(match.NewContains(string(separator), true))
+	}
+
+	return every
+}
+
+func minimizeMatchers(matchers []match.Matcher) []match.Matcher {
+	var done match.Matcher
+	var left, right, count int
+
+	for l := 0; l < len(matchers); l++ {
+		for r := len(matchers); r > l; r-- {
+			if glued := glueMatchers(matchers[l:r]); glued != nil {
+				var swap bool
+
+				if done == nil {
+					swap = true
+				} else {
+					cl, gl := done.Len(), glued.Len()
+					swap = cl > -1 && gl > -1 && gl > cl
+					swap = swap || count < r-l
+				}
+
+				if swap {
+					done = glued
+					left = l
+					right = r
+					count = r - l
+				}
+			}
+		}
+	}
+
+	if done == nil {
+		return matchers
+	}
+
+	next := append(append([]match.Matcher{}, matchers[:left]...), done)
+	if right < len(matchers) {
+		next = append(next, matchers[right:]...)
+	}
+
+	if len(next) == len(matchers) {
+		return next
+	}
+
+	return minimizeMatchers(next)
+}
+
+func minimizeAnyOf(children []node) node {
+	var nodes [][]node
+	var min int
+	var idx int
+	for i, desc := range children {
+		pat, ok := desc.(*nodePattern)
+		if !ok {
+			return nil
+		}
+
+		n := pat.children()
+		ln := len(n)
+		if len(nodes) == 0 || (ln < min) {
+			min = ln
+			idx = i
+		}
+
+		nodes = append(nodes, pat.children())
+	}
+
+	minNodes := nodes[idx]
+	if idx+1 < len(nodes) {
+		nodes = append(nodes[:idx], nodes[idx+1:]...)
+	} else {
+		nodes = nodes[:idx]
+	}
+
+	var commonLeft []node
+	var commonLeftCount int
+	for i, n := range minNodes {
+		has := true
+		for _, t := range nodes {
+			if !reflect.DeepEqual(n, t[i]) {
+				has = false
+				break
+			}
+		}
+
+		if has {
+			commonLeft = append(commonLeft, n)
+			commonLeftCount++
+		} else {
+			break
+		}
+	}
+
+	var commonRight []node
+	var commonRightCount int
+	for i := min - 1; i > commonLeftCount-1; i-- {
+		n := minNodes[i]
+		has := true
+		for _, t := range nodes {
+			if !reflect.DeepEqual(n, t[len(t)-(min-i)]) {
+				has = false
+				break
+			}
+		}
+
+		if has {
+			commonRight = append(commonRight, n)
+			commonRightCount++
+		} else {
+			break
+		}
+	}
+
+	if commonLeftCount == 0 && commonRightCount == 0 {
+		return nil
+	}
+
+	nodes = append(nodes, minNodes)
+	nodes[len(nodes)-1], nodes[idx] = nodes[idx], nodes[len(nodes)-1]
+
+	var result []node
+	if commonLeftCount > 0 {
+		result = append(result, &nodePattern{nodeImpl: nodeImpl{desc: commonLeft}})
+	}
+
+	var anyOf []node
+	for _, n := range nodes {
+		if commonLeftCount+commonRightCount == len(n) {
+			anyOf = append(anyOf, nil)
+		} else {
+			anyOf = append(anyOf, &nodePattern{nodeImpl: nodeImpl{desc: n[commonLeftCount : len(n)-commonRightCount]}})
+		}
+	}
+
+	anyOf = uniqueNodes(anyOf)
+	if len(anyOf) == 1 {
+		if anyOf[0] != nil {
+			result = append(result, &nodePattern{nodeImpl: nodeImpl{desc: anyOf}})
+		}
+	} else {
+		result = append(result, &nodeAnyOf{nodeImpl: nodeImpl{desc: anyOf}})
+	}
+
+	if commonRightCount > 0 {
+		result = append(result, &nodePattern{nodeImpl: nodeImpl{desc: commonRight}})
+	}
+
+	return &nodePattern{nodeImpl: nodeImpl{desc: result}}
+}
+
+func uniqueNodes(nodes []node) (result []node) {
+head:
+	for _, n := range nodes {
+		for _, e := range result {
+			if reflect.DeepEqual(e, n) {
+				continue head
+			}
+		}
+
+		result = append(result, n)
+	}
+
+	return
+}
+
+func compileMatchers(matchers []match.Matcher) (match.Matcher, error) {
+	if len(matchers) == 0 {
+		return nil, fmt.Errorf("compile error: need at least one matcher")
+	}
+
+	if len(matchers) == 1 {
+		return matchers[0], nil
+	}
+
+	if m := glueMatchers(matchers); m != nil {
+		return m, nil
+	}
+
+	var (
+		val match.Matcher
+		idx int
+	)
+	maxLen := -1
+	for i, matcher := range matchers {
+		l := matcher.Len()
+		if l >= maxLen {
+			maxLen = l
+			idx = i
+			val = matcher
+		}
+	}
+
+	left := matchers[:idx]
+	var right []match.Matcher
+	if len(matchers) > idx+1 {
+		right = matchers[idx+1:]
+	}
+
+	var l, r match.Matcher
+	var err error
+	if len(left) > 0 {
+		l, err = compileMatchers(left)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if len(right) > 0 {
+		r, err = compileMatchers(right)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return match.NewBTree(val, l, r), nil
+}
+
+//func complexity(m match.Matcher) int {
+//	var matchers []match.Matcher
+//	var k int
+//
+//	switch matcher := m.(type) {
+//
+//	case match.Nothing:
+//		return 0
+//
+//	case match.Max, match.Range, match.Suffix, match.Text:
+//		return 1
+//
+//	case match.PrefixSuffix, match.Single, match.Row:
+//		return 2
+//
+//	case match.Any, match.Contains, match.List, match.Min, match.Prefix, match.Super:
+//		return 4
+//
+//	case match.BTree:
+//		matchers = append(matchers, matcher.Value)
+//		if matcher.Left != nil {
+//			matchers = append(matchers, matcher.Left)
+//		}
+//		if matcher.Right != nil {
+//			matchers = append(matchers, matcher.Right)
+//		}
+//		k = 1
+//
+//	case match.AnyOf:
+//		matchers = matcher.Matchers
+//		k = 1
+//	case match.EveryOf:
+//		matchers = matcher.Matchers
+//		k = 1
+//
+//	default:
+//		return 0
+//	}
+//
+//	var sum int
+//	for _, m := range matchers {
+//		sum += complexity(m)
+//	}
+//
+//	return sum * k
+//}
+
+func doAnyOf(n *nodeAnyOf, s []rune) (match.Matcher, error) {
+	var matchers []match.Matcher
+	for _, desc := range n.children() {
+		if desc == nil {
+			matchers = append(matchers, match.NewNothing())
+			continue
+		}
+
+		m, err := do(desc, s)
+		if err != nil {
+			return nil, err
+		}
+		matchers = append(matchers, optimize(m))
+	}
+
+	return match.NewAnyOf(matchers...), nil
+}
+
+func do(leaf node, s []rune) (m match.Matcher, err error) {
+	switch n := leaf.(type) {
+
+	case *nodeAnyOf:
+		// todo this could be faster on pattern_alternatives_combine_lite
+		if n := minimizeAnyOf(n.children()); n != nil {
+			return do(n, s)
+		}
+
+		var matchers []match.Matcher
+		for _, desc := range n.children() {
+			if desc == nil {
+				matchers = append(matchers, match.NewNothing())
+				continue
+			}
+
+			m, err := do(desc, s)
+			if err != nil {
+				return nil, err
+			}
+			matchers = append(matchers, optimize(m))
+		}
+
+		return match.NewAnyOf(matchers...), nil
+
+	case *nodePattern:
+		nodes := leaf.children()
+		if len(nodes) == 0 {
+			return match.NewNothing(), nil
+		}
+
+		var matchers []match.Matcher
+		for _, desc := range nodes {
+			m, err := do(desc, s)
+			if err != nil {
+				return nil, err
+			}
+			matchers = append(matchers, optimize(m))
+		}
+
+		m, err = compileMatchers(minimizeMatchers(matchers))
+		if err != nil {
+			return nil, err
+		}
+
+	case *nodeList:
+		m = match.NewList([]rune(n.chars), n.not)
+
+	case *nodeRange:
+		m = match.NewRange(n.lo, n.hi, n.not)
+
+	case *nodeAny:
+		m = match.NewAny(s)
+
+	case *nodeSuper:
+		m = match.NewSuper()
+
+	case *nodeSingle:
+		m = match.NewSingle(s)
+
+	case *nodeText:
+		m = match.NewText(n.text)
+
+	default:
+		return nil, fmt.Errorf("could not compile tree: unknown node type")
+	}
+
+	return optimize(m), nil
+}
+
+func do2(node node, s []rune) ([]match.Matcher, error) {
+	var result []match.Matcher
+
+	switch n := node.(type) {
+
+	case *nodePattern:
+		ways := [][]match.Matcher{[]match.Matcher{}}
+
+		for _, desc := range node.children() {
+			variants, err := do2(desc, s)
+			if err != nil {
+				return nil, err
+			}
+
+			fmt.Println("variants pat", variants)
+
+			for i, l := 0, len(ways); i < l; i++ {
+				for i := 0; i < len(variants); i++ {
+					o := optimize(variants[i])
+					if i == len(variants)-1 {
+						ways[i] = append(ways[i], o)
+					} else {
+						var w []match.Matcher
+						copy(w, ways[i])
+						ways = append(ways, append(w, o))
+					}
+				}
+			}
+
+			fmt.Println("ways pat", ways)
+		}
+
+		for _, matchers := range ways {
+			c, err := compileMatchers(minimizeMatchers(matchers))
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, c)
+		}
+
+	case *nodeAnyOf:
+		ways := make([][]match.Matcher, len(node.children()))
+		for _, desc := range node.children() {
+			variants, err := do2(desc, s)
+			if err != nil {
+				return nil, err
+			}
+
+			fmt.Println("variants any", variants)
+
+			for x, l := 0, len(ways); x < l; x++ {
+				for i := 0; i < len(variants); i++ {
+					o := optimize(variants[i])
+					if i == len(variants)-1 {
+						ways[x] = append(ways[x], o)
+					} else {
+						var w []match.Matcher
+						copy(w, ways[x])
+						ways = append(ways, append(w, o))
+					}
+				}
+			}
+
+			fmt.Println("ways any", ways)
+		}
+
+		for _, matchers := range ways {
+			c, err := compileMatchers(minimizeMatchers(matchers))
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, c)
+		}
+
+	case *nodeList:
+		result = append(result, match.NewList([]rune(n.chars), n.not))
+
+	case *nodeRange:
+		result = append(result, match.NewRange(n.lo, n.hi, n.not))
+
+	case *nodeAny:
+		result = append(result, match.NewAny(s))
+
+	case *nodeSuper:
+		result = append(result, match.NewSuper())
+
+	case *nodeSingle:
+		result = append(result, match.NewSingle(s))
+
+	case *nodeText:
+		result = append(result, match.NewText(n.text))
+
+	default:
+		return nil, fmt.Errorf("could not compile tree: unknown node type")
+	}
+
+	for i, m := range result {
+		result[i] = optimize(m)
+	}
+
+	return result, nil
+}
+
+func compile(ast *nodePattern, s []rune) (Glob, error) {
+	//	ms, err := do2(ast, s)
+	//	if err != nil {
+	//		return nil, err
+	//	}
+	//	if len(ms) == 1 {
+	//		return ms[0], nil
+	//	} else {
+	//		return match.NewAnyOf(ms), nil
+	//	}
+
+	g, err := do(ast, s)
+	if err != nil {
+		return nil, err
+	}
+
+	return g, nil
+}