fzf/src/item.go

264 lines
5.2 KiB
Go
Raw Normal View History

2015-01-01 19:49:30 +00:00
package fzf
2015-03-18 16:59:14 +00:00
import (
"math"
2015-03-18 16:59:14 +00:00
"github.com/junegunn/fzf/src/curses"
)
2015-01-11 18:01:24 +00:00
// Offset holds two 32-bit integers denoting the offsets of a matched substring
2015-01-08 17:37:08 +00:00
type Offset [2]int32
2015-01-01 19:49:30 +00:00
2015-03-22 07:05:54 +00:00
type colorOffset struct {
2015-03-18 16:59:14 +00:00
offset [2]int32
color int
bold bool
}
2015-01-11 18:01:24 +00:00
// Item represents each input line
2015-01-01 19:49:30 +00:00
type Item struct {
text []rune
origText *[]rune
transformed []Token
index uint32
2015-01-01 19:49:30 +00:00
offsets []Offset
2015-03-22 07:05:54 +00:00
colors []ansiOffset
2015-01-01 19:49:30 +00:00
rank Rank
}
2015-01-11 18:01:24 +00:00
// Rank is used to sort the search result
2015-01-08 17:37:08 +00:00
type Rank struct {
matchlen uint16
tiebreak uint16
2015-01-08 17:37:08 +00:00
index uint32
}
2015-01-01 19:49:30 +00:00
// Tiebreak criterion to use. Never changes once fzf is started.
var rankTiebreak tiebreak
2015-01-11 18:01:24 +00:00
// Rank calculates rank of the Item
2015-08-02 14:54:53 +00:00
func (item *Item) Rank(cache bool) Rank {
if cache && (item.rank.matchlen > 0 || item.rank.tiebreak > 0) {
return item.rank
2015-01-01 19:49:30 +00:00
}
matchlen := 0
prevEnd := 0
minBegin := math.MaxUint16
2015-08-02 14:54:53 +00:00
for _, offset := range item.offsets {
2015-01-08 17:37:08 +00:00
begin := int(offset[0])
end := int(offset[1])
2015-01-01 19:49:30 +00:00
if prevEnd > begin {
begin = prevEnd
}
if end > prevEnd {
prevEnd = end
}
if end > begin {
if begin < minBegin {
minBegin = begin
}
2015-01-01 19:49:30 +00:00
matchlen += end - begin
}
}
var tiebreak uint16
switch rankTiebreak {
case byLength:
// It is guaranteed that .transformed in not null in normal execution
2015-08-02 14:54:53 +00:00
if item.transformed != nil {
lenSum := 0
2015-08-02 14:54:53 +00:00
for _, token := range item.transformed {
lenSum += len(token.text)
}
tiebreak = uint16(lenSum)
} else {
2015-08-02 14:54:53 +00:00
tiebreak = uint16(len(item.text))
}
case byBegin:
2015-08-02 14:54:53 +00:00
// We can't just look at item.offsets[0][0] because it can be an inverse term
tiebreak = uint16(minBegin)
case byEnd:
if prevEnd > 0 {
2015-08-02 14:54:53 +00:00
tiebreak = uint16(1 + len(item.text) - prevEnd)
} else {
// Empty offsets due to inverse terms.
tiebreak = 1
}
case byIndex:
tiebreak = 1
}
2015-08-02 14:54:53 +00:00
rank := Rank{uint16(matchlen), tiebreak, item.index}
if cache {
2015-08-02 14:54:53 +00:00
item.rank = rank
}
return rank
2015-01-01 19:49:30 +00:00
}
2015-01-11 18:01:24 +00:00
// AsString returns the original string
2015-08-02 14:54:53 +00:00
func (item *Item) AsString() string {
return *item.StringPtr()
}
// StringPtr returns the pointer to the original string
2015-08-02 14:54:53 +00:00
func (item *Item) StringPtr() *string {
runes := item.text
if item.origText != nil {
runes = *item.origText
2015-01-01 19:49:30 +00:00
}
str := string(runes)
return &str
2015-01-01 19:49:30 +00:00
}
2015-03-22 07:05:54 +00:00
func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset {
2015-03-18 16:59:14 +00:00
if len(item.colors) == 0 {
2015-03-22 07:05:54 +00:00
var offsets []colorOffset
2015-03-18 16:59:14 +00:00
for _, off := range item.offsets {
2015-03-22 07:05:54 +00:00
offsets = append(offsets, colorOffset{offset: off, color: color, bold: bold})
2015-03-18 16:59:14 +00:00
}
return offsets
}
// Find max column
2015-03-22 07:05:54 +00:00
var maxCol int32
2015-03-18 16:59:14 +00:00
for _, off := range item.offsets {
if off[1] > maxCol {
maxCol = off[1]
}
}
for _, ansi := range item.colors {
if ansi.offset[1] > maxCol {
maxCol = ansi.offset[1]
}
}
cols := make([]int, maxCol)
for colorIndex, ansi := range item.colors {
for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
cols[i] = colorIndex + 1 // XXX
}
}
for _, off := range item.offsets {
for i := off[0]; i < off[1]; i++ {
cols[i] = -1
}
}
// sort.Sort(ByOrder(offsets))
// Merge offsets
// ------------ ---- -- ----
// ++++++++ ++++++++++
// --++++++++-- --++++++++++---
curr := 0
start := 0
2015-03-22 07:05:54 +00:00
var offsets []colorOffset
2015-03-18 16:59:14 +00:00
add := func(idx int) {
if curr != 0 && idx > start {
if curr == -1 {
2015-03-22 07:05:54 +00:00
offsets = append(offsets, colorOffset{
2015-03-18 16:59:14 +00:00
offset: Offset{int32(start), int32(idx)}, color: color, bold: bold})
} else {
ansi := item.colors[curr-1]
2015-05-31 07:46:54 +00:00
fg := ansi.color.fg
if fg == -1 {
if current {
fg = curses.CurrentFG
} else {
fg = curses.FG
}
}
2015-03-18 16:59:14 +00:00
bg := ansi.color.bg
2015-05-31 07:46:54 +00:00
if bg == -1 {
if current {
bg = curses.DarkBG
} else {
bg = curses.BG
}
2015-03-18 16:59:14 +00:00
}
2015-03-22 07:05:54 +00:00
offsets = append(offsets, colorOffset{
2015-03-18 16:59:14 +00:00
offset: Offset{int32(start), int32(idx)},
2015-05-31 07:46:54 +00:00
color: curses.PairFor(fg, bg),
2015-03-18 16:59:14 +00:00
bold: ansi.color.bold || bold})
}
}
}
for idx, col := range cols {
if col != curr {
add(idx)
start = idx
curr = col
}
}
add(int(maxCol))
return offsets
}
2015-01-11 18:01:24 +00:00
// ByOrder is for sorting substring offsets
2015-01-01 19:49:30 +00:00
type ByOrder []Offset
func (a ByOrder) Len() int {
return len(a)
}
func (a ByOrder) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
func (a ByOrder) Less(i, j int) bool {
ioff := a[i]
joff := a[j]
return (ioff[0] < joff[0]) || (ioff[0] == joff[0]) && (ioff[1] <= joff[1])
}
2015-01-11 18:01:24 +00:00
// ByRelevance is for sorting Items
2015-01-01 19:49:30 +00:00
type ByRelevance []*Item
func (a ByRelevance) Len() int {
return len(a)
}
func (a ByRelevance) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
func (a ByRelevance) Less(i, j int) bool {
irank := a[i].Rank(true)
jrank := a[j].Rank(true)
2015-01-01 19:49:30 +00:00
return compareRanks(irank, jrank, false)
2015-01-01 19:49:30 +00:00
}
// ByRelevanceTac is for sorting Items
type ByRelevanceTac []*Item
func (a ByRelevanceTac) Len() int {
return len(a)
}
func (a ByRelevanceTac) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
func (a ByRelevanceTac) Less(i, j int) bool {
irank := a[i].Rank(true)
jrank := a[j].Rank(true)
return compareRanks(irank, jrank, true)
}
func compareRanks(irank Rank, jrank Rank, tac bool) bool {
2015-01-08 17:37:08 +00:00
if irank.matchlen < jrank.matchlen {
return true
} else if irank.matchlen > jrank.matchlen {
return false
}
if irank.tiebreak < jrank.tiebreak {
2015-01-08 17:37:08 +00:00
return true
} else if irank.tiebreak > jrank.tiebreak {
2015-01-08 17:37:08 +00:00
return false
}
return (irank.index <= jrank.index) != tac
2015-01-01 19:49:30 +00:00
}