fzf/src/core.go

400 lines
10 KiB
Go
Raw Normal View History

2022-08-12 13:11:15 +00:00
// Package fzf implements fzf, a command-line fuzzy finder.
2015-01-01 19:49:30 +00:00
package fzf
import (
"fmt"
"sync"
2015-01-01 19:49:30 +00:00
"time"
"unsafe"
2015-01-12 03:56:17 +00:00
"github.com/junegunn/fzf/src/util"
2015-01-01 19:49:30 +00:00
)
/*
2015-01-11 18:01:24 +00:00
Reader -> EvtReadFin
Reader -> EvtReadNew -> Matcher (restart)
2015-03-31 13:05:02 +00:00
Terminal -> EvtSearchNew:bool -> Matcher (restart)
2015-01-11 18:01:24 +00:00
Matcher -> EvtSearchProgress -> Terminal (update info)
Matcher -> EvtSearchFin -> Terminal (update list)
2015-07-21 18:21:20 +00:00
Matcher -> EvtHeader -> Terminal (update header)
2015-01-01 19:49:30 +00:00
*/
func ustring(data []byte) string {
return unsafe.String(unsafe.SliceData(data), len(data))
}
func sbytes(data string) []byte {
return unsafe.Slice(unsafe.StringData(data), len(data))
}
2015-01-11 18:01:24 +00:00
// Run starts fzf
2020-10-26 16:46:43 +00:00
func Run(opts *Options, version string, revision string) {
defer util.RunAtExitFuncs()
2015-03-31 13:05:02 +00:00
sort := opts.Sort > 0
sortCriteria = opts.Criteria
2015-01-01 19:49:30 +00:00
if opts.Version {
2017-06-02 08:57:28 +00:00
if len(revision) > 0 {
fmt.Printf("%s (%s)\n", version, revision)
} else {
fmt.Println(version)
}
util.Exit(exitOk)
2015-01-01 19:49:30 +00:00
}
// Event channel
2015-01-12 03:56:17 +00:00
eventBox := util.NewEventBox()
2015-01-01 19:49:30 +00:00
2015-03-18 16:59:14 +00:00
// ANSI code processor
ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
return util.ToChars(data), nil
}
var lineAnsiState, prevLineAnsiState *ansiState
2015-03-18 16:59:14 +00:00
if opts.Ansi {
if opts.Theme.Colored {
ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
prevLineAnsiState = lineAnsiState
trimmed, offsets, newState := extractColor(ustring(data), lineAnsiState, nil)
lineAnsiState = newState
return util.ToChars(sbytes(trimmed)), offsets
2015-03-18 16:59:14 +00:00
}
} else {
// When color is disabled but ansi option is given,
// we simply strip out ANSI codes from the input
ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
trimmed, _, _ := extractColor(ustring(data), nil, nil)
return util.ToChars(sbytes(trimmed)), nil
2015-03-18 16:59:14 +00:00
}
}
}
2015-01-01 19:49:30 +00:00
// Chunk list
var chunkList *ChunkList
2017-08-16 03:26:06 +00:00
var itemIndex int32
2015-07-21 18:21:20 +00:00
header := make([]string, 0, opts.HeaderLines)
2015-01-01 19:49:30 +00:00
if len(opts.WithNth) == 0 {
2017-08-16 03:26:06 +00:00
chunkList = NewChunkList(func(item *Item, data []byte) bool {
2015-07-21 18:21:20 +00:00
if len(header) < opts.HeaderLines {
header = append(header, ustring(data))
2015-07-21 18:21:20 +00:00
eventBox.Set(EvtHeader, header)
2017-08-14 16:10:41 +00:00
return false
2015-07-21 18:21:20 +00:00
}
2017-08-14 16:10:41 +00:00
item.text, item.colors = ansiProcessor(data)
2017-08-16 03:26:06 +00:00
item.text.Index = itemIndex
itemIndex++
2017-08-14 16:10:41 +00:00
return true
2015-01-01 19:49:30 +00:00
})
} else {
2017-08-16 03:26:06 +00:00
chunkList = NewChunkList(func(item *Item, data []byte) bool {
tokens := Tokenize(ustring(data), opts.Delimiter)
if opts.Ansi && opts.Theme.Colored && len(tokens) > 1 {
var ansiState *ansiState
if prevLineAnsiState != nil {
ansiStateDup := *prevLineAnsiState
ansiState = &ansiStateDup
}
for _, token := range tokens {
prevAnsiState := ansiState
_, _, ansiState = extractColor(token.text.ToString(), ansiState, nil)
if prevAnsiState != nil {
token.text.Prepend("\x1b[m" + prevAnsiState.ToString())
} else {
token.text.Prepend("\x1b[m")
}
}
}
trans := Transform(tokens, opts.WithNth)
transformed := joinTokens(trans)
2015-07-21 18:21:20 +00:00
if len(header) < opts.HeaderLines {
header = append(header, transformed)
2015-07-21 18:21:20 +00:00
eventBox.Set(EvtHeader, header)
2017-08-14 16:10:41 +00:00
return false
2015-07-21 18:21:20 +00:00
}
item.text, item.colors = ansiProcessor(sbytes(transformed))
item.text.TrimTrailingWhitespaces()
2017-08-16 03:26:06 +00:00
item.text.Index = itemIndex
2017-08-14 16:10:41 +00:00
item.origText = &data
2017-08-16 03:26:06 +00:00
itemIndex++
2017-08-14 16:10:41 +00:00
return true
2015-01-01 19:49:30 +00:00
})
}
// Reader
2015-03-31 13:05:02 +00:00
streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
var reader *Reader
if !streamingFilter {
reader = NewReader(func(data []byte) bool {
return chunkList.Push(data)
}, eventBox, opts.ReadZero, opts.Filter == nil)
go reader.ReadSource(opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
}
2015-01-01 19:49:30 +00:00
// Matcher
forward := true
withPos := false
for idx := len(opts.Criteria) - 1; idx > 0; idx-- {
switch opts.Criteria[idx] {
case byChunk:
withPos = true
case byEnd:
forward = false
case byBegin:
forward = true
}
}
2015-01-01 19:49:30 +00:00
patternBuilder := func(runes []rune) *Pattern {
return BuildPattern(
opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
2016-09-07 00:58:18 +00:00
opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
2015-01-01 19:49:30 +00:00
}
inputRevision := 0
snapshotRevision := 0
matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox, inputRevision)
2015-01-01 19:49:30 +00:00
// Filtering mode
if opts.Filter != nil {
if opts.PrintQuery {
2016-09-17 19:52:47 +00:00
opts.Printer(*opts.Filter)
2015-01-01 19:49:30 +00:00
}
pattern := patternBuilder([]rune(*opts.Filter))
matcher.sort = pattern.sortable
found := false
if streamingFilter {
2016-09-07 00:58:18 +00:00
slab := util.MakeSlab(slab16Size, slab32Size)
mutex := sync.Mutex{}
reader := NewReader(
func(runes []byte) bool {
2017-08-14 16:10:41 +00:00
item := Item{}
2017-08-16 03:26:06 +00:00
if chunkList.trans(&item, runes) {
mutex.Lock()
if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
2016-09-17 19:52:47 +00:00
opts.Printer(item.text.ToString())
2016-08-19 16:46:54 +00:00
found = true
}
mutex.Unlock()
}
2015-07-21 18:21:20 +00:00
return false
}, eventBox, opts.ReadZero, false)
reader.ReadSource(opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
} else {
eventBox.Unwatch(EvtReadNew)
eventBox.WaitFor(EvtReadFin)
snapshot, _ := chunkList.Snapshot()
merger, _ := matcher.scan(MatchRequest{
chunks: snapshot,
pattern: pattern})
for i := 0; i < merger.Length(); i++ {
2016-09-17 19:52:47 +00:00
opts.Printer(merger.Get(i).item.AsString(opts.Ansi))
found = true
}
}
if found {
util.Exit(exitOk)
}
util.Exit(exitNoMatch)
2015-01-01 19:49:30 +00:00
}
2015-02-13 03:25:19 +00:00
// Synchronous search
if opts.Sync {
eventBox.Unwatch(EvtReadNew)
eventBox.WaitFor(EvtReadFin)
}
2015-01-01 19:49:30 +00:00
// Go interactive
go matcher.Loop()
// Terminal I/O
terminal := NewTerminal(opts, eventBox)
maxFit := 0 // Maximum number of items that can fit on screen
padHeight := 0
heightUnknown := opts.Height.auto
if heightUnknown {
maxFit, padHeight = terminal.MaxFitAndPad()
}
deferred := opts.Select1 || opts.Exit0
2015-01-01 19:49:30 +00:00
go terminal.Loop()
if !deferred && !heightUnknown {
// Start right away
terminal.startChan <- fitpad{-1, -1}
}
2015-01-01 19:49:30 +00:00
// Event coordination
reading := true
ticks := 0
var nextCommand *string
var nextEnviron []string
2015-01-11 18:01:24 +00:00
eventBox.Watch(EvtReadNew)
total := 0
query := []rune{}
determine := func(final bool) {
if heightUnknown {
if total >= maxFit || final {
deferred = false
heightUnknown = false
terminal.startChan <- fitpad{util.Min(total, maxFit), padHeight}
}
} else if deferred {
deferred = false
terminal.startChan <- fitpad{-1, -1}
}
}
2022-12-29 11:03:51 +00:00
useSnapshot := false
var snapshot []*Chunk
var count int
restart := func(command string, environ []string) {
2022-12-29 11:03:51 +00:00
reading = true
chunkList.Clear()
itemIndex = 0
inputRevision++
2022-12-29 11:03:51 +00:00
header = make([]string, 0, opts.HeaderLines)
go reader.restart(command, environ)
2022-12-29 11:03:51 +00:00
}
2015-01-01 19:49:30 +00:00
for {
delay := true
2015-01-11 18:01:24 +00:00
ticks++
input := func() []rune {
paused, input := terminal.Input()
if !paused {
query = input
}
return query
}
2015-01-12 03:56:17 +00:00
eventBox.Wait(func(events *util.Events) {
if _, fin := (*events)[EvtReadFin]; fin {
delete(*events, EvtReadNew)
}
2015-01-01 19:49:30 +00:00
for evt, value := range *events {
switch evt {
case EvtQuit:
if reading {
reader.terminate()
}
util.Exit(value.(int))
2015-01-11 18:01:24 +00:00
case EvtReadNew, EvtReadFin:
if evt == EvtReadFin && nextCommand != nil {
restart(*nextCommand, nextEnviron)
nextCommand = nil
nextEnviron = nil
break
} else {
reading = reading && evt == EvtReadNew
}
2022-12-29 11:03:51 +00:00
if useSnapshot && evt == EvtReadFin {
useSnapshot = false
}
if !useSnapshot {
if snapshotRevision != inputRevision {
query = []rune{}
}
2022-12-29 11:03:51 +00:00
snapshot, count = chunkList.Snapshot()
snapshotRevision = inputRevision
2022-12-29 11:03:51 +00:00
}
total = count
terminal.UpdateCount(total, !reading, value.(*string))
if opts.Sync {
terminal.UpdateList(PassMerger(&snapshot, opts.Tac, snapshotRevision), false)
}
if heightUnknown && !deferred {
determine(!reading)
}
matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
2015-01-01 19:49:30 +00:00
2015-01-11 18:01:24 +00:00
case EvtSearchNew:
var command *string
var environ []string
var changed bool
switch val := value.(type) {
case searchRequest:
sort = val.sort
command = val.command
environ = val.environ
changed = val.changed
2022-12-29 11:03:51 +00:00
if command != nil {
useSnapshot = val.sync
}
}
if command != nil {
if reading {
reader.terminate()
nextCommand = command
nextEnviron = environ
} else {
restart(*command, environ)
}
}
if !changed {
break
2015-03-31 13:05:02 +00:00
}
2022-12-29 11:03:51 +00:00
if !useSnapshot {
newSnapshot, newCount := chunkList.Snapshot()
// We want to avoid showing empty list when reload is triggered
// and the query string is changed at the same time i.e. command != nil && changed
if command == nil || newCount > 0 {
if snapshotRevision != inputRevision {
query = []rune{}
}
snapshot = newSnapshot
snapshotRevision = inputRevision
}
2022-12-29 11:03:51 +00:00
}
matcher.Reset(snapshot, input(), true, !reading, sort, snapshotRevision)
2015-01-01 19:49:30 +00:00
delay = false
2015-01-11 18:01:24 +00:00
case EvtSearchProgress:
2015-01-01 19:49:30 +00:00
switch val := value.(type) {
case float32:
terminal.UpdateProgress(val)
}
2015-07-21 18:21:20 +00:00
case EvtHeader:
2019-12-16 09:47:05 +00:00
headerPadded := make([]string, opts.HeaderLines)
copy(headerPadded, value.([]string))
terminal.UpdateHeader(headerPadded)
2015-07-21 18:21:20 +00:00
2015-01-11 18:01:24 +00:00
case EvtSearchFin:
2015-01-01 19:49:30 +00:00
switch val := value.(type) {
case *Merger:
if deferred {
count := val.Length()
if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
determine(val.final)
} else if val.final {
if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
if opts.PrintQuery {
2016-09-17 19:52:47 +00:00
opts.Printer(opts.Query)
}
if len(opts.Expect) > 0 {
2016-09-17 19:52:47 +00:00
opts.Printer("")
}
for i := 0; i < count; i++ {
2016-09-17 19:52:47 +00:00
opts.Printer(val.Get(i).item.AsString(opts.Ansi))
}
if count > 0 {
util.Exit(exitOk)
}
util.Exit(exitNoMatch)
}
determine(val.final)
}
}
terminal.UpdateList(val, true)
2015-01-01 19:49:30 +00:00
}
}
}
events.Clear()
2015-01-01 19:49:30 +00:00
})
2015-01-08 13:07:04 +00:00
if delay && reading {
2015-01-12 03:56:17 +00:00
dur := util.DurWithin(
2015-01-11 18:01:24 +00:00
time.Duration(ticks)*coordinatorDelayStep,
0, coordinatorDelayMax)
2015-01-08 13:07:04 +00:00
time.Sleep(dur)
2015-01-01 19:49:30 +00:00
}
}
}