clerk @ 05a3553

package fuzzy

import (

	"strings"

	"unicode"

)

// Matcher scores a precompiled pattern against candidate texts; [Compile]

// hoists the lowercasing and rune conversion out of a per-candidate loop.

type Matcher struct {

	p []rune // lowercased pattern runes; empty matches everything

}

// Compile builds a matcher for pattern. The empty pattern matches every

// text with score 1.

func Compile(pattern string) Matcher {

	if pattern == "" {

		return Matcher{}

	}

	return Matcher{p: []rune(strings.ToLower(pattern))}

}

// Score scores how well the pattern matches text as a subsequence.

// It returns 0 if pattern is not a case-insensitive subsequence of text,

// otherwise a score in (0, 1], where 1 is a perfect contiguous match at a

// segment boundary. An empty pattern matches everything with score 1.

//

// Matching is greedy and leftmost; each matched rune scores base 1, plus 3 if

// it starts a segment (text start or after a separator), plus 2 if it is

// contiguous with the previous matched rune, plus 1 if the case matches

// exactly. The total is normalized by 4L+1, the maximum score of a perfect

// match of length L, so exact segment matches score 1 regardless of length

// ("food" and "expenses" both match "expenses:food" at 1.0).

func (m Matcher) Score(text string) float64 {

	p := m.p

	if len(p) == 0 {

		return 1

	}

	t := []rune(text)

	total := 0

	prev := -1

	for i, pr := range p {

		j := prev + 1

		for ; j < len(t); j++ {

			if unicode.ToLower(t[j]) == pr {

				break

			}

		}

		if j == len(t) {

			return 0

		}

		w := 1

		if j == 0 || isFuzzySep(t[j-1]) {

			w += 3

		}

		if i > 0 && j == prev+1 {

			w += 2

		}

		if t[j] == p[i] {

			w++

		}

		total += w

		prev = j

	}

	score := float64(total) / float64(4*len(p)+1)

	if score > 1 {

		return 1

	}

	return score

}

// Score scores pattern against text; see [Matcher.Score].

func Score(pattern, text string) float64 { return Compile(pattern).Score(text) }

// isFuzzySep reports whether r is a segment boundary for fuzzy matching:

// account-name separators and word boundaries.

func isFuzzySep(r rune) bool {

	switch r {

	case ':', '.', '-', '_', '/', ' ', '\t':

		return true

	}

	return false

}