diff --git a/fzf b/fzf deleted file mode 100755 index 62893af..0000000 --- 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 3d07565..96c94d2 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