Update install/build script from Homebrew

Rewritten in Go

.gitignore

@@ -1,3 +1,5 @@
+bin
+src/fzf/fzf_*
 pkg
 Gemfile.lock
 .DS_Store

.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+sudo: false
+rvm:
+  - "1.8.7"
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.1"
+
+install: gem install curses minitest
+

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Junegunn Choi
+
+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.

README.md

@@ -8,11 +8,6 @@ fzf is a general-purpose fuzzy finder for your shell.
 It was heavily inspired by [ctrlp.vim](https://github.com/kien/ctrlp.vim) and
 the likes.
 
-Requirements
-------------
-
-fzf requires Ruby (>= 1.8.5).
-
 Installation
 ------------
 
@@ -51,8 +46,12 @@ Once you have cloned the repository, add the following line to your .vimrc.
 set rtp+=~/.fzf
 ```
 
-Or you may use any Vim plugin manager, such as
-[vim-plug](https://github.com/junegunn/vim-plug).
+Or you may use [vim-plug](https://github.com/junegunn/vim-plug) to manage fzf
+inside Vim:
+
+```vim
+Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' }
+```
 
 Usage
 -----
@@ -61,35 +60,39 @@ Usage
 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 indexes for limiting
-                         search scope (positive or negative integers)
-    -d, --delimiter=STR  Field delimiter regex for --nth (default: AWK-style)
+    -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.
+    -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
+    -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.
+    -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")
+    FZF_DEFAULT_COMMAND   Default command to use when input is tty
+    FZF_DEFAULT_OPTS      Defaults options. (e.g. "-x -m --sort 10000")
 ```
 
 fzf will launch curses-based finder, read the list from STDIN, and write the
@@ -123,6 +126,7 @@ The following readline key bindings should also work as expected.
 
 - CTRL-A / CTRL-E
 - CTRL-B / CTRL-F
+- CTRL-H / CTRL-D
 - CTRL-W / CTRL-U / CTRL-Y
 - ALT-B / ALT-F
 
@@ -173,12 +177,6 @@ fd() {
   cd "$dir"
 }
 
-# fda - including hidden directories
-fda() {
-  local dir
-  dir=$(find ${1:-.} -type d 2> /dev/null | fzf +m) && cd "$dir"
-}
-
 # fh - repeat history
 fh() {
   eval $(([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s | sed 's/ *[0-9]* *//')
@@ -188,33 +186,6 @@ fh() {
 fkill() {
   ps -ef | sed 1d | fzf -m | awk '{print $2}' | xargs kill -${1:-9}
 }
-
-# fbr - checkout git branch
-fbr() {
-  local branches branch
-  branches=$(git branch) &&
-  branch=$(echo "$branches" | fzf +s +m) &&
-  git checkout $(echo "$branch" | sed "s/.* //")
-}
-
-# fco - checkout git commit
-fco() {
-  local commits commit
-  commits=$(git log --pretty=oneline --abbrev-commit --reverse) &&
-  commit=$(echo "$commits" | fzf +s +m -e) &&
-  git checkout $(echo "$commit" | sed "s/ .*//")
-}
-
-# ftags - search ctags
-ftags() {
-  local line
-  [ -e tags ] &&
-  line=$(
-    awk 'BEGIN { FS="\t" } !/^!/ {print toupper($4)"\t"$1"\t"$2"\t"$3}' tags |
-    cut -c1-80 | fzf --nth=1,2
-  ) && $EDITOR $(cut -f3 <<< "$line") -c "set nocst" \
-                                      -c "silent tag $(cut -f2 <<< "$line")"
-}
 ```
 
 For more examples, see [the wiki
@@ -299,6 +270,14 @@ ssh **<TAB>
 telnet **<TAB>
 ```
 
+#### Environment variables / Aliases
+
+```sh
+unset **<TAB>
+export **<TAB>
+unalias **<TAB>
+```
+
 #### Settings
 
 ```sh
@@ -318,7 +297,7 @@ TODO :smiley:
 Usage as Vim plugin
 -------------------
 
-(fzf is a command-line utility, naturally it is only accessible in terminal Vim)
+(Note: To use fzf in GVim, an external terminal emulator is required.)
 
 ### `:FZF[!]`
 
@@ -342,6 +321,22 @@ If you're on a tmux session, `:FZF` will launch fzf in a new split-window whose
 height can be adjusted with `g:fzf_tmux_height` (default: '40%'). However, the
 bang version (`:FZF!`) will always start in fullscreen.
 
+In GVim, you need an external terminal emulator to start fzf with. `xterm`
+command is used by default, but you can customize it with `g:fzf_launcher`.
+
+```vim
+" This is the default. %s is replaced with fzf command
+let g:fzf_launcher = 'xterm -e bash -ic %s'
+
+" Use urxvt instead
+let g:fzf_launcher = 'urxvt -geometry 120x30 -e sh -c %s'
+```
+
+If you're running MacVim on OSX, I recommend you to use iTerm2 as the launcher.
+Refer to the [this wiki
+page](https://github.com/junegunn/fzf/wiki/fzf-with-MacVim-and-iTerm2) to see
+how to set up.
+
 ### `fzf#run([options])`
 
 For more advanced uses, you can call `fzf#run()` function which returns the list
@@ -349,16 +344,17 @@ of the selected items.
 
 `fzf#run()` may take an options-dictionary:
 
-| Option name   | Type          | Description                                                        |
-| ------------- | ------------- | ------------------------------------------------------------------ |
-| `source`      | string        | External command to generate input to fzf (e.g. `find .`)          |
-| `source`      | list          | Vim list as input to fzf                                           |
-| `sink`        | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)         |
-| `sink`        | funcref       | Reference to function to process each selected item                |
-| `options`     | string        | Options to fzf                                                     |
-| `dir`         | string        | Working directory                                                  |
-| `tmux_width`  | number/string | Use tmux vertical split with the given height (e.g. `20`, `50%`)   |
-| `tmux_height` | number/string | Use tmux horizontal split with the given height (e.g. `20`, `50%`) |
+| Option name     | Type          | Description                                                        |
+| --------------- | ------------- | ------------------------------------------------------------------ |
+| `source`        | string        | External command to generate input to fzf (e.g. `find .`)          |
+| `source`        | list          | Vim list as input to fzf                                           |
+| `sink`          | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)         |
+| `sink`          | funcref       | Reference to function to process each selected item                |
+| `options`       | string        | Options to fzf                                                     |
+| `dir`           | string        | Working directory                                                  |
+| `tmux_width`    | number/string | Use tmux vertical split with the given height (e.g. `20`, `50%`)   |
+| `tmux_height`   | number/string | Use tmux horizontal split with the given height (e.g. `20`, `50%`) |
+| `launcher`      | string        | External terminal emulator to start fzf with (Only used in GVim)   |
 
 #### Examples
 
@@ -386,7 +382,8 @@ nnoremap <silent> <Leader>C :call fzf#run({
 \         "substitute(fnamemodify(v:val, ':t'), '\\..\\{-}$', '', '')"),
 \   'sink':       'colo',
 \   'options':    '+m',
-\   'tmux_width': 20
+\   'tmux_width': 20,
+\   'launcher':   'xterm -geometry 20x30 -e bash -ic %s'
 \ })<CR>
 ```
 
@@ -395,20 +392,20 @@ handy mapping that selects an open buffer.
 
 ```vim
 " List of buffers
-function! g:buflist()
+function! BufList()
   redir => ls
   silent ls
   redir END
   return split(ls, '\n')
 endfunction
 
-function! g:bufopen(e)
+function! BufOpen(e)
   execute 'buffer '. matchstr(a:e, '^[ 0-9]*')
 endfunction
 
 nnoremap <silent> <Leader><Enter> :call fzf#run({
-\   'source':      reverse(g:buflist()),
-\   'sink':        function('g:bufopen'),
+\   'source':      reverse(BufList()),
+\   'sink':        function('BufOpen'),
 \   'options':     '+m',
 \   'tmux_height': '40%'
 \ })<CR>
@@ -434,21 +431,6 @@ If you have any rendering issues, check the followings:
   option. And if it solves your problem, I recommend including it in
   `FZF_DEFAULT_OPTS` for further convenience.
 4. If you still have problem, try `--no-256` option or even `--no-color`.
-5. Ruby 1.9 or above is required for correctly displaying unicode characters.
-
-### Ranking algorithm
-
-fzf sorts the result first by the length of the matched substring, then by the
-length of the whole string. However it only does so when the number of matches
-is less than the limit which is by default 1000, in order to avoid the cost of
-sorting a large list and limit the response time of the query.
-
-This limit can be adjusted with `-s` option, or with the environment variable
-`FZF_DEFAULT_OPTS`.
-
-```sh
-export FZF_DEFAULT_OPTS="--sort 20000"
-```
 
 ### Respecting `.gitignore`, `.hgignore`, and `svn:ignore`
 
@@ -475,7 +457,7 @@ speed of the traversal.
 ```sh
 # Copy the original fzf function to __fzf
 declare -f __fzf > /dev/null ||
-  eval "$(echo "__fzf() {"; declare -f fzf | grep -v '^{' | tail -n +2)"
+  eval "$(echo "__fzf() {"; declare -f fzf | \grep -v '^{' | tail -n +2)"
 
 # Use git ls-tree when possible
 fzf() {
@@ -487,6 +469,39 @@ fzf() {
 }
 ```
 
+### Using fzf with tmux splits
+
+It isn't too hard to write your own fzf-tmux combo like the default
+CTRL-T key binding. (Or is it?)
+
+```sh
+# This is a helper function that splits the current pane to start the given
+# command ($1) and sends its output back to the original pane with any number of
+# optional keys (shift; $*).
+fzf_tmux_helper() {
+  [ -n "$TMUX_PANE" ] || return
+  local cmd=$1
+  shift
+  tmux split-window -p 40 \
+    "bash -c \"\$(tmux send-keys -t $TMUX_PANE \"\$(source ~/.fzf.bash; $cmd)\" $*)\""
+}
+
+# This is the function we are going to run in the split pane.
+# - "find" to list the directories
+# - "sed" will escape spaces in the paths.
+# - "paste" will join the selected paths into a single line
+fzf_tmux_dir() {
+  fzf_tmux_helper \
+    'find * -path "*/\.*" -prune -o -type d -print 2> /dev/null |
+     fzf --multi |
+     sed "s/ /\\\\ /g" |
+     paste -sd" " -' Space
+}
+
+# Bind CTRL-X-CTRL-D to fzf_tmux_dir
+bind '"\C-x\C-d": "$(fzf_tmux_dir)\e\C-e"'
+```
+
 ### Fish shell
 
 It's [a known bug of fish](https://github.com/fish-shell/fish-shell/issues/1362)
@@ -510,17 +525,18 @@ function fe
 end
 ```
 
-### Windows
+### Handling UTF-8 NFD paths on OSX
 
-fzf works on [Cygwin](http://www.cygwin.com/) and
-[MSYS2](http://sourceforge.net/projects/msys2/). You may need to use `--black`
-option on MSYS2 to avoid rendering issues.
+Use iconv to convert NFD paths to NFC:
 
+```sh
+find . | iconv -f utf-8-mac -t utf8//ignore | fzf
+```
 
 License
 -------
 
-MIT
+[MIT](LICENSE)
 
 Author
 ------

Rakefile

@@ -6,3 +6,4 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
+task :default => :test

fzf

@@ -7,7 +7,7 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/    Fuzzy finder for your shell
 #
-# Version: 0.8.4 (May 17, 2014)
+# Version: 0.8.9 (Dec 24, 2014)
 #
 # Author:  Junegunn Choi
 # URL:     https://github.com/junegunn/fzf
@@ -36,8 +36,14 @@
 # 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 'curses'
 require 'set'
 
 unless String.method_defined? :force_encoding
@@ -48,29 +54,55 @@ unless String.method_defined? :force_encoding
   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,
-              :mouse, :multi, :query, :select1, :exit0, :filter, :extended
+  attr_reader :rxflag, :sort, :nth, :color, :black, :ansi256, :reverse, :prompt,
+              :mouse, :multi, :query, :select1, :exit0, :filter, :extended,
+              :print_query, :with_nth
 
-  class AtomicVar
-    def initialize value
-      @value = value
-      @mutex = Mutex.new
-    end
+  def sync
+    @shr_mtx.synchronize { yield }
+  end
 
-    def get
-      @mutex.synchronize { @value }
-    end
+  def get name
+    sync { instance_variable_get name }
+  end
 
-    def set value = nil
-      @mutex.synchronize do
-        @value = block_given? ? yield(@value) : value
-      end
-    end
+  def geta(*names)
+    sync { names.map { |name| instance_variable_get name } }
+  end
 
-    def method_missing sym, *args, &blk
-      @mutex.synchronize { @value.send(sym, *args, &blk) }
+  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
 
@@ -87,8 +119,12 @@ class FZF
     @exit0    = false
     @filter   = nil
     @nth      = nil
+    @with_nth = nil
     @delim    = nil
     @reverse  = false
+    @prompt   = '> '
+    @shr_mtx  = Mutex.new
+    @print_query = false
 
     argv =
       if opts = ENV['FZF_DEFAULT_OPTS']
@@ -124,20 +160,24 @@ class FZF
       when '+0', '--no-exit-0'   then @exit0    = false
       when '-q', '--query'
         usage 1, 'query string required' unless query = argv.shift
-        @query = AtomicVar.new query.dup
+        @query = query
       when /^-q(.*)$/, /^--query=(.*)$/
-        @query = AtomicVar.new($1)
+        @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 number required' unless nth = argv.shift
-        usage 1, 'invalid field number' if nth.to_i == 0
+        usage 1, 'field expression required' unless nth = argv.shift
         @nth = parse_nth nth
-      when /^-n([0-9,-]+)$/, /^--nth=([0-9,-]+)$/
+      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
@@ -149,6 +189,13 @@ class FZF
         @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
       else
@@ -156,34 +203,50 @@ class FZF
       end
     end
 
-    @source   = source.clone
-    @mtx      = Mutex.new
-    @cv       = ConditionVariable.new
-    @events   = {}
-    @new      = []
-    @queue    = Queue.new
-    @pending  = nil
+    @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
-      @query  ||= AtomicVar.new('')
-      @cursor_x = AtomicVar.new(@query.length)
-      @matches  = AtomicVar.new([])
-      @count    = AtomicVar.new(0)
-      @vcursor  = AtomicVar.new(0)
-      @vcursors = AtomicVar.new(Set.new)
-      @spinner  = AtomicVar.new('-\|/-\|/'.split(//))
-      @selects  = AtomicVar.new({}) # ordered >= 1.9
-      @main     = Thread.current
-      @plcount  = 0
+      # 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
-    nth.split(',').map { |n|
-      ni = n.to_i
-      usage 1, "invalid field number: #{n}" if ni == 0
-      ni
+    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
@@ -191,21 +254,28 @@ class FZF
     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
-      emit(:key) { q = @query.get; [q, q.length] } unless empty = @query.empty?
+      query = get(:@query)
+      emit(:key) { [query, query.length] } unless empty = query.empty?
       if @select1 || @exit0
         start_search do |loaded, matches|
-          len = empty ? @count.get : matches.length
+          len = empty ? get(:@count) : matches.length
           if loaded
             if @select1 && len == 1
-              puts empty ? matches.first : matches.first.first
+              puts @query if @print_query
+              burp(empty ? matches.first : matches.first.first)
               exit 0
             elsif @exit0 && len == 0
+              puts @query if @print_query
               exit 0
             end
           end
@@ -226,6 +296,7 @@ class FZF
   end
 
   def filter_list list
+    puts @filter if @print_query
     matches = matcher.match(list, @filter, '', '')
     if @sort && matches.length <= @sort
       matches = FZF.sort(matches)
@@ -277,155 +348,44 @@ class FZF
     $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 indexes for limiting
-                         search scope (positive or negative integers)
-    -d, --delimiter=STR  Field delimiter regex for --nth (default: AWK-style)
+    -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.
+    -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
+    -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.
+    -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
-
-  case RUBY_PLATFORM
-  when /darwin/
-    module UConv
-      CHOSUNG   = 0x1100
-      JUNGSUNG  = 0x1161
-      JONGSUNG  = 0x11A7
-      CHOSUNGS  = 19
-      JUNGSUNGS = 21
-      JONGSUNGS = 28
-      JJCOUNT   = JUNGSUNGS * JONGSUNGS
-      NFC_BEGIN = 0xAC00
-      NFC_END   = NFC_BEGIN + CHOSUNGS * JUNGSUNGS * JONGSUNGS
-
-      def self.nfd str
-        str.split(//).map do |c|
-          cp = c.ord
-          if cp >= NFC_BEGIN && cp < NFC_END
-            chr = ''
-            idx  = cp - NFC_BEGIN
-            cho  = CHOSUNG  + idx / JJCOUNT
-            jung = JUNGSUNG + (idx % JJCOUNT) / JONGSUNGS
-            jong = JONGSUNG + idx % JONGSUNGS
-            chr << cho << jung
-            chr << jong if jong != JONGSUNG
-            chr
-          else
-            c
-          end
-        end
-      end
-
-      def self.to_nfc arr
-        [NFC_BEGIN + arr[0] * JJCOUNT +
-         (arr[1] || 0) * JONGSUNGS +
-         (arr[2] || 0)].pack('U*')
-      end
-
-      if String.method_defined?(:each_char)
-        def self.split str
-          str.each_char.to_a
-        end
-      else
-        def self.split str
-          str.split('')
-        end
-      end
-
-      def self.nfc str, offsets = []
-        ret  = ''
-        omap = []
-        pend = []
-        split(str).each_with_index do |c, idx|
-          cp =
-            begin
-              c.ord
-            rescue Exception
-              next
-            end
-          omap << ret.length
-          unless pend.empty?
-            if cp >= JUNGSUNG && cp < JUNGSUNG + JUNGSUNGS
-              pend << cp - JUNGSUNG
-              next
-            elsif cp >= JONGSUNG && cp < JONGSUNG + JONGSUNGS
-              pend << cp - JONGSUNG
-              next
-            else
-              omap[-1] = omap[-1] + 1
-              ret << to_nfc(pend)
-              pend.clear
-            end
-          end
-          if cp >= CHOSUNG && cp < CHOSUNG + CHOSUNGS
-            pend << cp - CHOSUNG
-          else
-            ret << c
-          end
-        end
-        ret << to_nfc(pend) unless pend.empty?
-        return [ret,
-                offsets.map { |pair|
-                  b, e = pair
-                  [omap[b] || 0, omap[e] || ((omap.last || 0) + 1)] }]
-      end
-    end
-
-    def convert_item item
-      UConv.nfc(*item)
-    end
-
-    class Matcher
-      def query_chars q
-        UConv.nfd(q)
-      end
-
-      def sanitize q
-        UConv.nfd(q).join
-      end
-    end
-  else
-    def convert_item item
-      item
-    end
-
-    class Matcher
-      def query_chars q
-        q.split(//)
-      end
-
-      def sanitize q
-        q
-      end
-    end
+    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
-    @mtx.synchronize do
+    @evt_mtx.synchronize do
       @events[event] = yield
       @cv.broadcast
     end
@@ -443,39 +403,44 @@ class FZF
     end if str
   end
   def addstr_safe str
-    C.addstr str.gsub("\0", '')
+    str = str.gsub("\0", '') rescue str
+    C.addstr str
   end
 
   def print_input
     C.setpos cursor_y, 0
     C.clrtoeol
-    cprint '> ', color(:prompt, true)
+    cprint @prompt, color(:prompt, true)
     C.attron(C::A_BOLD) do
-      C.addstr @query.get
+      C.addstr get(:@query)
     end
   end
 
   def print_info msg = nil
     C.setpos cursor_y(1), 0
     C.clrtoeol
+
     prefix =
-      if spinner = @spinner.first
-        cprint spinner, color(:spinner, true)
+      if spin_char = call(:@spinner, :first)
+        cprint spin_char, color(:spinner, true)
         ' '
       else
         '  '
       end
     C.attron color(:info, false) do
-      C.addstr "#{prefix}#{@matches.length}/#{@count.get}"
-      if (selected = @selects.length) > 0
-        C.addstr " (#{selected})"
+      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
-    C.setpos cursor_y, 2 + width(@query[0, @cursor_x.get])
+    query, xcur = geta(:@query, :@xcur)
+    C.setpos cursor_y, @prompt.length + width(query[0, xcur])
     C.refresh
   end
 
@@ -558,7 +523,7 @@ class FZF
       width = width str
       diff  = 0
       while width > len
-        width -= (left ? str[0, 1] : str[-1, 1]) =~ @@wrx ? 2 : 1
+        width -= ((left ? str[0, 1] : str[-1, 1]) =~ @@wrx ? 2 : 1) rescue 1
         str    = left ? str[1..-1] : str[0...-1]
         diff  += 1
       end
@@ -592,7 +557,6 @@ class FZF
   end
 
   def init_screen
-    @stdout = $stdout.clone
     $stdout.reopen($stderr)
 
     C.init_screen
@@ -667,14 +631,28 @@ class FZF
       end
 
     Thread.new do
-      while line = stream.gets
-        emit(:new) { @new << line.chomp }
+      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   = []
@@ -685,12 +663,12 @@ class FZF
 
       begin
         while true
-          @mtx.synchronize do
+          @evt_mtx.synchronize do
             while true
               events.merge! @events
 
               if @events.empty? # No new events
-                @cv.wait @mtx
+                @cv.wait @evt_mtx
                 next
               end
               @events.clear
@@ -699,8 +677,8 @@ class FZF
 
             if events[:new]
               lists << @new
-              @count.set { |c| c + @new.length }
-              @spinner.set { |spinner|
+              set(:@count) { |c| c + @new.length }
+              set(:@spinner) { |spinner|
                 if e = spinner.shift
                   spinner.push e
                 end; spinner
@@ -724,17 +702,20 @@ class FZF
               cnt   = 0
               lists.each do |list|
                 cnt += list.length
-                skip = @mtx.synchronize { @events[:key] }
+                skip = @evt_mtx.synchronize { @events[:key] }
                 break if skip
 
-                if !empty && (progress = 100 * cnt / @count.get) < 100 && Time.now - started_at > 0.5
+                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
-              next if skip
+              if skip
+                sleep 0.1
+                next
+              end
               matches = @sort ? found : found.reverse
               if !empty && @sort && matches.length <= @sort
                 matches = FZF.sort(matches)
@@ -743,7 +724,7 @@ class FZF
             end
 
             # Atomic update
-            @matches.set matches
+            set(:@matches, matches)
           end#new_search
 
           callback = nil if callback &&
@@ -762,14 +743,45 @@ class FZF
   end
 
   def pick
-    items = @matches[0, max_items]
-    curr = [0, [@vcursor.get, items.length - 1].min].max
-    [*items.fetch(curr, [])][0]
+    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
-      items = @matches[0, max_items]
+      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
@@ -780,20 +792,18 @@ class FZF
       end
       @plcount = items.length
 
-      maxc    = C.cols - 3
-      vcursor = @vcursor.set { |v| [0, [v, items.length - 1].min].max }
-      cleanse = Set[vcursor]
-      @vcursors.set { |vs|
-        cleanse.merge vs
+      dirty = Set[pos]
+      set(:@dirty) do |vs|
+        dirty.merge vs
         Set.new
-      }
+      end
       items.each_with_index do |item, idx|
-        next unless wipe || cleanse.include?(idx)
+        next unless wipe || dirty.include?(idx)
         row           = cursor_y(idx + 2)
-        chosen        = idx == vcursor
+        chosen        = idx == pos
         selected      = @selects.include?([*item][0])
-        line, offsets = convert_item item
-        tokens        = format line, maxc, offsets
+        line, offsets = item
+        tokens        = format line, C.cols - 3, offsets
         print_item row, tokens, chosen, selected
       end
       print_info
@@ -822,7 +832,10 @@ class FZF
   end
 
   def vselect &prc
-    @vcursor.set { |v| @vcursors << v; prc.call v }
+    sync do
+      @dirty << @ycur - @yoff
+      @ycur = prc.call @ycur
+    end
     update_list false
   end
 
@@ -879,7 +892,13 @@ class FZF
   end
 
   def get_input actions
-    @tty ||= IO.open(IO.sysopen('/dev/tty'), 'r')
+    @tty ||=
+      begin
+        require 'io/console'
+        IO.console
+      rescue LoadError
+        IO.open(IO.sysopen('/dev/tty'), 'r')
+      end
 
     if pending = @pending
       @pending = nil
@@ -911,7 +930,7 @@ class FZF
 
       ord =
         case read_nb(1, :esc)
-        when 91
+        when 91, 79
           case read_nb(1, nil)
           when 68 then ctrl(:b)
           when 67 then ctrl(:f)
@@ -926,6 +945,8 @@ class FZF
             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)
@@ -935,8 +956,10 @@ class FZF
             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
 
@@ -987,16 +1010,35 @@ class FZF
   def start_loop
     got = nil
     begin
-      input = @query.get.dup
+      input  = call(:@query, :dup)
       cursor = input.length
       yanked = ''
       mouse_event = MouseEvent.new
       backword = proc {
-        cursor = (input[0, cursor].rindex(/\s\S/) || -1) + 1
+        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 { exit 1 if input.empty? },
+        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
@@ -1008,40 +1050,46 @@ class FZF
         },
         ctrl(:a) => proc { cursor = 0; nil },
         ctrl(:e) => proc { cursor = input.length; nil },
-        ctrl(:j) => proc { vselect { |v| v - (@reverse ? -1 : 1) } },
-        ctrl(:k) => proc { vselect { |v| v + (@reverse ? -1 : 1) } },
-        ctrl(:w) => proc {
-          pcursor = cursor
-          backword.call
-          yanked = input[cursor...pcursor] if pcursor > cursor
-          input = input[0...cursor] + input[pcursor..-1]
-        },
+        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
-            if @selects.has_key? sel
-              @selects.delete sel
-            else
-              @selects[sel] = 1
+            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 * (@reverse ? -1 : 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 { |_| max_items } },
-        :pgdn  => proc { vselect { |_| 0 } },
-        :alt_b => proc { backword.call; nil },
-        :alt_f => proc {
-          cursor += (input[cursor..-1].index(/(\S\s)|(.$)/) || -1) + 1
-          nil
+        :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
@@ -1053,10 +1101,11 @@ class FZF
             case event
             when :click, :release
               x, y, shift = val.values_at :x, :y, :shift
-              if y == cursor_y
-                cursor = [0, [input.length, x - 2].min].max
+              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 = max_items - y - 1
+                tv = get(:@yoff) + max_items - y - 1
 
                 case event
                 when :click
@@ -1074,6 +1123,7 @@ class FZF
               actions[ctrl(:i)].call(:sclick) if shift
               actions[ctrl(diff > 0 ? :j : :k)].call
             end
+            nil
           end
         }
       }
@@ -1084,24 +1134,26 @@ class FZF
       actions[ctrl(:q)] = actions[ctrl(:g)] = actions[ctrl(:c)] = actions[:esc]
 
       while true
-        @cursor_x.set cursor
+        set(:@xcur, cursor)
         render { print_input }
 
         if key = get_input(actions)
           upd = actions.fetch(key, actions[:default]).call(key)
 
           # Dispatch key event
-          emit(:key) { [@query.set(input.dup), cursor] } if upd
+          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
       if got
-        if @selects.empty?
-          @stdout.puts got
+        if selects.empty?
+          burp got
         else
-          @selects.each do |sel, _|
-            @stdout.puts sel
+          selects.each do |sel, orig|
+            burp sel, orig
           end
         end
       end
@@ -1120,32 +1172,21 @@ class FZF
     end
 
     def initialize nth, delim
-      @nth = nth && nth.map { |n| n > 0 ? n - 1 : n }
+      @nth = nth
       @delim = delim
       @tokens_cache = {}
     end
 
     def tokenize str
-      @tokens_cache[str] ||=
-        unless @delim
-          # AWK default
-          prefix_length = str[/^\s+/].length rescue 0
-          [prefix_length, (str.strip.scan(/\S+\s*/) rescue [])]
-        else
-          prefix_length = 0
-          [prefix_length, (str.scan(@delim) rescue [])]
-        end
+      @tokens_cache[str] ||= str.tokenize(@delim, @nth)
     end
 
     def do_match str, pat
       if @nth
-        prefix_length, tokens = tokenize str
-
-        @nth.each do |n|
-          if (token = tokens[n]) && (md = token.match(pat) rescue nil)
-            prefix_length += (tokens[0...n] || []).join.length
-            offset = md.offset(0).map { |o| o + prefix_length }
-            return MatchData.new(offset)
+        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
@@ -1176,7 +1217,7 @@ class FZF
     def fuzzy_regex q
       @regexp[q] ||= begin
         q = q.downcase if @rxflag == Regexp::IGNORECASE
-        Regexp.new(query_chars(q).inject('') { |sum, e|
+        Regexp.new(q.split(//).inject('') { |sum, e|
           e = Regexp.escape e
           sum << (e.length > 1 ? "(?:#{e}).*?" :  # FIXME: not equivalent
                                  "#{e}[^#{e}]*?")
@@ -1234,7 +1275,7 @@ class FZF
             when ''
               nil
             when /^\^(.*)\$$/
-              Regexp.new('^' << sanitize(Regexp.escape($1)) << '$', rxflag_for(w))
+              Regexp.new('^' << Regexp.escape($1) << '$', rxflag_for(w))
             when /^'/
               if @mode == :fuzzy && w.length > 1
                 exact_regex w[1..-1]
@@ -1243,10 +1284,10 @@ class FZF
               end
             when /^\^/
               w.length > 1 ?
-                Regexp.new('^' << sanitize(Regexp.escape(w[1..-1])), rxflag_for(w)) : nil
+                Regexp.new('^' << Regexp.escape(w[1..-1]), rxflag_for(w)) : nil
             when /\$$/
               w.length > 1 ?
-                Regexp.new(sanitize(Regexp.escape(w[0..-2])) << '$', rxflag_for(w)) : nil
+                Regexp.new(Regexp.escape(w[0..-2]) << '$', rxflag_for(w)) : nil
             else
               @mode == :fuzzy ? fuzzy_regex(w) : exact_regex(w)
             end, invert ]
@@ -1254,7 +1295,7 @@ class FZF
     end
 
     def exact_regex w
-      Regexp.new(sanitize(Regexp.escape(w)), rxflag_for(w))
+      Regexp.new(Regexp.escape(w), rxflag_for(w))
     end
 
     def match list, q, prefix, suffix

fzf-completion.bash

@@ -8,12 +8,35 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+_fzf_orig_completion_filter() {
+  sed 's/.*-F *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\2=\1;/' |
+  sed 's/[^a-z0-9_= ;]/_/g'
+}
+
 _fzf_opts_completion() {
   local cur prev opts
   COMPREPLY=()
   cur="${COMP_WORDS[COMP_CWORD]}"
   prev="${COMP_WORDS[COMP_CWORD-1]}"
-  opts="-m --multi -x --extended -s --sort +s +i +c --no-color"
+  opts="
+    -x --extended
+    -e --extended-exact
+    -i +i
+    -n --nth
+    -d --delimiter
+    -s --sort +s
+    -m --multi
+    --no-mouse
+    +c --no-color
+    +2 --no-256
+    --black
+    --reverse
+    --prompt
+    -q --query
+    -1 --select-1
+    -0 --exit-0
+    -f --filter
+    --print-query"
 
   case "${prev}" in
   --sort|-s)
@@ -30,8 +53,26 @@ _fzf_opts_completion() {
   return 0
 }
 
-_fzf_generic_completion() {
-  local cur base dir leftover matches trigger
+_fzf_handle_dynamic_completion() {
+  local cmd orig ret
+  cmd="$1"
+  shift
+
+  orig=$(eval "echo \$_fzf_orig_completion_$cmd")
+  if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
+    $orig "$@"
+  elif [ -n "$_fzf_completion_loader" ]; then
+    _completion_loader "$@"
+    ret=$?
+    eval $(complete | \grep "\-F.* $cmd$" | _fzf_orig_completion_filter)
+    source $BASH_SOURCE
+    return $ret
+  fi
+}
+
+_fzf_path_completion() {
+  local cur base dir leftover matches trigger cmd
+  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER:-**}
   cur="${COMP_WORDS[COMP_CWORD]}"
@@ -46,7 +87,7 @@ _fzf_generic_completion() {
         leftover=${leftover/#\/}
         [ "$dir" = './' ] && dir=''
         tput sc
-        matches=$(find "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
+        matches=$(find -L "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
           printf '%q ' "$item"
         done)
         matches=${matches% }
@@ -61,25 +102,53 @@ _fzf_generic_completion() {
       dir=$(dirname "$dir")
       [[ "$dir" =~ /$ ]] || dir="$dir"/
     done
+  else
+    shift
+    shift
+    _fzf_handle_dynamic_completion "$cmd" "$@"
+  fi
+}
+
+_fzf_list_completion() {
+  local cur selected trigger cmd src
+  read -r src
+  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
+  trigger=${FZF_COMPLETION_TRIGGER:-**}
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  if [[ ${cur} == *"$trigger" ]]; then
+    cur=${cur:0:${#cur}-${#trigger}}
+
+    tput sc
+    selected=$(eval "$src | fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
+    selected=${selected% }
+    tput rc
+
+    if [ -n "$selected" ]; then
+      COMPREPLY=("$selected")
+      return 0
+    fi
+  else
+    shift
+    _fzf_handle_dynamic_completion "$cmd" "$@"
   fi
 }
 
 _fzf_all_completion() {
-  _fzf_generic_completion \
+  _fzf_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
-    "-m"
+    "-m" "$@"
 }
 
 _fzf_file_completion() {
-  _fzf_generic_completion \
+  _fzf_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type f -print -o -type l -print" \
-    "-m"
+    "-m" "$@"
 }
 
 _fzf_dir_completion() {
-  _fzf_generic_completion \
+  _fzf_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type d -print" \
-    ""
+    "" "$@"
 }
 
 _fzf_kill_completion() {
@@ -97,64 +166,69 @@ _fzf_kill_completion() {
 }
 
 _fzf_telnet_completion() {
-  local cur selected trigger
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  [[ ${cur} == *"$trigger" ]] || return 1
-  cur=${cur:0:${#cur}-${#trigger}}
-
-  tput sc
-  selected=$(grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{print $2}' | sort -u | fzf $FZF_COMPLETION_OPTS -q "$cur")
-  tput rc
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=("$selected")
-    return 0
-  fi
+  _fzf_list_completion '+m' "$@" << "EOF"
+  \grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{if (length($2) > 0) {print $2}}' | sort -u
+EOF
 }
 
 _fzf_ssh_completion() {
-  local cur selected trigger
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  [[ ${cur} == *"$trigger" ]] || return 1
-  cur=${cur:0:${#cur}-${#trigger}}
-
-  tput sc
-  selected=$(cat \
-    <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | grep -i ^host) \
-    <(grep -v '^\s*\(#\|$\)' /etc/hosts) | \
-    awk '{print $2}' | sort -u | fzf $FZF_COMPLETION_OPTS -q "$cur")
-  tput rc
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=("$selected")
-    return 0
-  fi
+  _fzf_list_completion '+m' "$@" << "EOF"
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i ^host | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts) | awk '{print $2}' | sort -u
+EOF
 }
 
+_fzf_env_var_completion() {
+  _fzf_list_completion '-m' "$@" << "EOF"
+  declare -xp | sed 's/=.*//' | sed 's/.* //'
+EOF
+}
+
+_fzf_alias_completion() {
+  _fzf_list_completion '-m' "$@" << "EOF"
+  alias | sed 's/=.*//' | sed 's/.* //'
+EOF
+}
+
+# fzf options
 complete -F _fzf_opts_completion fzf
 
+d_cmds="cd pushd rmdir"
+f_cmds="
+  awk cat diff diff3
+  emacs ex file ftp g++ gcc gvim head hg java
+  javac ld less more mvim patch perl python ruby
+  sed sftp sort source tail tee uniq vi view vim wc"
+a_cmds="
+  basename bunzip2 bzip2 chmod chown curl cp dirname du
+  find git grep gunzip gzip hg jar
+  ln ls mv open rm rsync scp
+  svn tar unzip zip"
+x_cmds="kill ssh telnet unset unalias export"
+
+# Preserve existing completion
+if [ "$_fzf_completion_loaded" != '0.8.6-1' ]; then
+  # Really wish I could use associative array but OSX comes with bash 3.2 :(
+  eval $(complete | \grep '\-F' | \grep -v _fzf_ |
+    \grep -E " ($(echo $d_cmds $f_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
+  export _fzf_completion_loaded=0.8.6-1
+fi
+
+if type _completion_loader > /dev/null 2>&1; then
+  _fzf_completion_loader=1
+fi
+
 # Directory
-for cmd in "cd pushd rmdir"; do
+for cmd in $d_cmds; do
   complete -F _fzf_dir_completion -o default -o bashdefault $cmd
 done
 
 # File
-for cmd in "
-  awk cat diff diff3
-  emacs ex file ftp g++ gcc gvim head hg java
-  javac ld less more mvim patch perl python ruby
-  sed sftp sort source tail tee uniq vi view vim wc"; do
+for cmd in $f_cmds; do
   complete -F _fzf_file_completion -o default -o bashdefault $cmd
 done
 
 # Anything
-for cmd in "
-  basename bunzip2 bzip2 chmod chown curl cp dirname du
-  find git grep gunzip gzip hg jar
-  ln ls mv open rm rsync scp
-  svn tar unzip zip"; do
+for cmd in $a_cmds; do
   complete -F _fzf_all_completion -o default -o bashdefault $cmd
 done
 
@@ -165,3 +239,9 @@ complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
 complete -F _fzf_ssh_completion -o default -o bashdefault ssh
 complete -F _fzf_telnet_completion -o default -o bashdefault telnet
 
+# Environment variables / Aliases
+complete -F _fzf_env_var_completion -o default -o bashdefault unset
+complete -F _fzf_env_var_completion -o default -o bashdefault export
+complete -F _fzf_alias_completion -o default -o bashdefault unalias
+
+unset cmd d_cmds f_cmds a_cmds x_cmds

install

@@ -1,70 +1,153 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-cd `dirname $BASH_SOURCE`
-fzf_base=`pwd`
+version=0.9.0
 
-# ruby executable
-echo -n "Checking Ruby executable ... "
-ruby=`which ruby`
-if [ $? -ne 0 ]; then
-  echo "ruby executable not found!"
-  exit 1
-fi
+cd $(dirname $BASH_SOURCE)
+fzf_base=$(pwd)
 
-# System ruby is preferred
-system_ruby=/usr/bin/ruby
-if [ -x $system_ruby -a $system_ruby != "$ruby" ]; then
-  $system_ruby --disable-gems -rcurses -e0 2> /dev/null
-  [ $? -eq 0 ] && ruby=$system_ruby
-fi
+ask() {
+  read -p "$1 ([y]/n) " -n 1 -r
+  echo
+  [[ ! $REPLY =~ ^[Nn]$ ]]
+}
 
-echo "OK ($ruby)"
+check_binary() {
+  echo -n "  - Checking fzf executable ... "
+  local output=$("$fzf_base"/bin/fzf --version 2>&1)
+  if [ "$version" = "$output" ]; then
+    echo "$output"
+  else
+    echo "$output != $version"
+    rm -f "$fzf_base"/bin/fzf
+    binary_error="Invalid binary"
+    return 1
+  fi
+}
 
-# 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 ... "
-  /usr/bin/env gem install curses -v 1.0.0 --user-install
+symlink() {
+  echo "  - Creating symlink: bin/$1 -> bin/fzf"
+  (cd "$fzf_base"/bin &&
+   rm -f fzf
+   ln -sf $1 fzf)
+}
+
+download() {
+  echo "Downloading bin/fzf ..."
+  if [ -x "$fzf_base"/bin/fzf ]; then
+    echo "  - Already exists"
+    check_binary && return
+  elif [ -x "$fzf_base"/bin/$1 ]; then
+    symlink $1
+    check_binary && return
+  fi
+  mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
   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
+    binary_error="Failed to create bin directory"
+    return
+  fi
+
+  local url=https://github.com/junegunn/fzf-bin/releases/download/$version/${1}.tgz
+  if which curl > /dev/null; then
+    curl -fL $url | tar -xz
+  elif which wget > /dev/null; then
+    wget -O - $url | tar -xz
+  else
+    binary_error="curl or wget not found"
+    return
+  fi
+
+  if [ ! -f $1 ]; then
+    binary_error="Failed to download ${1}"
+    return
+  fi
+
+  chmod +x $1 && symlink $1 && check_binary
+}
+
+# Try to download binary executable
+archi=$(uname -sm)
+binary_available=1
+binary_error=""
+case "$archi" in
+  Darwin\ x86_64) download fzf-$version-darwin_amd64 ;;
+  Darwin\ i*86)   download fzf-$version-darwin_386   ;;
+  Linux\ x86_64)  download fzf-$version-linux_amd64  ;;
+  Linux\ i*86)    download fzf-$version-linux_386    ;;
+  *)              binary_available=0                 ;;
+esac
+
+cd "$fzf_base"
+if [ -n "$binary_error" ]; then
+  if [ $binary_available -eq 0 ]; then
+    echo "No prebuilt binary for $archi ... "
+  else
+    echo "  - $binary_error !!!"
+  fi
+  echo "Installing legacy Ruby version ..."
+
+  # ruby executable
+  echo -n "Checking Ruby executable ... "
+  ruby=`which ruby`
+  if [ $? -ne 0 ]; then
+    echo "ruby executable not found !!!"
     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
+  # System ruby is preferred
+  system_ruby=/usr/bin/ruby
+  if [ -x $system_ruby -a $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
-    fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
+    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
-else
-  echo "< 1.9"
-  fzf_cmd="$ruby $fzf_base/fzf"
 fi
 
 # Auto-completion
-read -p "Do you want to add auto-completion support? ([y]/n) " -n 1 -r
-echo
-[[ ! $REPLY =~ ^[Nn]$ ]]
+ask "Do you want to add auto-completion support?"
 auto_completion=$?
 
 # Key-bindings
-read -p "Do you want to add key bindings? ([y]/n) " -n 1 -r
-echo
-[[ ! $REPLY =~ ^[Nn]$ ]]
+ask "Do you want to add key bindings?"
 key_bindings=$?
 
 echo
@@ -77,7 +160,8 @@ for shell in bash zsh; do
     fzf_completion="# $fzf_completion"
   fi
 
-  cat > $src << EOF
+  if [ -n "$binary_error" ]; then
+    cat > $src << EOF
 # Setup fzf function
 # ------------------
 unalias fzf 2> /dev/null
@@ -91,6 +175,22 @@ export -f fzf > /dev/null
 $fzf_completion
 
 EOF
+  else
+    cat > $src << EOF
+# Setup fzf
+# ---------
+unalias fzf 2> /dev/null
+unset fzf 2> /dev/null
+if [[ ! "\$PATH" =~ "$fzf_base/bin" ]]; then
+  export PATH="$fzf_base/bin:\$PATH"
+fi
+
+# Auto-completion
+# ---------------
+$fzf_completion
+
+EOF
+  fi
 
   if [ $key_bindings -eq 0 ]; then
     if [ $shell = bash ]; then
@@ -98,7 +198,7 @@ EOF
 # Key bindings
 # ------------
 __fsel() {
-  find * -path '*/\.*' -prune \
+  command find * -path '*/\.*' -prune \
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | fzf -m | while read item; do
@@ -122,13 +222,13 @@ __fsel_tmux() {
 
 __fcd() {
   local dir
-  dir=$(find ${1:-*} -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf +m) && printf 'cd %q' "$dir"
+  dir=$(command find -L ${1:-*} -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf +m) && printf 'cd %q' "$dir"
 }
 
 __use_tmux=0
 [ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ] && __use_tmux=1
 
-if [ -z "$(set -o | grep '^vi.*on')" ]; then
+if [ -z "$(set -o | \grep '^vi.*on')" ]; then
   # Required to refresh the prompt after fzf
   bind '"\er": redraw-current-line'
 
@@ -140,7 +240,7 @@ if [ -z "$(set -o | grep '^vi.*on')" ]; then
   fi
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": " \C-e\C-u$(HISTTIMEFORMAT= history | fzf +s | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
+  bind '"\C-r": " \C-e\C-u$(HISTTIMEFORMAT= history | fzf +s +m -n2..,.. | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
 
   # ALT-C - cd into the selected directory
   bind '"\ec": " \C-e\C-u$(__fcd)\e\C-e\er\C-m"'
@@ -155,12 +255,15 @@ else
   else
     bind '"\C-t": "\e$a \eddi$(__fsel)\C-x\C-e\e0Px$a \C-x\C-r\exa "'
   fi
+  bind -m vi-command '"\C-t": "i\C-t"'
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": "\eddi$(HISTTIMEFORMAT= history | fzf +s | sed \"s/ *[0-9]* *//\")\C-x\C-e\e$a\C-x\C-r"'
+  bind '"\C-r": "\eddi$(HISTTIMEFORMAT= history | fzf +s +m -n2..,.. | sed \"s/ *[0-9]* *//\")\C-x\C-e\e$a\C-x\C-r"'
+  bind -m vi-command '"\C-r": "i\C-r"'
 
   # ALT-C - cd into the selected directory
   bind '"\ec": "\eddi$(__fcd)\C-x\C-e\C-x\C-r\C-m"'
+  bind -m vi-command '"\ec": "i\ec"'
 fi
 
 unset __use_tmux
@@ -174,7 +277,7 @@ EOFZF
 # CTRL-T - Paste the selected file path(s) into the command line
 __fsel() {
   set -o nonomatch
-  find * -path '*/\.*' -prune \
+  command find * -path '*/\.*' -prune \
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | fzf -m | while read item; do
@@ -198,7 +301,7 @@ if [ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ]; then
   }
 else
   fzf-file-widget() {
-    LBUFFER="${LBUFFER%% #}$(__fsel)"
+    LBUFFER="${LBUFFER}$(__fsel)"
     zle redisplay
   }
 fi
@@ -207,7 +310,7 @@ bindkey '^T' fzf-file-widget
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  cd "${$(set -o nonomatch; find * -path '*/\.*' -prune \
+  cd "${$(set -o nonomatch; command find -L * -path '*/\.*' -prune \
           -o -type d -print 2> /dev/null | fzf):-.}"
   zle reset-prompt
 }
@@ -216,7 +319,7 @@ bindkey '\ec' fzf-cd-widget
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  LBUFFER=$(fc -l 1 | fzf +s | sed "s/ *[0-9]* *//")
+  LBUFFER=$(fc -l 1 | fzf +s +m -n2..,.. | sed "s/ *[0-9*]* *//")
   zle redisplay
 }
 zle     -N   fzf-history-widget
@@ -236,57 +339,85 @@ if [ -n "$(which fish)" ]; then
   has_fish=1
   echo -n "Generate ~/.config/fish/functions/fzf.fish ... "
   mkdir -p ~/.config/fish/functions
-  cat > ~/.config/fish/functions/fzf.fish << EOFZF
+  if [ -n "$binary_error" ]; then
+    cat > ~/.config/fish/functions/fzf.fish << EOFZF
 function fzf
   $fzf_cmd \$argv
 end
 EOFZF
-  echo "ok"
+  else
+    cat > ~/.config/fish/functions/fzf.fish << EOFZF
+function fzf
+  $fzf_base/bin/fzf \$argv
+end
+EOFZF
+  fi
+  echo "OK"
 
   if [ $key_bindings -eq 0 ]; then
     echo -n "Generate ~/.config/fish/functions/fzf_key_bindings.fish ... "
     cat > ~/.config/fish/functions/fzf_key_bindings.fish << "EOFZF"
 function fzf_key_bindings
-  function __fzf_select
-    find * -path '*/\.*' -prune \
+  # Due to a bug of fish, we cannot use command substitution,
+  # so we use temporary file instead
+  if [ -z "$TMPDIR" ]
+    set -g TMPDIR /tmp
+  end
+
+  function __fzf_list
+    command find * -path '*/\.*' -prune \
       -o -type f -print \
       -o -type d -print \
-      -o -type l -print 2> /dev/null | fzf -m | while read item
-      echo -n (echo -n "$item" | sed 's/ /\\\\ /g')' '
+      -o -type l -print 2> /dev/null
+  end
+
+  function __fzf_list_dir
+    command find -L * -path '*/\.*' -prune -o -type d -print 2> /dev/null
+  end
+
+  function __fzf_escape
+    while read item
+      echo -n (echo -n "$item" | sed -E 's/([ "$~'\''([{<>})])/\\\\\\1/g')' '
     end
-    echo
   end
 
   function __fzf_ctrl_t
     if [ -n "$TMUX_PANE" -a "$FZF_TMUX" != "0" ]
       tmux split-window (__fzf_tmux_height) "fish -c 'fzf_key_bindings; __fzf_ctrl_t_tmux \\$TMUX_PANE'"
     else
-      __fzf_select > $TMPDIR/fzf.result
-      and commandline -i (cat $TMPDIR/fzf.result)
+      __fzf_list | fzf -m > $TMPDIR/fzf.result
+      and commandline -i (cat $TMPDIR/fzf.result | __fzf_escape)
+      commandline -f repaint
       rm -f $TMPDIR/fzf.result
     end
   end
 
   function __fzf_ctrl_t_tmux
-    __fzf_select > $TMPDIR/fzf.result
-    and tmux send-keys -t $argv[1] (cat $TMPDIR/fzf.result)
+    __fzf_list | fzf -m > $TMPDIR/fzf.result
+    and tmux send-keys -t $argv[1] (cat $TMPDIR/fzf.result | __fzf_escape)
     rm -f $TMPDIR/fzf.result
   end
 
-  function __fzf_ctrl_r
-    if history | fzf +s +m > $TMPDIR/fzf.result
-      commandline (cat $TMPDIR/fzf.result)
+  function __fzf_reverse
+    if which tac > /dev/null
+      tac $argv
     else
-      commandline -f repaint
+      tail -r $argv
     end
+  end
+
+  function __fzf_ctrl_r
+    history | __fzf_reverse | fzf +s +m > $TMPDIR/fzf.result
+    and commandline (cat $TMPDIR/fzf.result)
+    commandline -f repaint
     rm -f $TMPDIR/fzf.result
   end
 
   function __fzf_alt_c
-    find * -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf +m > $TMPDIR/fzf.result
-    if [ (cat $TMPDIR/fzf.result | wc -l) -gt 0 ]
-      cd (cat $TMPDIR/fzf.result)
-    end
+    # Fish hangs if the command before pipe redirects (2> /dev/null)
+    __fzf_list_dir | fzf +m > $TMPDIR/fzf.result
+    [ (cat $TMPDIR/fzf.result | wc -l) -gt 0 ]
+    and cd (cat $TMPDIR/fzf.result)
     commandline -f repaint
     rm -f $TMPDIR/fzf.result
   end
@@ -297,7 +428,7 @@ function fzf_key_bindings
     else
       set height 40%
     end
-    if echo $height | grep -q -E '%$'
+    if echo $height | \grep -q -E '%$'
       echo "-p "(echo $height | sed 's/%$//')
     else
       echo "-l $height"
@@ -310,7 +441,7 @@ function fzf_key_bindings
   bind \ec '__fzf_alt_c'
 end
 EOFZF
-    echo "ok"
+    echo "OK"
   fi
 fi
 
@@ -318,24 +449,34 @@ append_line() {
   echo "Update $2:"
   echo "  - $1"
   [ -f "$2" ] || touch "$2"
-  line=$(grep -nF "$1" "$2" | sed 's/:.*//')
+  if [ $# -lt 3 ]; then
+    line=$(\grep -nF "$1" "$2" | sed 's/:.*//' | tr '\n' ' ')
+  else
+    line=$(\grep -nF "$3" "$2" | sed 's/:.*//' | tr '\n' ' ')
+  fi
   if [ -n "$line" ]; then
-    echo "    - Already exists (line #$line)"
+    echo "    - Already exists: line #$line"
   else
     echo "$1" >> "$2"
-    echo "    - Added"
+    echo "    + Added"
   fi
   echo
 }
 
 echo
 for shell in bash zsh; do
-  append_line "source ~/.fzf.${shell}" ~/.${shell}rc
+  append_line "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" ~/.${shell}rc "~/.fzf.${shell}"
 done
 
 if [ $key_bindings -eq 0 -a $has_fish -eq 1 ]; then
   bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
   append_line "fzf_key_bindings" "$bind_file"
+
+  echo '  * Due to a known bug of fish, you may have issues running fzf on fish.'
+  echo '  * If that happens, try the following:'
+  echo '    - Remove ~/.config/fish/functions/fzf.fish'
+  echo '    - Place fzf executable in a directory included in $PATH'
+  echo
 fi
 
 cat << EOF
@@ -345,7 +486,7 @@ Finished. Restart your shell or reload config file.
 EOF
 [ $has_fish -eq 1 ] && echo "   fzf_key_bindings  # fish"; cat << EOF
 
-To uninstall fzf, simply remove the added lines.
+Use uninstall script to remove fzf.
 
 For more information, see: https://github.com/junegunn/fzf
 EOF

plugin/fzf.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2014 Junegunn Choi
+" Copyright (c) 2015 Junegunn Choi
 "
 " MIT License
 "
@@ -24,24 +24,36 @@
 let s:min_tmux_width  = 10
 let s:min_tmux_height = 3
 let s:default_tmux_height = '40%'
+let s:launcher = 'xterm -e bash -ic %s'
+let s:fzf_go = expand('<sfile>:h:h').'/bin/fzf'
+let s:fzf_rb = expand('<sfile>:h:h').'/fzf'
 
 let s:cpo_save = &cpo
 set cpo&vim
 
-call system('type fzf')
-if v:shell_error
-  let s:fzf_rb = expand('<sfile>:h:h').'/fzf'
-  if executable(s:fzf_rb)
-    let s:exec = s:fzf_rb
+function! s:fzf_exec()
+  if !exists('s:exec')
+    call system('type fzf')
+    if v:shell_error
+      let s:exec = executable(s:fzf_go) ?
+            \ s:fzf_go : (executable(s:fzf_rb) ? s:fzf_rb : '')
+    else
+      let s:exec = 'fzf'
+    endif
+    return s:fzf_exec()
+  elseif empty(s:exec)
+    unlet s:exec
+    throw 'fzf executable not found'
   else
-    echoerr 'fzf executable not found'
-    finish
+    return s:exec
   endif
-else
-  let s:exec = 'fzf'
-endif
+endfunction
 
 function! s:tmux_enabled()
+  if has('gui_running')
+    return 0
+  endif
+
   if exists('s:tmux')
     return s:tmux
   endif
@@ -63,14 +75,14 @@ function! s:escape(path)
 endfunction
 
 function! fzf#run(...) abort
-  if has('gui_running')
-    echohl Error
-    echo 'GVim is not supported'
-    return []
-  endif
   let dict   = exists('a:1') ? a:1 : {}
   let temps  = { 'result': tempname() }
   let optstr = get(dict, 'options', '')
+  try
+    let fzf_exec = s:fzf_exec()
+  catch
+    throw v:exception
+  endtry
 
   if has_key(dict, 'source')
     let source = dict.source
@@ -87,7 +99,7 @@ function! fzf#run(...) abort
   else
     let prefix = ''
   endif
-  let command = prefix.s:exec.' '.optstr.' > '.temps.result
+  let command = prefix.fzf_exec.' '.optstr.' > '.temps.result
 
   if s:tmux_enabled() && s:tmux_splittable(dict)
     return s:execute_tmux(dict, command, temps)
@@ -103,7 +115,7 @@ function! s:tmux_splittable(dict)
 endfunction
 
 function! s:pushd(dict)
-  if has_key(a:dict, 'dir')
+  if !empty(get(a:dict, 'dir', ''))
     let a:dict.prev_dir = getcwd()
     execute 'chdir '.s:escape(a:dict.dir)
   endif
@@ -118,20 +130,38 @@ endfunction
 function! s:execute(dict, command, temps)
   call s:pushd(a:dict)
   silent !clear
-  execute 'silent !'.a:command
+  if has('gui_running')
+    let launcher = get(a:dict, 'launcher', get(g:, 'fzf_launcher', s:launcher))
+    let command = printf(launcher, "'".substitute(a:command, "'", "'\"'\"'", 'g')."'")
+  else
+    let command = a:command
+  endif
+  execute 'silent !'.command
   redraw!
   if v:shell_error
+    " Do not print error message on exit status 1
+    if v:shell_error > 1
+      echohl ErrorMsg
+      echo 'Error running ' . command
+    endif
     return []
   else
     return s:callback(a:dict, a:temps, 0)
   endif
 endfunction
 
-function! s:execute_tmux(dict, command, temps)
-  if has_key(a:dict, 'dir')
-    let command = 'cd '.s:escape(a:dict.dir).' && '.a:command
+function! s:env_var(name)
+  if exists('$'.a:name)
+    return a:name . "='". substitute(expand('$'.a:name), "'", "'\\\\''", 'g') . "' "
   else
-    let command = a:command
+    return ''
+  endif
+endfunction
+
+function! s:execute_tmux(dict, command, temps)
+  let command = s:env_var('FZF_DEFAULT_OPTS').s:env_var('FZF_DEFAULT_COMMAND').a:command
+  if !empty(get(a:dict, 'dir', ''))
+    let command = 'cd '.s:escape(a:dict.dir).' && '.command
   endif
 
   let splitopt = '-v'

src/Dockerfile.arch

@@ -0,0 +1,27 @@
+FROM base/archlinux:2014.07.03
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# apt-get
+RUN pacman-db-upgrade && pacman -Syu --noconfirm base-devel git
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4
+
+ENV GOPATH /go
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+# For i386 build
+RUN echo '[multilib]' >> /etc/pacman.conf && \
+    echo 'Include = /etc/pacman.d/mirrorlist' >> /etc/pacman.conf && \
+    pacman-db-upgrade && yes | pacman -Sy gcc-multilib lib32-ncurses && \
+    cd $GOROOT/src && GOARCH=386 ./make.bash
+
+# Volume
+VOLUME /go
+
+# Default CMD
+CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+

src/Dockerfile.centos

@@ -0,0 +1,21 @@
+FROM centos:centos7
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# yum
+RUN yum install -y git gcc make tar ncurses-devel
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4
+
+ENV GOPATH /go
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+# Volume
+VOLUME /go
+
+# Default CMD
+CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+

src/Dockerfile.ubuntu

@@ -0,0 +1,26 @@
+FROM ubuntu:14.04
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# apt-get
+RUN apt-get update && apt-get -y upgrade && \
+    apt-get install -y --force-yes git curl build-essential libncurses-dev
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4
+
+ENV GOPATH /go
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+# For i386 build
+RUN apt-get install -y lib32ncurses5-dev && \
+    cd $GOROOT/src && GOARCH=386 ./make.bash
+
+# Volume
+VOLUME /go
+
+# Default CMD
+CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+

src/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Junegunn Choi
+
+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.

src/Makefile

@@ -0,0 +1,89 @@
+ifndef GOPATH
+$(error GOPATH is undefined)
+endif
+
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+	GOOS := darwin
+else ifeq ($(UNAME_S),Linux)
+	GOOS := linux
+endif
+
+ifneq ($(shell uname -m),x86_64)
+$(error "Build on $(UNAME_M) is not supported, yet.")
+endif
+
+SOURCES   := $(wildcard *.go */*.go)
+BINDIR    := ../bin
+
+BINARY32  := fzf-$(GOOS)_386
+BINARY64  := fzf-$(GOOS)_amd64
+VERSION    = $(shell fzf/$(BINARY64) --version)
+RELEASE32  = fzf-$(VERSION)-$(GOOS)_386
+RELEASE64  = fzf-$(VERSION)-$(GOOS)_amd64
+BREW       = fzf-$(VERSION)-homebrew.tgz
+
+all: test release
+
+brew: ../$(BREW)
+
+../$(BREW): release
+ifneq ($(UNAME_S),Darwin)
+$(error brew package must be built on OS X)
+endif
+	mkdir -p ../bin && \
+	cp fzf/$(RELEASE64) fzf/$(RELEASE32) ../bin && \
+	cd .. && ln -sf . fzf-$(VERSION) && \
+	tar -cvzf $(BREW) \
+		fzf-$(VERSION)/{{,un}install,fzf-completion.{ba,z}sh,LICENSE} \
+		fzf-$(VERSION)/{plugin/fzf.vim,bin/{$(RELEASE64),$(RELEASE32)}} && \
+	rm fzf-$(VERSION) && \
+	openssl sha1 $(notdir $@)
+
+release: build
+	cd fzf && \
+	cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32) && \
+	cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64)
+
+build: fzf/$(BINARY32) fzf/$(BINARY64)
+
+test:
+	go get
+	go test -v ./...
+
+install: $(BINDIR)/fzf
+
+uninstall:
+	rm -f $(BINDIR)/fzf $(BINDIR)/$(BINARY64)
+
+clean:
+	cd fzf && rm -f $(BINARY32) $(BINARY64) $(RELEASE32).tgz $(RELEASE64).tgz
+
+fzf/$(BINARY32): $(SOURCES)
+	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -o $(BINARY32)
+
+fzf/$(BINARY64): $(SOURCES)
+	cd fzf && go build -o $(BINARY64)
+
+$(BINDIR)/fzf: fzf/$(BINARY64) | $(BINDIR)
+	cp -f fzf/$(BINARY64) $(BINDIR)
+	cd $(BINDIR) && ln -sf $(BINARY64) fzf
+
+$(BINDIR):
+	mkdir -p $@
+
+# Linux distribution to build fzf on
+DISTRO := arch
+
+docker:
+	docker build -t junegunn/$(DISTRO)-sandbox - < Dockerfile.$(DISTRO)
+
+linux: docker
+	docker run -i -t -v $(GOPATH):/go junegunn/$(DISTRO)-sandbox \
+		/bin/bash -ci 'cd /go/src/github.com/junegunn/fzf/src; make'
+
+$(DISTRO): docker
+	docker run -i -t -v $(GOPATH):/go junegunn/$(DISTRO)-sandbox \
+		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
+
+.PHONY: all brew build release test install uninstall clean docker linux $(DISTRO)

src/README.md

@@ -0,0 +1,118 @@
+fzf in Go
+=========
+
+This directory contains the source code for the new fzf implementation in
+[Go][go].
+
+Upgrade from Ruby version
+-------------------------
+
+The install script has been updated to download the right binary for your
+system. If you already have installed fzf, simply git-pull the repository and
+rerun the install script.
+
+```sh
+cd ~/.fzf
+git pull
+./install
+```
+
+Motivations
+-----------
+
+### No Ruby dependency
+
+There have always been complaints about fzf being a Ruby script. To make
+matters worse, Ruby 2.1 removed ncurses binding from its standard libary.
+Because of the change, users running Ruby 2.1 or above are forced to build C
+extensions of curses gem to meet the requirement of fzf. The new Go version
+will be distributed as an executable binary so it will be much more accessible
+and should be easier to setup.
+
+### Performance
+
+Many people have been surprised to see how fast fzf is even when it was
+written in Ruby. It stays quite responsive even for 100k+ lines, which is
+well above the size of the usual input.
+
+The new Go version, of course, is significantly faster than that. It has all
+the performance optimization techniques used in Ruby implementation and more.
+It also doesn't suffer from [GIL][gil], so the search performance scales
+proportional to the number of CPU cores. On my MacBook Pro (Mid 2012), the new
+version was shown to be an order of magnitude faster on certain cases. It also
+starts much faster though the difference may not be noticeable.
+
+Differences with Ruby version
+-----------------------------
+
+The Go version is designed to be perfectly compatible with the previous Ruby
+version. The only behavioral difference is that the new version ignores the
+numeric argument to `--sort=N` option and always sorts the result regardless
+of the number of matches. The value was introduced to limit the response time
+of the query, but the Go version is blazingly fast (almost instant response
+even for 1M+ items) so I decided that it's no longer required.
+
+System requirements
+-------------------
+
+Currently, prebuilt binaries are provided only for OS X and Linux. The install
+script will fall back to the legacy Ruby version on the other systems, but if
+you have Go 1.4 installed, you can try building it yourself.
+
+However, as pointed out in [golang.org/doc/install][req], the Go version may
+not run on CentOS/RHEL 5.x, and if that's the case, the install script will
+choose the Ruby version instead.
+
+The Go version depends on [ncurses][ncurses] and some Unix system calls, so it
+shouldn't run natively on Windows at the moment. But it won't be impossible to
+support Windows by falling back to a cross-platform alternative such as
+[termbox][termbox] only on Windows. If you're interested in making fzf work on
+Windows, please let me know.
+
+Build
+-----
+
+```sh
+# Build fzf executables and tarballs
+make
+
+# Install the executable to ../bin directory
+make install
+
+# Build executables and tarballs for Linux using Docker
+make linux
+
+# Build tarball for Homebrew release
+make brew
+```
+
+Contribution
+------------
+
+For the time being, I will not add or accept any new features until we can be
+sure that the implementation is stable and we have a sufficient number of test
+cases. However, fixes for obvious bugs and new test cases are welcome.
+
+I also care much about the performance of the implementation, so please make
+sure that your change does not result in performance regression. And please be
+noted that we don't have a quantitative measure of the performance yet.
+
+Third-party libraries used
+--------------------------
+
+- [ncurses][ncurses]
+- [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
+    - Licensed under [MIT](http://mattn.mit-license.org/2013)
+- [mattn/go-shellwords](https://github.com/mattn/go-shellwords)
+    - Licensed under [MIT](http://mattn.mit-license.org/2014)
+
+License
+-------
+
+[MIT](LICENSE)
+
+[go]:      https://golang.org/
+[gil]:     http://en.wikipedia.org/wiki/Global_Interpreter_Lock
+[ncurses]: https://www.gnu.org/software/ncurses/
+[req]:     http://golang.org/doc/install
+[termbox]: https://github.com/nsf/termbox-go

src/algo/algo.go

@@ -0,0 +1,155 @@
+package algo
+
+import "strings"
+
+/*
+ * String matching algorithms here do not use strings.ToLower to avoid
+ * performance penalty. And they assume pattern runes are given in lowercase
+ * letters when caseSensitive is false.
+ *
+ * In short: They try to do as little work as possible.
+ */
+
+// FuzzyMatch performs fuzzy-match
+func FuzzyMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(*input)
+
+	// 0. (FIXME) How to find the shortest match?
+	//    a_____b__c__abc
+	//    ^^^^^^^^^^  ^^^
+	// 1. forward scan (abc)
+	//   *-----*-----*>
+	//   a_____b___abc__
+	// 2. reverse scan (cba)
+	//   a_____b___abc__
+	//            <***
+	pidx := 0
+	sidx := -1
+	eidx := -1
+
+	for index, char := range runes {
+		// This is considerably faster than blindly applying strings.ToLower to the
+		// whole string
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if char == pattern[pidx] {
+			if sidx < 0 {
+				sidx = index
+			}
+			if pidx++; pidx == len(pattern) {
+				eidx = index + 1
+				break
+			}
+		}
+	}
+
+	if sidx >= 0 && eidx >= 0 {
+		pidx--
+		for index := eidx - 1; index >= sidx; index-- {
+			char := runes[index]
+			if !caseSensitive && char >= 65 && char <= 90 {
+				char += 32
+			}
+			if char == pattern[pidx] {
+				if pidx--; pidx < 0 {
+					sidx = index
+					break
+				}
+			}
+		}
+		return sidx, eidx
+	}
+	return -1, -1
+}
+
+// ExactMatchStrings performs exact-match using strings package.
+// Currently not used.
+func ExactMatchStrings(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	var str string
+	if caseSensitive {
+		str = *input
+	} else {
+		str = strings.ToLower(*input)
+	}
+
+	if idx := strings.Index(str, string(pattern)); idx >= 0 {
+		prefixRuneLen := len([]rune((*input)[:idx]))
+		return prefixRuneLen, prefixRuneLen + len(pattern)
+	}
+	return -1, -1
+}
+
+// ExactMatchNaive is a basic string searching algorithm that handles case
+// sensitivity. Although naive, it still performs better than the combination
+// of strings.ToLower + strings.Index for typical fzf use cases where input
+// strings and patterns are not very long.
+//
+// We might try to implement better algorithms in the future:
+// http://en.wikipedia.org/wiki/String_searching_algorithm
+func ExactMatchNaive(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(*input)
+	numRunes := len(runes)
+	plen := len(pattern)
+	if numRunes < plen {
+		return -1, -1
+	}
+
+	pidx := 0
+	for index := 0; index < numRunes; index++ {
+		char := runes[index]
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if pattern[pidx] == char {
+			pidx++
+			if pidx == plen {
+				return index - plen + 1, index + 1
+			}
+		} else {
+			index -= pidx
+			pidx = 0
+		}
+	}
+	return -1, -1
+}
+
+// PrefixMatch performs prefix-match
+func PrefixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(*input)
+	if len(runes) < len(pattern) {
+		return -1, -1
+	}
+
+	for index, r := range pattern {
+		char := runes[index]
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if char != r {
+			return -1, -1
+		}
+	}
+	return 0, len(pattern)
+}
+
+// SuffixMatch performs suffix-match
+func SuffixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(strings.TrimRight(*input, " "))
+	trimmedLen := len(runes)
+	diff := trimmedLen - len(pattern)
+	if diff < 0 {
+		return -1, -1
+	}
+
+	for index, r := range pattern {
+		char := runes[index+diff]
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if char != r {
+			return -1, -1
+		}
+	}
+	return trimmedLen - len(pattern), trimmedLen
+}

src/algo/algo_test.go

@@ -0,0 +1,44 @@
+package algo
+
+import (
+	"strings"
+	"testing"
+)
+
+func assertMatch(t *testing.T, fun func(bool, *string, []rune) (int, int), caseSensitive bool, input string, pattern string, sidx int, eidx int) {
+	if !caseSensitive {
+		pattern = strings.ToLower(pattern)
+	}
+	s, e := fun(caseSensitive, &input, []rune(pattern))
+	if s != sidx {
+		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", s, sidx, input, pattern)
+	}
+	if e != eidx {
+		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", e, eidx, input, pattern)
+	}
+}
+
+func TestFuzzyMatch(t *testing.T) {
+	assertMatch(t, FuzzyMatch, false, "fooBarbaz", "oBZ", 2, 9)
+	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "oBZ", -1, -1)
+	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "oBz", 2, 9)
+	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "fooBarbazz", -1, -1)
+}
+
+func TestExactMatchNaive(t *testing.T) {
+	assertMatch(t, ExactMatchNaive, false, "fooBarbaz", "oBA", 2, 5)
+	assertMatch(t, ExactMatchNaive, true, "fooBarbaz", "oBA", -1, -1)
+	assertMatch(t, ExactMatchNaive, true, "fooBarbaz", "fooBarbazz", -1, -1)
+}
+
+func TestPrefixMatch(t *testing.T) {
+	assertMatch(t, PrefixMatch, false, "fooBarbaz", "Foo", 0, 3)
+	assertMatch(t, PrefixMatch, true, "fooBarbaz", "Foo", -1, -1)
+	assertMatch(t, PrefixMatch, false, "fooBarbaz", "baz", -1, -1)
+}
+
+func TestSuffixMatch(t *testing.T) {
+	assertMatch(t, SuffixMatch, false, "fooBarbaz", "Foo", -1, -1)
+	assertMatch(t, SuffixMatch, false, "fooBarbaz", "baz", 6, 9)
+	assertMatch(t, SuffixMatch, true, "fooBarbaz", "Baz", -1, -1)
+}

src/cache.go

@@ -0,0 +1,53 @@
+package fzf
+
+import "sync"
+
+// QueryCache associates strings to lists of items
+type QueryCache map[string][]*Item
+
+// ChunkCache associates Chunk and query string to lists of items
+type ChunkCache struct {
+	mutex sync.Mutex
+	cache map[*Chunk]*QueryCache
+}
+
+// NewChunkCache returns a new ChunkCache
+func NewChunkCache() ChunkCache {
+	return ChunkCache{sync.Mutex{}, make(map[*Chunk]*QueryCache)}
+}
+
+// Add adds the list to the cache
+func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Item) {
+	if len(key) == 0 || !chunk.IsFull() {
+		return
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if !ok {
+		cc.cache[chunk] = &QueryCache{}
+		qc = cc.cache[chunk]
+	}
+	(*qc)[key] = list
+}
+
+// Find is called to lookup ChunkCache
+func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Item, bool) {
+	if len(key) == 0 || !chunk.IsFull() {
+		return nil, false
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if ok {
+		list, ok := (*qc)[key]
+		if ok {
+			return list, true
+		}
+	}
+	return nil, false
+}

src/cache_test.go

@@ -0,0 +1,40 @@
+package fzf
+
+import "testing"
+
+func TestChunkCache(t *testing.T) {
+	cache := NewChunkCache()
+	chunk2 := make(Chunk, ChunkSize)
+	chunk1p := &Chunk{}
+	chunk2p := &chunk2
+	items1 := []*Item{&Item{}}
+	items2 := []*Item{&Item{}, &Item{}}
+	cache.Add(chunk1p, "foo", items1)
+	cache.Add(chunk2p, "foo", items1)
+	cache.Add(chunk2p, "bar", items2)
+
+	{ // chunk1 is not full
+		cached, found := cache.Find(chunk1p, "foo")
+		if found {
+			t.Error("Cached disabled for non-empty chunks", found, cached)
+		}
+	}
+	{
+		cached, found := cache.Find(chunk2p, "foo")
+		if !found || len(cached) != 1 {
+			t.Error("Expected 1 item cached", found, cached)
+		}
+	}
+	{
+		cached, found := cache.Find(chunk2p, "bar")
+		if !found || len(cached) != 2 {
+			t.Error("Expected 2 items cached", found, cached)
+		}
+	}
+	{
+		cached, found := cache.Find(chunk1p, "foobar")
+		if found {
+			t.Error("Expected 0 item cached", found, cached)
+		}
+	}
+}

src/chunklist.go

@@ -0,0 +1,88 @@
+package fzf
+
+import "sync"
+
+// Capacity of each chunk
+const ChunkSize int = 100
+
+// Chunk is a list of Item pointers whose size has the upper limit of ChunkSize
+type Chunk []*Item // >>> []Item
+
+// ItemBuilder is a closure type that builds Item object from a pointer to a
+// string and an integer
+type ItemBuilder func(*string, int) *Item
+
+// ChunkList is a list of Chunks
+type ChunkList struct {
+	chunks []*Chunk
+	count  int
+	mutex  sync.Mutex
+	trans  ItemBuilder
+}
+
+// NewChunkList returns a new ChunkList
+func NewChunkList(trans ItemBuilder) *ChunkList {
+	return &ChunkList{
+		chunks: []*Chunk{},
+		count:  0,
+		mutex:  sync.Mutex{},
+		trans:  trans}
+}
+
+func (c *Chunk) push(trans ItemBuilder, data *string, index int) {
+	*c = append(*c, trans(data, index))
+}
+
+// IsFull returns true if the Chunk is full
+func (c *Chunk) IsFull() bool {
+	return len(*c) == ChunkSize
+}
+
+func (cl *ChunkList) lastChunk() *Chunk {
+	return cl.chunks[len(cl.chunks)-1]
+}
+
+// CountItems returns the total number of Items
+func CountItems(cs []*Chunk) int {
+	if len(cs) == 0 {
+		return 0
+	}
+	return ChunkSize*(len(cs)-1) + len(*(cs[len(cs)-1]))
+}
+
+// Push adds the item to the list
+func (cl *ChunkList) Push(data string) {
+	cl.mutex.Lock()
+	defer cl.mutex.Unlock()
+
+	if len(cl.chunks) == 0 || cl.lastChunk().IsFull() {
+		newChunk := Chunk(make([]*Item, 0, ChunkSize))
+		cl.chunks = append(cl.chunks, &newChunk)
+	}
+
+	cl.lastChunk().push(cl.trans, &data, cl.count)
+	cl.count++
+}
+
+// Snapshot returns immutable snapshot of the ChunkList
+func (cl *ChunkList) Snapshot() ([]*Chunk, int) {
+	cl.mutex.Lock()
+	defer cl.mutex.Unlock()
+
+	ret := make([]*Chunk, len(cl.chunks))
+	copy(ret, cl.chunks)
+
+	// Duplicate the last chunk
+	if cnt := len(ret); cnt > 0 {
+		ret[cnt-1] = ret[cnt-1].dupe()
+	}
+	return ret, cl.count
+}
+
+func (c *Chunk) dupe() *Chunk {
+	newChunk := make(Chunk, len(*c))
+	for idx, ptr := range *c {
+		newChunk[idx] = ptr
+	}
+	return &newChunk
+}

src/chunklist_test.go

@@ -0,0 +1,74 @@
+package fzf
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestChunkList(t *testing.T) {
+	cl := NewChunkList(func(s *string, i int) *Item {
+		return &Item{text: s, rank: Rank{0, 0, uint32(i * 2)}}
+	})
+
+	// Snapshot
+	snapshot, count := cl.Snapshot()
+	if len(snapshot) > 0 || count > 0 {
+		t.Error("Snapshot should be empty now")
+	}
+
+	// Add some data
+	cl.Push("hello")
+	cl.Push("world")
+
+	// Previously created snapshot should remain the same
+	if len(snapshot) > 0 {
+		t.Error("Snapshot should not have changed")
+	}
+
+	// But the new snapshot should contain the added items
+	snapshot, count = cl.Snapshot()
+	if len(snapshot) != 1 && count != 2 {
+		t.Error("Snapshot should not be empty now")
+	}
+
+	// Check the content of the ChunkList
+	chunk1 := snapshot[0]
+	if len(*chunk1) != 2 {
+		t.Error("Snapshot should contain only two items")
+	}
+	if *(*chunk1)[0].text != "hello" || (*chunk1)[0].rank.index != 0 ||
+		*(*chunk1)[1].text != "world" || (*chunk1)[1].rank.index != 2 {
+		t.Error("Invalid data")
+	}
+	if chunk1.IsFull() {
+		t.Error("Chunk should not have been marked full yet")
+	}
+
+	// Add more data
+	for i := 0; i < ChunkSize*2; i++ {
+		cl.Push(fmt.Sprintf("item %d", i))
+	}
+
+	// Previous snapshot should remain the same
+	if len(snapshot) != 1 {
+		t.Error("Snapshot should stay the same")
+	}
+
+	// New snapshot
+	snapshot, count = cl.Snapshot()
+	if len(snapshot) != 3 || !snapshot[0].IsFull() ||
+		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != ChunkSize*2+2 {
+		t.Error("Expected two full chunks and one more chunk")
+	}
+	if len(*snapshot[2]) != 2 {
+		t.Error("Unexpected number of items")
+	}
+
+	cl.Push("hello")
+	cl.Push("world")
+
+	lastChunkCount := len(*snapshot[len(snapshot)-1])
+	if lastChunkCount != 2 {
+		t.Error("Unexpected number of items:", lastChunkCount)
+	}
+}

src/constants.go

@@ -0,0 +1,18 @@
+package fzf
+
+import (
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Current version
+const Version = "0.9.0"
+
+// fzf events
+const (
+	EvtReadNew util.EventType = iota
+	EvtReadFin
+	EvtSearchNew
+	EvtSearchProgress
+	EvtSearchFin
+	EvtClose
+)

src/core.go

@@ -0,0 +1,196 @@
+/*
+Package fzf implements fzf, a command-line fuzzy finder.
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Junegunn Choi
+
+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.
+*/
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const coordinatorDelayMax time.Duration = 100 * time.Millisecond
+const coordinatorDelayStep time.Duration = 10 * time.Millisecond
+
+func initProcs() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+}
+
+/*
+Reader   -> EvtReadFin
+Reader   -> EvtReadNew        -> Matcher  (restart)
+Terminal -> EvtSearchNew      -> Matcher  (restart)
+Matcher  -> EvtSearchProgress -> Terminal (update info)
+Matcher  -> EvtSearchFin      -> Terminal (update list)
+*/
+
+// Run starts fzf
+func Run(options *Options) {
+	initProcs()
+
+	opts := ParseOptions()
+
+	if opts.Version {
+		fmt.Println(Version)
+		os.Exit(0)
+	}
+
+	// Event channel
+	eventBox := util.NewEventBox()
+
+	// Chunk list
+	var chunkList *ChunkList
+	if len(opts.WithNth) == 0 {
+		chunkList = NewChunkList(func(data *string, index int) *Item {
+			return &Item{
+				text:  data,
+				index: uint32(index),
+				rank:  Rank{0, 0, uint32(index)}}
+		})
+	} else {
+		chunkList = NewChunkList(func(data *string, index int) *Item {
+			tokens := Tokenize(data, opts.Delimiter)
+			item := Item{
+				text:     Transform(tokens, opts.WithNth).whole,
+				origText: data,
+				index:    uint32(index),
+				rank:     Rank{0, 0, uint32(index)}}
+			return &item
+		})
+	}
+
+	// Reader
+	reader := Reader{func(str string) { chunkList.Push(str) }, eventBox}
+	go reader.ReadSource()
+
+	// Matcher
+	patternBuilder := func(runes []rune) *Pattern {
+		return BuildPattern(
+			opts.Mode, opts.Case, opts.Nth, opts.Delimiter, runes)
+	}
+	matcher := NewMatcher(patternBuilder, opts.Sort > 0, eventBox)
+
+	// Defered-interactive / Non-interactive
+	//   --select-1 | --exit-0 | --filter
+	if filtering := opts.Filter != nil; filtering || opts.Select1 || opts.Exit0 {
+		limit := 0
+		var patternString string
+		if filtering {
+			patternString = *opts.Filter
+		} else {
+			if opts.Select1 || opts.Exit0 {
+				limit = 1
+			}
+			patternString = opts.Query
+		}
+		pattern := patternBuilder([]rune(patternString))
+
+		looping := true
+		eventBox.Unwatch(EvtReadNew)
+		for looping {
+			eventBox.Wait(func(events *util.Events) {
+				for evt := range *events {
+					switch evt {
+					case EvtReadFin:
+						looping = false
+						return
+					}
+				}
+			})
+		}
+
+		snapshot, _ := chunkList.Snapshot()
+		merger, cancelled := matcher.scan(MatchRequest{
+			chunks:  snapshot,
+			pattern: pattern}, limit)
+
+		if !cancelled && (filtering ||
+			opts.Exit0 && merger.Length() == 0 ||
+			opts.Select1 && merger.Length() == 1) {
+			if opts.PrintQuery {
+				fmt.Println(patternString)
+			}
+			for i := 0; i < merger.Length(); i++ {
+				fmt.Println(merger.Get(i).AsString())
+			}
+			os.Exit(0)
+		}
+	}
+
+	// Go interactive
+	go matcher.Loop()
+
+	// Terminal I/O
+	terminal := NewTerminal(opts, eventBox)
+	go terminal.Loop()
+
+	// Event coordination
+	reading := true
+	ticks := 0
+	eventBox.Watch(EvtReadNew)
+	for {
+		delay := true
+		ticks++
+		eventBox.Wait(func(events *util.Events) {
+			defer events.Clear()
+			for evt, value := range *events {
+				switch evt {
+
+				case EvtReadNew, EvtReadFin:
+					reading = reading && evt == EvtReadNew
+					snapshot, count := chunkList.Snapshot()
+					terminal.UpdateCount(count, !reading)
+					matcher.Reset(snapshot, terminal.Input(), false)
+
+				case EvtSearchNew:
+					snapshot, _ := chunkList.Snapshot()
+					matcher.Reset(snapshot, terminal.Input(), true)
+					delay = false
+
+				case EvtSearchProgress:
+					switch val := value.(type) {
+					case float32:
+						terminal.UpdateProgress(val)
+					}
+
+				case EvtSearchFin:
+					switch val := value.(type) {
+					case *Merger:
+						terminal.UpdateList(val)
+					}
+				}
+			}
+		})
+		if delay && reading {
+			dur := util.DurWithin(
+				time.Duration(ticks)*coordinatorDelayStep,
+				0, coordinatorDelayMax)
+			time.Sleep(dur)
+		}
+	}
+}

src/curses/curses.go

@@ -0,0 +1,426 @@
+package curses
+
+/*
+#include <ncurses.h>
+#include <locale.h>
+#cgo LDFLAGS: -lncurses
+void swapOutput() {
+  FILE* temp = stdout;
+  stdout = stderr;
+  stderr = temp;
+}
+*/
+import "C"
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+	"unicode/utf8"
+)
+
+// Types of user action
+const (
+	Rune = iota
+
+	CtrlA
+	CtrlB
+	CtrlC
+	CtrlD
+	CtrlE
+	CtrlF
+	CtrlG
+	CtrlH
+	Tab
+	CtrlJ
+	CtrlK
+	CtrlL
+	CtrlM
+	CtrlN
+	CtrlO
+	CtrlP
+	CtrlQ
+	CtrlR
+	CtrlS
+	CtrlT
+	CtrlU
+	CtrlV
+	CtrlW
+	CtrlX
+	CtrlY
+	CtrlZ
+	ESC
+
+	Invalid
+	Mouse
+
+	BTab
+
+	Del
+	PgUp
+	PgDn
+
+	AltB
+	AltF
+	AltD
+	AltBS
+)
+
+// Pallete
+const (
+	ColNormal = iota
+	ColPrompt
+	ColMatch
+	ColCurrent
+	ColCurrentMatch
+	ColSpinner
+	ColInfo
+	ColCursor
+	ColSelected
+)
+
+const (
+	doubleClickDuration = 500 * time.Millisecond
+)
+
+type Event struct {
+	Type       int
+	Char       rune
+	MouseEvent *MouseEvent
+}
+
+type MouseEvent struct {
+	Y      int
+	X      int
+	S      int
+	Down   bool
+	Double bool
+	Mod    bool
+}
+
+var (
+	_buf          []byte
+	_in           *os.File
+	_color        func(int, bool) C.int
+	_prevDownTime time.Time
+	_prevDownY    int
+	_clickY       []int
+)
+
+func init() {
+	_prevDownTime = time.Unix(0, 0)
+	_clickY = []int{}
+}
+
+func attrColored(pair int, bold bool) C.int {
+	var attr C.int
+	if pair > ColNormal {
+		attr = C.COLOR_PAIR(C.int(pair))
+	}
+	if bold {
+		attr = attr | C.A_BOLD
+	}
+	return attr
+}
+
+func attrMono(pair int, bold bool) C.int {
+	var attr C.int
+	switch pair {
+	case ColCurrent:
+		if bold {
+			attr = C.A_REVERSE
+		}
+	case ColMatch:
+		attr = C.A_UNDERLINE
+	case ColCurrentMatch:
+		attr = C.A_UNDERLINE | C.A_REVERSE
+	}
+	if bold {
+		attr = attr | C.A_BOLD
+	}
+	return attr
+}
+
+func MaxX() int {
+	return int(C.COLS)
+}
+
+func MaxY() int {
+	return int(C.LINES)
+}
+
+func getch(nonblock bool) int {
+	b := make([]byte, 1)
+	syscall.SetNonblock(int(_in.Fd()), nonblock)
+	_, err := _in.Read(b)
+	if err != nil {
+		return -1
+	}
+	return int(b[0])
+}
+
+func Init(color bool, color256 bool, black bool, mouse bool) {
+	{
+		in, err := os.OpenFile("/dev/tty", syscall.O_RDONLY, 0)
+		if err != nil {
+			panic("Failed to open /dev/tty")
+		}
+		_in = in
+		// Break STDIN
+		// syscall.Dup2(int(in.Fd()), int(os.Stdin.Fd()))
+	}
+
+	C.swapOutput()
+
+	C.setlocale(C.LC_ALL, C.CString(""))
+	C.initscr()
+	if mouse {
+		C.mousemask(C.ALL_MOUSE_EVENTS, nil)
+	}
+	C.cbreak()
+	C.noecho()
+	C.raw() // stty dsusp undef
+
+	intChan := make(chan os.Signal, 1)
+	signal.Notify(intChan, os.Interrupt, os.Kill)
+	go func() {
+		<-intChan
+		Close()
+		os.Exit(1)
+	}()
+
+	if color {
+		C.start_color()
+		var bg C.short
+		if black {
+			bg = C.COLOR_BLACK
+		} else {
+			C.use_default_colors()
+			bg = -1
+		}
+		if color256 {
+			C.init_pair(ColPrompt, 110, bg)
+			C.init_pair(ColMatch, 108, bg)
+			C.init_pair(ColCurrent, 254, 236)
+			C.init_pair(ColCurrentMatch, 151, 236)
+			C.init_pair(ColSpinner, 148, bg)
+			C.init_pair(ColInfo, 144, bg)
+			C.init_pair(ColCursor, 161, 236)
+			C.init_pair(ColSelected, 168, 236)
+		} else {
+			C.init_pair(ColPrompt, C.COLOR_BLUE, bg)
+			C.init_pair(ColMatch, C.COLOR_GREEN, bg)
+			C.init_pair(ColCurrent, C.COLOR_YELLOW, C.COLOR_BLACK)
+			C.init_pair(ColCurrentMatch, C.COLOR_GREEN, C.COLOR_BLACK)
+			C.init_pair(ColSpinner, C.COLOR_GREEN, bg)
+			C.init_pair(ColInfo, C.COLOR_WHITE, bg)
+			C.init_pair(ColCursor, C.COLOR_RED, C.COLOR_BLACK)
+			C.init_pair(ColSelected, C.COLOR_MAGENTA, C.COLOR_BLACK)
+		}
+		_color = attrColored
+	} else {
+		_color = attrMono
+	}
+}
+
+func Close() {
+	C.endwin()
+	C.swapOutput()
+}
+
+func GetBytes() []byte {
+	c := getch(false)
+	_buf = append(_buf, byte(c))
+
+	for {
+		c = getch(true)
+		if c == -1 {
+			break
+		}
+		_buf = append(_buf, byte(c))
+	}
+
+	return _buf
+}
+
+// 27 (91 79) 77 type x y
+func mouseSequence(sz *int) Event {
+	if len(_buf) < 6 {
+		return Event{Invalid, 0, nil}
+	}
+	*sz = 6
+	switch _buf[3] {
+	case 32, 36, 40, 48, // mouse-down / shift / cmd / ctrl
+		35, 39, 43, 51: // mouse-up / shift / cmd / ctrl
+		mod := _buf[3] >= 36
+		down := _buf[3]%2 == 0
+		x := int(_buf[4] - 33)
+		y := int(_buf[5] - 33)
+		double := false
+		if down {
+			now := time.Now()
+			if now.Sub(_prevDownTime) < doubleClickDuration {
+				_clickY = append(_clickY, y)
+			} else {
+				_clickY = []int{y}
+			}
+			_prevDownTime = now
+		} else {
+			if len(_clickY) > 1 && _clickY[0] == _clickY[1] &&
+				time.Now().Sub(_prevDownTime) < doubleClickDuration {
+				double = true
+			}
+		}
+		return Event{Mouse, 0, &MouseEvent{y, x, 0, down, double, mod}}
+	case 96, 100, 104, 112, // scroll-up / shift / cmd / ctrl
+		97, 101, 105, 113: // scroll-down / shift / cmd / ctrl
+		mod := _buf[3] >= 100
+		s := 1 - int(_buf[3]%2)*2
+		return Event{Mouse, 0, &MouseEvent{0, 0, s, false, false, mod}}
+	}
+	return Event{Invalid, 0, nil}
+}
+
+func escSequence(sz *int) Event {
+	if len(_buf) < 2 {
+		return Event{ESC, 0, nil}
+	}
+	*sz = 2
+	switch _buf[1] {
+	case 98:
+		return Event{AltB, 0, nil}
+	case 100:
+		return Event{AltD, 0, nil}
+	case 102:
+		return Event{AltF, 0, nil}
+	case 127:
+		return Event{AltBS, 0, nil}
+	case 91, 79:
+		if len(_buf) < 3 {
+			return Event{Invalid, 0, nil}
+		}
+		*sz = 3
+		switch _buf[2] {
+		case 68:
+			return Event{CtrlB, 0, nil}
+		case 67:
+			return Event{CtrlF, 0, nil}
+		case 66:
+			return Event{CtrlJ, 0, nil}
+		case 65:
+			return Event{CtrlK, 0, nil}
+		case 90:
+			return Event{BTab, 0, nil}
+		case 72:
+			return Event{CtrlA, 0, nil}
+		case 70:
+			return Event{CtrlE, 0, nil}
+		case 77:
+			return mouseSequence(sz)
+		case 49, 50, 51, 52, 53, 54:
+			if len(_buf) < 4 {
+				return Event{Invalid, 0, nil}
+			}
+			*sz = 4
+			switch _buf[2] {
+			case 50:
+				return Event{Invalid, 0, nil} // INS
+			case 51:
+				return Event{Del, 0, nil}
+			case 52:
+				return Event{CtrlE, 0, nil}
+			case 53:
+				return Event{PgUp, 0, nil}
+			case 54:
+				return Event{PgDn, 0, nil}
+			case 49:
+				switch _buf[3] {
+				case 126:
+					return Event{CtrlA, 0, nil}
+				case 59:
+					if len(_buf) != 6 {
+						return Event{Invalid, 0, nil}
+					}
+					*sz = 6
+					switch _buf[4] {
+					case 50:
+						switch _buf[5] {
+						case 68:
+							return Event{CtrlA, 0, nil}
+						case 67:
+							return Event{CtrlE, 0, nil}
+						}
+					case 53:
+						switch _buf[5] {
+						case 68:
+							return Event{AltB, 0, nil}
+						case 67:
+							return Event{AltF, 0, nil}
+						}
+					} // _buf[4]
+				} // _buf[3]
+			} // _buf[2]
+		} // _buf[2]
+	} // _buf[1]
+	return Event{Invalid, 0, nil}
+}
+
+func GetChar() Event {
+	if len(_buf) == 0 {
+		_buf = GetBytes()
+	}
+	if len(_buf) == 0 {
+		panic("Empty _buffer")
+	}
+
+	sz := 1
+	defer func() {
+		_buf = _buf[sz:]
+	}()
+
+	switch _buf[0] {
+	case CtrlC, CtrlG, CtrlQ:
+		return Event{CtrlC, 0, nil}
+	case 127:
+		return Event{CtrlH, 0, nil}
+	case ESC:
+		return escSequence(&sz)
+	}
+
+	// CTRL-A ~ CTRL-Z
+	if _buf[0] <= CtrlZ {
+		return Event{int(_buf[0]), 0, nil}
+	}
+	r, rsz := utf8.DecodeRune(_buf)
+	sz = rsz
+	return Event{Rune, r, nil}
+}
+
+func Move(y int, x int) {
+	C.move(C.int(y), C.int(x))
+}
+
+func MoveAndClear(y int, x int) {
+	Move(y, x)
+	C.clrtoeol()
+}
+
+func Print(text string) {
+	C.addstr(C.CString(text))
+}
+
+func CPrint(pair int, bold bool, text string) {
+	attr := _color(pair, bold)
+	C.attron(attr)
+	Print(text)
+	C.attroff(attr)
+}
+
+func Clear() {
+	C.clear()
+}
+
+func Refresh() {
+	C.refresh()
+}

src/fzf/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "github.com/junegunn/fzf/src"
+
+func main() {
+	fzf.Run(fzf.ParseOptions())
+}

src/item.go

@@ -0,0 +1,110 @@
+package fzf
+
+// Offset holds two 32-bit integers denoting the offsets of a matched substring
+type Offset [2]int32
+
+// Item represents each input line
+type Item struct {
+	text        *string
+	origText    *string
+	transformed *Transformed
+	index       uint32
+	offsets     []Offset
+	rank        Rank
+}
+
+// Rank is used to sort the search result
+type Rank struct {
+	matchlen uint16
+	strlen   uint16
+	index    uint32
+}
+
+// Rank calculates rank of the Item
+func (i *Item) Rank(cache bool) Rank {
+	if cache && (i.rank.matchlen > 0 || i.rank.strlen > 0) {
+		return i.rank
+	}
+	matchlen := 0
+	prevEnd := 0
+	for _, offset := range i.offsets {
+		begin := int(offset[0])
+		end := int(offset[1])
+		if prevEnd > begin {
+			begin = prevEnd
+		}
+		if end > prevEnd {
+			prevEnd = end
+		}
+		if end > begin {
+			matchlen += end - begin
+		}
+	}
+	rank := Rank{uint16(matchlen), uint16(len(*i.text)), i.index}
+	if cache {
+		i.rank = rank
+	}
+	return rank
+}
+
+// AsString returns the original string
+func (i *Item) AsString() string {
+	if i.origText != nil {
+		return *i.origText
+	}
+	return *i.text
+}
+
+// ByOrder is for sorting substring offsets
+type ByOrder []Offset
+
+func (a ByOrder) Len() int {
+	return len(a)
+}
+
+func (a ByOrder) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByOrder) Less(i, j int) bool {
+	ioff := a[i]
+	joff := a[j]
+	return (ioff[0] < joff[0]) || (ioff[0] == joff[0]) && (ioff[1] <= joff[1])
+}
+
+// ByRelevance is for sorting Items
+type ByRelevance []*Item
+
+func (a ByRelevance) Len() int {
+	return len(a)
+}
+
+func (a ByRelevance) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevance) Less(i, j int) bool {
+	irank := a[i].Rank(true)
+	jrank := a[j].Rank(true)
+
+	return compareRanks(irank, jrank)
+}
+
+func compareRanks(irank Rank, jrank Rank) bool {
+	if irank.matchlen < jrank.matchlen {
+		return true
+	} else if irank.matchlen > jrank.matchlen {
+		return false
+	}
+
+	if irank.strlen < jrank.strlen {
+		return true
+	} else if irank.strlen > jrank.strlen {
+		return false
+	}
+
+	if irank.index <= jrank.index {
+		return true
+	}
+	return false
+}

src/item_test.go

@@ -0,0 +1,67 @@
+package fzf
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestOffsetSort(t *testing.T) {
+	offsets := []Offset{
+		Offset{3, 5}, Offset{2, 7},
+		Offset{1, 3}, Offset{2, 9}}
+	sort.Sort(ByOrder(offsets))
+
+	if offsets[0][0] != 1 || offsets[0][1] != 3 ||
+		offsets[1][0] != 2 || offsets[1][1] != 7 ||
+		offsets[2][0] != 2 || offsets[2][1] != 9 ||
+		offsets[3][0] != 3 || offsets[3][1] != 5 {
+		t.Error("Invalid order:", offsets)
+	}
+}
+
+func TestRankComparison(t *testing.T) {
+	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}) ||
+		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}) ||
+		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}) ||
+		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}) {
+		t.Error("Invalid order")
+	}
+}
+
+// Match length, string length, index
+func TestItemRank(t *testing.T) {
+	strs := []string{"foo", "foobar", "bar", "baz"}
+	item1 := Item{text: &strs[0], index: 1, offsets: []Offset{}}
+	rank1 := item1.Rank(true)
+	if rank1.matchlen != 0 || rank1.strlen != 3 || rank1.index != 1 {
+		t.Error(item1.Rank(true))
+	}
+	// Only differ in index
+	item2 := Item{text: &strs[0], index: 0, offsets: []Offset{}}
+
+	items := []*Item{&item1, &item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != &item2 || items[1] != &item1 {
+		t.Error(items)
+	}
+
+	items = []*Item{&item2, &item1, &item1, &item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != &item2 || items[1] != &item2 ||
+		items[2] != &item1 || items[3] != &item1 {
+		t.Error(items)
+	}
+
+	// Sort by relevance
+	item3 := Item{text: &strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item4 := Item{text: &strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	item5 := Item{text: &strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item6 := Item{text: &strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	items = []*Item{&item1, &item2, &item3, &item4, &item5, &item6}
+	sort.Sort(ByRelevance(items))
+	if items[0] != &item2 || items[1] != &item1 ||
+		items[2] != &item6 || items[3] != &item4 ||
+		items[4] != &item5 || items[5] != &item3 {
+		t.Error(items)
+	}
+}

src/matcher.go

@@ -0,0 +1,214 @@
+package fzf
+
+import (
+	"fmt"
+	"runtime"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+// MatchRequest represents a search request
+type MatchRequest struct {
+	chunks  []*Chunk
+	pattern *Pattern
+}
+
+// Matcher is responsible for performing search
+type Matcher struct {
+	patternBuilder func([]rune) *Pattern
+	sort           bool
+	eventBox       *util.EventBox
+	reqBox         *util.EventBox
+	partitions     int
+	mergerCache    map[string]*Merger
+}
+
+const (
+	reqRetry util.EventType = iota
+	reqReset
+)
+
+const (
+	progressMinDuration = 200 * time.Millisecond
+)
+
+// NewMatcher returns a new Matcher
+func NewMatcher(patternBuilder func([]rune) *Pattern,
+	sort bool, eventBox *util.EventBox) *Matcher {
+	return &Matcher{
+		patternBuilder: patternBuilder,
+		sort:           sort,
+		eventBox:       eventBox,
+		reqBox:         util.NewEventBox(),
+		partitions:     runtime.NumCPU(),
+		mergerCache:    make(map[string]*Merger)}
+}
+
+// Loop puts Matcher in action
+func (m *Matcher) Loop() {
+	prevCount := 0
+
+	for {
+		var request MatchRequest
+
+		m.reqBox.Wait(func(events *util.Events) {
+			for _, val := range *events {
+				switch val := val.(type) {
+				case MatchRequest:
+					request = val
+				default:
+					panic(fmt.Sprintf("Unexpected type: %T", val))
+				}
+			}
+			events.Clear()
+		})
+
+		// Restart search
+		patternString := request.pattern.AsString()
+		var merger *Merger
+		cancelled := false
+		count := CountItems(request.chunks)
+
+		foundCache := false
+		if count == prevCount {
+			// Look up mergerCache
+			if cached, found := m.mergerCache[patternString]; found {
+				foundCache = true
+				merger = cached
+			}
+		} else {
+			// Invalidate mergerCache
+			prevCount = count
+			m.mergerCache = make(map[string]*Merger)
+		}
+
+		if !foundCache {
+			merger, cancelled = m.scan(request, 0)
+		}
+
+		if !cancelled {
+			m.mergerCache[patternString] = merger
+			m.eventBox.Set(EvtSearchFin, merger)
+		}
+	}
+}
+
+func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
+	perSlice := len(chunks) / m.partitions
+
+	// No need to parallelize
+	if perSlice == 0 {
+		return [][]*Chunk{chunks}
+	}
+
+	slices := make([][]*Chunk, m.partitions)
+	for i := 0; i < m.partitions; i++ {
+		start := i * perSlice
+		end := start + perSlice
+		if i == m.partitions-1 {
+			end = len(chunks)
+		}
+		slices[i] = chunks[start:end]
+	}
+	return slices
+}
+
+type partialResult struct {
+	index   int
+	matches []*Item
+}
+
+func (m *Matcher) scan(request MatchRequest, limit int) (*Merger, bool) {
+	startedAt := time.Now()
+
+	numChunks := len(request.chunks)
+	if numChunks == 0 {
+		return EmptyMerger, false
+	}
+	pattern := request.pattern
+	empty := pattern.IsEmpty()
+	cancelled := util.NewAtomicBool(false)
+
+	slices := m.sliceChunks(request.chunks)
+	numSlices := len(slices)
+	resultChan := make(chan partialResult, numSlices)
+	countChan := make(chan int, numChunks)
+	waitGroup := sync.WaitGroup{}
+
+	for idx, chunks := range slices {
+		waitGroup.Add(1)
+		go func(idx int, chunks []*Chunk) {
+			defer func() { waitGroup.Done() }()
+			sliceMatches := []*Item{}
+			for _, chunk := range chunks {
+				var matches []*Item
+				if empty {
+					matches = *chunk
+				} else {
+					matches = request.pattern.Match(chunk)
+				}
+				sliceMatches = append(sliceMatches, matches...)
+				if cancelled.Get() {
+					return
+				}
+				countChan <- len(matches)
+			}
+			if !empty && m.sort {
+				sort.Sort(ByRelevance(sliceMatches))
+			}
+			resultChan <- partialResult{idx, sliceMatches}
+		}(idx, chunks)
+	}
+
+	wait := func() bool {
+		cancelled.Set(true)
+		waitGroup.Wait()
+		return true
+	}
+
+	count := 0
+	matchCount := 0
+	for matchesInChunk := range countChan {
+		count++
+		matchCount += matchesInChunk
+
+		if limit > 0 && matchCount > limit {
+			return nil, wait() // For --select-1 and --exit-0
+		}
+
+		if count == numChunks {
+			break
+		}
+
+		if !empty && m.reqBox.Peak(reqReset) {
+			return nil, wait()
+		}
+
+		if time.Now().Sub(startedAt) > progressMinDuration {
+			m.eventBox.Set(EvtSearchProgress, float32(count)/float32(numChunks))
+		}
+	}
+
+	partialResults := make([][]*Item, numSlices)
+	for range slices {
+		partialResult := <-resultChan
+		partialResults[partialResult.index] = partialResult.matches
+	}
+	return NewMerger(partialResults, !empty && m.sort), false
+}
+
+// Reset is called to interrupt/signal the ongoing search
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool) {
+	pattern := m.patternBuilder(patternRunes)
+
+	var event util.EventType
+	if cancel {
+		event = reqReset
+	} else {
+		event = reqRetry
+	}
+	m.reqBox.Set(event, MatchRequest{chunks, pattern})
+}

src/merger.go

@@ -0,0 +1,84 @@
+package fzf
+
+import "fmt"
+
+// Merger with no data
+var EmptyMerger = NewMerger([][]*Item{}, false)
+
+// Merger holds a set of locally sorted lists of items and provides the view of
+// a single, globally-sorted list
+type Merger struct {
+	lists   [][]*Item
+	merged  []*Item
+	cursors []int
+	sorted  bool
+	count   int
+}
+
+// NewMerger returns a new Merger
+func NewMerger(lists [][]*Item, sorted bool) *Merger {
+	mg := Merger{
+		lists:   lists,
+		merged:  []*Item{},
+		cursors: make([]int, len(lists)),
+		sorted:  sorted,
+		count:   0}
+
+	for _, list := range mg.lists {
+		mg.count += len(list)
+	}
+	return &mg
+}
+
+// Length returns the number of items
+func (mg *Merger) Length() int {
+	return mg.count
+}
+
+// Get returns the pointer to the Item object indexed by the given integer
+func (mg *Merger) Get(idx int) *Item {
+	if len(mg.lists) == 1 {
+		return mg.lists[0][idx]
+	} else if !mg.sorted {
+		for _, list := range mg.lists {
+			numItems := len(list)
+			if idx < numItems {
+				return list[idx]
+			}
+			idx -= numItems
+		}
+		panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
+	}
+	return mg.mergedGet(idx)
+}
+
+func (mg *Merger) mergedGet(idx int) *Item {
+	for i := len(mg.merged); i <= idx; i++ {
+		minRank := Rank{0, 0, 0}
+		minIdx := -1
+		for listIdx, list := range mg.lists {
+			cursor := mg.cursors[listIdx]
+			if cursor < 0 || cursor == len(list) {
+				mg.cursors[listIdx] = -1
+				continue
+			}
+			if cursor >= 0 {
+				rank := list[cursor].Rank(false)
+				if minIdx < 0 || compareRanks(rank, minRank) {
+					minRank = rank
+					minIdx = listIdx
+				}
+			}
+			mg.cursors[listIdx] = cursor
+		}
+
+		if minIdx >= 0 {
+			chosen := mg.lists[minIdx]
+			mg.merged = append(mg.merged, chosen[mg.cursors[minIdx]])
+			mg.cursors[minIdx]++
+		} else {
+			panic(fmt.Sprintf("Index out of bounds (sorted, %d/%d)", i, mg.count))
+		}
+	}
+	return mg.merged[idx]
+}

src/merger_test.go

@@ -0,0 +1,93 @@
+package fzf
+
+import (
+	"fmt"
+	"math/rand"
+	"sort"
+	"testing"
+)
+
+func assert(t *testing.T, cond bool, msg ...string) {
+	if !cond {
+		t.Error(msg)
+	}
+}
+
+func randItem() *Item {
+	str := fmt.Sprintf("%d", rand.Uint32())
+	offsets := make([]Offset, rand.Int()%3)
+	for idx := range offsets {
+		sidx := int32(rand.Uint32() % 20)
+		eidx := sidx + int32(rand.Uint32()%20)
+		offsets[idx] = Offset{sidx, eidx}
+	}
+	return &Item{
+		text:    &str,
+		index:   rand.Uint32(),
+		offsets: offsets}
+}
+
+func TestEmptyMerger(t *testing.T) {
+	assert(t, EmptyMerger.Length() == 0, "Not empty")
+	assert(t, EmptyMerger.count == 0, "Invalid count")
+	assert(t, len(EmptyMerger.lists) == 0, "Invalid lists")
+	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
+}
+
+func buildLists(partiallySorted bool) ([][]*Item, []*Item) {
+	numLists := 4
+	lists := make([][]*Item, numLists)
+	cnt := 0
+	for i := 0; i < numLists; i++ {
+		numItems := rand.Int() % 20
+		cnt += numItems
+		lists[i] = make([]*Item, numItems)
+		for j := 0; j < numItems; j++ {
+			item := randItem()
+			lists[i][j] = item
+		}
+		if partiallySorted {
+			sort.Sort(ByRelevance(lists[i]))
+		}
+	}
+	items := []*Item{}
+	for _, list := range lists {
+		items = append(items, list...)
+	}
+	return lists, items
+}
+
+func TestMergerUnsorted(t *testing.T) {
+	lists, items := buildLists(false)
+	cnt := len(items)
+
+	// Not sorted: same order
+	mg := NewMerger(lists, false)
+	assert(t, cnt == mg.Length(), "Invalid Length")
+	for i := 0; i < cnt; i++ {
+		assert(t, items[i] == mg.Get(i), "Invalid Get")
+	}
+}
+
+func TestMergerSorted(t *testing.T) {
+	lists, items := buildLists(true)
+	cnt := len(items)
+
+	// Sorted sorted order
+	mg := NewMerger(lists, true)
+	assert(t, cnt == mg.Length(), "Invalid Length")
+	sort.Sort(ByRelevance(items))
+	for i := 0; i < cnt; i++ {
+		if items[i] != mg.Get(i) {
+			t.Error("Not sorted", items[i], mg.Get(i))
+		}
+	}
+
+	// Inverse order
+	mg2 := NewMerger(lists, true)
+	for i := cnt - 1; i >= 0; i-- {
+		if items[i] != mg2.Get(i) {
+			t.Error("Not sorted", items[i], mg2.Get(i))
+		}
+	}
+}

src/options.go

@@ -0,0 +1,282 @@
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/junegunn/go-shellwords"
+)
+
+const usage = `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            Sort the result
+    +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")
+
+`
+
+// Mode denotes the current search mode
+type Mode int
+
+// Search modes
+const (
+	ModeFuzzy Mode = iota
+	ModeExtended
+	ModeExtendedExact
+)
+
+// Case denotes case-sensitivity of search
+type Case int
+
+// Case-sensitivities
+const (
+	CaseSmart Case = iota
+	CaseIgnore
+	CaseRespect
+)
+
+// Options stores the values of command-line options
+type Options struct {
+	Mode       Mode
+	Case       Case
+	Nth        []Range
+	WithNth    []Range
+	Delimiter  *regexp.Regexp
+	Sort       int
+	Multi      bool
+	Mouse      bool
+	Color      bool
+	Color256   bool
+	Black      bool
+	Reverse    bool
+	Prompt     string
+	Query      string
+	Select1    bool
+	Exit0      bool
+	Filter     *string
+	PrintQuery bool
+	Version    bool
+}
+
+func defaultOptions() *Options {
+	return &Options{
+		Mode:       ModeFuzzy,
+		Case:       CaseSmart,
+		Nth:        make([]Range, 0),
+		WithNth:    make([]Range, 0),
+		Delimiter:  nil,
+		Sort:       1000,
+		Multi:      false,
+		Mouse:      true,
+		Color:      true,
+		Color256:   strings.Contains(os.Getenv("TERM"), "256"),
+		Black:      false,
+		Reverse:    false,
+		Prompt:     "> ",
+		Query:      "",
+		Select1:    false,
+		Exit0:      false,
+		Filter:     nil,
+		PrintQuery: false,
+		Version:    false}
+}
+
+func help(ok int) {
+	os.Stderr.WriteString(usage)
+	os.Exit(ok)
+}
+
+func errorExit(msg string) {
+	os.Stderr.WriteString(msg + "\n")
+	help(1)
+}
+
+func optString(arg string, prefix string) (bool, string) {
+	rx, _ := regexp.Compile(fmt.Sprintf("^(?:%s)(.*)$", prefix))
+	matches := rx.FindStringSubmatch(arg)
+	if len(matches) > 1 {
+		return true, matches[1]
+	}
+	return false, ""
+}
+
+func nextString(args []string, i *int, message string) string {
+	if len(args) > *i+1 {
+		*i++
+	} else {
+		errorExit(message)
+	}
+	return args[*i]
+}
+
+func optionalNumeric(args []string, i *int) int {
+	if len(args) > *i+1 {
+		if strings.IndexAny(args[*i+1], "0123456789") == 0 {
+			*i++
+		}
+	}
+	return 1 // Don't care
+}
+
+func splitNth(str string) []Range {
+	if match, _ := regexp.MatchString("^[0-9,-.]+$", str); !match {
+		errorExit("invalid format: " + str)
+	}
+
+	tokens := strings.Split(str, ",")
+	ranges := make([]Range, len(tokens))
+	for idx, s := range tokens {
+		r, ok := ParseRange(&s)
+		if !ok {
+			errorExit("invalid format: " + str)
+		}
+		ranges[idx] = r
+	}
+	return ranges
+}
+
+func delimiterRegexp(str string) *regexp.Regexp {
+	rx, e := regexp.Compile(str)
+	if e != nil {
+		str = regexp.QuoteMeta(str)
+	}
+
+	rx, e = regexp.Compile(fmt.Sprintf("(?:.*?%s)|(?:.+?$)", str))
+	if e != nil {
+		errorExit("invalid regular expression: " + e.Error())
+	}
+	return rx
+}
+
+func parseOptions(opts *Options, allArgs []string) {
+	for i := 0; i < len(allArgs); i++ {
+		arg := allArgs[i]
+		switch arg {
+		case "-h", "--help":
+			help(0)
+		case "-x", "--extended":
+			opts.Mode = ModeExtended
+		case "-e", "--extended-exact":
+			opts.Mode = ModeExtendedExact
+		case "+x", "--no-extended", "+e", "--no-extended-exact":
+			opts.Mode = ModeFuzzy
+		case "-q", "--query":
+			opts.Query = nextString(allArgs, &i, "query string required")
+		case "-f", "--filter":
+			filter := nextString(allArgs, &i, "query string required")
+			opts.Filter = &filter
+		case "-d", "--delimiter":
+			opts.Delimiter = delimiterRegexp(nextString(allArgs, &i, "delimiter required"))
+		case "-n", "--nth":
+			opts.Nth = splitNth(nextString(allArgs, &i, "nth expression required"))
+		case "--with-nth":
+			opts.WithNth = splitNth(nextString(allArgs, &i, "nth expression required"))
+		case "-s", "--sort":
+			opts.Sort = optionalNumeric(allArgs, &i)
+		case "+s", "--no-sort":
+			opts.Sort = 0
+		case "-i":
+			opts.Case = CaseIgnore
+		case "+i":
+			opts.Case = CaseRespect
+		case "-m", "--multi":
+			opts.Multi = true
+		case "+m", "--no-multi":
+			opts.Multi = false
+		case "--no-mouse":
+			opts.Mouse = false
+		case "+c", "--no-color":
+			opts.Color = false
+		case "+2", "--no-256":
+			opts.Color256 = false
+		case "--black":
+			opts.Black = true
+		case "--no-black":
+			opts.Black = false
+		case "--reverse":
+			opts.Reverse = true
+		case "--no-reverse":
+			opts.Reverse = false
+		case "-1", "--select-1":
+			opts.Select1 = true
+		case "+1", "--no-select-1":
+			opts.Select1 = false
+		case "-0", "--exit-0":
+			opts.Exit0 = true
+		case "+0", "--no-exit-0":
+			opts.Exit0 = false
+		case "--print-query":
+			opts.PrintQuery = true
+		case "--no-print-query":
+			opts.PrintQuery = false
+		case "--prompt":
+			opts.Prompt = nextString(allArgs, &i, "prompt string required")
+		case "--version":
+			opts.Version = true
+		default:
+			if match, value := optString(arg, "-q|--query="); match {
+				opts.Query = value
+			} else if match, value := optString(arg, "-f|--filter="); match {
+				opts.Filter = &value
+			} else if match, value := optString(arg, "-d|--delimiter="); match {
+				opts.Delimiter = delimiterRegexp(value)
+			} else if match, value := optString(arg, "--prompt="); match {
+				opts.Prompt = value
+			} else if match, value := optString(arg, "-n|--nth="); match {
+				opts.Nth = splitNth(value)
+			} else if match, value := optString(arg, "--with-nth="); match {
+				opts.WithNth = splitNth(value)
+			} else if match, _ := optString(arg, "-s|--sort="); match {
+				opts.Sort = 1 // Don't care
+			} else {
+				errorExit("unknown option: " + arg)
+			}
+		}
+	}
+}
+
+// ParseOptions parses command-line options
+func ParseOptions() *Options {
+	opts := defaultOptions()
+
+	// Options from Env var
+	words, _ := shellwords.Parse(os.Getenv("FZF_DEFAULT_OPTS"))
+	parseOptions(opts, words)
+
+	// Options from command-line arguments
+	parseOptions(opts, os.Args[1:])
+	return opts
+}

src/options_test.go

@@ -0,0 +1,37 @@
+package fzf
+
+import "testing"
+
+func TestDelimiterRegex(t *testing.T) {
+	rx := delimiterRegexp("*")
+	tokens := rx.FindAllString("-*--*---**---", -1)
+	if tokens[0] != "-*" || tokens[1] != "--*" || tokens[2] != "---*" ||
+		tokens[3] != "*" || tokens[4] != "---" {
+		t.Errorf("%s %s %d", rx, tokens, len(tokens))
+	}
+}
+
+func TestSplitNth(t *testing.T) {
+	{
+		ranges := splitNth("..")
+		if len(ranges) != 1 ||
+			ranges[0].begin != rangeEllipsis ||
+			ranges[0].end != rangeEllipsis {
+			t.Errorf("%s", ranges)
+		}
+	}
+	{
+		ranges := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2")
+		if len(ranges) != 8 ||
+			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
+			ranges[1].begin != 1 || ranges[1].end != rangeEllipsis ||
+			ranges[2].begin != 2 || ranges[2].end != 3 ||
+			ranges[3].begin != 4 || ranges[3].end != -1 ||
+			ranges[4].begin != -3 || ranges[4].end != -2 ||
+			ranges[5].begin != rangeEllipsis || ranges[5].end != rangeEllipsis ||
+			ranges[6].begin != 2 || ranges[6].end != 2 ||
+			ranges[7].begin != -2 || ranges[7].end != -2 {
+			t.Errorf("%s", ranges)
+		}
+	}
+}

src/pattern.go

@@ -0,0 +1,309 @@
+package fzf
+
+import (
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/junegunn/fzf/src/algo"
+)
+
+const uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+// fuzzy
+// 'exact
+// ^exact-prefix
+// exact-suffix$
+// !not-fuzzy
+// !'not-exact
+// !^not-exact-prefix
+// !not-exact-suffix$
+
+type termType int
+
+const (
+	termFuzzy termType = iota
+	termExact
+	termPrefix
+	termSuffix
+)
+
+type term struct {
+	typ      termType
+	inv      bool
+	text     []rune
+	origText []rune
+}
+
+// Pattern represents search pattern
+type Pattern struct {
+	mode          Mode
+	caseSensitive bool
+	text          []rune
+	terms         []term
+	hasInvTerm    bool
+	delimiter     *regexp.Regexp
+	nth           []Range
+	procFun       map[termType]func(bool, *string, []rune) (int, int)
+}
+
+var (
+	_patternCache map[string]*Pattern
+	_splitRegex   *regexp.Regexp
+	_cache        ChunkCache
+)
+
+func init() {
+	// We can uniquely identify the pattern for a given string since
+	// mode and caseMode do not change while the program is running
+	_patternCache = make(map[string]*Pattern)
+	_splitRegex = regexp.MustCompile("\\s+")
+	_cache = NewChunkCache()
+}
+
+func clearPatternCache() {
+	_patternCache = make(map[string]*Pattern)
+}
+
+// BuildPattern builds Pattern object from the given arguments
+func BuildPattern(mode Mode, caseMode Case,
+	nth []Range, delimiter *regexp.Regexp, runes []rune) *Pattern {
+
+	var asString string
+	switch mode {
+	case ModeExtended, ModeExtendedExact:
+		asString = strings.Trim(string(runes), " ")
+	default:
+		asString = string(runes)
+	}
+
+	cached, found := _patternCache[asString]
+	if found {
+		return cached
+	}
+
+	caseSensitive, hasInvTerm := true, false
+	terms := []term{}
+
+	switch caseMode {
+	case CaseSmart:
+		if !strings.ContainsAny(asString, uppercaseLetters) {
+			runes, caseSensitive = []rune(strings.ToLower(asString)), false
+		}
+	case CaseIgnore:
+		runes, caseSensitive = []rune(strings.ToLower(asString)), false
+	}
+
+	switch mode {
+	case ModeExtended, ModeExtendedExact:
+		terms = parseTerms(mode, string(runes))
+		for _, term := range terms {
+			if term.inv {
+				hasInvTerm = true
+			}
+		}
+	}
+
+	ptr := &Pattern{
+		mode:          mode,
+		caseSensitive: caseSensitive,
+		text:          runes,
+		terms:         terms,
+		hasInvTerm:    hasInvTerm,
+		nth:           nth,
+		delimiter:     delimiter,
+		procFun:       make(map[termType]func(bool, *string, []rune) (int, int))}
+
+	ptr.procFun[termFuzzy] = algo.FuzzyMatch
+	ptr.procFun[termExact] = algo.ExactMatchNaive
+	ptr.procFun[termPrefix] = algo.PrefixMatch
+	ptr.procFun[termSuffix] = algo.SuffixMatch
+
+	_patternCache[asString] = ptr
+	return ptr
+}
+
+func parseTerms(mode Mode, str string) []term {
+	tokens := _splitRegex.Split(str, -1)
+	terms := []term{}
+	for _, token := range tokens {
+		typ, inv, text := termFuzzy, false, token
+		origText := []rune(text)
+		if mode == ModeExtendedExact {
+			typ = termExact
+		}
+
+		if strings.HasPrefix(text, "!") {
+			inv = true
+			text = text[1:]
+		}
+
+		if strings.HasPrefix(text, "'") {
+			if mode == ModeExtended {
+				typ = termExact
+				text = text[1:]
+			}
+		} else if strings.HasPrefix(text, "^") {
+			typ = termPrefix
+			text = text[1:]
+		} else if strings.HasSuffix(text, "$") {
+			typ = termSuffix
+			text = text[:len(text)-1]
+		}
+
+		if len(text) > 0 {
+			terms = append(terms, term{
+				typ:      typ,
+				inv:      inv,
+				text:     []rune(text),
+				origText: origText})
+		}
+	}
+	return terms
+}
+
+// IsEmpty returns true if the pattern is effectively empty
+func (p *Pattern) IsEmpty() bool {
+	if p.mode == ModeFuzzy {
+		return len(p.text) == 0
+	}
+	return len(p.terms) == 0
+}
+
+// AsString returns the search query in string type
+func (p *Pattern) AsString() string {
+	return string(p.text)
+}
+
+// CacheKey is used to build string to be used as the key of result cache
+func (p *Pattern) CacheKey() string {
+	if p.mode == ModeFuzzy {
+		return p.AsString()
+	}
+	cacheableTerms := []string{}
+	for _, term := range p.terms {
+		if term.inv {
+			continue
+		}
+		cacheableTerms = append(cacheableTerms, string(term.origText))
+	}
+	return strings.Join(cacheableTerms, " ")
+}
+
+// Match returns the list of matches Items in the given Chunk
+func (p *Pattern) Match(chunk *Chunk) []*Item {
+	space := chunk
+
+	// ChunkCache: Exact match
+	cacheKey := p.CacheKey()
+	if !p.hasInvTerm { // Because we're excluding Inv-term from cache key
+		if cached, found := _cache.Find(chunk, cacheKey); found {
+			return cached
+		}
+	}
+
+	// ChunkCache: Prefix/suffix match
+Loop:
+	for idx := 1; idx < len(cacheKey); idx++ {
+		// [---------| ] | [ |---------]
+		// [--------|  ] | [  |--------]
+		// [-------|   ] | [   |-------]
+		prefix := cacheKey[:len(cacheKey)-idx]
+		suffix := cacheKey[idx:]
+		for _, substr := range [2]*string{&prefix, &suffix} {
+			if cached, found := _cache.Find(chunk, *substr); found {
+				cachedChunk := Chunk(cached)
+				space = &cachedChunk
+				break Loop
+			}
+		}
+	}
+
+	var matches []*Item
+	if p.mode == ModeFuzzy {
+		matches = p.fuzzyMatch(space)
+	} else {
+		matches = p.extendedMatch(space)
+	}
+
+	if !p.hasInvTerm {
+		_cache.Add(chunk, cacheKey, matches)
+	}
+	return matches
+}
+
+func dupItem(item *Item, offsets []Offset) *Item {
+	sort.Sort(ByOrder(offsets))
+	return &Item{
+		text:        item.text,
+		origText:    item.origText,
+		transformed: item.transformed,
+		index:       item.index,
+		offsets:     offsets,
+		rank:        Rank{0, 0, item.index}}
+}
+
+func (p *Pattern) fuzzyMatch(chunk *Chunk) []*Item {
+	matches := []*Item{}
+	for _, item := range *chunk {
+		input := p.prepareInput(item)
+		if sidx, eidx := p.iter(algo.FuzzyMatch, input, p.text); sidx >= 0 {
+			matches = append(matches,
+				dupItem(item, []Offset{Offset{int32(sidx), int32(eidx)}}))
+		}
+	}
+	return matches
+}
+
+func (p *Pattern) extendedMatch(chunk *Chunk) []*Item {
+	matches := []*Item{}
+	for _, item := range *chunk {
+		input := p.prepareInput(item)
+		offsets := []Offset{}
+		for _, term := range p.terms {
+			pfun := p.procFun[term.typ]
+			if sidx, eidx := p.iter(pfun, input, term.text); sidx >= 0 {
+				if term.inv {
+					break
+				}
+				offsets = append(offsets, Offset{int32(sidx), int32(eidx)})
+			} else if term.inv {
+				offsets = append(offsets, Offset{0, 0})
+			}
+		}
+		if len(offsets) == len(p.terms) {
+			matches = append(matches, dupItem(item, offsets))
+		}
+	}
+	return matches
+}
+
+func (p *Pattern) prepareInput(item *Item) *Transformed {
+	if item.transformed != nil {
+		return item.transformed
+	}
+
+	var ret *Transformed
+	if len(p.nth) > 0 {
+		tokens := Tokenize(item.text, p.delimiter)
+		ret = Transform(tokens, p.nth)
+	} else {
+		trans := Transformed{
+			whole: item.text,
+			parts: []Token{Token{text: item.text, prefixLength: 0}}}
+		ret = &trans
+	}
+	item.transformed = ret
+	return ret
+}
+
+func (p *Pattern) iter(pfun func(bool, *string, []rune) (int, int),
+	inputs *Transformed, pattern []rune) (int, int) {
+	for _, part := range inputs.parts {
+		prefixLength := part.prefixLength
+		if sidx, eidx := pfun(p.caseSensitive, part.text, pattern); sidx >= 0 {
+			return sidx + prefixLength, eidx + prefixLength
+		}
+	}
+	return -1, -1
+}

src/pattern_test.go

@@ -0,0 +1,115 @@
+package fzf
+
+import (
+	"testing"
+
+	"github.com/junegunn/fzf/src/algo"
+)
+
+func TestParseTermsExtended(t *testing.T) {
+	terms := parseTerms(ModeExtended,
+		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
+	if len(terms) != 8 ||
+		terms[0].typ != termFuzzy || terms[0].inv ||
+		terms[1].typ != termExact || terms[1].inv ||
+		terms[2].typ != termPrefix || terms[2].inv ||
+		terms[3].typ != termSuffix || terms[3].inv ||
+		terms[4].typ != termFuzzy || !terms[4].inv ||
+		terms[5].typ != termExact || !terms[5].inv ||
+		terms[6].typ != termPrefix || !terms[6].inv ||
+		terms[7].typ != termSuffix || !terms[7].inv {
+		t.Errorf("%s", terms)
+	}
+	for idx, term := range terms {
+		if len(term.text) != 3 {
+			t.Errorf("%s", term)
+		}
+		if idx > 0 && len(term.origText) != 4+idx/5 {
+			t.Errorf("%s", term)
+		}
+	}
+}
+
+func TestParseTermsExtendedExact(t *testing.T) {
+	terms := parseTerms(ModeExtendedExact,
+		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
+	if len(terms) != 8 ||
+		terms[0].typ != termExact || terms[0].inv || len(terms[0].text) != 3 ||
+		terms[1].typ != termExact || terms[1].inv || len(terms[1].text) != 4 ||
+		terms[2].typ != termPrefix || terms[2].inv || len(terms[2].text) != 3 ||
+		terms[3].typ != termSuffix || terms[3].inv || len(terms[3].text) != 3 ||
+		terms[4].typ != termExact || !terms[4].inv || len(terms[4].text) != 3 ||
+		terms[5].typ != termExact || !terms[5].inv || len(terms[5].text) != 4 ||
+		terms[6].typ != termPrefix || !terms[6].inv || len(terms[6].text) != 3 ||
+		terms[7].typ != termSuffix || !terms[7].inv || len(terms[7].text) != 3 {
+		t.Errorf("%s", terms)
+	}
+}
+
+func TestParseTermsEmpty(t *testing.T) {
+	terms := parseTerms(ModeExtended, "' $ ^ !' !^ !$")
+	if len(terms) != 0 {
+		t.Errorf("%s", terms)
+	}
+}
+
+func TestExact(t *testing.T) {
+	defer clearPatternCache()
+	clearPatternCache()
+	pattern := BuildPattern(ModeExtended, CaseSmart,
+		[]Range{}, nil, []rune("'abc"))
+	str := "aabbcc abc"
+	sidx, eidx := algo.ExactMatchNaive(pattern.caseSensitive, &str, pattern.terms[0].text)
+	if sidx != 7 || eidx != 10 {
+		t.Errorf("%s / %d / %d", pattern.terms, sidx, eidx)
+	}
+}
+
+func TestCaseSensitivity(t *testing.T) {
+	defer clearPatternCache()
+	clearPatternCache()
+	pat1 := BuildPattern(ModeFuzzy, CaseSmart, []Range{}, nil, []rune("abc"))
+	clearPatternCache()
+	pat2 := BuildPattern(ModeFuzzy, CaseSmart, []Range{}, nil, []rune("Abc"))
+	clearPatternCache()
+	pat3 := BuildPattern(ModeFuzzy, CaseIgnore, []Range{}, nil, []rune("abc"))
+	clearPatternCache()
+	pat4 := BuildPattern(ModeFuzzy, CaseIgnore, []Range{}, nil, []rune("Abc"))
+	clearPatternCache()
+	pat5 := BuildPattern(ModeFuzzy, CaseRespect, []Range{}, nil, []rune("abc"))
+	clearPatternCache()
+	pat6 := BuildPattern(ModeFuzzy, CaseRespect, []Range{}, nil, []rune("Abc"))
+
+	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
+		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
+		string(pat3.text) != "abc" || pat3.caseSensitive != false ||
+		string(pat4.text) != "abc" || pat4.caseSensitive != false ||
+		string(pat5.text) != "abc" || pat5.caseSensitive != true ||
+		string(pat6.text) != "Abc" || pat6.caseSensitive != true {
+		t.Error("Invalid case conversion")
+	}
+}
+
+func TestOrigTextAndTransformed(t *testing.T) {
+	strptr := func(str string) *string {
+		return &str
+	}
+	pattern := BuildPattern(ModeExtended, CaseSmart, []Range{}, nil, []rune("jg"))
+	tokens := Tokenize(strptr("junegunn"), nil)
+	trans := Transform(tokens, []Range{Range{1, 1}})
+
+	for _, fun := range []func(*Chunk) []*Item{pattern.fuzzyMatch, pattern.extendedMatch} {
+		chunk := Chunk{
+			&Item{
+				text:        strptr("junegunn"),
+				origText:    strptr("junegunn.choi"),
+				transformed: trans},
+		}
+		matches := fun(&chunk)
+		if *matches[0].text != "junegunn" || *matches[0].origText != "junegunn.choi" ||
+			matches[0].offsets[0][0] != 0 || matches[0].offsets[0][1] != 5 ||
+			matches[0].transformed != trans {
+			t.Error("Invalid match result", matches)
+		}
+	}
+}

src/reader.go

@@ -0,0 +1,59 @@
+package fzf
+
+import (
+	"bufio"
+	"io"
+	"os"
+	"os/exec"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const defaultCommand = `find * -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null`
+
+// Reader reads from command or standard input
+type Reader struct {
+	pusher   func(string)
+	eventBox *util.EventBox
+}
+
+// ReadSource reads data from the default command or from standard input
+func (r *Reader) ReadSource() {
+	if util.IsTty() {
+		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
+		if len(cmd) == 0 {
+			cmd = defaultCommand
+		}
+		r.readFromCommand(cmd)
+	} else {
+		r.readFromStdin()
+	}
+	r.eventBox.Set(EvtReadFin, nil)
+}
+
+func (r *Reader) feed(src io.Reader) {
+	if scanner := bufio.NewScanner(src); scanner != nil {
+		for scanner.Scan() {
+			r.pusher(scanner.Text())
+			r.eventBox.Set(EvtReadNew, nil)
+		}
+	}
+}
+
+func (r *Reader) readFromStdin() {
+	r.feed(os.Stdin)
+}
+
+func (r *Reader) readFromCommand(cmd string) {
+	listCommand := exec.Command("sh", "-c", cmd)
+	out, err := listCommand.StdoutPipe()
+	if err != nil {
+		return
+	}
+	err = listCommand.Start()
+	if err != nil {
+		return
+	}
+	defer listCommand.Wait()
+	r.feed(out)
+}

src/reader_test.go

@@ -0,0 +1,56 @@
+package fzf
+
+import (
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func TestReadFromCommand(t *testing.T) {
+	strs := []string{}
+	eb := util.NewEventBox()
+	reader := Reader{
+		pusher:   func(s string) { strs = append(strs, s) },
+		eventBox: eb}
+
+	// Check EventBox
+	if eb.Peak(EvtReadNew) {
+		t.Error("EvtReadNew should not be set yet")
+	}
+
+	// Normal command
+	reader.readFromCommand(`echo abc && echo def`)
+	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
+		t.Errorf("%s", strs)
+	}
+
+	// Check EventBox again
+	if !eb.Peak(EvtReadNew) {
+		t.Error("EvtReadNew should be set yet")
+	}
+
+	// Wait should return immediately
+	eb.Wait(func(events *util.Events) {
+		if _, found := (*events)[EvtReadNew]; !found {
+			t.Errorf("%s", events)
+		}
+		events.Clear()
+	})
+
+	// EventBox is cleared
+	if eb.Peak(EvtReadNew) {
+		t.Error("EvtReadNew should not be set yet")
+	}
+
+	// Failing command
+	reader.readFromCommand(`no-such-command`)
+	strs = []string{}
+	if len(strs) > 0 {
+		t.Errorf("%s", strs)
+	}
+
+	// Check EventBox again
+	if eb.Peak(EvtReadNew) {
+		t.Error("Command failed. EvtReadNew should be set")
+	}
+}

src/terminal.go

@@ -0,0 +1,626 @@
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"sort"
+	"sync"
+	"time"
+
+	C "github.com/junegunn/fzf/src/curses"
+	"github.com/junegunn/fzf/src/util"
+
+	"github.com/junegunn/go-runewidth"
+)
+
+// Terminal represents terminal input/output
+type Terminal struct {
+	prompt     string
+	reverse    bool
+	tac        bool
+	cx         int
+	cy         int
+	offset     int
+	yanked     []rune
+	input      []rune
+	multi      bool
+	printQuery bool
+	count      int
+	progress   int
+	reading    bool
+	merger     *Merger
+	selected   map[*string]*string
+	reqBox     *util.EventBox
+	eventBox   *util.EventBox
+	mutex      sync.Mutex
+	initFunc   func()
+	suppress   bool
+}
+
+var _spinner = []string{`-`, `\`, `|`, `/`, `-`, `\`, `|`, `/`}
+
+const (
+	reqPrompt util.EventType = iota
+	reqInfo
+	reqList
+	reqRefresh
+	reqRedraw
+	reqClose
+	reqQuit
+)
+
+const (
+	initialDelay    = 100 * time.Millisecond
+	spinnerDuration = 200 * time.Millisecond
+)
+
+// NewTerminal returns new Terminal object
+func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
+	input := []rune(opts.Query)
+	return &Terminal{
+		prompt:     opts.Prompt,
+		tac:        opts.Sort == 0,
+		reverse:    opts.Reverse,
+		cx:         displayWidth(input),
+		cy:         0,
+		offset:     0,
+		yanked:     []rune{},
+		input:      input,
+		multi:      opts.Multi,
+		printQuery: opts.PrintQuery,
+		merger:     EmptyMerger,
+		selected:   make(map[*string]*string),
+		reqBox:     util.NewEventBox(),
+		eventBox:   eventBox,
+		mutex:      sync.Mutex{},
+		suppress:   true,
+		initFunc: func() {
+			C.Init(opts.Color, opts.Color256, opts.Black, opts.Mouse)
+		}}
+}
+
+// Input returns current query string
+func (t *Terminal) Input() []rune {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	return copySlice(t.input)
+}
+
+// UpdateCount updates the count information
+func (t *Terminal) UpdateCount(cnt int, final bool) {
+	t.mutex.Lock()
+	t.count = cnt
+	t.reading = !final
+	t.mutex.Unlock()
+	t.reqBox.Set(reqInfo, nil)
+	if final {
+		t.reqBox.Set(reqRefresh, nil)
+	}
+}
+
+// UpdateProgress updates the search progress
+func (t *Terminal) UpdateProgress(progress float32) {
+	t.mutex.Lock()
+	newProgress := int(progress * 100)
+	changed := t.progress != newProgress
+	t.progress = newProgress
+	t.mutex.Unlock()
+
+	if changed {
+		t.reqBox.Set(reqInfo, nil)
+	}
+}
+
+// UpdateList updates Merger to display the list
+func (t *Terminal) UpdateList(merger *Merger) {
+	t.mutex.Lock()
+	t.progress = 100
+	t.merger = merger
+	t.mutex.Unlock()
+	t.reqBox.Set(reqInfo, nil)
+	t.reqBox.Set(reqList, nil)
+}
+
+func (t *Terminal) listIndex(y int) int {
+	if t.tac {
+		return t.merger.Length() - y - 1
+	}
+	return y
+}
+
+func (t *Terminal) output() {
+	if t.printQuery {
+		fmt.Println(string(t.input))
+	}
+	if len(t.selected) == 0 {
+		if t.merger.Length() > t.cy {
+			fmt.Println(t.merger.Get(t.listIndex(t.cy)).AsString())
+		}
+	} else {
+		for ptr, orig := range t.selected {
+			if orig != nil {
+				fmt.Println(*orig)
+			} else {
+				fmt.Println(*ptr)
+			}
+		}
+	}
+}
+
+func displayWidth(runes []rune) int {
+	l := 0
+	for _, r := range runes {
+		l += runewidth.RuneWidth(r)
+	}
+	return l
+}
+
+func (t *Terminal) move(y int, x int, clear bool) {
+	maxy := C.MaxY()
+	if !t.reverse {
+		y = maxy - y - 1
+	}
+
+	if clear {
+		C.MoveAndClear(y, x)
+	} else {
+		C.Move(y, x)
+	}
+}
+
+func (t *Terminal) placeCursor() {
+	t.move(0, len(t.prompt)+displayWidth(t.input[:t.cx]), false)
+}
+
+func (t *Terminal) printPrompt() {
+	t.move(0, 0, true)
+	C.CPrint(C.ColPrompt, true, t.prompt)
+	C.CPrint(C.ColNormal, true, string(t.input))
+}
+
+func (t *Terminal) printInfo() {
+	t.move(1, 0, true)
+	if t.reading {
+		duration := int64(spinnerDuration)
+		idx := (time.Now().UnixNano() % (duration * int64(len(_spinner)))) / duration
+		C.CPrint(C.ColSpinner, true, _spinner[idx])
+	}
+
+	t.move(1, 2, false)
+	output := fmt.Sprintf("%d/%d", t.merger.Length(), t.count)
+	if t.multi && len(t.selected) > 0 {
+		output += fmt.Sprintf(" (%d)", len(t.selected))
+	}
+	if t.progress > 0 && t.progress < 100 {
+		output += fmt.Sprintf(" (%d%%)", t.progress)
+	}
+	C.CPrint(C.ColInfo, false, output)
+}
+
+func (t *Terminal) printList() {
+	t.constrain()
+
+	maxy := maxItems()
+	count := t.merger.Length() - t.offset
+	for i := 0; i < maxy; i++ {
+		t.move(i+2, 0, true)
+		if i < count {
+			t.printItem(t.merger.Get(t.listIndex(i+t.offset)), i == t.cy-t.offset)
+		}
+	}
+}
+
+func (t *Terminal) printItem(item *Item, current bool) {
+	_, selected := t.selected[item.text]
+	if current {
+		C.CPrint(C.ColCursor, true, ">")
+		if selected {
+			C.CPrint(C.ColCurrent, true, ">")
+		} else {
+			C.CPrint(C.ColCurrent, true, " ")
+		}
+		t.printHighlighted(item, true, C.ColCurrent, C.ColCurrentMatch)
+	} else {
+		C.CPrint(C.ColCursor, true, " ")
+		if selected {
+			C.CPrint(C.ColSelected, true, ">")
+		} else {
+			C.Print(" ")
+		}
+		t.printHighlighted(item, false, 0, C.ColMatch)
+	}
+}
+
+func trimRight(runes []rune, width int) ([]rune, int) {
+	currentWidth := displayWidth(runes)
+	trimmed := 0
+
+	for currentWidth > width && len(runes) > 0 {
+		sz := len(runes)
+		currentWidth -= runewidth.RuneWidth(runes[sz-1])
+		runes = runes[:sz-1]
+		trimmed++
+	}
+	return runes, trimmed
+}
+
+func trimLeft(runes []rune, width int) ([]rune, int32) {
+	currentWidth := displayWidth(runes)
+	var trimmed int32
+
+	for currentWidth > width && len(runes) > 0 {
+		currentWidth -= runewidth.RuneWidth(runes[0])
+		runes = runes[1:]
+		trimmed++
+	}
+	return runes, trimmed
+}
+
+func (*Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int) {
+	var maxe int32
+	for _, offset := range item.offsets {
+		if offset[1] > maxe {
+			maxe = offset[1]
+		}
+	}
+
+	// Overflow
+	text := []rune(*item.text)
+	offsets := item.offsets
+	maxWidth := C.MaxX() - 3
+	fullWidth := displayWidth(text)
+	if fullWidth > maxWidth {
+		// Stri..
+		matchEndWidth := displayWidth(text[:maxe])
+		if matchEndWidth <= maxWidth-2 {
+			text, _ = trimRight(text, maxWidth-2)
+			text = append(text, []rune("..")...)
+		} else {
+			// Stri..
+			if matchEndWidth < fullWidth-2 {
+				text = append(text[:maxe], []rune("..")...)
+			}
+			// ..ri..
+			var diff int32
+			text, diff = trimLeft(text, maxWidth-2)
+
+			// Transform offsets
+			offsets = make([]Offset, len(item.offsets))
+			for idx, offset := range item.offsets {
+				b, e := offset[0], offset[1]
+				b += 2 - diff
+				e += 2 - diff
+				b = util.Max32(b, 2)
+				if b < e {
+					offsets[idx] = Offset{b, e}
+				}
+			}
+			text = append([]rune(".."), text...)
+		}
+	}
+
+	sort.Sort(ByOrder(offsets))
+	var index int32
+	for _, offset := range offsets {
+		b := util.Max32(index, offset[0])
+		e := util.Max32(index, offset[1])
+		C.CPrint(col1, bold, string(text[index:b]))
+		C.CPrint(col2, bold, string(text[b:e]))
+		index = e
+	}
+	if index < int32(len(text)) {
+		C.CPrint(col1, bold, string(text[index:]))
+	}
+}
+
+func (t *Terminal) printAll() {
+	t.printList()
+	t.printInfo()
+	t.printPrompt()
+}
+
+func (t *Terminal) refresh() {
+	if !t.suppress {
+		C.Refresh()
+	}
+}
+
+func (t *Terminal) delChar() bool {
+	if len(t.input) > 0 && t.cx < len(t.input) {
+		t.input = append(t.input[:t.cx], t.input[t.cx+1:]...)
+		return true
+	}
+	return false
+}
+
+func findLastMatch(pattern string, str string) int {
+	rx, err := regexp.Compile(pattern)
+	if err != nil {
+		return -1
+	}
+	locs := rx.FindAllStringIndex(str, -1)
+	if locs == nil {
+		return -1
+	}
+	return locs[len(locs)-1][0]
+}
+
+func findFirstMatch(pattern string, str string) int {
+	rx, err := regexp.Compile(pattern)
+	if err != nil {
+		return -1
+	}
+	loc := rx.FindStringIndex(str)
+	if loc == nil {
+		return -1
+	}
+	return loc[0]
+}
+
+func copySlice(slice []rune) []rune {
+	ret := make([]rune, len(slice))
+	copy(ret, slice)
+	return ret
+}
+
+func (t *Terminal) rubout(pattern string) {
+	pcx := t.cx
+	after := t.input[t.cx:]
+	t.cx = findLastMatch(pattern, string(t.input[:t.cx])) + 1
+	t.yanked = copySlice(t.input[t.cx:pcx])
+	t.input = append(t.input[:t.cx], after...)
+}
+
+// Loop is called to start Terminal I/O
+func (t *Terminal) Loop() {
+	{ // Late initialization
+		t.mutex.Lock()
+		t.initFunc()
+		t.printPrompt()
+		t.placeCursor()
+		C.Refresh()
+		t.printInfo()
+		t.mutex.Unlock()
+		go func() {
+			timer := time.NewTimer(initialDelay)
+			<-timer.C
+			t.reqBox.Set(reqRefresh, nil)
+		}()
+	}
+
+	go func() {
+		for {
+			t.reqBox.Wait(func(events *util.Events) {
+				defer events.Clear()
+				t.mutex.Lock()
+				for req := range *events {
+					switch req {
+					case reqPrompt:
+						t.printPrompt()
+					case reqInfo:
+						t.printInfo()
+					case reqList:
+						t.printList()
+					case reqRefresh:
+						t.suppress = false
+					case reqRedraw:
+						C.Clear()
+						t.printAll()
+					case reqClose:
+						C.Close()
+						t.output()
+						os.Exit(0)
+					case reqQuit:
+						C.Close()
+						os.Exit(1)
+					}
+				}
+				t.placeCursor()
+				t.mutex.Unlock()
+			})
+			t.refresh()
+		}
+	}()
+
+	looping := true
+	for looping {
+		event := C.GetChar()
+
+		t.mutex.Lock()
+		previousInput := t.input
+		events := []util.EventType{reqPrompt}
+		req := func(evts ...util.EventType) {
+			for _, event := range evts {
+				events = append(events, event)
+				if event == reqClose || event == reqQuit {
+					looping = false
+				}
+			}
+		}
+		toggle := func() {
+			idx := t.listIndex(t.cy)
+			if idx < t.merger.Length() {
+				item := t.merger.Get(idx)
+				if _, found := t.selected[item.text]; !found {
+					t.selected[item.text] = item.origText
+				} else {
+					delete(t.selected, item.text)
+				}
+				req(reqInfo)
+			}
+		}
+		switch event.Type {
+		case C.Invalid:
+			t.mutex.Unlock()
+			continue
+		case C.CtrlA:
+			t.cx = 0
+		case C.CtrlB:
+			if t.cx > 0 {
+				t.cx--
+			}
+		case C.CtrlC, C.CtrlG, C.CtrlQ, C.ESC:
+			req(reqQuit)
+		case C.CtrlD:
+			if !t.delChar() && t.cx == 0 {
+				req(reqQuit)
+			}
+		case C.CtrlE:
+			t.cx = len(t.input)
+		case C.CtrlF:
+			if t.cx < len(t.input) {
+				t.cx++
+			}
+		case C.CtrlH:
+			if t.cx > 0 {
+				t.input = append(t.input[:t.cx-1], t.input[t.cx:]...)
+				t.cx--
+			}
+		case C.Tab:
+			if t.multi && t.merger.Length() > 0 {
+				toggle()
+				t.vmove(-1)
+				req(reqList)
+			}
+		case C.BTab:
+			if t.multi && t.merger.Length() > 0 {
+				toggle()
+				t.vmove(1)
+				req(reqList)
+			}
+		case C.CtrlJ, C.CtrlN:
+			t.vmove(-1)
+			req(reqList)
+		case C.CtrlK, C.CtrlP:
+			t.vmove(1)
+			req(reqList)
+		case C.CtrlM:
+			req(reqClose)
+		case C.CtrlL:
+			req(reqRedraw)
+		case C.CtrlU:
+			if t.cx > 0 {
+				t.yanked = copySlice(t.input[:t.cx])
+				t.input = t.input[t.cx:]
+				t.cx = 0
+			}
+		case C.CtrlW:
+			if t.cx > 0 {
+				t.rubout("\\s\\S")
+			}
+		case C.AltBS:
+			if t.cx > 0 {
+				t.rubout("[^[:alnum:]][[:alnum:]]")
+			}
+		case C.CtrlY:
+			t.input = append(append(t.input[:t.cx], t.yanked...), t.input[t.cx:]...)
+			t.cx += len(t.yanked)
+		case C.Del:
+			t.delChar()
+		case C.PgUp:
+			t.vmove(maxItems() - 1)
+			req(reqList)
+		case C.PgDn:
+			t.vmove(-(maxItems() - 1))
+			req(reqList)
+		case C.AltB:
+			t.cx = findLastMatch("[^[:alnum:]][[:alnum:]]", string(t.input[:t.cx])) + 1
+		case C.AltF:
+			t.cx += findFirstMatch("[[:alnum:]][^[:alnum:]]|(.$)", string(t.input[t.cx:])) + 1
+		case C.AltD:
+			ncx := t.cx +
+				findFirstMatch("[[:alnum:]][^[:alnum:]]|(.$)", string(t.input[t.cx:])) + 1
+			if ncx > t.cx {
+				t.yanked = copySlice(t.input[t.cx:ncx])
+				t.input = append(t.input[:t.cx], t.input[ncx:]...)
+			}
+		case C.Rune:
+			prefix := copySlice(t.input[:t.cx])
+			t.input = append(append(prefix, event.Char), t.input[t.cx:]...)
+			t.cx++
+		case C.Mouse:
+			me := event.MouseEvent
+			mx, my := util.Constrain(me.X-len(t.prompt), 0, len(t.input)), me.Y
+			if !t.reverse {
+				my = C.MaxY() - my - 1
+			}
+			if me.S != 0 {
+				// Scroll
+				if t.merger.Length() > 0 {
+					if t.multi && me.Mod {
+						toggle()
+					}
+					t.vmove(me.S)
+					req(reqList)
+				}
+			} else if me.Double {
+				// Double-click
+				if my >= 2 {
+					if t.vset(my-2) && t.listIndex(t.cy) < t.merger.Length() {
+						req(reqClose)
+					}
+				}
+			} else if me.Down {
+				if my == 0 && mx >= 0 {
+					// Prompt
+					t.cx = mx
+				} else if my >= 2 {
+					// List
+					if t.vset(t.offset+my-2) && t.multi && me.Mod {
+						toggle()
+					}
+					req(reqList)
+				}
+			}
+		}
+		changed := string(previousInput) != string(t.input)
+		t.mutex.Unlock() // Must be unlocked before touching reqBox
+
+		if changed {
+			t.eventBox.Set(EvtSearchNew, nil)
+		}
+		for _, event := range events {
+			t.reqBox.Set(event, nil)
+		}
+	}
+}
+
+func (t *Terminal) constrain() {
+	count := t.merger.Length()
+	height := C.MaxY() - 2
+	diffpos := t.cy - t.offset
+
+	t.cy = util.Constrain(t.cy, 0, count-1)
+
+	if t.cy > t.offset+(height-1) {
+		// Ceil
+		t.offset = t.cy - (height - 1)
+	} else if t.offset > t.cy {
+		// Floor
+		t.offset = t.cy
+	}
+
+	// Adjustment
+	if count-t.offset < height {
+		t.offset = util.Max(0, count-height)
+		t.cy = util.Constrain(t.offset+diffpos, 0, count-1)
+	}
+}
+
+func (t *Terminal) vmove(o int) {
+	if t.reverse {
+		t.vset(t.cy - o)
+	} else {
+		t.vset(t.cy + o)
+	}
+}
+
+func (t *Terminal) vset(o int) bool {
+	t.cy = util.Constrain(o, 0, t.merger.Length()-1)
+	return t.cy == o
+}
+
+func maxItems() int {
+	return C.MaxY() - 2
+}

src/tokenizer.go

@@ -0,0 +1,204 @@
+package fzf
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const rangeEllipsis = 0
+
+// Range represents nth-expression
+type Range struct {
+	begin int
+	end   int
+}
+
+// Transformed holds the result of tokenization and transformation
+type Transformed struct {
+	whole *string
+	parts []Token
+}
+
+// Token contains the tokenized part of the strings and its prefix length
+type Token struct {
+	text         *string
+	prefixLength int
+}
+
+// ParseRange parses nth-expression and returns the corresponding Range object
+func ParseRange(str *string) (Range, bool) {
+	if (*str) == ".." {
+		return Range{rangeEllipsis, rangeEllipsis}, true
+	} else if strings.HasPrefix(*str, "..") {
+		end, err := strconv.Atoi((*str)[2:])
+		if err != nil || end == 0 {
+			return Range{}, false
+		}
+		return Range{rangeEllipsis, end}, true
+	} else if strings.HasSuffix(*str, "..") {
+		begin, err := strconv.Atoi((*str)[:len(*str)-2])
+		if err != nil || begin == 0 {
+			return Range{}, false
+		}
+		return Range{begin, rangeEllipsis}, true
+	} else if strings.Contains(*str, "..") {
+		ns := strings.Split(*str, "..")
+		if len(ns) != 2 {
+			return Range{}, false
+		}
+		begin, err1 := strconv.Atoi(ns[0])
+		end, err2 := strconv.Atoi(ns[1])
+		if err1 != nil || err2 != nil {
+			return Range{}, false
+		}
+		return Range{begin, end}, true
+	}
+
+	n, err := strconv.Atoi(*str)
+	if err != nil || n == 0 {
+		return Range{}, false
+	}
+	return Range{n, n}, true
+}
+
+func withPrefixLengths(tokens []string, begin int) []Token {
+	ret := make([]Token, len(tokens))
+
+	prefixLength := begin
+	for idx, token := range tokens {
+		// Need to define a new local variable instead of the reused token to take
+		// the pointer to it
+		str := token
+		ret[idx] = Token{text: &str, prefixLength: prefixLength}
+		prefixLength += len([]rune(token))
+	}
+	return ret
+}
+
+const (
+	awkNil = iota
+	awkBlack
+	awkWhite
+)
+
+func awkTokenizer(input *string) ([]string, int) {
+	// 9, 32
+	ret := []string{}
+	str := []rune{}
+	prefixLength := 0
+	state := awkNil
+	for _, r := range []rune(*input) {
+		white := r == 9 || r == 32
+		switch state {
+		case awkNil:
+			if white {
+				prefixLength++
+			} else {
+				state = awkBlack
+				str = append(str, r)
+			}
+		case awkBlack:
+			str = append(str, r)
+			if white {
+				state = awkWhite
+			}
+		case awkWhite:
+			if white {
+				str = append(str, r)
+			} else {
+				ret = append(ret, string(str))
+				state = awkBlack
+				str = []rune{r}
+			}
+		}
+	}
+	if len(str) > 0 {
+		ret = append(ret, string(str))
+	}
+	return ret, prefixLength
+}
+
+// Tokenize tokenizes the given string with the delimiter
+func Tokenize(str *string, delimiter *regexp.Regexp) []Token {
+	if delimiter == nil {
+		// AWK-style (\S+\s*)
+		tokens, prefixLength := awkTokenizer(str)
+		return withPrefixLengths(tokens, prefixLength)
+	}
+	tokens := delimiter.FindAllString(*str, -1)
+	return withPrefixLengths(tokens, 0)
+}
+
+func joinTokens(tokens []Token) string {
+	ret := ""
+	for _, token := range tokens {
+		ret += *token.text
+	}
+	return ret
+}
+
+// Transform is used to transform the input when --with-nth option is given
+func Transform(tokens []Token, withNth []Range) *Transformed {
+	transTokens := make([]Token, len(withNth))
+	numTokens := len(tokens)
+	whole := ""
+	for idx, r := range withNth {
+		part := ""
+		minIdx := 0
+		if r.begin == r.end {
+			idx := r.begin
+			if idx == rangeEllipsis {
+				part += joinTokens(tokens)
+			} else {
+				if idx < 0 {
+					idx += numTokens + 1
+				}
+				if idx >= 1 && idx <= numTokens {
+					minIdx = idx - 1
+					part += *tokens[idx-1].text
+				}
+			}
+		} else {
+			var begin, end int
+			if r.begin == rangeEllipsis { // ..N
+				begin, end = 1, r.end
+				if end < 0 {
+					end += numTokens + 1
+				}
+			} else if r.end == rangeEllipsis { // N..
+				begin, end = r.begin, numTokens
+				if begin < 0 {
+					begin += numTokens + 1
+				}
+			} else {
+				begin, end = r.begin, r.end
+				if begin < 0 {
+					begin += numTokens + 1
+				}
+				if end < 0 {
+					end += numTokens + 1
+				}
+			}
+			minIdx = util.Max(0, begin-1)
+			for idx := begin; idx <= end; idx++ {
+				if idx >= 1 && idx <= numTokens {
+					part += *tokens[idx-1].text
+				}
+			}
+		}
+		whole += part
+		var prefixLength int
+		if minIdx < numTokens {
+			prefixLength = tokens[minIdx].prefixLength
+		} else {
+			prefixLength = 0
+		}
+		transTokens[idx] = Token{&part, prefixLength}
+	}
+	return &Transformed{
+		whole: &whole,
+		parts: transTokens}
+}

src/tokenizer_test.go

@@ -0,0 +1,101 @@
+package fzf
+
+import "testing"
+
+func TestParseRange(t *testing.T) {
+	{
+		i := ".."
+		r, _ := ParseRange(&i)
+		if r.begin != rangeEllipsis || r.end != rangeEllipsis {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "3.."
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != rangeEllipsis {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "3..5"
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != 5 {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "-3..-5"
+		r, _ := ParseRange(&i)
+		if r.begin != -3 || r.end != -5 {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "3"
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != 3 {
+			t.Errorf("%s", r)
+		}
+	}
+}
+
+func TestTokenize(t *testing.T) {
+	// AWK-style
+	input := "  abc:  def:  ghi  "
+	tokens := Tokenize(&input, nil)
+	if *tokens[0].text != "abc:  " || tokens[0].prefixLength != 2 {
+		t.Errorf("%s", tokens)
+	}
+
+	// With delimiter
+	tokens = Tokenize(&input, delimiterRegexp(":"))
+	if *tokens[0].text != "  abc:" || tokens[0].prefixLength != 0 {
+		t.Errorf("%s", tokens)
+	}
+}
+
+func TestTransform(t *testing.T) {
+	input := "  abc:  def:  ghi:  jkl"
+	{
+		tokens := Tokenize(&input, nil)
+		{
+			ranges := splitNth("1,2,3")
+			tx := Transform(tokens, ranges)
+			if *tx.whole != "abc:  def:  ghi:  " {
+				t.Errorf("%s", *tx)
+			}
+		}
+		{
+			ranges := splitNth("1..2,3,2..,1")
+			tx := Transform(tokens, ranges)
+			if *tx.whole != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
+				len(tx.parts) != 4 ||
+				*tx.parts[0].text != "abc:  def:  " || tx.parts[0].prefixLength != 2 ||
+				*tx.parts[1].text != "ghi:  " || tx.parts[1].prefixLength != 14 ||
+				*tx.parts[2].text != "def:  ghi:  jkl" || tx.parts[2].prefixLength != 8 ||
+				*tx.parts[3].text != "abc:  " || tx.parts[3].prefixLength != 2 {
+				t.Errorf("%s", *tx)
+			}
+		}
+	}
+	{
+		tokens := Tokenize(&input, delimiterRegexp(":"))
+		{
+			ranges := splitNth("1..2,3,2..,1")
+			tx := Transform(tokens, ranges)
+			if *tx.whole != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
+				len(tx.parts) != 4 ||
+				*tx.parts[0].text != "  abc:  def:" || tx.parts[0].prefixLength != 0 ||
+				*tx.parts[1].text != "  ghi:" || tx.parts[1].prefixLength != 12 ||
+				*tx.parts[2].text != "  def:  ghi:  jkl" || tx.parts[2].prefixLength != 6 ||
+				*tx.parts[3].text != "  abc:" || tx.parts[3].prefixLength != 0 {
+				t.Errorf("%s", *tx)
+			}
+		}
+	}
+}
+
+func TestTransformIndexOutOfBounds(t *testing.T) {
+	Transform([]Token{}, splitNth("1"))
+}

src/util/atomicbool.go

@@ -0,0 +1,32 @@
+package util
+
+import "sync"
+
+// AtomicBool is a boxed-class that provides synchronized access to the
+// underlying boolean value
+type AtomicBool struct {
+	mutex sync.Mutex
+	state bool
+}
+
+// NewAtomicBool returns a new AtomicBool
+func NewAtomicBool(initialState bool) *AtomicBool {
+	return &AtomicBool{
+		mutex: sync.Mutex{},
+		state: initialState}
+}
+
+// Get returns the current boolean value synchronously
+func (a *AtomicBool) Get() bool {
+	a.mutex.Lock()
+	defer a.mutex.Unlock()
+	return a.state
+}
+
+// Set updates the boolean value synchronously
+func (a *AtomicBool) Set(newState bool) bool {
+	a.mutex.Lock()
+	defer a.mutex.Unlock()
+	a.state = newState
+	return a.state
+}

src/util/atomicbool_test.go

@@ -0,0 +1,17 @@
+package util
+
+import "testing"
+
+func TestAtomicBool(t *testing.T) {
+	if !NewAtomicBool(true).Get() || NewAtomicBool(false).Get() {
+		t.Error("Invalid initial value")
+	}
+
+	ab := NewAtomicBool(true)
+	if ab.Set(false) {
+		t.Error("Invalid return value")
+	}
+	if ab.Get() {
+		t.Error("Invalid state")
+	}
+}

src/util/eventbox.go

@@ -0,0 +1,80 @@
+package util
+
+import "sync"
+
+// EventType is the type for fzf events
+type EventType int
+
+// Events is a type that associates EventType to any data
+type Events map[EventType]interface{}
+
+// EventBox is used for coordinating events
+type EventBox struct {
+	events Events
+	cond   *sync.Cond
+	ignore map[EventType]bool
+}
+
+// NewEventBox returns a new EventBox
+func NewEventBox() *EventBox {
+	return &EventBox{
+		events: make(Events),
+		cond:   sync.NewCond(&sync.Mutex{}),
+		ignore: make(map[EventType]bool)}
+}
+
+// Wait blocks the goroutine until signaled
+func (b *EventBox) Wait(callback func(*Events)) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+
+	if len(b.events) == 0 {
+		b.cond.Wait()
+	}
+
+	callback(&b.events)
+}
+
+// Set turns on the event type on the box
+func (b *EventBox) Set(event EventType, value interface{}) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+	b.events[event] = value
+	if _, found := b.ignore[event]; !found {
+		b.cond.Broadcast()
+	}
+}
+
+// Clear clears the events
+// Unsynchronized; should be called within Wait routine
+func (events *Events) Clear() {
+	for event := range *events {
+		delete(*events, event)
+	}
+}
+
+// Peak peaks at the event box if the given event is set
+func (b *EventBox) Peak(event EventType) bool {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+	_, ok := b.events[event]
+	return ok
+}
+
+// Watch deletes the events from the ignore list
+func (b *EventBox) Watch(events ...EventType) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+	for _, event := range events {
+		delete(b.ignore, event)
+	}
+}
+
+// Unwatch adds the events to the ignore list
+func (b *EventBox) Unwatch(events ...EventType) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+	for _, event := range events {
+		b.ignore[event] = true
+	}
+}

src/util/eventbox_test.go

@@ -0,0 +1,61 @@
+package util
+
+import "testing"
+
+// fzf events
+const (
+	EvtReadNew EventType = iota
+	EvtReadFin
+	EvtSearchNew
+	EvtSearchProgress
+	EvtSearchFin
+	EvtClose
+)
+
+func TestEventBox(t *testing.T) {
+	eb := NewEventBox()
+
+	// Wait should return immediately
+	ch := make(chan bool)
+
+	go func() {
+		eb.Set(EvtReadNew, 10)
+		ch <- true
+		<-ch
+		eb.Set(EvtSearchNew, 10)
+		eb.Set(EvtSearchNew, 15)
+		eb.Set(EvtSearchNew, 20)
+		eb.Set(EvtSearchProgress, 30)
+		ch <- true
+		<-ch
+		eb.Set(EvtSearchFin, 40)
+		ch <- true
+		<-ch
+	}()
+
+	count := 0
+	sum := 0
+	looping := true
+	for looping {
+		<-ch
+		eb.Wait(func(events *Events) {
+			for _, value := range *events {
+				switch val := value.(type) {
+				case int:
+					sum += val
+					looping = sum < 100
+				}
+			}
+			events.Clear()
+		})
+		ch <- true
+		count++
+	}
+
+	if count != 3 {
+		t.Error("Invalid number of events", count)
+	}
+	if sum != 100 {
+		t.Error("Invalid sum", sum)
+	}
+}

src/util/util.go

@@ -0,0 +1,56 @@
+package util
+
+// #include <unistd.h>
+import "C"
+
+import (
+	"os"
+	"time"
+)
+
+// Max returns the largest integer
+func Max(first int, items ...int) int {
+	max := first
+	for _, item := range items {
+		if item > max {
+			max = item
+		}
+	}
+	return max
+}
+
+// Max32 returns the largest 32-bit integer
+func Max32(first int32, second int32) int32 {
+	if first > second {
+		return first
+	}
+	return second
+}
+
+// Constrain limits the given integer with the upper and lower bounds
+func Constrain(val int, min int, max int) int {
+	if val < min {
+		return min
+	}
+	if val > max {
+		return max
+	}
+	return val
+}
+
+// DurWithin limits the given time.Duration with the upper and lower bounds
+func DurWithin(
+	val time.Duration, min time.Duration, max time.Duration) time.Duration {
+	if val < min {
+		return min
+	}
+	if val > max {
+		return max
+	}
+	return val
+}
+
+// IsTty returns true is stdin is a terminal
+func IsTty() bool {
+	return int(C.isatty(C.int(os.Stdin.Fd()))) != 0
+}

src/util/util_test.go

@@ -0,0 +1,22 @@
+package util
+
+import "testing"
+
+func TestMax(t *testing.T) {
+	if Max(-2, 5, 1, 4, 3) != 5 {
+		t.Error("Invalid result")
+	}
+}
+
+func TestContrain(t *testing.T) {
+	if Constrain(-3, -1, 3) != -1 {
+		t.Error("Expected", -1)
+	}
+	if Constrain(2, -1, 3) != 2 {
+		t.Error("Expected", 2)
+	}
+
+	if Constrain(5, -1, 3) != 3 {
+		t.Error("Expected", 3)
+	}
+}

test/test_fzf.rb

@@ -1,14 +1,59 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
 
+require 'rubygems'
 require 'curses'
 require 'timeout'
 require 'stringio'
 require 'minitest/autorun'
+require 'tempfile'
 $LOAD_PATH.unshift File.expand_path('../..', __FILE__)
 ENV['FZF_EXECUTABLE'] = '0'
 load 'fzf'
 
+class MockTTY
+  def initialize
+    @buffer = ''
+    @mutex = Mutex.new
+    @condv = ConditionVariable.new
+  end
+
+  def read_nonblock sz
+    @mutex.synchronize do
+      take sz
+    end
+  end
+
+  def take sz
+    if @buffer.length >= sz
+      ret = @buffer[0, sz]
+      @buffer = @buffer[sz..-1]
+      ret
+    end
+  end
+
+  def getc
+    sleep 0.1
+    while true
+      @mutex.synchronize do
+        if char = take(1)
+          return char
+        else
+          @condv.wait(@mutex)
+        end
+      end
+    end
+  end
+
+  def << str
+    @mutex.synchronize do
+      @buffer << str
+      @condv.broadcast
+    end
+    self
+  end
+end
+
 class TestFZF < MiniTest::Unit::TestCase
   def setup
     ENV.delete 'FZF_DEFAULT_SORT'
@@ -24,15 +69,18 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal nil,   fzf.rxflag
     assert_equal true,  fzf.mouse
     assert_equal nil,   fzf.nth
+    assert_equal nil,   fzf.with_nth
     assert_equal true,  fzf.color
     assert_equal false, fzf.black
     assert_equal true,  fzf.ansi256
-    assert_equal '',    fzf.query.get
+    assert_equal '',    fzf.query
     assert_equal false, fzf.select1
     assert_equal false, fzf.exit0
     assert_equal nil,   fzf.filter
     assert_equal nil,   fzf.extended
     assert_equal false, fzf.reverse
+    assert_equal '> ',  fzf.prompt
+    assert_equal false, fzf.print_query
   end
 
   def test_environment_variables
@@ -43,12 +91,12 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal nil,   fzf.nth
 
     ENV['FZF_DEFAULT_OPTS'] =
-      '-x -m -s 10000 -q "  hello  world  " +c +2 --select-1 -0 ' +
-      '--no-mouse -f "goodbye world" --black --nth=3,-1,2 --reverse'
+      '-x -m -s 10000 -q "  hello  world  " +c +2 --select-1 -0 ' <<
+      '--no-mouse -f "goodbye world" --black --with-nth=3,-3..,2 --nth=3,-1,2 --reverse --print-query'
     fzf = FZF.new []
     assert_equal 10000,   fzf.sort
     assert_equal '  hello  world  ',
-                          fzf.query.get
+                          fzf.query
     assert_equal 'goodbye world',
                           fzf.filter
     assert_equal :fuzzy,  fzf.extended
@@ -60,14 +108,17 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal true,    fzf.select1
     assert_equal true,    fzf.exit0
     assert_equal true,    fzf.reverse
-    assert_equal [3, -1, 2], fzf.nth
+    assert_equal true,    fzf.print_query
+    assert_equal [2..2, -1..-1, 1..1], fzf.nth
+    assert_equal [2..2, -3..-1, 1..1], fzf.with_nth
   end
 
   def test_option_parser
     # Long opts
     fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query hello --select-1
                      --exit-0 --filter=howdy --extended-exact
-                     --no-mouse --no-256 --nth=1 --reverse]
+                     --no-mouse --no-256 --nth=1 --with-nth=.. --reverse --prompt (hi)
+                     --print-query]
     assert_equal 2000,    fzf.sort
     assert_equal true,    fzf.multi
     assert_equal false,   fzf.color
@@ -75,20 +126,24 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal false,   fzf.black
     assert_equal false,   fzf.mouse
     assert_equal 0,       fzf.rxflag
-    assert_equal 'hello', fzf.query.get
+    assert_equal 'hello', fzf.query
     assert_equal true,    fzf.select1
     assert_equal true,    fzf.exit0
     assert_equal 'howdy', fzf.filter
     assert_equal :exact,  fzf.extended
-    assert_equal [1],     fzf.nth
+    assert_equal [0..0],  fzf.nth
+    assert_equal nil,     fzf.with_nth
     assert_equal true,    fzf.reverse
+    assert_equal '(hi)',  fzf.prompt
+    assert_equal true,    fzf.print_query
 
     # Long opts (left-to-right)
     fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query=hello
                      --filter a --filter b --no-256 --black --nth -1 --nth -2
                      --select-1 --exit-0 --no-select-1 --no-exit-0
                      --no-sort -i --color --no-multi --256
-                     --reverse --no-reverse]
+                     --reverse --no-reverse --prompt (hi) --prompt=(HI)
+                     --print-query --no-print-query]
     assert_equal nil,     fzf.sort
     assert_equal false,   fzf.multi
     assert_equal true,    fzf.color
@@ -97,12 +152,14 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal true,    fzf.mouse
     assert_equal 1,       fzf.rxflag
     assert_equal 'b',     fzf.filter
-    assert_equal 'hello', fzf.query.get
+    assert_equal 'hello', fzf.query
     assert_equal false,   fzf.select1
     assert_equal false,   fzf.exit0
     assert_equal nil,     fzf.extended
-    assert_equal [-2],    fzf.nth
+    assert_equal [-2..-2], fzf.nth
     assert_equal false,   fzf.reverse
+    assert_equal '(HI)',  fzf.prompt
+    assert_equal false,    fzf.print_query
 
     # Short opts
     fzf = FZF.new %w[-s2000 +c -m +i -qhello -x -fhowdy +2 -n3 -1 -0]
@@ -111,10 +168,10 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal false,   fzf.color
     assert_equal false,   fzf.ansi256
     assert_equal 0,       fzf.rxflag
-    assert_equal 'hello', fzf.query.get
+    assert_equal 'hello', fzf.query
     assert_equal 'howdy', fzf.filter
     assert_equal :fuzzy,  fzf.extended
-    assert_equal [3],     fzf.nth
+    assert_equal [2..2],  fzf.nth
     assert_equal true,    fzf.select1
     assert_equal true,    fzf.exit0
 
@@ -129,37 +186,41 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal true,    fzf.ansi256
     assert_equal false,   fzf.black
     assert_equal 1,       fzf.rxflag
-    assert_equal 'world', fzf.query.get
+    assert_equal 'world', fzf.query
     assert_equal false,   fzf.select1
     assert_equal false,   fzf.exit0
     assert_equal 'world', fzf.filter
     assert_equal nil,     fzf.extended
-    assert_equal [4, 5],  fzf.nth
+    assert_equal [3..3, 4..4], fzf.nth
   rescue SystemExit => e
     assert false, "Exited"
   end
 
   def test_invalid_option
-    [%w[--unknown], %w[yo dawg]].each do |argv|
+    [
+      %w[--unknown],
+      %w[yo dawg],
+      %w[--nth=0],
+      %w[-n 0],
+      %w[-n 1..2..3],
+      %w[-n 1....],
+      %w[-n ....3],
+      %w[-n 1....3],
+      %w[-n 1..0],
+      %w[--nth ..0],
+    ].each do |argv|
       assert_raises(SystemExit) do
         fzf = FZF.new argv
       end
     end
-    assert_raises(SystemExit) do
-      fzf = FZF.new %w[--nth=0]
-    end
-    assert_raises(SystemExit) do
-      fzf = FZF.new %w[-n 0]
-    end
   end
 
-  # FIXME Only on 1.9 or above
   def test_width
     fzf = FZF.new []
     assert_equal 5, fzf.width('abcde')
     assert_equal 4, fzf.width('한글')
     assert_equal 5, fzf.width('한글.')
-  end
+  end if RUBY_VERSION >= '1.9'
 
   def test_trim
     fzf = FZF.new []
@@ -172,7 +233,7 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal ['가나a',   6], fzf.trim('가나ab라마바사.', 5, false)
     assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 6, false)
     assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 7, false)
-  end
+  end if RUBY_VERSION >= '1.9'
 
   def test_format
     fzf = FZF.new []
@@ -450,58 +511,11 @@ class TestFZF < MiniTest::Unit::TestCase
     assert_equal 2, exact.match(list, "-fuzzy", '', '').length
   end
 
-  if RUBY_PLATFORM =~ /darwin/
-    NFD = '한글'
-    def test_nfc
-      assert_equal 6, NFD.length
-      assert_equal ["한글", [[0, 1], [1, 2]]],
-        FZF::UConv.nfc(NFD, [[0, 3], [3, 6]])
-
-      nfd2 = 'before' + NFD + 'after'
-      assert_equal 6 + 6 + 5, nfd2.length
-
-      nfc, offsets = FZF::UConv.nfc(nfd2, [[4, 14], [9, 13]])
-      o1, o2 = offsets
-      assert_equal 'before한글after', nfc
-      assert_equal 're한글af',        nfc[(o1.first...o1.last)]
-      assert_equal '글a',             nfc[(o2.first...o2.last)]
-    end
-
-    def test_nfd
-      nfc = '한글'
-      nfd = FZF::UConv.nfd(nfc)
-      assert_equal 2, nfd.length
-      assert_equal 6, nfd.join.length
-      assert_equal NFD, nfd.join
-    end
-
-    def test_nfd_fuzzy_matcher
-      matcher = FZF::FuzzyMatcher.new 0
-      assert_equal [], matcher.match([NFD + NFD], '할', '', '')
-      match   = matcher.match([NFD + NFD], '글글', '', '')
-      assert_equal [[NFD + NFD, [[3, 12]]]], match
-      assert_equal ['한글한글', [[1, 4]]], FZF::UConv.nfc(*match.first)
-    end
-
-    def test_nfd_extended_fuzzy_matcher
-      matcher = FZF::ExtendedFuzzyMatcher.new 0
-      assert_equal [], matcher.match([NFD], "'글글", '', '')
-      match   = matcher.match([NFD], "'한글", '', '')
-      assert_equal [[NFD, [[0, 6]]]], match
-      assert_equal ['한글', [[0, 2]]], FZF::UConv.nfc(*match.first)
-    end
-  end
-
-  def test_split
-    assert_equal ["a", "b", "c", "\xFF", "d", "e", "f"],
-      FZF::UConv.split("abc\xFFdef")
-  end
-
   # ^$ -> matches empty item
   def test_format_empty_item
     fzf = FZF.new []
     item = ['', [[0, 0]]]
-    line, offsets = fzf.convert_item item
+    line, offsets = item
     tokens        = fzf.format line, 80, offsets
     assert_equal [], tokens
   end
@@ -534,126 +548,176 @@ class TestFZF < MiniTest::Unit::TestCase
       [list[0], [[2,  5]]],
       [list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
 
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2]
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1]
     assert_equal [[list[1], [[8, 9]]]], matcher.match(list, 'f', '', '')
     assert_equal [[list[0], [[8, 9]]]], matcher.match(list, 's', '', '')
 
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [3]
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2..2]
     assert_equal [[list[0], [[19, 20]]]], matcher.match(list, 'r', '', '')
 
     # Comma-separated
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [3, 1]
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2..2, 0..0]
     assert_equal [[list[0], [[19, 20]]], [list[1], [[3, 4]]]], matcher.match(list, 'r', '', '')
 
     # Ordered
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1, 3]
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0, 2..2]
     assert_equal [[list[0], [[3, 4]]], [list[1], [[3, 4]]]], matcher.match(list, 'r', '', '')
 
     regex = FZF.build_delim_regex "\t"
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1], regex
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0], regex
     assert_equal [[list[0], [[3, 10]]]], matcher.match(list, 're', '', '')
 
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2], regex
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1], regex
     assert_equal [], matcher.match(list, 'r', '', '')
     assert_equal [[list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
 
     # Negative indexing
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [-1], regex
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [-1..-1], regex
     assert_equal [[list[0], [[3, 6]]]], matcher.match(list, 'rt', '', '')
     assert_equal [[list[0], [[2, 5]]], [list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
 
     # Regex delimiter
     regex = FZF.build_delim_regex "[ \t]+"
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1], regex
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0], regex
     assert_equal [list[1]], matcher.match(list, 'f', '', '').map(&:first)
 
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2], regex
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1], regex
     assert_equal [[list[0], [[1, 2]]], [list[1], [[8, 9]]]], matcher.match(list, 'f', '', '')
   end
 
-  def stream_for str
+  def test_nth_match_range
+    list = [
+      ' first  second  third',
+      'fourth	 fifth   sixth',
+    ]
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..2]
+    assert_equal [[list[0], [[8, 20]]]], matcher.match(list, 'sr', '', '')
+    assert_equal [], matcher.match(list, 'fo', '', '')
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..-1, 0..0]
+    assert_equal [[list[0], [[8, 20]]]], matcher.match(list, 'sr', '', '')
+    assert_equal [[list[1], [[0, 2]]]], matcher.match(list, 'fo', '', '')
+
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [0..0, 1..2]
+    assert_equal [], matcher.match(list, '^t', '', '')
+
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [0..1, 2..2]
+    assert_equal [[list[0], [[16, 17]]]], matcher.match(list, '^t', '', '')
+
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [1..-1]
+    assert_equal [[list[0], [[8, 9]]]], matcher.match(list, '^s', '', '')
+  end
+
+  def stream_for str, delay = 0
     StringIO.new(str).tap do |sio|
       sio.instance_eval do
         alias org_gets gets
 
         def gets
-          org_gets.tap { |e| sleep 0.5 unless e.nil? }
+          org_gets.tap { |e| sleep(@delay) unless e.nil? }
+        end
+
+        def reopen _
         end
       end
+      sio.instance_variable_set :@delay, delay
+    end
+  end
+
+  def assert_fzf_output opts, given, expected
+    stream = stream_for given
+    output = stream_for ''
+
+    def sorted_lines line
+      line.split($/).sort
+    end
+
+    begin
+      tty = MockTTY.new
+      $stdout = output
+      fzf = FZF.new(opts, stream)
+      fzf.instance_variable_set :@tty, tty
+      thr = block_given? && Thread.new { yield tty }
+      fzf.start
+      thr && thr.join
+    rescue SystemExit => e
+      assert_equal 0, e.status
+      assert_equal sorted_lines(expected), sorted_lines(output.string)
+    ensure
+      $stdout = STDOUT
+    end
+  end
+
+  def test_filter
+    {
+      %w[--filter=ol] => 'World',
+      %w[--filter=ol --print-query] => "ol\nWorld",
+    }.each do |opts, expected|
+      assert_fzf_output opts, "Hello\nWorld", expected
     end
   end
 
   def test_select_1
-    stream = stream_for "Hello\nWorld"
-    output = StringIO.new
-
-    begin
-      $stdout = output
-      FZF.new(%w[--query=ol --select-1], stream).start
-    rescue SystemExit => e
-      assert_equal 0, e.status
-      assert_equal 'World', output.string.chomp
-    ensure
-      $stdout = STDOUT
+    {
+      %w[--query=ol --select-1] => 'World',
+      %w[--query=ol --select-1 --print-query] => "ol\nWorld",
+    }.each do |opts, expected|
+      assert_fzf_output opts, "Hello\nWorld", expected
     end
   end
 
   def test_select_1_without_query
-    stream = stream_for "Hello World"
-    output = StringIO.new
-
-    begin
-      $stdout = output
-      FZF.new(%w[--select-1], stream).start
-    rescue SystemExit => e
-      assert_equal 0, e.status
-      assert_equal 'Hello World', output.string.chomp
-    ensure
-      $stdout = STDOUT
-    end
+    assert_fzf_output %w[--select-1], 'Hello World', 'Hello World'
   end
 
   def test_select_1_ambiguity
-    stream = stream_for "Hello\nWorld"
     begin
-      Timeout::timeout(3) do
-        FZF.new(%w[--query=o --select-1], stream).start
+      Timeout::timeout(0.5) do
+        assert_fzf_output %w[--query=o --select-1], "hello\nworld", "should not match"
       end
-      flunk 'Should not reach here'
-    rescue Exception => e
+    rescue Timeout::Error
       Curses.close_screen
-      assert_instance_of Timeout::Error, e
     end
   end
 
   def test_exit_0
-    stream = stream_for "Hello\nWorld"
-    output = StringIO.new
-
-    begin
-      $stdout = output
-      FZF.new(%w[--query=zz --exit-0], stream).start
-    rescue SystemExit => e
-      assert_equal 0, e.status
-      assert_equal '', output.string
-    ensure
-      $stdout = STDOUT
+    {
+      %w[--query=zz --exit-0] => '',
+      %w[--query=zz --exit-0 --print-query] => 'zz',
+    }.each do |opts, expected|
+      assert_fzf_output opts, "Hello\nWorld", expected
     end
   end
 
   def test_exit_0_without_query
-    stream = stream_for ""
-    output = StringIO.new
+    assert_fzf_output %w[--exit-0], '', ''
+  end
 
-    begin
-      $stdout = output
-      FZF.new(%w[--exit-0], stream).start
-    rescue SystemExit => e
-      assert_equal 0, e.status
-      assert_equal '', output.string
-    ensure
-      $stdout = STDOUT
-    end
+  def test_with_nth
+    source = "hello world\nbatman"
+    assert_fzf_output %w[-0 -1 --with-nth=2,1 -x -q ^worl],
+      source, 'hello world'
+    assert_fzf_output %w[-0 -1 --with-nth=2,1 -x -q llo$],
+      source, 'hello world'
+    assert_fzf_output %w[-0 -1 --with-nth=.. -x -q llo$],
+      source, ''
+    assert_fzf_output %w[-0 -1 --with-nth=2,2,2,..,1 -x -q worlworlworlhellworlhell],
+      source, 'hello world'
+    assert_fzf_output %w[-0 -1 --with-nth=1,1,-1,1 -x -q batbatbatbat],
+      source, 'batman'
+  end
+
+  def test_with_nth_transform
+    fzf = FZF.new %w[--with-nth 2..,1]
+    assert_equal 'my world hello', fzf.transform('hello my world')
+    assert_equal 'my   world hello', fzf.transform('hello   my   world')
+    assert_equal 'my   world  hello', fzf.transform('hello   my   world  ')
+
+    fzf = FZF.new %w[--with-nth 2,-1,2]
+    assert_equal 'my world my', fzf.transform('hello my world')
+    assert_equal 'world world world', fzf.transform('hello world')
+    assert_equal 'world  world  world', fzf.transform('hello world  ')
   end
 
   def test_ranking_overlap_match_regions
@@ -666,5 +730,121 @@ class TestFZF < MiniTest::Unit::TestCase
       ['1           3   4      2', [[0, 24], [12, 17]]],
     ], FZF.sort(FZF::ExtendedFuzzyMatcher.new(nil).match(list, '12 34', '', ''))
   end
+
+  def test_constrain
+    fzf = FZF.new []
+
+    # [#****             ]
+    assert_equal [false, 0, 0], fzf.constrain(0, 0, 5, 100)
+
+    # *****[**#**  ...   ] => [**#*******  ... ]
+    assert_equal [true, 0, 2], fzf.constrain(5, 7, 10, 100)
+
+    # [**********]**#** => ***[*********#]**
+    assert_equal [true, 3, 12], fzf.constrain(0, 12, 15, 10)
+
+    # *****[**#**  ] => ***[**#****]
+    assert_equal [true, 3, 5], fzf.constrain(5, 7, 10, 7)
+
+    # *****[**#** ] => ****[**#***]
+    assert_equal [true, 4, 6], fzf.constrain(5, 7, 10, 6)
+
+    # *****  [#] => ****[#]
+    assert_equal [true, 4, 4], fzf.constrain(10, 10, 5, 1)
+
+    # [ ] #**** => [#]****
+    assert_equal [true, 0, 0], fzf.constrain(-5, 0, 5, 1)
+
+    # [ ] **#** => **[#]**
+    assert_equal [true, 2, 2], fzf.constrain(-5, 2, 5, 1)
+
+    # [*****  #] => [****#   ]
+    assert_equal [true, 0, 4], fzf.constrain(0, 7, 5, 10)
+
+    # **[*****  #] => [******# ]
+    assert_equal [true, 0, 6], fzf.constrain(2, 10, 7, 10)
+  end
+
+  def test_invalid_utf8
+    tmp = Tempfile.new('fzf')
+    tmp << 'hello ' << [0xff].pack('C*') << ' world' << $/ << [0xff].pack('C*')
+    tmp.close
+    begin
+      Timeout::timeout(0.5) do
+        FZF.new(%w[-n..,1,2.. -q^ -x], File.open(tmp.path)).start
+      end
+    rescue Timeout::Error
+      Curses.close_screen
+    end
+  ensure
+    tmp.unlink
+  end
+
+  def test_with_nth_mock_tty
+    # Manual selection with input
+    assert_fzf_output ["--with-nth=2,1"], "hello world", "hello world" do |tty|
+      tty << "world"
+      tty << "hell"
+      tty << "\r"
+    end
+
+    # Manual selection without input
+    assert_fzf_output ["--with-nth=2,1"], "hello world", "hello world" do |tty|
+      tty << "\r"
+    end
+
+    # Manual selection with input and --multi
+    lines = "hello world\ngoodbye world"
+    assert_fzf_output %w[-m --with-nth=2,1], lines, lines do |tty|
+      tty << "o"
+      tty << "\e[Z\e[Z"
+      tty << "\r"
+    end
+
+    # Manual selection without input and --multi
+    assert_fzf_output %w[-m --with-nth=2,1], lines, lines do |tty|
+      tty << "\e[Z\e[Z"
+      tty << "\r"
+    end
+
+    # ALT-D
+    assert_fzf_output %w[--print-query], "", "hello  baby = world" do |tty|
+      tty << "hello world baby"
+      tty << alt(:b) << alt(:b) << alt(:d)
+      tty << ctrl(:e) << " = " << ctrl(:y)
+      tty << "\r"
+    end
+
+    # ALT-BACKSPACE
+    assert_fzf_output %w[--print-query], "", "hello baby = world " do |tty|
+      tty << "hello world baby"
+      tty << alt(:b) << alt(127.chr)
+      tty << ctrl(:e) << " = " << ctrl(:y)
+      tty << "\r"
+    end
+
+    # Word-movements
+    assert_fzf_output %w[--print-query], "", "ello!_orld!~ foo=?" do |tty|
+      tty << "hello_world==baby?"
+      tty << alt(:b) << ctrl(:d)
+      tty << alt(:b) << ctrl(:d)
+      tty << alt(:b) << ctrl(:d)
+      tty << alt(:f) << '!'
+      tty << alt(:f) << '!'
+      tty << alt(:d) << '~'
+      tty << " foo=bar foo=bar"
+      tty << ctrl(:w)
+      tty << alt(127.chr)
+      tty << "\r"
+    end
+  end
+
+  def alt chr
+    "\e#{chr}"
+  end
+
+  def ctrl char
+    char.to_s.ord - 'a'.ord + 1
+  end
 end
 

uninstall

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+
+confirm() {
+  while [ 1 ]; do
+    read -p "$1" -n 1 -r
+    echo
+    if [[ "$REPLY" =~ ^[Yy] ]]; then
+      return 0
+    elif [[ "$REPLY" =~ ^[Nn] ]]; then
+      return 1
+    fi
+  done
+}
+
+remove() {
+  echo "Remove $1"
+  rm -f "$1"
+}
+
+remove_line() {
+  src=$(readlink "$1")
+  if [ $? -eq 0 ]; then
+    echo "Remove from $1 ($src):"
+  else
+    src=$1
+    echo "Remove from $1:"
+  fi
+
+  shift
+  line_no=1
+  match=0
+  while [ -n "$1" ]; do
+    line=$(sed -n "$line_no,\$p" "$src" | \grep -m1 -nF "$1")
+    if [ $? -ne 0 ]; then
+      shift
+      line_no=1
+      continue
+    fi
+    line_no=$(( $(sed 's/:.*//' <<< "$line") + line_no - 1 ))
+    content=$(sed 's/^[0-9]*://' <<< "$line")
+    match=1
+    echo    "  - Line #$line_no: $content"
+    [ "$content" = "$1" ] || confirm "    - Remove (y/n) ? "
+    if [ $? -eq 0 ]; then
+      awk -v n=$line_no 'NR == n {next} {print}' "$src" > "$src.bak" &&
+        mv "$src.bak" "$src" || break
+      echo  "      - Removed"
+    else
+      echo  "      - Skipped"
+      line_no=$(( line_no + 1 ))
+    fi
+  done
+  [ $match -eq 0 ] && echo "  - Nothing found"
+  echo
+}
+
+for shell in bash zsh; do
+  remove ~/.fzf.${shell}
+  remove_line ~/.${shell}rc \
+    "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" \
+    "source ~/.fzf.${shell}"
+done
+
+bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
+if [ -f "$bind_file" ]; then
+  remove_line "$bind_file" "fzf_key_bindings"
+fi
+
+if [ -d ~/.config/fish/functions ]; then
+  remove ~/.config/fish/functions/fzf.fish
+
+  if [ "$(ls -A ~/.config/fish/functions)" ]; then
+    echo "Can't delete non-empty directory: \"~/.config/fish/functions\""
+  else
+    rmdir ~/.config/fish/functions
+  fi
+fi
+