Llewellyn/fzf
1
0
Fork 0
mirror of https://github.com/Llewellynvdm/fzf.git synced 2024-11-26 06:46:35 +00:00
Code Issues Projects Releases Wiki Activity

Remove Offset slice from Result struct

Browse Source
This commit is contained in:
Junegunn Choi 2016-08-20 01:46:54 +09:00
parent 3e88849386
commit 827a83efbc
No known key found for this signature in database
GPG Key ID: 254BC280FEF9C627
9 changed files with 55 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/core.go
View File

@ -161,10 +161,12 @@ func Run(opts *Options) {
reader := Reader{
func(runes []byte) bool {
item := chunkList.trans(runes, 0)
if item != nil && pattern.MatchItem(item) != nil {
if item != nil {
if result, _ := pattern.MatchItem(item); result != nil {
fmt.Println(item.text.ToString())
found = true
}
}
return false
}, eventBox, opts.ReadZero}
reader.ReadSource()

2
src/matcher.go
View File

@ -211,7 +211,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
partialResult := <-resultChan
partialResults[partialResult.index] = partialResult.matches
}
return NewMerger(partialResults, m.sort, m.tac), false
return NewMerger(pattern, partialResults, m.sort, m.tac), false
}
// Reset is called to interrupt/signal the ongoing search

7
src/merger.go
View File

@ -3,11 +3,12 @@ package fzf
import "fmt"
// EmptyMerger is a Merger with no data
var EmptyMerger = NewMerger([][]*Result{}, false, false)
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
@ -22,6 +23,7 @@ type Merger struct {
// original order
func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
mg := Merger{
pattern: nil,
chunks: chunks,
tac: tac,
count: 0}
@ -33,8 +35,9 @@ func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
}
// NewMerger returns a new Merger
func NewMerger(lists [][]*Result, sorted bool, tac bool) *Merger {
func NewMerger(pattern *Pattern, lists [][]*Result, sorted bool, tac bool) *Merger {
mg := Merger{
pattern: pattern,
lists: lists,
merged: []*Result{},
chunks: nil,

13
src/merger_test.go
View File

@ -17,15 +17,8 @@ func assert(t *testing.T, cond bool, msg ...string) {
func randResult() *Result {
str := fmt.Sprintf("%d", rand.Uint32())
offsets := make([]Offset, rand.Int()%3)
for idx := range offsets {
sidx := int32(rand.Uint32() % 20)
eidx := sidx + int32(rand.Uint32()%20)
offsets[idx] = Offset{sidx, eidx}
}
return &Result{
item: &Item{text: util.RunesToChars([]rune(str))},
offsets: offsets,
rank: rank{index: rand.Int31()}}
}
@ -64,7 +57,7 @@ func TestMergerUnsorted(t *testing.T) {
cnt := len(items)
// Not sorted: same order
mg := NewMerger(lists, false, false)
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")
@ -76,7 +69,7 @@ func TestMergerSorted(t *testing.T) {
cnt := len(items)
// Sorted sorted order
mg := NewMerger(lists, true, false)
mg := NewMerger(nil, lists, true, false)
assert(t, cnt == mg.Length(), "Invalid Length")
sort.Sort(ByRelevance(items))
for i := 0; i < cnt; i++ {
@ -86,7 +79,7 @@ func TestMergerSorted(t *testing.T) {
}
// Inverse order
mg2 := NewMerger(lists, true, false)
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))

15
src/pattern.go
View File

@ -273,13 +273,13 @@ func (p *Pattern) matchChunk(chunk *Chunk, space []*Result) []*Result {
if space == nil {
for _, item := range *chunk {
if match := p.MatchItem(item); match != nil {
if match, _ := p.MatchItem(item); match != nil {
matches = append(matches, match)
}
}
} else {
for _, result := range space {
if match := p.MatchItem(result.item); match != nil {
if match, _ := p.MatchItem(result.item); match != nil {
matches = append(matches, match)
}
}
@ -288,18 +288,19 @@ func (p *Pattern) matchChunk(chunk *Chunk, space []*Result) []*Result {
}
// MatchItem returns true if the Item is a match
func (p *Pattern) MatchItem(item *Item) *Result {
func (p *Pattern) MatchItem(item *Item) (*Result, []Offset) {
if p.extended {
if offsets, bonus, trimLen := p.extendedMatch(item); len(offsets) == len(p.termSets) {
return buildResult(item, offsets, bonus, trimLen)
return buildResult(item, offsets, bonus, trimLen), offsets
}
return nil
return nil, nil
}
offset, bonus, trimLen := p.basicMatch(item)
if sidx := offset[0]; sidx >= 0 {
return buildResult(item, []Offset{offset}, bonus, trimLen)
offsets := []Offset{offset}
return buildResult(item, offsets, bonus, trimLen), offsets
}
return nil
return nil, nil
}
func (p *Pattern) basicMatch(item *Item) (Offset, int, int) {

8
src/pattern_test.go
View File

@ -135,10 +135,16 @@ func TestOrigTextAndTransformed(t *testing.T) {
pattern.extended = extended
matches := pattern.matchChunk(&chunk, nil) // No cache
if matches[0].item.text.ToString() != "junegunn" || string(*matches[0].item.origText) != "junegunn.choi" ||
matches[0].offsets[0][0] != 0 || matches[0].offsets[0][1] != 5 ||
!reflect.DeepEqual(matches[0].item.transformed, trans) {
t.Error("Invalid match result", matches)
}
match, offsets := pattern.MatchItem(chunk[0])
if match.item.text.ToString() != "junegunn" || string(*match.item.origText) != "junegunn.choi" ||
offsets[0][0] != 0 || offsets[0][1] != 5 ||
!reflect.DeepEqual(match.item.transformed, trans) {
t.Error("Invalid match result", match)
}
}
}

13
src/result.go
View File

@ -19,14 +19,13 @@ type colorOffset struct {
}
type rank struct {
index int32
// byMatchLen, byBonus, ...
points [5]uint16
index int32
}
type Result struct {
item *Item
offsets []Offset
rank rank
}
@ -35,7 +34,7 @@ func buildResult(item *Item, offsets []Offset, bonus int, trimLen int) *Result {
sort.Sort(ByOrder(offsets))
}
result := Result{item: item, offsets: offsets, rank: rank{index: item.index}}
result := Result{item: item, rank: rank{index: item.index}}
matchlen := 0
prevEnd := 0
@ -110,12 +109,12 @@ func minRank() rank {
return rank{index: 0, points: [5]uint16{0, math.MaxUint16, 0, 0, 0}}
}
func (result *Result) colorOffsets(color int, bold bool, current bool) []colorOffset {
func (result *Result) colorOffsets(matchOffsets []Offset, color int, bold bool, current bool) []colorOffset {
itemColors := result.item.Colors()
if len(itemColors) == 0 {
var offsets []colorOffset
for _, off := range result.offsets {
for _, off := range matchOffsets {
offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: color, bold: bold})
}
@ -124,7 +123,7 @@ func (result *Result) colorOffsets(color int, bold bool, current bool) []colorOf
// Find max column
var maxCol int32
for _, off := range result.offsets {
for _, off := range matchOffsets {
if off[1] > maxCol {
maxCol = off[1]
}
@ -142,7 +141,7 @@ func (result *Result) colorOffsets(color int, bold bool, current bool) []colorOf
}
}
for _, off := range result.offsets {
for _, off := range matchOffsets {
for i := off[0]; i < off[1]; i++ {
cols[i] = -1
}

7
src/result_test.go
View File

@ -88,8 +88,9 @@ func TestColorOffset(t *testing.T) {
// ------------ 20 ---- -- ----
// ++++++++ ++++++++++
// --++++++++-- --++++++++++---
offsets := []Offset{Offset{5, 15}, Offset{25, 35}}
item := Result{
offsets: []Offset{Offset{5, 15}, Offset{25, 35}},
item: &Item{
colors: &[]ansiOffset{
ansiOffset{[2]int32{0, 20}, ansiState{1, 5, false}},
@ -98,9 +99,9 @@ func TestColorOffset(t *testing.T) {
ansiOffset{[2]int32{33, 40}, ansiState{4, 8, true}}}}}
// [{[0 5] 9 false} {[5 15] 99 false} {[15 20] 9 false} {[22 25] 10 true} {[25 35] 99 false} {[35 40] 11 true}]
offsets := item.colorOffsets(99, false, true)
colors := item.colorOffsets(offsets, 99, false, true)
assert := func(idx int, b int32, e int32, c int, bold bool) {
o := offsets[idx]
o := colors[idx]
if o.offset[0] != b || o.offset[1] != e || o.color != c || o.bold != bold {
t.Error(o)
}

14
src/terminal.go
View File

@ -669,15 +669,19 @@ func overflow(runes []rune, max int) bool {
func (t *Terminal) printHighlighted(result *Result, bold bool, col1 int, col2 int, current bool) {
item := result.item
var maxe int
for _, offset := range result.offsets {
maxe = util.Max(maxe, int(offset[1]))
}
// Overflow
text := make([]rune, item.text.Length())
copy(text, item.text.ToRunes())
offsets := result.colorOffsets(col2, bold, current)
matchOffsets := []Offset{}
if t.merger.pattern != nil {
_, matchOffsets = t.merger.pattern.MatchItem(item)
}
var maxe int
for _, offset := range matchOffsets {
maxe = util.Max(maxe, int(offset[1]))
}
offsets := result.colorOffsets(matchOffsets, col2, bold, current)
maxWidth := t.window.Width - 3
maxe = util.Constrain(maxe+util.Min(maxWidth/2-2, t.hscrollOff), 0, len(text))
if overflow(text, maxWidth) {