mirror of
https://github.com/Llewellynvdm/fzf.git
synced 2024-12-23 11:29:01 +00:00
8270f7f0ca
`--null` is ambiguous. For completeness' sake, we need both `--read0` and `--print0`. `--read0` only makes sense when the input contains multiline entries. However, fzf currently cannot correctly display multiline entries, I'm going to make `--read0` an undocumented feature.
1349 lines
36 KiB
Ruby
Executable File
1349 lines
36 KiB
Ruby
Executable File
#!/usr/bin/env ruby
|
|
# encoding: utf-8
|
|
#
|
|
# ____ ____
|
|
# / __/___ / __/
|
|
# / /_/_ / / /_
|
|
# / __/ / /_/ __/
|
|
# /_/ /___/_/ Fuzzy finder for your shell
|
|
#
|
|
# Version: 0.8.9 (Dec 24, 2014)
|
|
# Deprecation alert:
|
|
# This script is no longer maintained. Use the new Go version.
|
|
#
|
|
# Author: Junegunn Choi
|
|
# URL: https://github.com/junegunn/fzf
|
|
# License: MIT
|
|
#
|
|
# Copyright (c) 2014 Junegunn Choi
|
|
#
|
|
# MIT License
|
|
#
|
|
# 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.
|
|
|
|
begin
|
|
require 'curses'
|
|
rescue LoadError
|
|
$stderr.puts 'curses gem is not installed. Try `gem install curses`.'
|
|
sleep 1
|
|
exit 1
|
|
end
|
|
require 'thread'
|
|
require 'set'
|
|
|
|
unless String.method_defined? :force_encoding
|
|
class String
|
|
def force_encoding *arg
|
|
self
|
|
end
|
|
end
|
|
end
|
|
|
|
class String
|
|
attr_accessor :orig
|
|
|
|
def tokenize delim, nth
|
|
unless delim
|
|
# AWK default
|
|
prefix_length = (index(/\S/) || 0) rescue 0
|
|
tokens = scan(/\S+\s*/) rescue []
|
|
else
|
|
prefix_length = 0
|
|
tokens = scan(delim) rescue []
|
|
end
|
|
nth.map { |n|
|
|
if n.begin == 0 && n.end == -1
|
|
[prefix_length, tokens.join]
|
|
elsif part = tokens[n]
|
|
[prefix_length + (tokens[0...(n.begin)] || []).join.length,
|
|
part.join]
|
|
end
|
|
}.compact
|
|
end
|
|
end
|
|
|
|
class FZF
|
|
C = Curses
|
|
attr_reader :rxflag, :sort, :nth, :color, :black, :ansi256, :reverse, :prompt,
|
|
:mouse, :multi, :query, :select1, :exit0, :filter, :extended,
|
|
:print_query, :with_nth
|
|
|
|
def sync
|
|
@shr_mtx.synchronize { yield }
|
|
end
|
|
|
|
def get name
|
|
sync { instance_variable_get name }
|
|
end
|
|
|
|
def geta(*names)
|
|
sync { names.map { |name| instance_variable_get name } }
|
|
end
|
|
|
|
def call(name, method, *args)
|
|
sync { instance_variable_get(name).send(method, *args) }
|
|
end
|
|
|
|
def set name, value = nil
|
|
sync do
|
|
instance_variable_set name,
|
|
(block_given? ? yield(instance_variable_get(name)) : value)
|
|
end
|
|
end
|
|
|
|
def initialize argv, source = $stdin
|
|
@rxflag = nil
|
|
@sort = ENV.fetch('FZF_DEFAULT_SORT', 1000).to_i
|
|
@color = true
|
|
@ansi256 = true
|
|
@black = false
|
|
@multi = false
|
|
@mouse = true
|
|
@extended = nil
|
|
@select1 = false
|
|
@exit0 = false
|
|
@filter = nil
|
|
@nth = nil
|
|
@with_nth = nil
|
|
@delim = nil
|
|
@reverse = false
|
|
@prompt = '> '
|
|
@shr_mtx = Mutex.new
|
|
@expect = false
|
|
@print_query = false
|
|
|
|
argv =
|
|
if opts = ENV['FZF_DEFAULT_OPTS']
|
|
require 'shellwords'
|
|
Shellwords.shellwords(opts) + argv
|
|
else
|
|
argv.dup
|
|
end
|
|
while o = argv.shift
|
|
case o
|
|
when '--version' then FZF.version
|
|
when '-h', '--help' then usage 0
|
|
when '-m', '--multi' then @multi = true
|
|
when '+m', '--no-multi' then @multi = false
|
|
when '-x', '--extended' then @extended = :fuzzy
|
|
when '+x', '--no-extended' then @extended = nil
|
|
when '-i' then @rxflag = Regexp::IGNORECASE
|
|
when '+i' then @rxflag = 0
|
|
when '-c', '--color' then @color = true
|
|
when '+c', '--no-color' then @color = false
|
|
when '-2', '--256' then @ansi256 = true
|
|
when '+2', '--no-256' then @ansi256 = false
|
|
when '--black' then @black = true
|
|
when '--no-black' then @black = false
|
|
when '--mouse' then @mouse = true
|
|
when '--no-mouse' then @mouse = false
|
|
when '--reverse' then @reverse = true
|
|
when '--no-reverse' then @reverse = false
|
|
when '+s', '--no-sort' then @sort = nil
|
|
when '-1', '--select-1' then @select1 = true
|
|
when '+1', '--no-select-1' then @select1 = false
|
|
when '-0', '--exit-0' then @exit0 = true
|
|
when '+0', '--no-exit-0' then @exit0 = false
|
|
when '-q', '--query'
|
|
usage 1, 'query string required' unless query = argv.shift
|
|
@query = query
|
|
when /^-q(.*)$/, /^--query=(.*)$/
|
|
@query = $1
|
|
when '-f', '--filter'
|
|
usage 1, 'query string required' unless query = argv.shift
|
|
@filter = query
|
|
when /^-f(.*)$/, /^--filter=(.*)$/
|
|
@filter = $1
|
|
when '-n', '--nth'
|
|
usage 1, 'field expression required' unless nth = argv.shift
|
|
@nth = parse_nth nth
|
|
when /^-n([0-9,-\.]+)$/, /^--nth=([0-9,-\.]+)$/
|
|
@nth = parse_nth $1
|
|
when '--with-nth'
|
|
usage 1, 'field expression required' unless nth = argv.shift
|
|
@with_nth = parse_nth nth
|
|
when /^--with-nth=([0-9,-\.]+)$/
|
|
@with_nth = parse_nth $1
|
|
when '-d', '--delimiter'
|
|
usage 1, 'delimiter required' unless delim = argv.shift
|
|
@delim = FZF.build_delim_regex delim
|
|
when /^-d(.+)$/, /^--delimiter=(.+)$/
|
|
@delim = FZF.build_delim_regex $1
|
|
when '-s', '--sort'
|
|
usage 1, 'sort size required' unless sort = argv.shift
|
|
usage 1, 'invalid sort size' unless sort =~ /^[0-9]+$/
|
|
@sort = sort.to_i
|
|
when /^-s([0-9]+)$/, /^--sort=([0-9]+)$/
|
|
@sort = $1.to_i
|
|
when '--prompt'
|
|
usage 1, 'prompt string required' unless prompt = argv.shift
|
|
@prompt = prompt
|
|
when /^--prompt=(.*)$/
|
|
@prompt = $1
|
|
when '--print-query' then @print_query = true
|
|
when '--no-print-query' then @print_query = false
|
|
when '-e', '--extended-exact' then @extended = :exact
|
|
when '+e', '--no-extended-exact' then @extended = nil
|
|
when '--expect'
|
|
argv.shift
|
|
@expect = true
|
|
when /^--expect=(.*)$/
|
|
@expect = true
|
|
when '--toggle-sort', '--tiebreak', '--color', '--bind', '--history', '--history-size'
|
|
argv.shift
|
|
when '--tac', '--no-tac', '--sync', '--no-sync', '--hscroll', '--no-hscroll',
|
|
'--inline-info', '--no-inline-info', '--read0', '--cycle', /^--bind=(.*)$/,
|
|
/^--color=(.*)$/, /^--toggle-sort=(.*)$/, /^--tiebreak=(.*)$/, /^--history(-max)?=(.*)$/
|
|
# XXX
|
|
else
|
|
usage 1, "illegal option: #{o}"
|
|
end
|
|
end
|
|
|
|
@source = source.clone
|
|
@evt_mtx = Mutex.new
|
|
@cv = ConditionVariable.new
|
|
@events = {}
|
|
@new = []
|
|
@queue = Queue.new
|
|
@pending = nil
|
|
@rev_dir = @reverse ? -1 : 1
|
|
@stdout = $stdout.clone
|
|
|
|
unless @filter
|
|
# Shared variables: needs protection
|
|
@query ||= ''
|
|
@matches = []
|
|
@count = 0
|
|
@xcur = @query.length
|
|
@ycur = 0
|
|
@yoff = 0
|
|
@dirty = Set.new
|
|
@spinner = '-\|/-\|/'.split(//)
|
|
@selects = {} # ordered >= 1.9
|
|
|
|
@main = Thread.current
|
|
@plcount = 0
|
|
end
|
|
end
|
|
|
|
def parse_nth nth
|
|
ranges = nth.split(',').map { |expr|
|
|
x = proc { usage 1, "invalid field expression: #{expr}" }
|
|
first, second = expr.split('..', 2)
|
|
x.call if !first.empty? && first.to_i == 0 ||
|
|
second && !second.empty? && (second.to_i == 0 || second.include?('.'))
|
|
|
|
first = first.empty? ? 1 : first.to_i
|
|
second = case second
|
|
when nil then first
|
|
when '' then -1
|
|
else second.to_i
|
|
end
|
|
|
|
Range.new(*[first, second].map { |e| e > 0 ? e - 1 : e })
|
|
}
|
|
ranges == [0..-1] ? nil : ranges
|
|
end
|
|
|
|
def FZF.build_delim_regex delim
|
|
Regexp.compile(delim) rescue (delim = Regexp.escape(delim))
|
|
Regexp.compile "(?:.*?#{delim})|(?:.+?$)"
|
|
end
|
|
|
|
def burp string, orig = nil
|
|
@stdout.puts(orig || string.orig || string)
|
|
end
|
|
|
|
def start
|
|
if @filter
|
|
start_reader.join
|
|
filter_list @new
|
|
else
|
|
start_reader
|
|
query = get(:@query)
|
|
emit(:key) { [query, query.length] } unless empty = query.empty?
|
|
if @select1 || @exit0
|
|
start_search do |loaded, matches|
|
|
len = empty ? get(:@count) : matches.length
|
|
if loaded
|
|
if @select1 && len == 1
|
|
puts @query if @print_query
|
|
puts if @expect
|
|
burp(empty ? matches.first : matches.first.first)
|
|
exit 0
|
|
elsif @exit0 && len == 0
|
|
puts @query if @print_query
|
|
puts if @expect
|
|
exit 0
|
|
end
|
|
end
|
|
|
|
if loaded || len > 1
|
|
start_renderer
|
|
Thread.new { start_loop }
|
|
end
|
|
end
|
|
|
|
sleep
|
|
else
|
|
start_search
|
|
start_renderer
|
|
start_loop
|
|
end
|
|
end
|
|
end
|
|
|
|
def filter_list list
|
|
puts @filter if @print_query
|
|
matches = matcher.match(list, @filter, '', '')
|
|
if @sort && matches.length <= @sort
|
|
matches = FZF.sort(matches)
|
|
end
|
|
matches.each { |m| puts m.first }
|
|
end
|
|
|
|
def matcher
|
|
@matcher ||=
|
|
if @extended
|
|
ExtendedFuzzyMatcher.new @rxflag, @extended, @nth, @delim
|
|
else
|
|
FuzzyMatcher.new @rxflag, @nth, @delim
|
|
end
|
|
end
|
|
|
|
class << self
|
|
def version
|
|
File.open(__FILE__, 'r') do |f|
|
|
f.each_line do |line|
|
|
if line =~ /Version: (.*)/
|
|
$stdout.puts 'fzf ' << $1
|
|
exit
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def sort list
|
|
list.sort_by { |tuple| rank tuple }
|
|
end
|
|
|
|
def rank tuple
|
|
line, offsets = tuple
|
|
matchlen = 0
|
|
pe = 0
|
|
offsets.sort.each do |pair|
|
|
b, e = pair
|
|
b = pe if pe > b
|
|
pe = e if e > pe
|
|
matchlen += e - b if e > b
|
|
end
|
|
[matchlen, line.length, line]
|
|
end
|
|
end
|
|
|
|
def usage x, message = nil
|
|
$stderr.puts message if message
|
|
$stderr.puts %[usage: fzf [options]
|
|
|
|
Search
|
|
-x, --extended Extended-search mode
|
|
-e, --extended-exact Extended-search mode (exact match)
|
|
-i Case-insensitive match (default: smart-case match)
|
|
+i Case-sensitive match
|
|
-n, --nth=N[,..] Comma-separated list of field index expressions
|
|
for limiting search scope. Each can be a non-zero
|
|
integer or a range expression ([BEGIN]..[END])
|
|
--with-nth=N[,..] Transform the item using index expressions for search
|
|
-d, --delimiter=STR Field delimiter regex for --nth (default: AWK-style)
|
|
|
|
Search result
|
|
-s, --sort=MAX Maximum number of matched items to sort (default: 1000)
|
|
+s, --no-sort Do not sort the result. Keep the sequence unchanged.
|
|
|
|
Interface
|
|
-m, --multi Enable multi-select with tab/shift-tab
|
|
--no-mouse Disable mouse
|
|
+c, --no-color Disable colors
|
|
+2, --no-256 Disable 256-color
|
|
--black Use black background
|
|
--reverse Reverse orientation
|
|
--prompt=STR Input prompt (default: '> ')
|
|
|
|
Scripting
|
|
-q, --query=STR Start the finder with the given query
|
|
-1, --select-1 Automatically select the only match
|
|
-0, --exit-0 Exit immediately when there's no match
|
|
-f, --filter=STR Filter mode. Do not start interactive finder.
|
|
--print-query Print query as the first line
|
|
|
|
Environment variables
|
|
FZF_DEFAULT_COMMAND Default command to use when input is tty
|
|
FZF_DEFAULT_OPTS Defaults options. (e.g. "-x -m --sort 10000")] + $/ + $/
|
|
exit x
|
|
end
|
|
|
|
def emit event
|
|
@evt_mtx.synchronize do
|
|
@events[event] = yield
|
|
@cv.broadcast
|
|
end
|
|
end
|
|
|
|
def max_items; C.lines - 2; end
|
|
|
|
def cursor_y offset = 0
|
|
@reverse ? (offset) : (C.lines - 1 - offset)
|
|
end
|
|
|
|
def cprint str, col
|
|
C.attron(col) do
|
|
addstr_safe str
|
|
end if str
|
|
end
|
|
def addstr_safe str
|
|
str = str.gsub("\0", '') rescue str
|
|
C.addstr str
|
|
end
|
|
|
|
def print_input
|
|
C.setpos cursor_y, 0
|
|
C.clrtoeol
|
|
cprint @prompt, color(:prompt, true)
|
|
C.attron(C::A_BOLD) do
|
|
C.addstr get(:@query)
|
|
end
|
|
end
|
|
|
|
def print_info msg = nil
|
|
C.setpos cursor_y(1), 0
|
|
C.clrtoeol
|
|
|
|
prefix =
|
|
if spin_char = call(:@spinner, :first)
|
|
cprint spin_char, color(:spinner, true)
|
|
' '
|
|
else
|
|
' '
|
|
end
|
|
C.attron color(:info, false) do
|
|
sync do
|
|
C.addstr "#{prefix}#{@matches.length}/#{@count}"
|
|
if (selected = @selects.length) > 0
|
|
C.addstr " (#{selected})"
|
|
end
|
|
end
|
|
C.addstr msg if msg
|
|
end
|
|
end
|
|
|
|
def refresh
|
|
query, xcur = geta(:@query, :@xcur)
|
|
C.setpos cursor_y, @prompt.length + width(query[0, xcur])
|
|
C.refresh
|
|
end
|
|
|
|
def ctrl char
|
|
char.to_s.ord - 'a'.ord + 1
|
|
end
|
|
|
|
def format line, limit, offsets
|
|
offsets ||= []
|
|
maxe = offsets.map { |e| e.last }.max || 0
|
|
|
|
# Overflow
|
|
if width(line) > limit
|
|
ewidth = width(line[0...maxe])
|
|
# Stri..
|
|
if ewidth <= limit - 2
|
|
line, _ = trim line, limit - 2, false
|
|
line << '..'
|
|
# ..ring
|
|
else
|
|
# ..ri..
|
|
line = line[0...maxe] + '..' if ewidth < width(line) - 2
|
|
line, diff = trim line, limit - 2, true
|
|
offsets = offsets.map { |pair|
|
|
b, e = pair
|
|
b += 2 - diff
|
|
e += 2 - diff
|
|
b = [2, b].max
|
|
[b, e]
|
|
}
|
|
line = '..' + line
|
|
end
|
|
end
|
|
|
|
tokens = []
|
|
index = 0
|
|
offsets.select { |pair| pair.first < pair.last }.
|
|
sort_by { |pair| pair }.each do |pair|
|
|
b, e = pair.map { |x| [index, x].max }
|
|
tokens << [line[index...b], false]
|
|
tokens << [line[b...e], true]
|
|
index = e
|
|
end
|
|
tokens << [line[index..-1], false] if index < line.length
|
|
tokens.reject { |pair| pair.first.empty? }
|
|
end
|
|
|
|
def print_item row, tokens, chosen, selected
|
|
# Cursor
|
|
C.setpos row, 0
|
|
C.clrtoeol
|
|
cprint chosen ? '>' : ' ', color(:cursor, true)
|
|
cprint selected ? '>' : ' ',
|
|
chosen ? color(:chosen) : (selected ? color(:selected, true) : 0)
|
|
|
|
# Highlighted item
|
|
C.attron color(:chosen, true) if chosen
|
|
tokens.each do |pair|
|
|
token, highlighted = pair
|
|
|
|
if highlighted
|
|
cprint token, color(chosen ? :match! : :match, chosen)
|
|
C.attron color(:chosen, true) if chosen
|
|
else
|
|
addstr_safe token
|
|
end
|
|
end
|
|
C.attroff color(:chosen, true) if chosen
|
|
end
|
|
|
|
AFTER_1_9 = RUBY_VERSION.split('.').map { |e| e.rjust(3, '0') }.join >= '001009'
|
|
|
|
if AFTER_1_9
|
|
@@wrx = Regexp.new '\p{Han}|\p{Katakana}|\p{Hiragana}|\p{Hangul}'
|
|
def width str
|
|
str.gsub(@@wrx, ' ').length rescue str.length
|
|
end
|
|
|
|
def trim str, len, left
|
|
width = width str
|
|
diff = 0
|
|
while width > len
|
|
width -= ((left ? str[0, 1] : str[-1, 1]) =~ @@wrx ? 2 : 1) rescue 1
|
|
str = left ? str[1..-1] : str[0...-1]
|
|
diff += 1
|
|
end
|
|
[str, diff]
|
|
end
|
|
else
|
|
def width str
|
|
str.length
|
|
end
|
|
|
|
def trim str, len, left
|
|
diff = str.length - len
|
|
if diff > 0
|
|
[left ? str[diff..-1] : str[0...-diff], diff]
|
|
else
|
|
[str, 0]
|
|
end
|
|
end
|
|
|
|
class ::String
|
|
def ord
|
|
self.unpack('c').first
|
|
end
|
|
end
|
|
|
|
class ::Fixnum
|
|
def ord
|
|
self
|
|
end
|
|
end
|
|
end
|
|
|
|
def init_screen
|
|
$stdout.reopen($stderr)
|
|
|
|
C.init_screen
|
|
C.mousemask C::ALL_MOUSE_EVENTS if @mouse
|
|
C.start_color
|
|
dbg =
|
|
if !@black && C.respond_to?(:use_default_colors)
|
|
C.use_default_colors
|
|
-1
|
|
else
|
|
C::COLOR_BLACK
|
|
end
|
|
C.raw
|
|
C.noecho
|
|
|
|
if @color
|
|
if @ansi256 && ENV['TERM'].to_s =~ /256/
|
|
C.init_pair 1, 110, dbg
|
|
C.init_pair 2, 108, dbg
|
|
C.init_pair 3, 254, 236
|
|
C.init_pair 4, 151, 236
|
|
C.init_pair 5, 148, dbg
|
|
C.init_pair 6, 144, dbg
|
|
C.init_pair 7, 161, 236
|
|
C.init_pair 8, 168, 236
|
|
else
|
|
C.init_pair 1, C::COLOR_BLUE, dbg
|
|
C.init_pair 2, C::COLOR_GREEN, dbg
|
|
C.init_pair 3, C::COLOR_YELLOW, C::COLOR_BLACK
|
|
C.init_pair 4, C::COLOR_GREEN, C::COLOR_BLACK
|
|
C.init_pair 5, C::COLOR_GREEN, dbg
|
|
C.init_pair 6, C::COLOR_WHITE, dbg
|
|
C.init_pair 7, C::COLOR_RED, C::COLOR_BLACK
|
|
C.init_pair 8, C::COLOR_MAGENTA, C::COLOR_BLACK
|
|
end
|
|
|
|
def self.color sym, bold = false
|
|
C.color_pair([:prompt, :match, :chosen, :match!,
|
|
:spinner, :info, :cursor, :selected].index(sym) + 1) |
|
|
(bold ? C::A_BOLD : 0)
|
|
end
|
|
else
|
|
def self.color sym, bold = false
|
|
case sym
|
|
when :chosen
|
|
bold ? C::A_REVERSE : 0
|
|
when :match
|
|
C::A_UNDERLINE
|
|
when :match!
|
|
C::A_REVERSE | C::A_UNDERLINE
|
|
else
|
|
0
|
|
end | (bold ? C::A_BOLD : 0)
|
|
end
|
|
end
|
|
|
|
C.refresh
|
|
end
|
|
|
|
def start_reader
|
|
stream =
|
|
if @source.tty?
|
|
default_command = ENV['FZF_DEFAULT_COMMAND']
|
|
if default_command && !default_command.empty?
|
|
IO.popen(default_command)
|
|
elsif !`which find`.empty?
|
|
IO.popen("find * -path '*/\\.*' -prune -o -type f -print -o -type l -print 2> /dev/null")
|
|
else
|
|
exit 1
|
|
end
|
|
else
|
|
@source
|
|
end
|
|
|
|
Thread.new do
|
|
if @with_nth
|
|
while line = stream.gets
|
|
emit(:new) { @new << transform(line) }
|
|
end
|
|
else
|
|
while line = stream.gets
|
|
emit(:new) { @new << line.chomp }
|
|
end
|
|
end
|
|
emit(:loaded) { true }
|
|
@spinner.clear if @spinner
|
|
end
|
|
end
|
|
|
|
def transform line
|
|
line = line.chomp
|
|
mut = (line =~ / $/ ? line : line + ' ').
|
|
tokenize(@delim, @with_nth).map { |e| e.last }.join('').sub(/ *$/, '')
|
|
mut.orig = line
|
|
mut
|
|
end
|
|
|
|
def start_search &callback
|
|
Thread.new do
|
|
lists = []
|
|
events = {}
|
|
fcache = {}
|
|
q = ''
|
|
delay = -5
|
|
|
|
begin
|
|
while true
|
|
@evt_mtx.synchronize do
|
|
while true
|
|
events.merge! @events
|
|
|
|
if @events.empty? # No new events
|
|
@cv.wait @evt_mtx
|
|
next
|
|
end
|
|
@events.clear
|
|
break
|
|
end
|
|
|
|
if events[:new]
|
|
lists << @new
|
|
set(:@count) { |c| c + @new.length }
|
|
set(:@spinner) { |spinner|
|
|
if e = spinner.shift
|
|
spinner.push e
|
|
end; spinner
|
|
}
|
|
@new = []
|
|
fcache.clear
|
|
end
|
|
end#mtx
|
|
|
|
new_search = events[:key] || events.delete(:new)
|
|
user_input = events[:key]
|
|
progress = 0
|
|
started_at = Time.now
|
|
|
|
if updated = new_search && !lists.empty?
|
|
q, cx = events.delete(:key) || [q, 0]
|
|
empty = matcher.empty?(q)
|
|
unless matches = fcache[q]
|
|
found = []
|
|
skip = false
|
|
cnt = 0
|
|
lists.each do |list|
|
|
cnt += list.length
|
|
skip = @evt_mtx.synchronize { @events[:key] }
|
|
break if skip
|
|
|
|
if !empty && (progress = 100 * cnt / get(:@count)) < 100 && Time.now - started_at > 0.5
|
|
render { print_info " (#{progress}%)" }
|
|
end
|
|
|
|
found.concat(q.empty? ? list :
|
|
matcher.match(list, q, q[0, cx], q[cx..-1]))
|
|
end
|
|
if skip
|
|
sleep 0.1
|
|
next
|
|
end
|
|
matches = @sort ? found : found.reverse
|
|
if !empty && @sort && matches.length <= @sort
|
|
matches = FZF.sort(matches)
|
|
end
|
|
fcache[q] = matches
|
|
end
|
|
|
|
# Atomic update
|
|
set(:@matches, matches)
|
|
end#new_search
|
|
|
|
callback = nil if callback &&
|
|
(updated || events[:loaded]) &&
|
|
callback.call(events[:loaded], matches)
|
|
|
|
# This small delay reduces the number of partial lists
|
|
sleep((delay = [20, delay + 5].min) * 0.01) unless user_input
|
|
|
|
update_list new_search
|
|
end#while
|
|
rescue Exception => e
|
|
@main.raise e
|
|
end
|
|
end
|
|
end
|
|
|
|
def pick
|
|
sync do
|
|
item = @matches[@ycur]
|
|
item.is_a?(Array) ? item[0] : item
|
|
end
|
|
end
|
|
|
|
def constrain offset, cursor, count, height
|
|
original = [offset, cursor]
|
|
diffpos = cursor - offset
|
|
|
|
# Constrain cursor
|
|
cursor = [0, [cursor, count - 1].min].max
|
|
|
|
# Ceil
|
|
if cursor > offset + (height - 1)
|
|
offset = cursor - (height - 1)
|
|
# Floor
|
|
elsif offset > cursor
|
|
offset = cursor
|
|
end
|
|
|
|
# Adjustment
|
|
if count - offset < height
|
|
offset = [0, count - height].max
|
|
cursor = [0, [offset + diffpos, count - 1].min].max
|
|
end
|
|
|
|
[[offset, cursor] != original, offset, cursor]
|
|
end
|
|
|
|
def update_list wipe
|
|
render do
|
|
pos, items = sync {
|
|
changed, @yoff, @ycur =
|
|
constrain(@yoff, @ycur, @matches.length, max_items)
|
|
wipe ||= changed
|
|
|
|
[@ycur - @yoff, @matches[@yoff, max_items]]
|
|
}
|
|
|
|
# Wipe
|
|
if items.length < @plcount
|
|
@plcount.downto(items.length) do |idx|
|
|
C.setpos cursor_y(idx + 2), 0
|
|
C.clrtoeol
|
|
end
|
|
end
|
|
@plcount = items.length
|
|
|
|
dirty = Set[pos]
|
|
set(:@dirty) do |vs|
|
|
dirty.merge vs
|
|
Set.new
|
|
end
|
|
items.each_with_index do |item, idx|
|
|
next unless wipe || dirty.include?(idx)
|
|
row = cursor_y(idx + 2)
|
|
chosen = idx == pos
|
|
selected = @selects.include?([*item][0])
|
|
line, offsets = item
|
|
tokens = format line, C.cols - 3, offsets
|
|
print_item row, tokens, chosen, selected
|
|
end
|
|
print_info
|
|
print_input
|
|
end
|
|
end
|
|
|
|
def start_renderer
|
|
init_screen
|
|
|
|
Thread.new do
|
|
begin
|
|
while blk = @queue.shift
|
|
blk.call
|
|
refresh
|
|
end
|
|
rescue Exception => e
|
|
@main.raise e
|
|
end
|
|
end
|
|
end
|
|
|
|
def render &blk
|
|
@queue.push blk
|
|
nil
|
|
end
|
|
|
|
def vselect &prc
|
|
sync do
|
|
@dirty << @ycur - @yoff
|
|
@ycur = prc.call @ycur
|
|
end
|
|
update_list false
|
|
end
|
|
|
|
def num_unicode_bytes chr
|
|
# http://en.wikipedia.org/wiki/UTF-8
|
|
if chr & 0b10000000 > 0
|
|
bytes = 0
|
|
7.downto(2) do |shift|
|
|
break if (chr >> shift) & 0x1 == 0
|
|
bytes += 1
|
|
end
|
|
bytes
|
|
else
|
|
1
|
|
end
|
|
end
|
|
|
|
def read_nb chars = 1, default = nil, tries = 10
|
|
tries.times do |_|
|
|
begin
|
|
return @tty.read_nonblock(chars).ord
|
|
rescue Exception
|
|
sleep 0.01
|
|
end
|
|
end
|
|
default
|
|
end
|
|
|
|
def read_nbs
|
|
ords = []
|
|
while ord = read_nb
|
|
ords << ord
|
|
end
|
|
ords
|
|
end
|
|
|
|
def get_mouse
|
|
case ord = read_nb
|
|
when 32, 36, 40, 48, # mouse-down / shift / cmd / ctrl
|
|
35, 39, 43, 51 # mouse-up / shift / cmd / ctrl
|
|
x = read_nb - 33
|
|
y = read_nb - 33
|
|
{ :event => (ord % 2 == 0 ? :click : :release),
|
|
:x => x, :y => y, :shift => ord >= 36 }
|
|
when 96, 100, 104, 112, # scroll-up / shift / cmd / ctrl
|
|
97, 101, 105, 113 # scroll-down / shift / cmd / ctrl
|
|
read_nb(2)
|
|
{ :event => :scroll, :diff => (ord % 2 == 0 ? -1 : 1), :shift => ord >= 100 }
|
|
else
|
|
# e.g. 40, 43, 104, 105
|
|
read_nb(2)
|
|
nil
|
|
end
|
|
end
|
|
|
|
def get_input actions
|
|
@tty ||=
|
|
begin
|
|
require 'io/console'
|
|
IO.console
|
|
rescue LoadError
|
|
IO.open(IO.sysopen('/dev/tty'), 'r')
|
|
end
|
|
|
|
if pending = @pending
|
|
@pending = nil
|
|
return pending
|
|
end
|
|
|
|
str = ''
|
|
while true
|
|
ord =
|
|
if str.empty?
|
|
@tty.getc.ord
|
|
else
|
|
begin
|
|
ord = @tty.read_nonblock(1).ord
|
|
if (nb = num_unicode_bytes(ord)) > 1
|
|
ords = [ord]
|
|
(nb - 1).times do |_|
|
|
ords << @tty.read_nonblock(1).ord
|
|
end
|
|
# UTF-8 TODO Ruby 1.8
|
|
ords.pack('C*').force_encoding('UTF-8')
|
|
else
|
|
ord
|
|
end
|
|
rescue Exception
|
|
return str
|
|
end
|
|
end
|
|
|
|
ord =
|
|
case read_nb(1, :esc)
|
|
when 91, 79
|
|
case read_nb(1, nil)
|
|
when 68 then ctrl(:b)
|
|
when 67 then ctrl(:f)
|
|
when 66 then ctrl(:j)
|
|
when 65 then ctrl(:k)
|
|
when 90 then :stab
|
|
when 50 then read_nb; :ins
|
|
when 51 then read_nb; :del
|
|
when 53 then read_nb; :pgup
|
|
when 54 then read_nb; :pgdn
|
|
when 49
|
|
case read_nbs
|
|
when [59, 50, 68] then ctrl(:a)
|
|
when [59, 50, 67] then ctrl(:e)
|
|
when [59, 53, 68] then :alt_b
|
|
when [59, 53, 67] then :alt_f
|
|
when [126] then ctrl(:a)
|
|
end
|
|
when 52 then read_nb; ctrl(:e)
|
|
when 72 then ctrl(:a)
|
|
when 70 then ctrl(:e)
|
|
when 77
|
|
get_mouse
|
|
end
|
|
when 'b', 98 then :alt_b
|
|
when 'd', 100 then :alt_d
|
|
when 'f', 102 then :alt_f
|
|
when :esc then :esc
|
|
when 127 then :alt_bs
|
|
else next
|
|
end if ord == 27
|
|
|
|
return ord if ord.nil? || ord.is_a?(Hash)
|
|
|
|
if actions.has_key?(ord)
|
|
if str.empty?
|
|
return ord
|
|
else
|
|
@pending = ord
|
|
return str
|
|
end
|
|
else
|
|
unless ord.is_a? String
|
|
ord = [ord].pack('U*')
|
|
end
|
|
str << ord if ord =~ /[[:print:]]/
|
|
end
|
|
end
|
|
end
|
|
|
|
class MouseEvent
|
|
DOUBLE_CLICK_INTERVAL = 0.5
|
|
|
|
attr_reader :v
|
|
|
|
def initialize v = nil
|
|
@c = 0
|
|
@v = v
|
|
@t = Time.at 0
|
|
end
|
|
|
|
def v= v
|
|
@c = (@v == v && within?) ? @c + 1 : 0
|
|
@v = v
|
|
@t = Time.now
|
|
end
|
|
|
|
def double? v
|
|
@c == 1 && @v == v && within?
|
|
end
|
|
|
|
def within?
|
|
(Time.now - @t) < DOUBLE_CLICK_INTERVAL
|
|
end
|
|
end
|
|
|
|
def start_loop
|
|
got = nil
|
|
begin
|
|
input = call(:@query, :dup)
|
|
cursor = input.length
|
|
yanked = ''
|
|
mouse_event = MouseEvent.new
|
|
backword = proc {
|
|
cursor = (input[0, cursor].rindex(/[^[:alnum:]][[:alnum:]]/) || -1) + 1
|
|
nil
|
|
}
|
|
forward = proc {
|
|
cursor += (input[cursor..-1].index(/([[:alnum:]][^[:alnum:]])|(.$)/) || -1) + 1
|
|
nil
|
|
}
|
|
rubout = proc { |regex|
|
|
pcursor = cursor
|
|
cursor = (input[0, cursor].rindex(regex) || -1) + 1
|
|
if pcursor > cursor
|
|
yanked = input[cursor...pcursor]
|
|
input = input[0...cursor] + input[pcursor..-1]
|
|
end
|
|
}
|
|
actions = {
|
|
:esc => proc { exit 1 },
|
|
ctrl(:d) => proc {
|
|
if input.empty?
|
|
exit 1
|
|
elsif cursor < input.length
|
|
input = input[0...cursor] + input[(cursor + 1)..-1]
|
|
end
|
|
},
|
|
ctrl(:m) => proc {
|
|
got = pick
|
|
exit 0
|
|
},
|
|
ctrl(:u) => proc {
|
|
yanked = input[0...cursor] if cursor > 0
|
|
input = input[cursor..-1]
|
|
cursor = 0
|
|
},
|
|
ctrl(:a) => proc { cursor = 0; nil },
|
|
ctrl(:e) => proc { cursor = input.length; nil },
|
|
ctrl(:j) => proc { vselect { |v| v - @rev_dir } },
|
|
ctrl(:k) => proc { vselect { |v| v + @rev_dir } },
|
|
ctrl(:w) => proc { rubout.call /\s\S/ },
|
|
ctrl(:y) => proc { actions[:default].call yanked },
|
|
ctrl(:h) => proc { input[cursor -= 1] = '' if cursor > 0 },
|
|
ctrl(:i) => proc { |o|
|
|
if @multi && sel = pick
|
|
sync do
|
|
if @selects.has_key? sel
|
|
@selects.delete sel
|
|
else
|
|
@selects[sel] = sel.orig
|
|
end
|
|
end
|
|
vselect { |v| v + case o
|
|
when :stab then 1
|
|
when :sclick then 0
|
|
else -1
|
|
end * @rev_dir }
|
|
end
|
|
},
|
|
ctrl(:b) => proc { cursor = [0, cursor - 1].max; nil },
|
|
ctrl(:f) => proc { cursor = [input.length, cursor + 1].min; nil },
|
|
ctrl(:l) => proc { render { C.clear; C.refresh }; update_list true },
|
|
:del => proc { input[cursor] = '' if input.length > cursor },
|
|
:pgup => proc { vselect { |v| v + @rev_dir * (max_items - 1) } },
|
|
:pgdn => proc { vselect { |v| v - @rev_dir * (max_items - 1) } },
|
|
:alt_bs => proc { rubout.call /[^[:alnum:]][[:alnum:]]/ },
|
|
:alt_b => proc { backword.call },
|
|
:alt_d => proc {
|
|
pcursor = cursor
|
|
forward.call
|
|
if cursor > pcursor
|
|
yanked = input[pcursor...cursor]
|
|
input = input[0...pcursor] + input[cursor..-1]
|
|
cursor = pcursor
|
|
end
|
|
},
|
|
:alt_f => proc {
|
|
forward.call
|
|
},
|
|
:default => proc { |val|
|
|
case val
|
|
when String
|
|
input.insert cursor, val
|
|
cursor += val.length
|
|
when Hash
|
|
event = val[:event]
|
|
case event
|
|
when :click, :release
|
|
x, y, shift = val.values_at :x, :y, :shift
|
|
y = @reverse ? (C.lines - 1 - y) : y
|
|
if y == C.lines - 1
|
|
cursor = [0, [input.length, x - @prompt.length].min].max
|
|
elsif x > 1 && y <= max_items
|
|
tv = get(:@yoff) + max_items - y - 1
|
|
|
|
case event
|
|
when :click
|
|
vselect { |_| tv }
|
|
actions[ctrl(:i)].call(:sclick) if shift
|
|
mouse_event.v = tv
|
|
when :release
|
|
if !shift && mouse_event.double?(tv)
|
|
actions[ctrl(:m)].call
|
|
end
|
|
end
|
|
end
|
|
when :scroll
|
|
diff, shift = val.values_at :diff, :shift
|
|
actions[ctrl(:i)].call(:sclick) if shift
|
|
actions[ctrl(diff > 0 ? :j : :k)].call
|
|
end
|
|
nil
|
|
end
|
|
}
|
|
}
|
|
actions[ctrl(:p)] = actions[ctrl(:k)]
|
|
actions[ctrl(:n)] = actions[ctrl(:j)]
|
|
actions[:stab] = actions[ctrl(:i)]
|
|
actions[127] = actions[ctrl(:h)]
|
|
actions[ctrl(:q)] = actions[ctrl(:g)] = actions[ctrl(:c)] = actions[:esc]
|
|
|
|
while true
|
|
set(:@xcur, cursor)
|
|
render { print_input }
|
|
|
|
if key = get_input(actions)
|
|
upd = actions.fetch(key, actions[:default]).call(key)
|
|
|
|
# Dispatch key event
|
|
emit(:key) { [set(:@query, input.dup), cursor] } if upd
|
|
end
|
|
end
|
|
ensure
|
|
C.close_screen
|
|
q, selects = geta(:@query, :@selects)
|
|
@stdout.puts q if @print_query
|
|
@stdout.puts if @expect
|
|
if got
|
|
if selects.empty?
|
|
burp got
|
|
else
|
|
selects.each do |sel, orig|
|
|
burp sel, orig
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
class Matcher
|
|
class MatchData
|
|
def initialize n
|
|
@n = n
|
|
end
|
|
|
|
def offset _
|
|
@n
|
|
end
|
|
end
|
|
|
|
def initialize nth, delim
|
|
@nth = nth
|
|
@delim = delim
|
|
@tokens_cache = {}
|
|
end
|
|
|
|
def tokenize str
|
|
@tokens_cache[str] ||= str.tokenize(@delim, @nth)
|
|
end
|
|
|
|
def do_match str, pat
|
|
if @nth
|
|
tokenize(str).each do |pair|
|
|
prefix_length, token = pair
|
|
if md = token.match(pat) rescue nil
|
|
return MatchData.new(md.offset(0).map { |o| o + prefix_length })
|
|
end
|
|
end
|
|
nil
|
|
else
|
|
str.match(pat) rescue nil
|
|
end
|
|
end
|
|
end
|
|
|
|
class FuzzyMatcher < Matcher
|
|
attr_reader :caches, :rxflag
|
|
|
|
def initialize rxflag, nth = nil, delim = nil
|
|
super nth, delim
|
|
@caches = Hash.new { |h, k| h[k] = {} }
|
|
@regexp = {}
|
|
@rxflag = rxflag
|
|
end
|
|
|
|
def empty? q
|
|
q.empty?
|
|
end
|
|
|
|
def rxflag_for q
|
|
@rxflag || (q =~ /[A-Z]/ ? 0 : Regexp::IGNORECASE)
|
|
end
|
|
|
|
def fuzzy_regex q
|
|
@regexp[q] ||= begin
|
|
q = q.downcase if @rxflag == Regexp::IGNORECASE
|
|
Regexp.new(q.split(//).inject('') { |sum, e|
|
|
e = Regexp.escape e
|
|
sum << (e.length > 1 ? "(?:#{e}).*?" : # FIXME: not equivalent
|
|
"#{e}[^#{e}]*?")
|
|
}, rxflag_for(q))
|
|
end
|
|
end
|
|
|
|
def match list, q, prefix, suffix
|
|
regexp = fuzzy_regex q
|
|
|
|
cache = @caches[list.object_id]
|
|
prefix_cache = nil
|
|
(prefix.length - 1).downto(1) do |len|
|
|
break if prefix_cache = cache[prefix[0, len]]
|
|
end
|
|
|
|
suffix_cache = nil
|
|
0.upto(suffix.length - 1) do |idx|
|
|
break if suffix_cache = cache[suffix[idx..-1]]
|
|
end unless suffix.empty?
|
|
|
|
partial_cache = [prefix_cache,
|
|
suffix_cache].compact.sort_by { |e| e.length }.first
|
|
cache[q] ||= (partial_cache ?
|
|
partial_cache.map { |e| e.first } : list).map { |line|
|
|
# Ignore errors: e.g. invalid byte sequence in UTF-8
|
|
md = do_match(line, regexp)
|
|
md && [line, [md.offset(0)]]
|
|
}.compact
|
|
end
|
|
end
|
|
|
|
class ExtendedFuzzyMatcher < FuzzyMatcher
|
|
def initialize rxflag, mode = :fuzzy, nth = nil, delim = nil
|
|
super rxflag, nth, delim
|
|
@regexps = {}
|
|
@mode = mode
|
|
end
|
|
|
|
def empty? q
|
|
parse(q).empty?
|
|
end
|
|
|
|
def parse q
|
|
q = q.strip
|
|
@regexps[q] ||= q.split(/\s+/).map { |w|
|
|
invert =
|
|
if w =~ /^!/
|
|
w = w[1..-1]
|
|
true
|
|
end
|
|
|
|
[ @regexp[w] ||=
|
|
case w
|
|
when ''
|
|
nil
|
|
when /^\^(.*)\$$/
|
|
Regexp.new('^' << Regexp.escape($1) << '$', rxflag_for(w))
|
|
when /^'/
|
|
if @mode == :fuzzy && w.length > 1
|
|
exact_regex w[1..-1]
|
|
elsif @mode == :exact
|
|
exact_regex w
|
|
end
|
|
when /^\^/
|
|
w.length > 1 ?
|
|
Regexp.new('^' << Regexp.escape(w[1..-1]), rxflag_for(w)) : nil
|
|
when /\$$/
|
|
w.length > 1 ?
|
|
Regexp.new(Regexp.escape(w[0..-2]) << '$', rxflag_for(w)) : nil
|
|
else
|
|
@mode == :fuzzy ? fuzzy_regex(w) : exact_regex(w)
|
|
end, invert ]
|
|
}.select { |pair| pair.first }
|
|
end
|
|
|
|
def exact_regex w
|
|
Regexp.new(Regexp.escape(w), rxflag_for(w))
|
|
end
|
|
|
|
def match list, q, prefix, suffix
|
|
regexps = parse q
|
|
# Look for prefix cache
|
|
cache = @caches[list.object_id]
|
|
prefix = prefix.strip.sub(/\$\S*$/, '').sub(/(^|\s)!\S*$/, '')
|
|
prefix_cache = nil
|
|
(prefix.length - 1).downto(1) do |len|
|
|
break if prefix_cache = cache[Set[@regexps[prefix[0, len]]]]
|
|
end
|
|
|
|
cache[Set[regexps]] ||= (prefix_cache ?
|
|
prefix_cache.map { |e| e.first } :
|
|
list).map { |line|
|
|
offsets = []
|
|
regexps.all? { |pair|
|
|
regexp, invert = pair
|
|
md = do_match(line, regexp)
|
|
if md && !invert
|
|
offsets << md.offset(0)
|
|
elsif !md && invert
|
|
true
|
|
end
|
|
} && [line, offsets]
|
|
}.select { |e| e }
|
|
end
|
|
end
|
|
end#FZF
|
|
|
|
FZF.new(ARGV, $stdin).start if ENV.fetch('FZF_EXECUTABLE', '1') == '1'
|
|
|