mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-16 13:08:25 +00:00
Some checks are pending
CI / Linux (python=3.14 cc=clang sanitize=1) (push) Waiting to run
CI / Linux (python=3.12 cc=gcc sanitize=0) (push) Waiting to run
CI / Linux (python=3.13 cc=gcc sanitize=1) (push) Waiting to run
CI / Linux package (push) Waiting to run
CI / Bundle test (macos-latest) (push) Waiting to run
CI / Bundle test (ubuntu-latest) (push) Waiting to run
CI / macOS Brew (push) Waiting to run
CI / Test ./dev.sh and benchmark (push) Waiting to run
CodeQL / CodeQL-Build (actions, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, macos-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (go, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (python, ubuntu-latest) (push) Waiting to run
Depscan / Scan dependencies for vulnerabilities (push) Waiting to run
Use Capture.ByteRange() from v2 instead of a hand-rolled rune to byte offset mapping. The old mapping required capture offsets to be monotonic across matches, so a capture inside a lookaround overlapping a later match in non-ASCII text caused all matches to be silently dropped. Also propagate match errors instead of discarding them. Drops the v1 dependency, v2 was already pulled in by chroma.
765 lines
20 KiB
Go
765 lines
20 KiB
Go
// License: GPLv3 Copyright: 2023, Kovid Goyal, <kovid at kovidgoyal.net>
|
||
|
||
package hints
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"os/exec"
|
||
"regexp"
|
||
"slices"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"unicode"
|
||
"unicode/utf8"
|
||
|
||
"github.com/dlclark/regexp2/v2"
|
||
"github.com/dlclark/regexp2/v2/syntax"
|
||
"github.com/seancfoley/ipaddress-go/ipaddr"
|
||
|
||
"github.com/kovidgoyal/kitty"
|
||
"github.com/kovidgoyal/kitty/tools/config"
|
||
"github.com/kovidgoyal/kitty/tools/tty"
|
||
"github.com/kovidgoyal/kitty/tools/utils"
|
||
)
|
||
|
||
var _ = fmt.Print
|
||
|
||
const (
|
||
DEFAULT_HINT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz"
|
||
FILE_EXTENSION = `\.(?:[a-zA-Z0-9]{2,7}|[ahcmo])(?:\b|[^.])`
|
||
)
|
||
|
||
func path_regex() string {
|
||
return fmt.Sprintf(`(?:\S*?/[\r\S]+)|(?:\S[\r\S]*%s)\b`, FILE_EXTENSION)
|
||
}
|
||
|
||
func default_linenum_regex() string {
|
||
return fmt.Sprintf(`(?P<path>%s):(?P<line>\d+)`, path_regex())
|
||
}
|
||
|
||
type Mark struct {
|
||
Index int `json:"index"`
|
||
Start int `json:"start"`
|
||
End int `json:"end"`
|
||
Text string `json:"text"`
|
||
Group_id string `json:"group_id"`
|
||
Is_hyperlink bool `json:"is_hyperlink"`
|
||
Groupdict map[string]any `json:"groupdict"`
|
||
}
|
||
|
||
func process_escape_codes(text string) (ans string, hyperlinks []Mark) {
|
||
removed_size, idx := 0, 0
|
||
active_hyperlink_url := ""
|
||
active_hyperlink_id := ""
|
||
active_hyperlink_start_offset := 0
|
||
|
||
add_hyperlink := func(end int) {
|
||
hyperlinks = append(hyperlinks, Mark{
|
||
Index: idx, Start: active_hyperlink_start_offset, End: end, Text: active_hyperlink_url, Is_hyperlink: true, Group_id: active_hyperlink_id})
|
||
active_hyperlink_url, active_hyperlink_id = "", ""
|
||
active_hyperlink_start_offset = 0
|
||
idx++
|
||
}
|
||
|
||
ans = utils.ReplaceAll(utils.MustCompile("\x1b(?:\\[[0-9;:]*?m|\\].*?\x1b\\\\)"), text, func(raw string, groupdict map[string]utils.SubMatch) string {
|
||
if !strings.HasPrefix(raw, "\x1b]8") {
|
||
removed_size += len(raw)
|
||
return ""
|
||
}
|
||
start := groupdict[""].Start - removed_size
|
||
removed_size += len(raw)
|
||
if active_hyperlink_url != "" {
|
||
add_hyperlink(start)
|
||
}
|
||
raw = raw[4 : len(raw)-2]
|
||
if metadata, url, found := strings.Cut(raw, ";"); found && url != "" {
|
||
active_hyperlink_url = url
|
||
active_hyperlink_start_offset = start
|
||
if metadata != "" {
|
||
for entry := range strings.SplitSeq(metadata, ":") {
|
||
if strings.HasPrefix(entry, "id=") && len(entry) > 3 {
|
||
active_hyperlink_id = entry[3:]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
})
|
||
if active_hyperlink_url != "" {
|
||
add_hyperlink(len(ans))
|
||
}
|
||
return
|
||
}
|
||
|
||
type PostProcessorFunc = func(string, int, int) (int, int)
|
||
type GroupProcessorFunc = func(map[string]string)
|
||
|
||
func is_punctuation(b string) bool {
|
||
switch b {
|
||
case ",", ".", "?", "!":
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
func closing_bracket_for(ch string) string {
|
||
switch ch {
|
||
case "(":
|
||
return ")"
|
||
case "[":
|
||
return "]"
|
||
case "{":
|
||
return "}"
|
||
case "<":
|
||
return ">"
|
||
case "*":
|
||
return "*"
|
||
case `"`:
|
||
return `"`
|
||
case "'":
|
||
return "'"
|
||
case "“":
|
||
return "”"
|
||
case "‘":
|
||
return "’"
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func char_at(s string, i int) string {
|
||
ans, _ := utf8.DecodeRuneInString(s[i:])
|
||
if ans == utf8.RuneError {
|
||
return ""
|
||
}
|
||
return string(ans)
|
||
}
|
||
|
||
func char_before(s string, i int) string {
|
||
ans, _ := utf8.DecodeLastRuneInString(s[:i])
|
||
if ans == utf8.RuneError {
|
||
return ""
|
||
}
|
||
return string(ans)
|
||
}
|
||
|
||
func matching_remover(openers ...string) PostProcessorFunc {
|
||
return func(text string, s, e int) (int, int) {
|
||
if s < e && e <= len(text) {
|
||
before := char_at(text, s)
|
||
if slices.Index(openers, before) > -1 {
|
||
q := closing_bracket_for(before)
|
||
if s+len(before) <= e-len(q) && char_before(text, e) == q {
|
||
s += len(before)
|
||
e -= len(q)
|
||
} else if char_at(text, e) == q {
|
||
s += len(before)
|
||
}
|
||
}
|
||
}
|
||
return s, e
|
||
}
|
||
}
|
||
|
||
func linenum_group_processor(gd map[string]string) {
|
||
pat := utils.MustCompile(`:\d+$`)
|
||
gd[`path`] = pat.ReplaceAllStringFunc(gd["path"], func(m string) string {
|
||
gd["line"] = m[1:]
|
||
return ``
|
||
})
|
||
gd[`path`] = utils.Expanduser(gd[`path`])
|
||
}
|
||
|
||
var PostProcessorMap = sync.OnceValue(func() map[string]PostProcessorFunc {
|
||
return map[string]PostProcessorFunc{
|
||
"url": func(text string, s, e int) (int, int) {
|
||
if s > 4 && text[s-5:s] == "link:" { // asciidoc URLs
|
||
url := text[s:e]
|
||
idx := strings.LastIndex(url, "[")
|
||
if idx > -1 {
|
||
e -= len(url) - idx
|
||
}
|
||
}
|
||
for e > 1 && is_punctuation(char_before(text, e)) { // remove trailing punctuation
|
||
e--
|
||
}
|
||
// truncate url at closing bracket/quote
|
||
if s > 0 && e <= len(text) {
|
||
if q := closing_bracket_for(char_before(text, s)); q != "" {
|
||
idx := strings.Index(text[s:], q)
|
||
if idx > 0 {
|
||
e = s + idx
|
||
}
|
||
}
|
||
}
|
||
// reStructuredText URLs
|
||
if e > 3 && text[e-2:e] == "`_" {
|
||
e -= 2
|
||
}
|
||
return s, e
|
||
},
|
||
|
||
"brackets": matching_remover("(", "{", "[", "<"),
|
||
"quotes": matching_remover("'", `"`, "“", "‘"),
|
||
"ip": func(text string, s, e int) (int, int) {
|
||
addr := ipaddr.NewHostName(text[s:e])
|
||
if !addr.IsAddress() {
|
||
return -1, -1
|
||
}
|
||
return s, e
|
||
},
|
||
}
|
||
})
|
||
|
||
type KittyOpts struct {
|
||
Url_prefixes *utils.Set[string]
|
||
Url_excluded_characters string
|
||
Select_by_word_characters string
|
||
}
|
||
|
||
func read_relevant_kitty_opts() KittyOpts {
|
||
ans := KittyOpts{
|
||
Select_by_word_characters: kitty.KittyConfigDefaults.Select_by_word_characters,
|
||
Url_excluded_characters: kitty.KittyConfigDefaults.Url_excluded_characters}
|
||
handle_line := func(key, val string) error {
|
||
switch key {
|
||
case "url_prefixes":
|
||
ans.Url_prefixes = utils.NewSetWithItems(strings.Split(val, " ")...)
|
||
case "select_by_word_characters":
|
||
ans.Select_by_word_characters = strings.TrimSpace(val)
|
||
case "url_excluded_characters":
|
||
if s, err := config.StringLiteral(val); err == nil {
|
||
ans.Url_excluded_characters = s
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
config.ReadKittyConfig(handle_line)
|
||
if ans.Url_prefixes == nil {
|
||
ans.Url_prefixes = utils.NewSetWithItems(kitty.KittyConfigDefaults.Url_prefixes...)
|
||
}
|
||
return ans
|
||
}
|
||
|
||
var RelevantKittyOpts = sync.OnceValue(func() KittyOpts {
|
||
return read_relevant_kitty_opts()
|
||
})
|
||
|
||
var debugprintln = tty.DebugPrintln
|
||
var _ = debugprintln
|
||
|
||
func url_excluded_characters_as_ranges_for_regex(extra_excluded string) string {
|
||
// See https://url.spec.whatwg.org/#url-code-points
|
||
ans := strings.Builder{}
|
||
ans.Grow(4096)
|
||
type cr struct{ start, end rune }
|
||
ranges := []cr{}
|
||
r := func(start rune, end ...rune) {
|
||
if len(end) == 0 {
|
||
ranges = append(ranges, cr{start, start})
|
||
} else {
|
||
ranges = append(ranges, cr{start, end[0]})
|
||
}
|
||
}
|
||
if !strings.Contains(extra_excluded, "\n") {
|
||
r('\n')
|
||
}
|
||
if !strings.Contains(extra_excluded, "\r") {
|
||
r('\r')
|
||
}
|
||
r('!')
|
||
r('$')
|
||
r('&')
|
||
r('#')
|
||
r('\'')
|
||
r('/')
|
||
r(':')
|
||
r(';')
|
||
r('@')
|
||
r('_')
|
||
r('~')
|
||
r('(')
|
||
r(')')
|
||
r('*')
|
||
r('+')
|
||
r(',')
|
||
r('-')
|
||
r('.')
|
||
r('=')
|
||
r('?')
|
||
r('%')
|
||
r('a', 'z')
|
||
r('A', 'Z')
|
||
r('0', '9')
|
||
slices.SortFunc(ranges, func(a, b cr) int { return int(a.start - b.start) })
|
||
var prev rune = -1
|
||
for _, cr := range ranges {
|
||
if cr.start-1 > prev+1 {
|
||
ans.WriteString(regexp.QuoteMeta(string(prev + 1)))
|
||
ans.WriteRune('-')
|
||
ans.WriteString(regexp.QuoteMeta(string(cr.start - 1)))
|
||
}
|
||
prev = cr.end
|
||
}
|
||
ans.WriteString(regexp.QuoteMeta(string(ranges[len(ranges)-1].end + 1)))
|
||
ans.WriteRune('-')
|
||
ans.WriteRune(0x9f)
|
||
ans.WriteString(`\x{d800}-\x{dfff}`)
|
||
ans.WriteString(`\x{fdd0}-\x{fdef}`)
|
||
w := func(x rune) { ans.WriteRune(x) }
|
||
|
||
w(0xFFFE)
|
||
w(0xFFFF)
|
||
w(0x1FFFE)
|
||
w(0x1FFFF)
|
||
w(0x2FFFE)
|
||
w(0x2FFFF)
|
||
w(0x3FFFE)
|
||
w(0x3FFFF)
|
||
w(0x4FFFE)
|
||
w(0x4FFFF)
|
||
w(0x5FFFE)
|
||
w(0x5FFFF)
|
||
w(0x6FFFE)
|
||
w(0x6FFFF)
|
||
w(0x7FFFE)
|
||
w(0x7FFFF)
|
||
w(0x8FFFE)
|
||
w(0x8FFFF)
|
||
w(0x9FFFE)
|
||
w(0x9FFFF)
|
||
w(0xAFFFE)
|
||
w(0xAFFFF)
|
||
w(0xBFFFE)
|
||
w(0xBFFFF)
|
||
w(0xCFFFE)
|
||
w(0xCFFFF)
|
||
w(0xDFFFE)
|
||
w(0xDFFFF)
|
||
w(0xEFFFE)
|
||
w(0xEFFFF)
|
||
w(0xFFFFE)
|
||
w(0xFFFFF)
|
||
|
||
if strings.Contains(extra_excluded, "-") {
|
||
extra_excluded = strings.ReplaceAll(extra_excluded, "-", "")
|
||
extra_excluded = regexp.QuoteMeta(extra_excluded) + "-"
|
||
} else {
|
||
extra_excluded = regexp.QuoteMeta(extra_excluded)
|
||
}
|
||
ans.WriteString(extra_excluded)
|
||
return ans.String()
|
||
|
||
}
|
||
|
||
func functions_for(opts *Options) (pattern string, post_processors []PostProcessorFunc, group_processors []GroupProcessorFunc, err error) {
|
||
switch opts.Type {
|
||
case "url":
|
||
var url_prefixes *utils.Set[string]
|
||
if opts.UrlPrefixes == "default" {
|
||
url_prefixes = RelevantKittyOpts().Url_prefixes
|
||
} else {
|
||
url_prefixes = utils.NewSetWithItems(strings.Split(opts.UrlPrefixes, ",")...)
|
||
}
|
||
url_excluded_characters := RelevantKittyOpts().Url_excluded_characters
|
||
if opts.UrlExcludedCharacters != "default" {
|
||
if url_excluded_characters, err = config.StringLiteral(opts.UrlExcludedCharacters); err != nil {
|
||
err = fmt.Errorf("Failed to parse --url-excluded-characters value: %#v with error: %w", opts.UrlExcludedCharacters, err)
|
||
return
|
||
}
|
||
}
|
||
pattern = fmt.Sprintf(`(?:%s)://[^%s]{3,}`, strings.Join(url_prefixes.AsSlice(), "|"), url_excluded_characters_as_ranges_for_regex(url_excluded_characters))
|
||
post_processors = append(post_processors, PostProcessorMap()["url"])
|
||
case "path":
|
||
pattern = path_regex()
|
||
post_processors = append(post_processors, PostProcessorMap()["brackets"], PostProcessorMap()["quotes"])
|
||
case "line":
|
||
pattern = "(?m)^\\s*(.+)[\\s\x00]*$"
|
||
case "hash":
|
||
pattern = "[0-9a-f][0-9a-f\r]{6,127}"
|
||
case "ip":
|
||
pattern = (
|
||
// IPv4 with no validation
|
||
`((?:\d{1,3}\.){3}\d{1,3}` + "|" +
|
||
// IPv6 with no validation
|
||
`(?:[a-fA-F0-9]{0,4}:){2,7}[a-fA-F0-9]{0,4})`)
|
||
post_processors = append(post_processors, PostProcessorMap()["ip"])
|
||
default:
|
||
pattern = opts.Regex
|
||
if opts.Type == "linenum" {
|
||
if pattern == kitty.HintsDefaultRegex {
|
||
pattern = default_linenum_regex()
|
||
}
|
||
post_processors = append(post_processors, PostProcessorMap()["brackets"], PostProcessorMap()["quotes"])
|
||
group_processors = append(group_processors, linenum_group_processor)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
type Capture struct {
|
||
Text string
|
||
Text_as_runes []rune
|
||
Byte_Offsets struct {
|
||
Start, End int
|
||
}
|
||
Rune_Offsets struct {
|
||
Start, End int
|
||
}
|
||
}
|
||
|
||
func (self Capture) String() string {
|
||
return fmt.Sprintf("Capture(start=%d, end=%d, %#v)", self.Byte_Offsets.Start, self.Byte_Offsets.End, self.Text)
|
||
}
|
||
|
||
type Group struct {
|
||
Name string
|
||
IsNamed bool
|
||
Captures []Capture
|
||
}
|
||
|
||
func (self Group) LastCapture() Capture {
|
||
if len(self.Captures) == 0 {
|
||
return Capture{}
|
||
}
|
||
return self.Captures[len(self.Captures)-1]
|
||
}
|
||
|
||
func (self Group) String() string {
|
||
return fmt.Sprintf("Group(name=%#v, captures=%v)", self.Name, self.Captures)
|
||
}
|
||
|
||
type Match struct {
|
||
Groups []Group
|
||
}
|
||
|
||
func (self Match) HasNamedGroups() bool {
|
||
for _, g := range self.Groups {
|
||
if g.IsNamed {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func find_all_matches(re *regexp2.Regexp, text string) (ans []Match, err error) {
|
||
m, err := re.FindStringMatch(text)
|
||
for m != nil && err == nil {
|
||
groups := m.Groups()
|
||
match := Match{Groups: make([]Group, len(groups))}
|
||
for i, g := range groups {
|
||
match.Groups[i].Name = g.Name
|
||
match.Groups[i].IsNamed = g.Name != "" && g.Name != strconv.Itoa(i)
|
||
for _, c := range g.Captures {
|
||
cn := Capture{Text: c.String(), Text_as_runes: c.Runes()}
|
||
cn.Rune_Offsets.Start, cn.Rune_Offsets.End = c.RuneIndex, c.RuneIndex+c.RuneLength
|
||
start, length := c.ByteRange()
|
||
cn.Byte_Offsets.Start, cn.Byte_Offsets.End = start, start+length
|
||
match.Groups[i].Captures = append(match.Groups[i].Captures, cn)
|
||
}
|
||
}
|
||
ans = append(ans, match)
|
||
m, err = re.FindNextMatch(m)
|
||
}
|
||
return
|
||
}
|
||
|
||
// Go's regexp only considers ASCII characters when matching \b whereas regexp2
|
||
// uses Unicode word characters. So replace every non-ASCII rune with a single
|
||
// ASCII byte that is a word character iff the rune is one, and return the byte
|
||
// offsets of the runes in text, to map match offsets back.
|
||
func ascii_word_proxy(text string) (proxy string, byte_offsets []int) {
|
||
if !slices.ContainsFunc(utils.UnsafeStringToBytes(text), func(b byte) bool { return b >= utf8.RuneSelf }) {
|
||
return text, nil
|
||
}
|
||
buf := make([]byte, 0, len(text))
|
||
byte_offsets = make([]int, 0, len(text)+1)
|
||
for i, r := range text {
|
||
byte_offsets = append(byte_offsets, i)
|
||
switch {
|
||
case r < utf8.RuneSelf:
|
||
buf = append(buf, byte(r))
|
||
case syntax.IsWordChar(r):
|
||
buf = append(buf, '_')
|
||
default:
|
||
buf = append(buf, 0x7f)
|
||
}
|
||
}
|
||
return string(buf), append(byte_offsets, len(text))
|
||
}
|
||
|
||
func find_all_matches_stdlib(re *regexp.Regexp, text string, unicode_word_boundaries bool) (ans []Match) {
|
||
haystack, byte_offsets := text, []int(nil)
|
||
if unicode_word_boundaries {
|
||
haystack, byte_offsets = ascii_word_proxy(text)
|
||
}
|
||
names := re.SubexpNames()
|
||
for _, loc := range re.FindAllStringSubmatchIndex(haystack, -1) {
|
||
match := Match{Groups: make([]Group, len(names))}
|
||
for i, name := range names {
|
||
match.Groups[i] = Group{Name: name, IsNamed: name != ""}
|
||
if s, e := loc[2*i], loc[2*i+1]; s > -1 {
|
||
if byte_offsets != nil {
|
||
s, e = byte_offsets[s], byte_offsets[e]
|
||
}
|
||
c := Capture{Text: text[s:e]}
|
||
c.Byte_Offsets.Start, c.Byte_Offsets.End = s, e
|
||
match.Groups[i].Captures = []Capture{c}
|
||
}
|
||
}
|
||
ans = append(ans, match)
|
||
}
|
||
return
|
||
}
|
||
|
||
func mark(all_matches []Match, post_processors []PostProcessorFunc, group_processors []GroupProcessorFunc, text string, opts *Options) (ans []Mark) {
|
||
sanitize_pat := regexp.MustCompile("[\r\n\x00]")
|
||
for i, m := range all_matches {
|
||
full_capture := m.Groups[0].LastCapture()
|
||
match_start, match_end := full_capture.Byte_Offsets.Start, full_capture.Byte_Offsets.End
|
||
for match_end > match_start+1 && text[match_end-1] == 0 {
|
||
match_end--
|
||
}
|
||
full_match := text[match_start:match_end]
|
||
if len([]rune(full_match)) < opts.MinimumMatchLength {
|
||
continue
|
||
}
|
||
for _, f := range post_processors {
|
||
match_start, match_end = f(text, match_start, match_end)
|
||
if match_start < 0 {
|
||
break
|
||
}
|
||
}
|
||
if match_start < 0 {
|
||
continue
|
||
}
|
||
full_match = sanitize_pat.ReplaceAllLiteralString(text[match_start:match_end], "")
|
||
gd := make(map[string]string, len(m.Groups))
|
||
for idx, g := range m.Groups {
|
||
if idx > 0 && g.IsNamed {
|
||
c := g.LastCapture()
|
||
if s, e := c.Byte_Offsets.Start, c.Byte_Offsets.End; s > -1 && e > -1 {
|
||
s = max(s, match_start)
|
||
e = min(e, match_end)
|
||
gd[g.Name] = sanitize_pat.ReplaceAllLiteralString(text[s:e], "")
|
||
}
|
||
}
|
||
}
|
||
for _, f := range group_processors {
|
||
f(gd)
|
||
}
|
||
gd2 := make(map[string]any, len(gd))
|
||
for k, v := range gd {
|
||
gd2[k] = v
|
||
}
|
||
if opts.Type == "regex" && len(m.Groups) > 1 && !m.HasNamedGroups() {
|
||
cp := m.Groups[1].LastCapture()
|
||
ms, me := cp.Byte_Offsets.Start, cp.Byte_Offsets.End
|
||
match_start = max(match_start, ms)
|
||
match_end = min(match_end, me)
|
||
full_match = sanitize_pat.ReplaceAllLiteralString(text[match_start:match_end], "")
|
||
}
|
||
if full_match != "" {
|
||
ans = append(ans, Mark{
|
||
Index: i, Start: match_start, End: match_end, Text: full_match, Groupdict: gd2,
|
||
})
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
type ErrNoMatches struct{ Type, Pattern string }
|
||
|
||
func is_word_char(ch rune, current_chars []rune) bool {
|
||
return unicode.IsLetter(ch) || unicode.IsNumber(ch) || (unicode.IsMark(ch) && len(current_chars) > 0 && unicode.IsLetter(current_chars[len(current_chars)-1]))
|
||
}
|
||
|
||
func mark_words(text string, opts *Options) (ans []Mark) {
|
||
left := text
|
||
var current_run struct {
|
||
chars []rune
|
||
start, size int
|
||
}
|
||
chars := opts.WordCharacters
|
||
if chars == "" {
|
||
chars = RelevantKittyOpts().Select_by_word_characters
|
||
}
|
||
allowed_chars := make(map[rune]bool, len(chars))
|
||
for _, ch := range chars {
|
||
allowed_chars[ch] = true
|
||
}
|
||
pos := 0
|
||
post_processors := []PostProcessorFunc{PostProcessorMap()["brackets"], PostProcessorMap()["quotes"]}
|
||
|
||
commit_run := func() {
|
||
if len(current_run.chars) >= opts.MinimumMatchLength {
|
||
match_start, match_end := current_run.start, current_run.start+current_run.size
|
||
for _, f := range post_processors {
|
||
match_start, match_end = f(text, match_start, match_end)
|
||
if match_start < 0 {
|
||
break
|
||
}
|
||
}
|
||
if match_start > -1 && match_end > match_start {
|
||
full_match := text[match_start:match_end]
|
||
if len([]rune(full_match)) >= opts.MinimumMatchLength {
|
||
ans = append(ans, Mark{
|
||
Index: len(ans), Start: match_start, End: match_end, Text: full_match,
|
||
})
|
||
}
|
||
}
|
||
}
|
||
current_run.chars = nil
|
||
current_run.start = 0
|
||
current_run.size = 0
|
||
}
|
||
|
||
for {
|
||
ch, size := utf8.DecodeRuneInString(left)
|
||
if ch == utf8.RuneError {
|
||
break
|
||
}
|
||
if allowed_chars[ch] || is_word_char(ch, current_run.chars) {
|
||
if len(current_run.chars) == 0 {
|
||
current_run.start = pos
|
||
}
|
||
current_run.chars = append(current_run.chars, ch)
|
||
current_run.size += size
|
||
} else {
|
||
commit_run()
|
||
}
|
||
left = left[size:]
|
||
pos += size
|
||
}
|
||
commit_run()
|
||
return
|
||
}
|
||
|
||
func adjust_python_offsets(text string, marks []Mark) error {
|
||
// python returns rune based offsets (unicode chars not utf-8 bytes)
|
||
adjust := utils.RuneOffsetsToByteOffsets(text)
|
||
for i := range marks {
|
||
mark := &marks[i]
|
||
if mark.End < mark.Start {
|
||
return fmt.Errorf("The end of a mark must not be before its start")
|
||
}
|
||
s, e := adjust(mark.Start), adjust(mark.End)
|
||
if s < 0 || e < 0 {
|
||
return fmt.Errorf("Overlapping marks are not supported")
|
||
}
|
||
mark.Start, mark.End = s, e
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (self *ErrNoMatches) Error() string {
|
||
none_of := "matches"
|
||
switch self.Type {
|
||
case "urls":
|
||
none_of = "URLs"
|
||
case "hyperlinks":
|
||
none_of = "hyperlinks"
|
||
}
|
||
if self.Pattern != "" {
|
||
return fmt.Sprintf("No %s found with pattern: %s", none_of, self.Pattern)
|
||
}
|
||
return fmt.Sprintf("No %s found", none_of)
|
||
}
|
||
|
||
func find_marks(text string, opts *Options, cli_args ...string) (sanitized_text string, ans []Mark, index_map map[int]*Mark, err error) {
|
||
sanitized_text, hyperlinks := process_escape_codes(text)
|
||
used_pattern := ""
|
||
|
||
run_basic_matching := func() error {
|
||
pattern, post_processors, group_processors, err := functions_for(opts)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
var matches []Match
|
||
// the builtin patterns dont need lookarounds, so use the linear time stdlib engine for them
|
||
if pattern != opts.Regex {
|
||
r, err := regexp.Compile(pattern)
|
||
if err != nil {
|
||
return fmt.Errorf("Failed to compile the regex pattern: %#v with error: %w", pattern, err)
|
||
}
|
||
// the proxy text is only valid for patterns that dont reference specific non-ASCII characters
|
||
matches = find_all_matches_stdlib(r, sanitized_text, opts.Type == "path" || opts.Type == "linenum")
|
||
} else {
|
||
r, err := regexp2.Compile(pattern, regexp2.RE2)
|
||
if err != nil {
|
||
return fmt.Errorf("Failed to compile the regex pattern: %#v with error: %w", pattern, err)
|
||
}
|
||
if matches, err = find_all_matches(r, sanitized_text); err != nil {
|
||
return fmt.Errorf("Failed to match the regex pattern: %#v with error: %w", pattern, err)
|
||
}
|
||
}
|
||
ans = mark(matches, post_processors, group_processors, sanitized_text, opts)
|
||
used_pattern = pattern
|
||
return nil
|
||
}
|
||
|
||
if opts.CustomizeProcessing != "" {
|
||
cmd := exec.Command(utils.KittyExe(), append([]string{"+runpy", "from kittens.hints.main import custom_marking; custom_marking()"}, cli_args...)...)
|
||
cmd.Stdin = strings.NewReader(sanitized_text)
|
||
stdout, stderr := bytes.Buffer{}, bytes.Buffer{}
|
||
cmd.Stdout, cmd.Stderr = &stdout, &stderr
|
||
err = cmd.Run()
|
||
if err != nil {
|
||
var e *exec.ExitError
|
||
if errors.As(err, &e) && e.ExitCode() == 2 {
|
||
err = run_basic_matching()
|
||
if err != nil {
|
||
return
|
||
}
|
||
goto process_answer
|
||
} else {
|
||
return "", nil, nil, fmt.Errorf("Failed to run custom processor %#v with error: %w\n%s", opts.CustomizeProcessing, err, stderr.String())
|
||
}
|
||
}
|
||
ans = make([]Mark, 0, 32)
|
||
err = json.Unmarshal(stdout.Bytes(), &ans)
|
||
if err != nil {
|
||
return "", nil, nil, fmt.Errorf("Failed to load output from custom processor %#v with error: %w", opts.CustomizeProcessing, err)
|
||
}
|
||
err = adjust_python_offsets(sanitized_text, ans)
|
||
if err != nil {
|
||
return "", nil, nil, fmt.Errorf("Custom processor %#v produced invalid mark output with error: %w", opts.CustomizeProcessing, err)
|
||
}
|
||
} else if opts.Type == "hyperlink" {
|
||
ans = hyperlinks
|
||
} else if opts.Type == "word" {
|
||
ans = mark_words(sanitized_text, opts)
|
||
} else {
|
||
err = run_basic_matching()
|
||
if err != nil {
|
||
return
|
||
}
|
||
}
|
||
process_answer:
|
||
if len(ans) == 0 {
|
||
return "", nil, nil, &ErrNoMatches{Type: opts.Type, Pattern: used_pattern}
|
||
}
|
||
largest_index := ans[len(ans)-1].Index
|
||
offset := max(0, opts.HintsOffset)
|
||
if opts.PrefixFree {
|
||
alphabetLength := len(opts.Alphabet)
|
||
if alphabetLength == 0 {
|
||
alphabetLength = len(DEFAULT_HINT_ALPHABET)
|
||
}
|
||
offset = max(offset, hints_to_skip(len(ans), alphabetLength))
|
||
}
|
||
index_map = make(map[int]*Mark, len(ans))
|
||
for i := range ans {
|
||
m := &ans[i]
|
||
if opts.Ascending {
|
||
m.Index += offset
|
||
} else {
|
||
m.Index = largest_index - m.Index + offset
|
||
}
|
||
index_map[m.Index] = m
|
||
}
|
||
return
|
||
}
|