glob/compiler.go

package glob

// TODO use constructor with all matchers, and to their structs private

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
}