fzf/fzf

#!/usr/bin/env bash
# vim: set filetype=ruby isk=@,48-57,_,192-255:
#
#     ____      ____
#    / __/___  / __/
#   / /_/_  / / /_
#  / __/ / /_/ __/
# /_/   /___/_/    Fuzzy finder for your shell
#
# URL:         https://github.com/junegunn/fzf
# Author:      Junegunn Choi
# License:     MIT
# Last update: October 24, 2013
#
# Copyright (c) 2013 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.

exec /usr/bin/env ruby -x "$0" $* 3>&1 1>&2 2>&3
#!ruby
# encoding: utf-8

require 'thread'
require 'ostruct'
require 'curses'

MAX_SORT_LEN = 500
C = Curses

@main     = Thread.current
@new      = []
@lists    = []
@query    = ''
@mtx      = Mutex.new
@smtx     = Mutex.new
@cv       = ConditionVariable.new
@count    = 0
@cursor_x = 0
@vcursor  = 0
@matches  = []
@loaded   = false
@sort     = ARGV.delete('--no-sort').nil?
@stat     = OpenStruct.new(:hit => 0, :partial_hit => 0,
                           :prefix_hit => 0, :search => 0)

def max_items; C.lines - 2; end
def cursor_y;  C.lines - 1; end
def cprint str, col, flag = C::A_BOLD
  C.attron  C.color_pair(col) | flag
  C.addstr  str
  C.attroff C.color_pair(col) | flag
end

def print_input
  C.setpos cursor_y, 0
  C.clrtoeol
  cprint '> ',   1
  cprint @query, 2
end

def print_info progress = true, msg = nil
  @fan ||= '-\|/-\|/'.split(//)
  C.setpos cursor_y - 1, 0
  C.clrtoeol
  prefix =
    if fan = @fan.shift
      @fan.push fan
      cprint fan, 5, 0
      ' '
    else
      '  '
    end
  C.addstr "#{prefix}#{@matches.length}/#{@count}" if progress
  C.addstr msg if msg
end

def refresh
  C.setpos cursor_y, 2 + ulen(@query[0, @cursor_x])
  C.refresh
end

def ctrl char
  char.to_s.ord - 'a'.ord + 1
end

if RUBY_VERSION.split('.').map { |e| e.rjust(3, '0') }.join > '001009'
  def ulen str
    expr = '\p{Han}|\p{Katakana}|\p{Hiragana}|\p{Hangul}'
    str.gsub(Regexp.new(expr), '  ').length
  end
else
  def ulen str
    str.length
  end

  class String
    def ord
      self.unpack('c').first
    end
  end

  class Fixnum
    def ord
      self
    end
  end
end

C.init_screen
C.start_color
C.raw
C.noecho
C.init_pair 1, C::COLOR_BLUE,   C::COLOR_BLACK
C.init_pair 2, C::COLOR_WHITE,  C::COLOR_BLACK
C.init_pair 3, C::COLOR_YELLOW, C::COLOR_BLACK
C.init_pair 4, C::COLOR_RED,    C::COLOR_BLACK
C.init_pair 5, C::COLOR_CYAN,   C::COLOR_BLACK

@read =
  if $stdin.tty?
    if !`which find`.empty?
      IO.popen("find * -path '*/\\.*' -prune -o -type f -print -o -type l -print 2> /dev/null")
    else
      exit 1
    end
  else
    $stdin
  end

reader = Thread.new {
  while line = @read.gets
    @mtx.synchronize do
      @new << line.chomp
      @cv.broadcast
    end
  end
  @mtx.synchronize do
    @loaded = true
    @cv.broadcast
  end
  @smtx.synchronize { @fan = [] }
}

searcher = Thread.new {
  fcache     = {}
  matches    = []
  new_length = 0
  pquery     = ''
  pvcursor   = 0
  ploaded    = false
  plength    = 0
  zz         = [0, 0]

  begin
    while true
      query_changed = nil
      new_items     = nil
      vcursor_moved = nil
      wait_for_completion = nil
      @mtx.synchronize do
        while true
          new_items           = !@new.empty?
          query_changed       = pquery   != @query
          vcursor_moved       = pvcursor != @vcursor
          loading_finished    = ploaded  != @loaded
          wait_for_completion = !@sort && !@loaded

          if !new_items && !query_changed && !vcursor_moved && !loading_finished
            @cv.wait @mtx
            next
          end
          break
        end

        if !wait_for_completion && new_items
          @lists << [@new, {}]
          @count += @new.length
          @new    = []
          fcache  = {}
        end

        pquery   = @query
        pvcursor = @vcursor
        ploaded  = @loaded
      end#mtx

      if wait_for_completion
        @smtx.synchronize do
          print_info false, " +#{@new.length}"
          print_input
          refresh
          sleep 0.1
        end
        next
      end

      new_search = new_items || query_changed
      if new_search && !@lists.empty?
        regexp = pquery.empty? ? nil :
          Regexp.new(pquery.split(//).inject('') { |sum, e|
            e = Regexp.escape e
            sum << "#{e}[^#{e}]*?"
          }, Regexp::IGNORECASE)

        matches =
          if fcache.has_key?(pquery)
            @stat.hit += 1
            fcache[pquery]
          else
            @smtx.synchronize do
              print_info true, ' ..'
              refresh
            end unless pquery.empty?

            found = @lists.map { |pair|
              list, cache = pair

              if cache[pquery]
                @stat.partial_hit += 1
                cache[pquery]
              else
                prefix_cache = nil
                (pquery.length - 1).downto(1) do |len|
                  prefix = pquery[0, len]
                  if prefix_cache = cache[prefix]
                    @stat.prefix_hit += 1
                    break
                  end
                end

                cache[pquery] ||= (prefix_cache ? prefix_cache.map { |e| e.first } : list).map { |line|
                  if regexp
                    # Ignore errors: e.g. invalid byte sequence in UTF-8
                    md = line.match(regexp) rescue nil
                    md ? [line, md.offset(0)] : nil
                  else
                    [line, zz]
                  end
                }.compact
              end
            }.inject([]) { |all, e| all.concat e }
            fcache[pquery] = @sort ? found : found.reverse
          end
        @stat.search += 1

        new_length = matches.length
        if @sort && new_length <= MAX_SORT_LEN
          matches.replace matches.sort_by { |pair|
            line, offset = pair
            [offset.last - offset.first, line.length, line]
          }
        end
      end#new_search

      # This small delay reduces the number of partial lists
      sleep 0.2 if !query_changed && !vcursor_moved

      if vcursor_moved || new_search
        @mtx.synchronize do
          plength  = [@matches.length, max_items].min
          @matches = matches
          pvcursor = @vcursor = [0, [@vcursor, new_length - 1, max_items - 1].min].max
        end
      end

      # Output
      @smtx.synchronize do
        item_length = [new_length, max_items].min
        if item_length < plength
          plength.downto(item_length) do |idx|
            C.setpos cursor_y - idx - 2, 0
            C.clrtoeol
          end
        end

        maxc = C.cols - 3
        matches[0, max_items].each_with_index do |item, idx|
          next if !new_search && !((pvcursor-1)..(pvcursor+1)).include?(idx)

          line, offset = item
          row = cursor_y - idx - 2
          chosen = idx == pvcursor

          if line.length > maxc
            line = line[0, maxc] + '..'
          end

          C.setpos row, 0
          C.clrtoeol
          C.attron C.color_pair(3) | C::A_BOLD if chosen

          b, e = offset
          e = [e, maxc].min
          if b < maxc && b < e
            C.addstr line[0, b]
            cprint   line[b...e], chosen ? 4 : 1
            C.attron C.color_pair(3) | C::A_BOLD if chosen
            C.addstr line[e..-1]
          else
            C.addstr line
          end
          C.attroff C.color_pair(3) | C::A_BOLD if chosen
        end

        print_info if !@lists.empty? || ploaded
        print_input
        refresh
      end
    end
  rescue Exception => e
    @main.raise e
  end
}

got = nil
begin
  tty     = IO.open(IO.sysopen('/dev/tty'), 'r')
  input   = ''
  cursor  = 0
  actions = {
    :nop     => proc {},
    ctrl(:c) => proc { exit 1 },
    ctrl(:d) => proc { exit 1 if input.empty? },
    ctrl(:m) => proc {
      @mtx.synchronize do
        got = @matches.fetch(@vcursor, [])[0]
      end
      exit 0
    },
    ctrl(:u) => proc { input = input[cursor..-1]; cursor = 0 },
    ctrl(:a) => proc { cursor = 0 },
    ctrl(:e) => proc { cursor = input.length },
    ctrl(:j) => proc {
      @mtx.synchronize do
        @vcursor -= 1
        @cv.broadcast
      end
    },
    ctrl(:k) => proc {
      @mtx.synchronize do
        @vcursor += 1
        @cv.broadcast
      end
    },
    ctrl(:w) => proc {
      ridx   = (input[0...cursor - 1].rindex(/\S\s/) || -2) + 2
      input  = input[0...ridx] + input[cursor..-1]
      cursor = ridx
    },
    127 => proc { input[cursor -= 1] = '' if cursor > 0 },
    :left => proc { cursor = [0, cursor - 1].max },
    :right => proc { cursor = [input.length, cursor + 1].min },
  }
  actions[ctrl(:b)] = actions[:left]
  actions[ctrl(:f)] = actions[:right]
  actions[ctrl(:h)] = actions[127]
  actions[ctrl(:n)] = actions[ctrl(:j)]
  actions[ctrl(:p)] = actions[ctrl(:k)]

  while true
    ord = tty.getc.ord
    if ord == 27
      ord = tty.getc.ord
      if ord == 91
        ord = case tty.getc.ord
              when 68 then :left
              when 67 then :right
              when 66 then ctrl(:j)
              when 65 then ctrl(:k)
              else :nop
              end
      end
    end

    actions.fetch(ord, proc { |ord|
      char = [ord].pack('U*')
      if char =~ /[[:print:]]/
        input.insert cursor, char
        cursor += 1
      end
    }).call(ord)

    # Dispatch key event
    @mtx.synchronize do
      @query = input.dup
      @cv.broadcast
    end

    # Update user input
    @smtx.synchronize do
      @cursor_x = cursor
      print_input
      refresh
    end
  end
ensure
  C.close_screen
  $stderr.puts got if got
end