doing 2.0.18 → 2.0.22

data/lib/helpers/fzf/src/constants.go

@@ -0,0 +1,85 @@
+package fzf
+
+import (
+	"math"
+	"os"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const (
+	// Core
+	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
+	coordinatorDelayStep time.Duration = 10 * time.Millisecond
+
+	// Reader
+	readerBufferSize       = 64 * 1024
+	readerPollIntervalMin  = 10 * time.Millisecond
+	readerPollIntervalStep = 5 * time.Millisecond
+	readerPollIntervalMax  = 50 * time.Millisecond
+
+	// Terminal
+	initialDelay      = 20 * time.Millisecond
+	initialDelayTac   = 100 * time.Millisecond
+	spinnerDuration   = 100 * time.Millisecond
+	previewCancelWait = 500 * time.Millisecond
+	previewChunkDelay = 100 * time.Millisecond
+	previewDelayed    = 500 * time.Millisecond
+	maxPatternLength  = 300
+	maxMulti          = math.MaxInt32
+
+	// Matcher
+	numPartitionsMultiplier = 8
+	maxPartitions           = 32
+	progressMinDuration     = 200 * time.Millisecond
+
+	// Capacity of each chunk
+	chunkSize int = 100
+
+	// Pre-allocated memory slices to minimize GC
+	slab16Size int = 100 * 1024 // 200KB * 32 = 12.8MB
+	slab32Size int = 2048       // 8KB * 32 = 256KB
+
+	// Do not cache results of low selectivity queries
+	queryCacheMax int = chunkSize / 5
+
+	// Not to cache mergers with large lists
+	mergerCacheMax int = 100000
+
+	// History
+	defaultHistoryMax int = 1000
+
+	// Jump labels
+	defaultJumpLabels string = "asdfghjklqwertyuiopzxcvbnm1234567890ASDFGHJKLQWERTYUIOPZXCVBNM`~;:,<.>/?'\"!@#$%^&*()[{]}-_=+"
+)
+
+var defaultCommand string
+
+func init() {
+	if !util.IsWindows() {
+		defaultCommand = `set -o pipefail; command find -L . -mindepth 1 \( -path '*/\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \) -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-`
+	} else if os.Getenv("TERM") == "cygwin" {
+		defaultCommand = `sh -c "command find -L . -mindepth 1 -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-"`
+	}
+}
+
+// fzf events
+const (
+	EvtReadNew util.EventType = iota
+	EvtReadFin
+	EvtSearchNew
+	EvtSearchProgress
+	EvtSearchFin
+	EvtHeader
+	EvtReady
+	EvtQuit
+)
+
+const (
+	exitCancel    = -1
+	exitOk        = 0
+	exitNoMatch   = 1
+	exitError     = 2
+	exitInterrupt = 130
+)

data/lib/helpers/fzf/src/core.go

@@ -0,0 +1,351 @@
+/*
+Package fzf implements fzf, a command-line fuzzy finder.
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2021 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+/*
+Reader   -> EvtReadFin
+Reader   -> EvtReadNew        -> Matcher  (restart)
+Terminal -> EvtSearchNew:bool -> Matcher  (restart)
+Matcher  -> EvtSearchProgress -> Terminal (update info)
+Matcher  -> EvtSearchFin      -> Terminal (update list)
+Matcher  -> EvtHeader         -> Terminal (update header)
+*/
+
+// Run starts fzf
+func Run(opts *Options, version string, revision string) {
+	sort := opts.Sort > 0
+	sortCriteria = opts.Criteria
+
+	if opts.Version {
+		if len(revision) > 0 {
+			fmt.Printf("%s (%s)\n", version, revision)
+		} else {
+			fmt.Println(version)
+		}
+		os.Exit(exitOk)
+	}
+
+	// Event channel
+	eventBox := util.NewEventBox()
+
+	// ANSI code processor
+	ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
+		return util.ToChars(data), nil
+	}
+
+	var lineAnsiState, prevLineAnsiState *ansiState
+	if opts.Ansi {
+		if opts.Theme.Colored {
+			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
+				prevLineAnsiState = lineAnsiState
+				trimmed, offsets, newState := extractColor(string(data), lineAnsiState, nil)
+				lineAnsiState = newState
+				return util.ToChars([]byte(trimmed)), offsets
+			}
+		} 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(string(data), nil, nil)
+				return util.ToChars([]byte(trimmed)), nil
+			}
+		}
+	}
+
+	// Chunk list
+	var chunkList *ChunkList
+	var itemIndex int32
+	header := make([]string, 0, opts.HeaderLines)
+	if len(opts.WithNth) == 0 {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
+			if len(header) < opts.HeaderLines {
+				header = append(header, string(data))
+				eventBox.Set(EvtHeader, header)
+				return false
+			}
+			item.text, item.colors = ansiProcessor(data)
+			item.text.Index = itemIndex
+			itemIndex++
+			return true
+		})
+	} else {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
+			tokens := Tokenize(string(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)
+			if len(header) < opts.HeaderLines {
+				header = append(header, transformed)
+				eventBox.Set(EvtHeader, header)
+				return false
+			}
+			item.text, item.colors = ansiProcessor([]byte(transformed))
+			item.text.TrimTrailingWhitespaces()
+			item.text.Index = itemIndex
+			item.origText = &data
+			itemIndex++
+			return true
+		})
+	}
+
+	// Reader
+	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()
+	}
+
+	// Matcher
+	forward := true
+	for _, cri := range opts.Criteria[1:] {
+		if cri == byEnd {
+			forward = false
+			break
+		}
+		if cri == byBegin {
+			break
+		}
+	}
+	patternBuilder := func(runes []rune) *Pattern {
+		return BuildPattern(
+			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward,
+			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
+	}
+	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)
+
+	// Filtering mode
+	if opts.Filter != nil {
+		if opts.PrintQuery {
+			opts.Printer(*opts.Filter)
+		}
+
+		pattern := patternBuilder([]rune(*opts.Filter))
+		matcher.sort = pattern.sortable
+
+		found := false
+		if streamingFilter {
+			slab := util.MakeSlab(slab16Size, slab32Size)
+			reader := NewReader(
+				func(runes []byte) bool {
+					item := Item{}
+					if chunkList.trans(&item, runes) {
+						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
+							opts.Printer(item.text.ToString())
+							found = true
+						}
+					}
+					return false
+				}, eventBox, opts.ReadZero, false)
+			reader.ReadSource()
+		} 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++ {
+				opts.Printer(merger.Get(i).item.AsString(opts.Ansi))
+				found = true
+			}
+		}
+		if found {
+			os.Exit(exitOk)
+		}
+		os.Exit(exitNoMatch)
+	}
+
+	// Synchronous search
+	if opts.Sync {
+		eventBox.Unwatch(EvtReadNew)
+		eventBox.WaitFor(EvtReadFin)
+	}
+
+	// Go interactive
+	go matcher.Loop()
+
+	// Terminal I/O
+	terminal := NewTerminal(opts, eventBox)
+	deferred := opts.Select1 || opts.Exit0
+	go terminal.Loop()
+	if !deferred {
+		terminal.startChan <- true
+	}
+
+	// Event coordination
+	reading := true
+	clearCache := util.Once(false)
+	clearSelection := util.Once(false)
+	ticks := 0
+	var nextCommand *string
+	restart := func(command string) {
+		reading = true
+		clearCache = util.Once(true)
+		clearSelection = util.Once(true)
+		chunkList.Clear()
+		itemIndex = 0
+		header = make([]string, 0, opts.HeaderLines)
+		go reader.restart(command)
+	}
+	eventBox.Watch(EvtReadNew)
+	query := []rune{}
+	for {
+		delay := true
+		ticks++
+		input := func() []rune {
+			paused, input := terminal.Input()
+			if !paused {
+				query = input
+			}
+			return query
+		}
+		eventBox.Wait(func(events *util.Events) {
+			if _, fin := (*events)[EvtReadFin]; fin {
+				delete(*events, EvtReadNew)
+			}
+			for evt, value := range *events {
+				switch evt {
+				case EvtQuit:
+					if reading {
+						reader.terminate()
+					}
+					os.Exit(value.(int))
+				case EvtReadNew, EvtReadFin:
+					if evt == EvtReadFin && nextCommand != nil {
+						restart(*nextCommand)
+						nextCommand = nil
+						break
+					} else {
+						reading = reading && evt == EvtReadNew
+					}
+					snapshot, count := chunkList.Snapshot()
+					terminal.UpdateCount(count, !reading, value.(*string))
+					if opts.Sync {
+						opts.Sync = false
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac), false)
+					}
+					matcher.Reset(snapshot, input(), false, !reading, sort, clearCache())
+
+				case EvtSearchNew:
+					var command *string
+					switch val := value.(type) {
+					case searchRequest:
+						sort = val.sort
+						command = val.command
+					}
+					if command != nil {
+						if reading {
+							reader.terminate()
+							nextCommand = command
+						} else {
+							restart(*command)
+						}
+						break
+					}
+					snapshot, _ := chunkList.Snapshot()
+					matcher.Reset(snapshot, input(), true, !reading, sort, clearCache())
+					delay = false
+
+				case EvtSearchProgress:
+					switch val := value.(type) {
+					case float32:
+						terminal.UpdateProgress(val)
+					}
+
+				case EvtHeader:
+					headerPadded := make([]string, opts.HeaderLines)
+					copy(headerPadded, value.([]string))
+					terminal.UpdateHeader(headerPadded)
+
+				case EvtSearchFin:
+					switch val := value.(type) {
+					case *Merger:
+						if deferred {
+							count := val.Length()
+							if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
+								deferred = false
+								terminal.startChan <- true
+							} else if val.final {
+								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
+									if opts.PrintQuery {
+										opts.Printer(opts.Query)
+									}
+									if len(opts.Expect) > 0 {
+										opts.Printer("")
+									}
+									for i := 0; i < count; i++ {
+										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
+									}
+									if count > 0 {
+										os.Exit(exitOk)
+									}
+									os.Exit(exitNoMatch)
+								}
+								deferred = false
+								terminal.startChan <- true
+							}
+						}
+						terminal.UpdateList(val, clearSelection())
+					}
+				}
+			}
+			events.Clear()
+		})
+		if delay && reading {
+			dur := util.DurWithin(
+				time.Duration(ticks)*coordinatorDelayStep,
+				0, coordinatorDelayMax)
+			time.Sleep(dur)
+		}
+	}
+}

data/lib/helpers/fzf/src/history.go

@@ -0,0 +1,96 @@
+package fzf
+
+import (
+	"errors"
+	"io/ioutil"
+	"os"
+	"strings"
+)
+
+// History struct represents input history
+type History struct {
+	path     string
+	lines    []string
+	modified map[int]string
+	maxSize  int
+	cursor   int
+}
+
+// NewHistory returns the pointer to a new History struct
+func NewHistory(path string, maxSize int) (*History, error) {
+	fmtError := func(e error) error {
+		if os.IsPermission(e) {
+			return errors.New("permission denied: " + path)
+		}
+		return errors.New("invalid history file: " + e.Error())
+	}
+
+	// Read history file
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		// If it doesn't exist, check if we can create a file with the name
+		if os.IsNotExist(err) {
+			data = []byte{}
+			if err := ioutil.WriteFile(path, data, 0600); err != nil {
+				return nil, fmtError(err)
+			}
+		} else {
+			return nil, fmtError(err)
+		}
+	}
+	// Split lines and limit the maximum number of lines
+	lines := strings.Split(strings.Trim(string(data), "\n"), "\n")
+	if len(lines[len(lines)-1]) > 0 {
+		lines = append(lines, "")
+	}
+	return &History{
+		path:     path,
+		maxSize:  maxSize,
+		lines:    lines,
+		modified: make(map[int]string),
+		cursor:   len(lines) - 1}, nil
+}
+
+func (h *History) append(line string) error {
+	// We don't append empty lines
+	if len(line) == 0 {
+		return nil
+	}
+
+	lines := append(h.lines[:len(h.lines)-1], line)
+	if len(lines) > h.maxSize {
+		lines = lines[len(lines)-h.maxSize:]
+	}
+	h.lines = append(lines, "")
+	return ioutil.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)
+}
+
+func (h *History) override(str string) {
+	// You can update the history but they're not written to the file
+	if h.cursor == len(h.lines)-1 {
+		h.lines[h.cursor] = str
+	} else if h.cursor < len(h.lines)-1 {
+		h.modified[h.cursor] = str
+	}
+}
+
+func (h *History) current() string {
+	if str, prs := h.modified[h.cursor]; prs {
+		return str
+	}
+	return h.lines[h.cursor]
+}
+
+func (h *History) previous() string {
+	if h.cursor > 0 {
+		h.cursor--
+	}
+	return h.current()
+}
+
+func (h *History) next() string {
+	if h.cursor < len(h.lines)-1 {
+		h.cursor++
+	}
+	return h.current()
+}

data/lib/helpers/fzf/src/history_test.go

@@ -0,0 +1,68 @@
+package fzf
+
+import (
+	"io/ioutil"
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestHistory(t *testing.T) {
+	maxHistory := 50
+
+	// Invalid arguments
+	var paths []string
+	if runtime.GOOS == "windows" {
+		// GOPATH should exist, so we shouldn't be able to override it
+		paths = []string{os.Getenv("GOPATH")}
+	} else {
+		paths = []string{"/etc", "/proc"}
+	}
+
+	for _, path := range paths {
+		if _, e := NewHistory(path, maxHistory); e == nil {
+			t.Error("Error expected for: " + path)
+		}
+	}
+
+	f, _ := ioutil.TempFile("", "fzf-history")
+	f.Close()
+
+	{ // Append lines
+		h, _ := NewHistory(f.Name(), maxHistory)
+		for i := 0; i < maxHistory+10; i++ {
+			h.append("foobar")
+		}
+	}
+	{ // Read lines
+		h, _ := NewHistory(f.Name(), maxHistory)
+		if len(h.lines) != maxHistory+1 {
+			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
+		}
+		for i := 0; i < maxHistory; i++ {
+			if h.lines[i] != "foobar" {
+				t.Error("Expected: foobar, actual: " + h.lines[i])
+			}
+		}
+	}
+	{ // Append lines
+		h, _ := NewHistory(f.Name(), maxHistory)
+		h.append("barfoo")
+		h.append("")
+		h.append("foobarbaz")
+	}
+	{ // Read lines again
+		h, _ := NewHistory(f.Name(), maxHistory)
+		if len(h.lines) != maxHistory+1 {
+			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
+		}
+		compare := func(idx int, exp string) {
+			if h.lines[idx] != exp {
+				t.Errorf("Expected: %s, actual: %s\n", exp, h.lines[idx])
+			}
+		}
+		compare(maxHistory-3, "foobar")
+		compare(maxHistory-2, "barfoo")
+		compare(maxHistory-1, "foobarbaz")
+	}
+}

data/lib/helpers/fzf/src/item.go

@@ -0,0 +1,44 @@
+package fzf
+
+import (
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Item represents each input line. 56 bytes.
+type Item struct {
+	text        util.Chars    // 32 = 24 + 1 + 1 + 2 + 4
+	transformed *[]Token      // 8
+	origText    *[]byte       // 8
+	colors      *[]ansiOffset // 8
+}
+
+// Index returns ordinal index of the Item
+func (item *Item) Index() int32 {
+	return item.text.Index
+}
+
+var minItem = Item{text: util.Chars{Index: -1}}
+
+func (item *Item) TrimLength() uint16 {
+	return item.text.TrimLength()
+}
+
+// Colors returns ansiOffsets of the Item
+func (item *Item) Colors() []ansiOffset {
+	if item.colors == nil {
+		return []ansiOffset{}
+	}
+	return *item.colors
+}
+
+// AsString returns the original string
+func (item *Item) AsString(stripAnsi bool) string {
+	if item.origText != nil {
+		if stripAnsi {
+			trimmed, _, _ := extractColor(string(*item.origText), nil, nil)
+			return trimmed
+		}
+		return string(*item.origText)
+	}
+	return item.text.ToString()
+}

data/lib/helpers/fzf/src/item_test.go

@@ -0,0 +1,23 @@
+package fzf
+
+import (
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func TestStringPtr(t *testing.T) {
+	orig := []byte("\x1b[34mfoo")
+	text := []byte("\x1b[34mbar")
+	item := Item{origText: &orig, text: util.ToChars(text)}
+	if item.AsString(true) != "foo" || item.AsString(false) != string(orig) {
+		t.Fail()
+	}
+	if item.AsString(true) != "foo" {
+		t.Fail()
+	}
+	item.origText = nil
+	if item.AsString(true) != string(text) || item.AsString(false) != string(text) {
+		t.Fail()
+	}
+}