doing 2.0.20 → 2.0.24

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

@@ -0,0 +1,235 @@
+package fzf
+
+import (
+	"fmt"
+	"runtime"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+// MatchRequest represents a search request
+type MatchRequest struct {
+	chunks     []*Chunk
+	pattern    *Pattern
+	final      bool
+	sort       bool
+	clearCache bool
+}
+
+// Matcher is responsible for performing search
+type Matcher struct {
+	patternBuilder func([]rune) *Pattern
+	sort           bool
+	tac            bool
+	eventBox       *util.EventBox
+	reqBox         *util.EventBox
+	partitions     int
+	slab           []*util.Slab
+	mergerCache    map[string]*Merger
+}
+
+const (
+	reqRetry util.EventType = iota
+	reqReset
+)
+
+// NewMatcher returns a new Matcher
+func NewMatcher(patternBuilder func([]rune) *Pattern,
+	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
+	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
+	return &Matcher{
+		patternBuilder: patternBuilder,
+		sort:           sort,
+		tac:            tac,
+		eventBox:       eventBox,
+		reqBox:         util.NewEventBox(),
+		partitions:     partitions,
+		slab:           make([]*util.Slab, partitions),
+		mergerCache:    make(map[string]*Merger)}
+}
+
+// Loop puts Matcher in action
+func (m *Matcher) Loop() {
+	prevCount := 0
+
+	for {
+		var request MatchRequest
+
+		m.reqBox.Wait(func(events *util.Events) {
+			for _, val := range *events {
+				switch val := val.(type) {
+				case MatchRequest:
+					request = val
+				default:
+					panic(fmt.Sprintf("Unexpected type: %T", val))
+				}
+			}
+			events.Clear()
+		})
+
+		if request.sort != m.sort || request.clearCache {
+			m.sort = request.sort
+			m.mergerCache = make(map[string]*Merger)
+			clearChunkCache()
+		}
+
+		// Restart search
+		patternString := request.pattern.AsString()
+		var merger *Merger
+		cancelled := false
+		count := CountItems(request.chunks)
+
+		foundCache := false
+		if count == prevCount {
+			// Look up mergerCache
+			if cached, found := m.mergerCache[patternString]; found {
+				foundCache = true
+				merger = cached
+			}
+		} else {
+			// Invalidate mergerCache
+			prevCount = count
+			m.mergerCache = make(map[string]*Merger)
+		}
+
+		if !foundCache {
+			merger, cancelled = m.scan(request)
+		}
+
+		if !cancelled {
+			if merger.cacheable() {
+				m.mergerCache[patternString] = merger
+			}
+			merger.final = request.final
+			m.eventBox.Set(EvtSearchFin, merger)
+		}
+	}
+}
+
+func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
+	partitions := m.partitions
+	perSlice := len(chunks) / partitions
+
+	if perSlice == 0 {
+		partitions = len(chunks)
+		perSlice = 1
+	}
+
+	slices := make([][]*Chunk, partitions)
+	for i := 0; i < partitions; i++ {
+		start := i * perSlice
+		end := start + perSlice
+		if i == partitions-1 {
+			end = len(chunks)
+		}
+		slices[i] = chunks[start:end]
+	}
+	return slices
+}
+
+type partialResult struct {
+	index   int
+	matches []Result
+}
+
+func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
+	startedAt := time.Now()
+
+	numChunks := len(request.chunks)
+	if numChunks == 0 {
+		return EmptyMerger, false
+	}
+	pattern := request.pattern
+	if pattern.IsEmpty() {
+		return PassMerger(&request.chunks, m.tac), false
+	}
+
+	cancelled := util.NewAtomicBool(false)
+
+	slices := m.sliceChunks(request.chunks)
+	numSlices := len(slices)
+	resultChan := make(chan partialResult, numSlices)
+	countChan := make(chan int, numChunks)
+	waitGroup := sync.WaitGroup{}
+
+	for idx, chunks := range slices {
+		waitGroup.Add(1)
+		if m.slab[idx] == nil {
+			m.slab[idx] = util.MakeSlab(slab16Size, slab32Size)
+		}
+		go func(idx int, slab *util.Slab, chunks []*Chunk) {
+			defer func() { waitGroup.Done() }()
+			count := 0
+			allMatches := make([][]Result, len(chunks))
+			for idx, chunk := range chunks {
+				matches := request.pattern.Match(chunk, slab)
+				allMatches[idx] = matches
+				count += len(matches)
+				if cancelled.Get() {
+					return
+				}
+				countChan <- len(matches)
+			}
+			sliceMatches := make([]Result, 0, count)
+			for _, matches := range allMatches {
+				sliceMatches = append(sliceMatches, matches...)
+			}
+			if m.sort {
+				if m.tac {
+					sort.Sort(ByRelevanceTac(sliceMatches))
+				} else {
+					sort.Sort(ByRelevance(sliceMatches))
+				}
+			}
+			resultChan <- partialResult{idx, sliceMatches}
+		}(idx, m.slab[idx], chunks)
+	}
+
+	wait := func() bool {
+		cancelled.Set(true)
+		waitGroup.Wait()
+		return true
+	}
+
+	count := 0
+	matchCount := 0
+	for matchesInChunk := range countChan {
+		count++
+		matchCount += matchesInChunk
+
+		if count == numChunks {
+			break
+		}
+
+		if m.reqBox.Peek(reqReset) {
+			return nil, wait()
+		}
+
+		if time.Since(startedAt) > progressMinDuration {
+			m.eventBox.Set(EvtSearchProgress, float32(count)/float32(numChunks))
+		}
+	}
+
+	partialResults := make([][]Result, numSlices)
+	for range slices {
+		partialResult := <-resultChan
+		partialResults[partialResult.index] = partialResult.matches
+	}
+	return NewMerger(pattern, partialResults, m.sort, m.tac), false
+}
+
+// Reset is called to interrupt/signal the ongoing search
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, clearCache bool) {
+	pattern := m.patternBuilder(patternRunes)
+
+	var event util.EventType
+	if cancel {
+		event = reqReset
+	} else {
+		event = reqRetry
+	}
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, clearCache})
+}

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

@@ -0,0 +1,120 @@
+package fzf
+
+import "fmt"
+
+// EmptyMerger is a Merger with no data
+var EmptyMerger = NewMerger(nil, [][]Result{}, false, false)
+
+// Merger holds a set of locally sorted lists of items and provides the view of
+// a single, globally-sorted list
+type Merger struct {
+	pattern *Pattern
+	lists   [][]Result
+	merged  []Result
+	chunks  *[]*Chunk
+	cursors []int
+	sorted  bool
+	tac     bool
+	final   bool
+	count   int
+}
+
+// PassMerger returns a new Merger that simply returns the items in the
+// original order
+func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
+	mg := Merger{
+		pattern: nil,
+		chunks:  chunks,
+		tac:     tac,
+		count:   0}
+
+	for _, chunk := range *mg.chunks {
+		mg.count += chunk.count
+	}
+	return &mg
+}
+
+// NewMerger returns a new Merger
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool) *Merger {
+	mg := Merger{
+		pattern: pattern,
+		lists:   lists,
+		merged:  []Result{},
+		chunks:  nil,
+		cursors: make([]int, len(lists)),
+		sorted:  sorted,
+		tac:     tac,
+		final:   false,
+		count:   0}
+
+	for _, list := range mg.lists {
+		mg.count += len(list)
+	}
+	return &mg
+}
+
+// Length returns the number of items
+func (mg *Merger) Length() int {
+	return mg.count
+}
+
+// Get returns the pointer to the Result object indexed by the given integer
+func (mg *Merger) Get(idx int) Result {
+	if mg.chunks != nil {
+		if mg.tac {
+			idx = mg.count - idx - 1
+		}
+		chunk := (*mg.chunks)[idx/chunkSize]
+		return Result{item: &chunk.items[idx%chunkSize]}
+	}
+
+	if mg.sorted {
+		return mg.mergedGet(idx)
+	}
+
+	if mg.tac {
+		idx = mg.count - idx - 1
+	}
+	for _, list := range mg.lists {
+		numItems := len(list)
+		if idx < numItems {
+			return list[idx]
+		}
+		idx -= numItems
+	}
+	panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
+}
+
+func (mg *Merger) cacheable() bool {
+	return mg.count < mergerCacheMax
+}
+
+func (mg *Merger) mergedGet(idx int) Result {
+	for i := len(mg.merged); i <= idx; i++ {
+		minRank := minRank()
+		minIdx := -1
+		for listIdx, list := range mg.lists {
+			cursor := mg.cursors[listIdx]
+			if cursor < 0 || cursor == len(list) {
+				mg.cursors[listIdx] = -1
+				continue
+			}
+			if cursor >= 0 {
+				rank := list[cursor]
+				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
+					minRank = rank
+					minIdx = listIdx
+				}
+			}
+		}
+
+		if minIdx >= 0 {
+			chosen := mg.lists[minIdx]
+			mg.merged = append(mg.merged, chosen[mg.cursors[minIdx]])
+			mg.cursors[minIdx]++
+		} else {
+			panic(fmt.Sprintf("Index out of bounds (sorted, %d/%d)", i, mg.count))
+		}
+	}
+	return mg.merged[idx]
+}

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

@@ -0,0 +1,88 @@
+package fzf
+
+import (
+	"fmt"
+	"math/rand"
+	"sort"
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func assert(t *testing.T, cond bool, msg ...string) {
+	if !cond {
+		t.Error(msg)
+	}
+}
+
+func randResult() Result {
+	str := fmt.Sprintf("%d", rand.Uint32())
+	chars := util.ToChars([]byte(str))
+	chars.Index = rand.Int31()
+	return Result{item: &Item{text: chars}}
+}
+
+func TestEmptyMerger(t *testing.T) {
+	assert(t, EmptyMerger.Length() == 0, "Not empty")
+	assert(t, EmptyMerger.count == 0, "Invalid count")
+	assert(t, len(EmptyMerger.lists) == 0, "Invalid lists")
+	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
+}
+
+func buildLists(partiallySorted bool) ([][]Result, []Result) {
+	numLists := 4
+	lists := make([][]Result, numLists)
+	cnt := 0
+	for i := 0; i < numLists; i++ {
+		numResults := rand.Int() % 20
+		cnt += numResults
+		lists[i] = make([]Result, numResults)
+		for j := 0; j < numResults; j++ {
+			item := randResult()
+			lists[i][j] = item
+		}
+		if partiallySorted {
+			sort.Sort(ByRelevance(lists[i]))
+		}
+	}
+	items := []Result{}
+	for _, list := range lists {
+		items = append(items, list...)
+	}
+	return lists, items
+}
+
+func TestMergerUnsorted(t *testing.T) {
+	lists, items := buildLists(false)
+	cnt := len(items)
+
+	// Not sorted: same order
+	mg := NewMerger(nil, lists, false, false)
+	assert(t, cnt == mg.Length(), "Invalid Length")
+	for i := 0; i < cnt; i++ {
+		assert(t, items[i] == mg.Get(i), "Invalid Get")
+	}
+}
+
+func TestMergerSorted(t *testing.T) {
+	lists, items := buildLists(true)
+	cnt := len(items)
+
+	// Sorted sorted order
+	mg := NewMerger(nil, lists, true, false)
+	assert(t, cnt == mg.Length(), "Invalid Length")
+	sort.Sort(ByRelevance(items))
+	for i := 0; i < cnt; i++ {
+		if items[i] != mg.Get(i) {
+			t.Error("Not sorted", items[i], mg.Get(i))
+		}
+	}
+
+	// Inverse order
+	mg2 := NewMerger(nil, lists, true, false)
+	for i := cnt - 1; i >= 0; i-- {
+		if items[i] != mg2.Get(i) {
+			t.Error("Not sorted", items[i], mg2.Get(i))
+		}
+	}
+}