diff --git a/fzf b/fzf
deleted file mode 100755
index 62893af48678d3cfaf311a95551e0d3d0778f589..0000000000000000000000000000000000000000
--- a/fzf
+++ /dev/null
@@ -1,1348 +0,0 @@
-#!/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 Default 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'
-
diff --git a/install b/install
index 3d0756561b6ee70a1053152be07bcaac552850f5..96c94d21aa9701cc6495a38f1942c71318b482a5 100755
--- a/install
+++ b/install
@@ -158,80 +158,9 @@ case "$archi" in
FreeBSD\ *86) download fzf-$version-freebsd_${binary_arch:-386} ;;
OpenBSD\ *64) download fzf-$version-openbsd_${binary_arch:-amd64} ;;
OpenBSD\ *86) download fzf-$version-openbsd_${binary_arch:-386} ;;
- *) binary_available=0 binary_error=1 ;;
+ *) binary_available=0 binary_error=1 ;;
esac
-install_ruby_fzf() {
- if [ -z "$allow_legacy" ]; then
- ask "Do you want to install legacy Ruby version instead?" && exit 1
- fi
- echo "Installing legacy Ruby version ..."
-
- # ruby executable
- echo -n "Checking Ruby executable ... "
- ruby=$(command -v ruby)
- if [ $? -ne 0 ]; then
- echo "ruby executable not found !!!"
- exit 1
- fi
-
- # System ruby is preferred
- system_ruby=/usr/bin/ruby
- if [ -x $system_ruby ] && [ $system_ruby != "$ruby" ]; then
- $system_ruby --disable-gems -rcurses -e0 2> /dev/null
- [ $? -eq 0 ] && ruby=$system_ruby
- fi
-
- echo "OK ($ruby)"
-
- # Curses-support
- echo -n "Checking Curses support ... "
- "$ruby" -rcurses -e0 2> /dev/null
- if [ $? -eq 0 ]; then
- echo "OK"
- else
- echo "Not found"
- echo "Installing 'curses' gem ... "
- if (( EUID )); then
- /usr/bin/env gem install curses --user-install
- else
- /usr/bin/env gem install curses
- fi
- if [ $? -ne 0 ]; then
- echo
- echo "Failed to install 'curses' gem."
- if [[ $(uname -r) =~ 'ARCH' ]]; then
- echo "Make sure that base-devel package group is installed."
- fi
- exit 1
- fi
- fi
-
- # Ruby version
- echo -n "Checking Ruby version ... "
- "$ruby" -e 'exit RUBY_VERSION >= "1.9"'
- if [ $? -eq 0 ]; then
- echo ">= 1.9"
- "$ruby" --disable-gems -rcurses -e0 2> /dev/null
- if [ $? -eq 0 ]; then
- fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
- else
- fzf_cmd="$ruby $fzf_base/fzf"
- fi
- else
- echo "< 1.9"
- fzf_cmd="$ruby $fzf_base/fzf"
- fi
-
- # Create fzf script
- echo -n "Creating wrapper script for fzf ... "
- rm -f "$fzf_base"/bin/fzf
- echo "#!/bin/sh" > "$fzf_base"/bin/fzf
- echo "$fzf_cmd \"\$@\"" >> "$fzf_base"/bin/fzf
- chmod +x "$fzf_base"/bin/fzf
- echo "OK"
-}
-
cd "$fzf_base"
if [ -n "$binary_error" ]; then
if [ $binary_available -eq 0 ]; then
@@ -249,12 +178,12 @@ if [ -n "$binary_error" ]; then
echo "OK"
cp "$GOPATH/bin/fzf" "$fzf_base/bin/"
else
- echo "Failed to build binary ..."
- install_ruby_fzf
+ echo "Failed to build binary. Installation failed."
+ exit 1
fi
else
- echo "go executable not found. Cannot build binary ..."
- install_ruby_fzf
+ echo "go executable not found. Installation failed."
+ exit 1
fi
fi