0.15.9

Close #357
Close #738

.github/ISSUE_TEMPLATE.md

@@ -11,6 +11,7 @@
     - [ ] Linux
     - [ ] Mac OS X
     - [ ] Windows
+    - [ ] Windows Subsystem for Linux
     - [ ] Etc.
 - Shell
     - [ ] bash

.travis.yml

@@ -1,6 +1,10 @@
 language: ruby
-rvm:
-- 2.2.0
+matrix:
+  include:
+    - env: TAGS=
+      rvm: 2.2.0
+#   - env: TAGS=tcell
+#     rvm: 2.2.0
 
 install:
 - sudo apt-get update

CHANGELOG.md

@@ -1,6 +1,95 @@
 CHANGELOG
 =========
 
+0.15.9
+------
+- Fixed rendering glitches introduced in 0.15.8
+- The default escape delay is reduced to 50ms and is configurable via
+  `$ESCDELAY`
+- Scroll indicator at the top-right corner of the preview window is always
+  displayed when there's overflow
+- Can now be built with ncurses 6 or tcell to support extra features
+    - *ncurses 6*
+        - Supports more than 256 color pairs
+        - Supports italics
+    - *tcell*
+        - 24-bit color support
+    - See https://github.com/junegunn/fzf/blob/master/src/README.md#build
+
+0.15.8
+------
+- Updated ANSI processor to handle more VT-100 escape sequences
+- Added `--no-bold` (and `--bold`) option
+- Improved escape sequence processing for WSL
+- Added support for `alt-[0-9]`, `f11`, and `f12` for `--bind` and `--expect`
+
+0.15.7
+------
+- Fixed panic when color is disabled and header lines contain ANSI colors
+
+0.15.6
+------
+- Windows binaries! (@kelleyma49)
+- Fixed the bug where header lines are cleared when preview window is toggled
+- Fixed not to display ^N and ^O on screen
+- Fixed cursor keys (or any key sequence that starts with ESC) on WSL by
+  making fzf wait for additional keystrokes after ESC for up to 100ms
+
+0.15.5
+------
+- Setting foreground color will no longer set background color to black
+    - e.g. `fzf --color fg:153`
+- `--tiebreak=end` will consider relative position instead of absolute distance
+- Updated `fzf#wrap` function to respect `g:fzf_colors`
+
+0.15.4
+------
+- Added support for range expression in preview and execute action
+    - e.g. `ls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1`
+    - `{q}` will be replaced to the single-quoted string of the current query
+- Fixed to properly handle unicode whitespace characters
+- Display scroll indicator in preview window
+- Inverse search term will use exact matcher by default
+    - This is a breaking change, but I believe it makes much more sense. It is
+      almost impossible to predict which entries will be filtered out due to
+      a fuzzy inverse term. You can still perform inverse-fuzzy-match by
+      prepending `!'` to the term.
+
+0.15.3
+------
+- Added support for more ANSI attributes: dim, underline, blink, and reverse
+- Fixed race condition in `toggle-preview`
+
+0.15.2
+------
+- Preview window is now scrollable
+    - With mouse scroll or with bindable actions
+        - `preview-up`
+        - `preview-down`
+        - `preview-page-up`
+        - `preview-page-down`
+- Updated ANSI processor to support high intensity colors and ignore
+  some VT100-related escape sequences
+
+0.15.1
+------
+- Fixed panic when the pattern occurs after 2^15-th column
+- Fixed rendering delay when displaying extremely long lines
+
+0.15.0
+------
+- Improved fuzzy search algorithm
+    - Added `--algo=[v1|v2]` option so one can still choose the old algorithm
+      which values the search performance over the quality of the result
+- Advanced scoring criteria
+- `--read0` to read input delimited by ASCII NUL character
+- `--print0` to print output delimited by ASCII NUL character
+
+0.13.5
+------
+- Memory and performance optimization
+    - Up to 2x performance with half the amount of memory
+
 0.13.4
 ------
 - Performance optimization

README.md

@@ -10,18 +10,15 @@ Pros
 
 - No dependencies
 - Blazingly fast
-    - e.g. `locate / | fzf`
-- Flexible layout
-    - Runs in fullscreen or in horizontal/vertical split using tmux
 - The most comprehensive feature set
-    - Try `fzf --help` and be surprised
+- Flexible layout using tmux panes
 - Batteries included
     - Vim/Neovim plugin, key bindings and fuzzy auto-completion
 
 Installation
 ------------
 
-fzf project consists of the following:
+fzf project consists of the following components:
 
 - `fzf` executable
 - `fzf-tmux` script for launching fzf in a tmux pane
@@ -30,12 +27,12 @@ fzf project consists of the following:
     - Fuzzy auto-completion (bash, zsh)
 - Vim/Neovim plugin
 
-You can [download fzf executable][bin] alone, but it's recommended that you
-install the extra stuff using the attached install script.
+You can [download fzf executable][bin] alone if you don't need the extra
+stuff.
 
 [bin]: https://github.com/junegunn/fzf-bin/releases
 
-#### Using git (recommended)
+### Using git
 
 Clone this repository and run
 [install](https://github.com/junegunn/fzf/blob/master/install) script.
@@ -45,7 +42,7 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
-#### Using Homebrew
+### Using Homebrew
 
 On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
 
@@ -56,31 +53,44 @@ brew install fzf
 /usr/local/opt/fzf/install
 ```
 
-#### Install as Vim plugin
+### Vim plugin
 
-Once you have cloned the repository, add the following line to your .vimrc.
+You can manually add the directory to `&runtimepath` as follows,
 
 ```vim
+" If installed using git
 set rtp+=~/.fzf
+
+" If installed using Homebrew
+set rtp+=/usr/local/opt/fzf
 ```
 
-Or you can have [vim-plug](https://github.com/junegunn/vim-plug) manage fzf
-(recommended):
+But it's recommended that you use a plugin manager like
+[vim-plug](https://github.com/junegunn/vim-plug).
 
 ```vim
 Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
 ```
 
-#### Upgrading fzf
+### Upgrading fzf
 
 fzf is being actively developed and you might want to upgrade it once in a
 while. Please follow the instruction below depending on the installation
-method.
+method used.
 
 - git: `cd ~/.fzf && git pull && ./install`
 - brew: `brew update; brew reinstall fzf`
 - vim-plug: `:PlugUpdate fzf`
 
+### Windows
+
+Pre-built binaries for Windows can be downloaded [here][bin]. However, other
+components of the project may not work on Windows. You might want to consider
+installing fzf on [Windows Subsystem for Linux][wsl] where everything runs
+flawlessly.
+
+[wsl]: https://blogs.msdn.microsoft.com/wsl/
+
 Usage
 -----
 
@@ -101,7 +111,7 @@ vim $(fzf)
 
 #### Using the finder
 
-- `CTRL-J` / `CTRL-K` (or `CTRL-N` / `CTRL-P)` to move cursor up and down
+- `CTRL-J` / `CTRL-K` (or `CTRL-N` / `CTRL-P`) to move cursor up and down
 - `Enter` key to select the item, `CTRL-C` / `CTRL-G` / `ESC` to exit
 - On multi-select mode (`-m`), `TAB` and `Shift-TAB` to mark multiple items
 - Emacs style key bindings
@@ -112,16 +122,16 @@ vim $(fzf)
 
 Unless otherwise specified, fzf starts in "extended-search mode" where you can
 type in multiple search terms delimited by spaces. e.g. `^music .mp3$ sbtrkt
-!rmx`
+!fire`
 
-| Token    | Match type           | Description                      |
-| -------- | -------------------- | -------------------------------- |
-| `sbtrkt` | fuzzy-match          | Items that match `sbtrkt`        |
-| `^music` | prefix-exact-match   | Items that start with `music`    |
-| `.mp3$`  | suffix-exact-match   | Items that end with `.mp3`       |
-| `'wild`  | exact-match (quoted) | Items that include `wild`        |
-| `!rmx`   | inverse-fuzzy-match  | Items that do not match `rmx`    |
-| `!'fire` | inverse-exact-match  | Items that do not include `fire` |
+| Token    | Match type                 | Description                       |
+| -------- | -------------------------- | --------------------------------- |
+| `sbtrkt` | fuzzy-match                | Items that match `sbtrkt`         |
+| `^music` | prefix-exact-match         | Items that start with `music`     |
+| `.mp3$`  | suffix-exact-match         | Items that end with `.mp3`        |
+| `'wild`  | exact-match (quoted)       | Items that include `wild`         |
+| `!fire`  | inverse-exact-match        | Items that do not include `fire`  |
+| `!.mp3$` | inverse-suffix-exact-match | Items that do not end with `.mp3` |
 
 If you don't prefer fuzzy matching and do not wish to "quote" every word,
 start fzf with `-e` or `--exact` option. Note that when  `--exact` is set,
@@ -144,6 +154,10 @@ or `py`.
     - Default options
     - e.g. `export FZF_DEFAULT_OPTS="--reverse --inline-info"`
 
+#### Options
+
+See the man page (`man fzf`) for the full list of options.
+
 Examples
 --------
 
@@ -195,6 +209,8 @@ If you use vi mode on bash, you need to add `set -o vi` *before* `source
 ~/.fzf.bash` in your .bashrc, so that it correctly sets up key bindings for vi
 mode.
 
+More tips can be found on [the wiki page](https://github.com/junegunn/fzf/wiki/Configuring-shell-key-bindings).
+
 Fuzzy completion for bash and zsh
 ---------------------------------
 
@@ -304,7 +320,7 @@ If you have set up fzf for Vim, `:FZF` command will be added.
 :FZF ~
 
 " With options
-:FZF --no-sort -m /tmp
+:FZF --no-sort --reverse --inline-info /tmp
 
 " Bang version starts in fullscreen instead of using tmux pane or Neovim split
 :FZF!
@@ -318,7 +334,7 @@ Note that the environment variables `FZF_DEFAULT_COMMAND` and
 `FZF_DEFAULT_OPTS` also apply here. Refer to [the wiki page][fzf-config] for
 customization.
 
-[fzf-config]: https://github.com/junegunn/fzf/wiki/Configuring-FZF-command-(vim)
+[fzf-config]: https://github.com/junegunn/fzf/wiki/Configuring-Vim-plugin
 
 #### `fzf#run`
 
@@ -344,9 +360,10 @@ page](https://github.com/junegunn/fzf/wiki/Examples-(vim)).
 
 #### `fzf#wrap`
 
-`fzf#wrap(name string, [opts dict, [fullscreen boolean]])` is a helper
+`fzf#wrap([name string,] [opts dict,] [fullscreen boolean])` is a helper
 function that decorates the options dictionary so that it understands
-`g:fzf_layout`, `g:fzf_action`, and `g:fzf_history_dir` like `:FZF`.
+`g:fzf_layout`, `g:fzf_action`, `g:fzf_colors`, and `g:fzf_history_dir` like
+`:FZF`.
 
 ```vim
 command! -bang MyStuff
@@ -390,6 +407,12 @@ fzf
 export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"
 ```
 
+If you don't want to exclude hidden files, use the following command:
+
+```sh
+export FZF_DEFAULT_COMMAND='ag --hidden --ignore .git -g ""'
+```
+
 #### `git ls-tree` for fast traversal
 
 If you're running fzf in a large git repository, `git ls-tree` can boost up the

bin/fzf-tmux

@@ -17,6 +17,7 @@ swap=""
 close=""
 term=""
 [[ -n "$LINES" ]] && lines=$LINES || lines=$(tput lines)
+[[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols)
 
 help() {
   >&2 echo 'usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
@@ -83,7 +84,7 @@ while [[ $# -gt 0 ]]; do
       else
         if [[ -n "$swap" ]]; then
           if [[ "$arg" =~ ^.l ]]; then
-            [[ -n "$COLUMNS" ]] && max=$COLUMNS || max=$(tput cols)
+            max=$columns
           else
             max=$lines
           fi
@@ -108,7 +109,7 @@ while [[ $# -gt 0 ]]; do
   [[ -n "$skip" ]] && args+=("$arg")
 done
 
-if [[ -z "$TMUX" ]] || [[ "$lines" -le 15 ]]; then
+if [[ -z "$TMUX" || "$opt" =~ ^-h && "$columns" -le 40 || ! "$opt" =~ ^-h && "$lines" -le 15 ]]; then
   "$fzf" "${args[@]}"
   exit $?
 fi
@@ -161,14 +162,14 @@ done
 
 if [[ -n "$term" ]] || [[ -t 0 ]]; then
   cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
-  tmux set-window-option synchronize-panes off \;\
+  TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
     set-window-option remain-on-exit off \;\
     split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap \
     > /dev/null 2>&1
 else
   mkfifo $fifo1
   cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
-  tmux set-window-option synchronize-panes off \;\
+  TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
     set-window-option remain-on-exit off \;\
     split-window $opt "$envs bash $argsf" $swap \
     > /dev/null 2>&1

install

@@ -2,8 +2,8 @@
 
 set -u
 
-[[ "$@" =~ --pre ]] && version=0.13.4 pre=1 ||
-                       version=0.13.4 pre=0
+[[ "$@" =~ --pre ]] && version=0.15.9 pre=1 ||
+                       version=0.15.9 pre=0
 
 auto_completion=
 key_bindings=

man/man1/fzf-tmux.1

@@ -21,7 +21,7 @@ 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.
 ..
-.TH fzf-tmux 1 "Aug 2016" "fzf 0.13.4" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Nov 2016" "fzf 0.15.9" "fzf-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf-tmux - open fzf in tmux split pane

man/man1/fzf.1

@@ -21,7 +21,7 @@ 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.
 ..
-.TH fzf 1 "Aug 2016" "fzf 0.13.4" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Nov 2016" "fzf 0.15.9" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -47,6 +47,16 @@ Case-insensitive match (default: smart-case match)
 .TP
 .B "+i"
 Case-sensitive match
+.TP
+.BI "--algo=" TYPE
+Fuzzy matching algorithm (default: v2)
+
+.br
+.BR v2 "     Optimal scoring algorithm (quality)"
+.br
+.BR v1 "     Faster but not guaranteed to find the optimal result (performance)"
+.br
+
 .TP
 .BI "-n, --nth=" "N[,..]"
 Comma-separated list of field index expressions for limiting search scope.
@@ -206,6 +216,9 @@ e.g. \fBfzf --color=bg+:24\fR
     \fBheader  \fRHeader
 .RE
 .TP
+.B "--no-bold"
+Do not use bold text
+.TP
 .B "--black"
 Use black background
 .SS History
@@ -222,11 +235,17 @@ automatically truncated when the number of the lines exceeds the value.
 .TP
 .BI "--preview=" "COMMAND"
 Execute the given command for the current line and display the result on the
-preview window. \fB{}\fR is the placeholder for the quoted string of the
-current line.
+preview window. \fB{}\fR in the command is the placeholder that is replaced to
+the single-quoted string of the current line. To transform the replacement
+string, specify field index expressions between the braces (See \fBFIELD INDEX
+EXPRESSION\fR for the details). Also, \fB{q}\fR is replaced to the current
+query string.
 
 .RS
 e.g. \fBfzf --preview="head -$LINES {}"\fR
+     \fBls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1\fR
+
+Note that you can escape a placeholder pattern by prepending a backslash.
 .RE
 .TP
 .BI "--preview-window=" "[POSITION][:SIZE[%]][:hidden]"
@@ -275,6 +294,12 @@ with the default enter key.
 e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s,f1,f2,~,@\fR
 .RE
 .TP
+.B "--read0"
+Read input delimited by ASCII NUL character instead of newline character
+.TP
+.B "--print0"
+Print output delimited by ASCII NUL character instead of newline character
+.TP
 .B "--sync"
 Synchronous search for multi-staged filtering. If specified, fzf will launch
 ncurses finder only after the input stream is complete.
@@ -342,7 +367,7 @@ with the given string. An anchored-match term is also an exact-match term.
 
 .SS Negation
 If a term is prefixed by \fB!\fR, fzf will exclude the lines that satisfy the
-term from the result.
+term from the result. In this case, fzf performs exact match by default.
 
 .SS Exact-match by default
 If you don't prefer fuzzy matching and do not wish to "quote" (prefixing with
@@ -366,7 +391,8 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
 .B AVAILABLE KEYS:    (SYNONYMS)
     \fIctrl-[a-z]\fR
     \fIalt-[a-z]\fR
-    \fIf[1-10]\fR
+    \fIalt-[0-9]\fR
+    \fIf[1-12]\fR
     \fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
     \fIspace\fR
     \fIbspace\fR      (\fIbs\fR)
@@ -418,6 +444,10 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fBnext-history\fR          (\fIctrl-n\fR on \fB--history\fR)
     \fBpage-down\fR             \fIpgdn\fR
     \fBpage-up\fR               \fIpgup\fR
+    \fBpreview-down\fR
+    \fBpreview-up\fR
+    \fBpreview-page-down\fR
+    \fBpreview-page-up\fR
     \fBprevious-history\fR      (\fIctrl-p\fR on \fB--history\fR)
     \fBprint-query\fR           (print query and exit)
     \fBselect-all\fR
@@ -440,9 +470,11 @@ binding \fBenter\fR key to \fBless\fR command like follows.
 
     \fBfzf --bind "enter:execute(less {})"\fR
 
-\fB{}\fR is the placeholder for the quoted string of the current line.
-If the command contains parentheses, you can use any of the following
-alternative notations to avoid parse errors.
+You can use the same placeholder expressions as in \fB--preview\fR.
+
+If the command contains parentheses, fzf may fail to parse the expression. In
+that case, you can use any of the following alternative notations to avoid
+parse errors.
 
     \fBexecute[...]\fR
     \fBexecute~...~\fR
@@ -461,7 +493,7 @@ alternative notations to avoid parse errors.
 .RS
 This is the special form that frees you from parse errors as it does not expect
 the closing character. The catch is that it should be the last one in the
-comma-separated list.
+comma-separated list of key-action pairs.
 .RE
 
 \fBexecute-multi(...)\fR is an alternative action that executes the command

plugin/fzf.vim

@@ -21,6 +21,11 @@
 " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+if exists('g:loaded_fzf')
+  finish
+endif
+let g:loaded_fzf = 1
+
 let s:default_layout = { 'down': '~40%' }
 let s:layout_keys = ['window', 'up', 'down', 'left', 'right']
 let s:fzf_go = expand('<sfile>:h:h').'/bin/fzf'
@@ -154,13 +159,37 @@ function! s:common_sink(action, lines) abort
   endtry
 endfunction
 
-" name string, [opts dict, [fullscreen boolean]]
-function! fzf#wrap(name, ...)
-  if type(a:name) != type('')
-    throw 'invalid name type: string expected'
-  endif
-  let opts = copy(get(a:000, 0, {}))
-  let bang = get(a:000, 1, 0)
+function! s:get_color(attr, ...)
+  for group in a:000
+    let code = synIDattr(synIDtrans(hlID(group)), a:attr, 'cterm')
+    if code =~ '^[0-9]\+$'
+      return code
+    endif
+  endfor
+  return ''
+endfunction
+
+function! s:defaults()
+  let rules = copy(get(g:, 'fzf_colors', {}))
+  let colors = join(map(items(filter(map(rules, 'call("s:get_color", v:val)'), '!empty(v:val)')), 'join(v:val, ":")'), ',')
+  return empty(colors) ? '' : ('--color='.colors)
+endfunction
+
+" [name string,] [opts dict,] [fullscreen boolean]
+function! fzf#wrap(...)
+  let args = ['', {}, 0]
+  let expects = map(copy(args), 'type(v:val)')
+  let tidx = 0
+  for arg in copy(a:000)
+    let tidx = index(expects, type(arg), tidx)
+    if tidx < 0
+      throw 'invalid arguments (expected: [name string] [opts dict] [fullscreen boolean])'
+    endif
+    let args[tidx] = arg
+    let tidx += 1
+    unlet arg
+  endfor
+  let [name, opts, bang] = args
 
   " Layout: g:fzf_layout (and deprecated g:fzf_height)
   if bang
@@ -177,14 +206,16 @@ function! fzf#wrap(name, ...)
     endif
   endif
 
+  " Colors: g:fzf_colors
+  let opts.options = s:defaults() .' '. get(opts, 'options', '')
+
   " History: g:fzf_history_dir
-  let opts.options = get(opts, 'options', '')
-  if len(get(g:, 'fzf_history_dir', ''))
+  if len(name) && len(get(g:, 'fzf_history_dir', ''))
     let dir = expand(g:fzf_history_dir)
     if !isdirectory(dir)
       call mkdir(dir, 'p')
     endif
-    let opts.options = join(['--history', s:escape(dir.'/'.a:name), opts.options])
+    let opts.options = join(['--history', s:escape(dir.'/'.name), opts.options])
   endif
 
   " Action: g:fzf_action
@@ -268,10 +299,10 @@ function! s:fzf_tmux(dict)
     if s:present(a:dict, o)
       let spec = a:dict[o]
       if (o == 'up' || o == 'down') && spec[0] == '~'
-        let size = '-'.o[0].s:calc_size(&lines, spec[1:], a:dict)
+        let size = '-'.o[0].s:calc_size(&lines, spec, a:dict)
       else
         " Legacy boolean option
-        let size = '-'.o[0].(spec == 1 ? '' : spec)
+        let size = '-'.o[0].(spec == 1 ? '' : substitute(spec, '^\~', '', ''))
       endif
       break
     endif
@@ -281,7 +312,8 @@ function! s:fzf_tmux(dict)
 endfunction
 
 function! s:splittable(dict)
-  return s:present(a:dict, 'up', 'down', 'left', 'right')
+  return s:present(a:dict, 'up', 'down') && &lines > 15 ||
+        \ s:present(a:dict, 'left', 'right') && &columns > 40
 endfunction
 
 function! s:pushd(dict)
@@ -367,10 +399,11 @@ function! s:execute_tmux(dict, command, temps) abort
 endfunction
 
 function! s:calc_size(max, val, dict)
-  if a:val =~ '%$'
-    let size = a:max * str2nr(a:val[:-2]) / 100
+  let val = substitute(a:val, '^\~', '', '')
+  if val =~ '%$'
+    let size = a:max * str2nr(val[:-2]) / 100
   else
-    let size = min([a:max, str2nr(a:val)])
+    let size = min([a:max, str2nr(val)])
   endif
 
   let srcsz = -1
@@ -396,24 +429,25 @@ function! s:split(dict)
   \ 'right': ['vertical botright', 'vertical resize', &columns] }
   let ppos = s:getpos()
   try
-    for [dir, triple] in items(directions)
-      let val = get(a:dict, dir, '')
-      if !empty(val)
-        let [cmd, resz, max] = triple
-        if (dir == 'up' || dir == 'down') && val[0] == '~'
-          let sz = s:calc_size(max, val[1:], a:dict)
-        else
-          let sz = s:calc_size(max, val, {})
-        endif
-        execute cmd sz.'new'
-        execute resz sz
-        return [ppos, {}]
-      endif
-    endfor
     if s:present(a:dict, 'window')
       execute a:dict.window
-    else
+    elseif !s:splittable(a:dict)
       execute (tabpagenr()-1).'tabnew'
+    else
+      for [dir, triple] in items(directions)
+        let val = get(a:dict, dir, '')
+        if !empty(val)
+          let [cmd, resz, max] = triple
+          if (dir == 'up' || dir == 'down') && val[0] == '~'
+            let sz = s:calc_size(max, val, a:dict)
+          else
+            let sz = s:calc_size(max, val, {})
+          endif
+          execute cmd sz.'new'
+          execute resz sz
+          return [ppos, {}]
+        endif
+      endfor
     endif
     return [ppos, { '&l:wfw': &l:wfw, '&l:wfh': &l:wfh }]
   finally
@@ -422,9 +456,11 @@ function! s:split(dict)
 endfunction
 
 function! s:execute_term(dict, command, temps) abort
+  let winrest = winrestcmd()
   let [ppos, winopts] = s:split(a:dict)
   let fzf = { 'buf': bufnr('%'), 'ppos': ppos, 'dict': a:dict, 'temps': a:temps,
-            \ 'winopts': winopts, 'command': a:command }
+            \ 'winopts': winopts, 'winrest': winrest, 'lines': &lines,
+            \ 'columns': &columns, 'command': a:command }
   function! fzf.switch_back(inplace)
     if a:inplace && bufnr('') == self.buf
       " FIXME: Can't re-enter normal mode from terminal mode
@@ -456,6 +492,10 @@ function! s:execute_term(dict, command, temps) abort
       execute 'bd!' self.buf
     endif
 
+    if &lines == self.lines && &columns == self.columns && s:getpos() == self.ppos
+      execute self.winrest
+    endif
+
     if !s:exit_handler(a:code, self.command, 1)
       return
     endif
@@ -543,11 +583,15 @@ let s:default_action = {
 
 function! s:cmd(bang, ...) abort
   let args = copy(a:000)
-  let opts = {}
+  let opts = { 'options': '--multi ' }
   if len(args) && isdirectory(expand(args[-1]))
-    let opts.dir = substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g')
+    let opts.dir = substitute(substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g'), '/*$', '/', '')
+    let opts.options .= ' --prompt '.shellescape(opts.dir)
+  else
+    let opts.options .= ' --prompt '.shellescape(pathshorten(getcwd()).'/')
   endif
-  call fzf#run(fzf#wrap('FZF', extend({'options': join(args)}, opts), a:bang))
+  let opts.options .= ' '.join(args)
+  call fzf#run(fzf#wrap('FZF', opts, a:bang))
 endfunction
 
 command! -nargs=* -complete=dir -bang FZF call s:cmd(<bang>0, <f-args>)

shell/completion.bash

@@ -32,7 +32,7 @@ fi
 
 _fzf_orig_completion_filter() {
   sed 's/^\(.*-F\) *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\3="\1 %s \3 #\2";/' |
-  awk -F= '{gsub(/[^a-z0-9_= ;]/, "_", $1); print $1"="$2}'
+  awk -F= '{gsub(/[^A-Za-z0-9_= ;]/, "_", $1); print $1"="$2}'
 }
 
 _fzf_opts_completion() {
@@ -117,7 +117,7 @@ _fzf_handle_dynamic_completion() {
 __fzf_generic_path_completion() {
   local cur base dir leftover matches trigger cmd fzf
   [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
-  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
+  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
@@ -162,7 +162,7 @@ _fzf_complete() {
   type -t "$post" > /dev/null 2>&1 || post=cat
   [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
 
-  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
+  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
   if [[ "$cur" == *"$trigger" ]]; then
@@ -277,7 +277,7 @@ _fzf_defc() {
   cmd="$1"
   func="$2"
   opts="$3"
-  orig_var="_fzf_orig_completion_$cmd"
+  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
   orig="${!orig_var}"
   if [ -n "$orig" ]; then
     printf -v def "$orig" "$func"

shell/completion.zsh

@@ -44,7 +44,7 @@ __fzf_generic_path_completion() {
   setopt localoptions nonomatch
   dir="$base"
   while [ 1 ]; do
-    if [ -z "$dir" -o -d ${~dir} ]; then
+    if [[ -z "$dir" || -d ${~dir} ]]; then
       leftover=${base/#"$dir"}
       leftover=${leftover/#\/}
       [ -z "$dir" ] && dir='.'
@@ -111,7 +111,7 @@ _fzf_complete_telnet() {
 
 _fzf_complete_ssh() {
   _fzf_complete '+m' "$@" < <(
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*') \
+    command cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*') \
         <(command grep -oE '^[^ ]+' ~/.ssh/known_hosts | tr ',' '\n' | awk '{ print $1 " " $1 }') \
         <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
@@ -186,7 +186,7 @@ fzf-completion() {
 
 [ -z "$fzf_default_completion" ] && {
   binding=$(bindkey '^I')
-  [[ $binding =~ 'undefined-key' ]] || fzf_default_completion=$binding[(w)2]
+  [[ $binding =~ 'undefined-key' ]] || fzf_default_completion=$binding[(s: :w)2]
   unset binding
 }
 

shell/key-bindings.bash

@@ -1,7 +1,7 @@
 # Key bindings
 # ------------
 __fzf_select__() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
@@ -41,7 +41,7 @@ fzf-file-widget() {
 
 __fzf_cd__() {
   local cmd dir
-  cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
     -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
   dir=$(eval "$cmd | $(__fzfcmd) +m $FZF_ALT_C_OPTS") && printf 'cd %q' "$dir"
 }

shell/key-bindings.fish

@@ -15,7 +15,7 @@ function fzf_key_bindings
 
   function fzf-file-widget
     set -q FZF_CTRL_T_COMMAND; or set -l FZF_CTRL_T_COMMAND "
-    command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+    command find -L . \\( -path '*/\\.*' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
       -o -type f -print \
       -o -type d -print \
       -o -type l -print 2> /dev/null | sed 1d | cut -b3-"
@@ -26,15 +26,15 @@ function fzf_key_bindings
   end
 
   function fzf-history-widget
-    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS > $TMPDIR/fzf.result
-    and commandline (cat $TMPDIR/fzf.result)
+    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS -q '(commandline)' > $TMPDIR/fzf.result
+    and commandline -- (cat $TMPDIR/fzf.result)
     commandline -f repaint
     rm -f $TMPDIR/fzf.result
   end
 
   function fzf-cd-widget
     set -q FZF_ALT_C_COMMAND; or set -l FZF_ALT_C_COMMAND "
-    command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+    command find -L . \\( -path '*/\\.*' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
       -o -type d -print 2> /dev/null | sed 1d | cut -b3-"
     # Fish hangs if the command before pipe redirects (2> /dev/null)
     eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)" +m $FZF_ALT_C_OPTS > $TMPDIR/fzf.result"

shell/key-bindings.zsh

@@ -4,7 +4,7 @@ if [[ $- == *i* ]]; then
 
 # CTRL-T - Paste the selected file path(s) into the command line
 __fsel() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
@@ -33,7 +33,7 @@ bindkey '^T' fzf-file-widget
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
     -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
   setopt localoptions pipefail 2> /dev/null
   cd "${$(eval "$cmd | $(__fzfcmd) +m $FZF_ALT_C_OPTS"):-.}"

src/Dockerfile.centos

@@ -11,18 +11,18 @@ RUN cd / && curl \
     https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
-# Install Go 1.5
+# Install Go 1.7
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.5.3.linux-amd64.tar.gz | \
-    tar -xz && mv go go1.5
+    https://storage.googleapis.com/golang/go1.7.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.7
 
 # Install RPMs for building static 32-bit binary
-RUN curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/ncurses-static-5.7-4.20090207.el6.i686.rpm -o rpm && rpm -i rpm && \
-    curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/gpm-static-1.20.6-12.el6.i686.rpm -o rpm && rpm -i rpm
+RUN curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.8/os/i386/Packages/ncurses-static-5.7-4.20090207.el6.i686.rpm -o rpm && rpm -i rpm && \
+    curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.8/os/i386/Packages/gpm-static-1.20.6-12.el6.i686.rpm -o rpm && rpm -i rpm
 
 ENV GOROOT_BOOTSTRAP /go1.4
-ENV GOROOT /go1.5
-ENV PATH /go1.5/bin:$PATH
+ENV GOROOT /go1.7
+ENV PATH /go1.7/bin:$PATH
 
 # For i386 build
 RUN cd $GOROOT/src && GOARCH=386 ./make.bash

src/Makefile

@@ -33,17 +33,24 @@ endif
 
 all: fzf/$(BINARY)
 
+ifeq ($(GOOS),windows)
+release: fzf/$(BINARY32) fzf/$(BINARY64)
+	-cd fzf && cp $(BINARY32) $(RELEASE32).exe && zip $(RELEASE32).zip $(RELEASE32).exe
+	cd fzf && cp $(BINARY64) $(RELEASE64).exe && zip $(RELEASE64).zip $(RELEASE64).exe && \
+	rm -f $(RELEASE32).exe $(RELEASE64).exe
+else
 release: test fzf/$(BINARY32) fzf/$(BINARY64)
 	-cd fzf && cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32)
 	cd fzf && cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
 	rm -f $(RELEASE32) $(RELEASE64)
+endif
 
 $(SRCDIR):
 	mkdir -p $(shell dirname $(SRCDIR))
 	ln -s $(ROOTDIR) $(SRCDIR)
 
 deps: $(SRCDIR) $(SOURCES)
-	cd $(SRCDIR) && go get
+	cd $(SRCDIR) && go get -tags "$(TAGS)"
 
 android-build: $(SRCDIR)
 	cd $(SRCDIR) && GOARCH=arm GOARM=7 CGO_ENABLED=1 go get
@@ -52,7 +59,7 @@ android-build: $(SRCDIR)
 	rm -f $(RELEASEARM7)
 
 test: deps
-	SHELL=/bin/sh go test -v ./...
+	SHELL=/bin/sh GOOS=$(GOOS) go test -v -tags "$(TAGS)" ./...
 
 install: $(BINDIR)/fzf
 
@@ -63,10 +70,10 @@ clean:
 	cd fzf && rm -f fzf-*
 
 fzf/$(BINARY32): deps
-	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -a -ldflags -w -tags "$(TAGS)" -o $(BINARY32)
+	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARY32)
 
 fzf/$(BINARY64): deps
-	cd fzf && go build -a -ldflags -w -tags "$(TAGS)" -o $(BINARY64)
+	cd fzf && go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARY64)
 
 $(BINDIR)/fzf: fzf/$(BINARY) | $(BINDIR)
 	cp -f fzf/$(BINARY) $(BINDIR)

src/README.md

@@ -47,33 +47,6 @@ 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
 -----
 
@@ -88,25 +61,74 @@ make install
 make linux
 ```
 
-Contribution
-------------
+### With ncurses 6
 
-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.
+The official binaries of fzf are built with ncurses 5 because it's widely
+supported by different platforms. However ncurses 5 is old and has a number of
+limitations.
 
-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.
+1. Does not support more than 256 color pairs (See [357][357])
+2. Does not support italics
+3. Does not support 24-bit color
+
+[357]: https://github.com/junegunn/fzf/issues/357
+
+But you can manually build fzf with ncurses 6 to overcome some of these
+limitations. ncurses 6 supports up to 32767 color pairs (1), and supports
+italics (2). To build fzf with ncurses 6, you have to install it first. On
+macOS, you can use Homebrew to install it.
+
+```sh
+brew install homebrew/dupes/ncurses
+LDFLAGS="-L/usr/local/opt/ncurses/lib" make install
+```
+
+### With tcell
+
+[tcell][tcell] is a portable alternative to ncurses and we currently use it to
+build Windows binaries. tcell has many benefits but most importantly, it
+supports 24-bit colors. To build fzf with tcell:
+
+```sh
+TAGS=tcell make install
+```
+
+However, note that tcell has its own issues.
+
+- Poor rendering performance compared to ncurses
+- Does not support bracketed-paste mode
+- Does not support italics unlike ncurses 6
+- Some wide characters are not correctly displayed
+
+Test
+----
+
+Unit tests can be run with `make test`. Integration tests are written in Ruby
+script that should be run on tmux.
+
+```sh
+# Unit tests
+make test
+
+# Install the executable to ../bin directory
+make install
+
+# Integration tests
+ruby ../test/test_go.rb
+```
 
 Third-party libraries used
 --------------------------
 
 - [ncurses][ncurses]
 - [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
-    - Licensed under [MIT](http://mattn.mit-license.org/2013)
+    - Licensed under [MIT](http://mattn.mit-license.org)
 - [mattn/go-shellwords](https://github.com/mattn/go-shellwords)
-    - Licensed under [MIT](http://mattn.mit-license.org/2014)
+    - Licensed under [MIT](http://mattn.mit-license.org)
+- [mattn/go-isatty](https://github.com/mattn/go-isatty)
+    - Licensed under [MIT](http://mattn.mit-license.org)
+- [tcell](https://github.com/gdamore/tcell)
+    - Licensed under [Apache License 2.0](https://github.com/gdamore/tcell/blob/master/LICENSE)
 
 License
 -------
@@ -118,4 +140,4 @@ License
 [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
+[tcell]:   https://github.com/gdamore/tcell

src/algo/algo.go

@@ -1,19 +1,91 @@
 package algo
 
+/*
+
+Algorithm
+---------
+
+FuzzyMatchV1 finds the first "fuzzy" occurrence of the pattern within the given
+text in O(n) time where n is the length of the text. Once the position of the
+last character is located, it traverses backwards to see if there's a shorter
+substring that matches the pattern.
+
+    a_____b___abc__  To find "abc"
+    *-----*-----*>   1. Forward scan
+             <***    2. Backward scan
+
+The algorithm is simple and fast, but as it only sees the first occurrence,
+it is not guaranteed to find the occurrence with the highest score.
+
+    a_____b__c__abc
+    *-----*--*  ***
+
+FuzzyMatchV2 implements a modified version of Smith-Waterman algorithm to find
+the optimal solution (highest score) according to the scoring criteria. Unlike
+the original algorithm, omission or mismatch of a character in the pattern is
+not allowed.
+
+Performance
+-----------
+
+The new V2 algorithm is slower than V1 as it examines all occurrences of the
+pattern instead of stopping immediately after finding the first one. The time
+complexity of the algorithm is O(nm) if a match is found and O(n) otherwise
+where n is the length of the item and m is the length of the pattern. Thus, the
+performance overhead may not be noticeable for a query with high selectivity.
+However, if the performance is more important than the quality of the result,
+you can still choose v1 algorithm with --algo=v1.
+
+Scoring criteria
+----------------
+
+- We prefer matches at special positions, such as the start of a word, or
+  uppercase character in camelCase words.
+
+- That is, we prefer an occurrence of the pattern with more characters
+  matching at special positions, even if the total match length is longer.
+    e.g. "fuzzyfinder" vs. "fuzzy-finder" on "ff"
+                            ````````````
+- Also, if the first character in the pattern appears at one of the special
+  positions, the bonus point for the position is multiplied by a constant
+  as it is extremely likely that the first character in the typed pattern
+  has more significance than the rest.
+    e.g. "fo-bar" vs. "foob-r" on "br"
+          ``````
+- But since fzf is still a fuzzy finder, not an acronym finder, we should also
+  consider the total length of the matched substring. This is why we have the
+  gap penalty. The gap penalty increases as the length of the gap (distance
+  between the matching characters) increases, so the effect of the bonus is
+  eventually cancelled at some point.
+    e.g. "fuzzyfinder" vs. "fuzzy-blurry-finder" on "ff"
+          ```````````
+- Consequently, it is crucial to find the right balance between the bonus
+  and the gap penalty. The parameters were chosen that the bonus is cancelled
+  when the gap size increases beyond 8 characters.
+
+- The bonus mechanism can have the undesirable side effect where consecutive
+  matches are ranked lower than the ones with gaps.
+    e.g. "foobar" vs. "foo-bar" on "foob"
+                       ```````
+- To correct this anomaly, we also give extra bonus point to each character
+  in a consecutive matching chunk.
+    e.g. "foobar" vs. "foo-bar" on "foob"
+          ``````
+- The amount of consecutive bonus is primarily determined by the bonus of the
+  first character in the chunk.
+    e.g. "foobar" vs. "out-of-bound" on "oob"
+                       ````````````
+*/
+
 import (
+	"fmt"
 	"strings"
 	"unicode"
 
 	"github.com/junegunn/fzf/src/util"
 )
 
-/*
- * 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.
- */
+var DEBUG bool
 
 func indexAt(index int, max int, forward bool) int {
 	if forward {
@@ -22,23 +94,50 @@ func indexAt(index int, max int, forward bool) int {
 	return max - index - 1
 }
 
-func runeAt(text util.Chars, index int, max int, forward bool) rune {
-	if forward {
-		return text.Get(index)
-	}
-	return text.Get(max - index - 1)
-}
-
-// Result conatins the results of running a match function.
+// Result contains the results of running a match function.
 type Result struct {
-	Start int32
-	End   int32
-
-	// Items are basically sorted by the lengths of matched substrings.
-	// But we slightly adjust the score with bonus for better results.
-	Bonus int32
+	// TODO int32 should suffice
+	Start int
+	End   int
+	Score int
 }
 
+const (
+	scoreMatch        = 16
+	scoreGapStart     = -3
+	scoreGapExtention = -1
+
+	// We prefer matches at the beginning of a word, but the bonus should not be
+	// too great to prevent the longer acronym matches from always winning over
+	// shorter fuzzy matches. The bonus point here was specifically chosen that
+	// the bonus is cancelled when the gap between the acronyms grows over
+	// 8 characters, which is approximately the average length of the words found
+	// in web2 dictionary and my file system.
+	bonusBoundary = scoreMatch / 2
+
+	// Although bonus point for non-word characters is non-contextual, we need it
+	// for computing bonus points for consecutive chunks starting with a non-word
+	// character.
+	bonusNonWord = scoreMatch / 2
+
+	// Edge-triggered bonus for matches in camelCase words.
+	// Compared to word-boundary case, they don't accompany single-character gaps
+	// (e.g. FooBar vs. foo-bar), so we deduct bonus point accordingly.
+	bonusCamel123 = bonusBoundary + scoreGapExtention
+
+	// Minimum bonus point given to characters in consecutive chunks.
+	// Note that bonus points for consecutive matches shouldn't have needed if we
+	// used fixed match score as in the original algorithm.
+	bonusConsecutive = -(scoreGapStart + scoreGapExtention)
+
+	// The first character in the typed pattern usually has more significance
+	// than the rest so it's important that it appears at special positions where
+	// bonus points are given. e.g. "to-go" vs. "ongoing" on "og" or on "ogo".
+	// The amount of the extra bonus should be limited so that the gap penalty is
+	// still respected.
+	bonusFirstCharMultiplier = 2
+)
+
 type charClass int
 
 const (
@@ -49,85 +148,351 @@ const (
 	charNumber
 )
 
-func evaluateBonus(caseSensitive bool, text util.Chars, pattern []rune, sidx int, eidx int) int32 {
-	var bonus int32
-	pidx := 0
-	lenPattern := len(pattern)
-	consecutive := false
-	prevClass := charNonWord
-	for index := util.Max(0, sidx-1); index < eidx; index++ {
-		char := text.Get(index)
-		var class charClass
-		if unicode.IsLower(char) {
-			class = charLower
-		} else if unicode.IsUpper(char) {
-			class = charUpper
-		} else if unicode.IsLetter(char) {
-			class = charLetter
-		} else if unicode.IsNumber(char) {
-			class = charNumber
-		} else {
-			class = charNonWord
-		}
-
-		var point int32
-		if prevClass == charNonWord && class != charNonWord {
-			// Word boundary
-			point = 2
-		} else if prevClass == charLower && class == charUpper ||
-			prevClass != charNumber && class == charNumber {
-			// camelCase letter123
-			point = 1
-		}
-		prevClass = class
-
-		if index >= sidx {
-			if !caseSensitive {
-				if char >= 'A' && char <= 'Z' {
-					char += 32
-				} else if char > unicode.MaxASCII {
-					char = unicode.To(unicode.LowerCase, char)
-				}
-			}
-			pchar := pattern[pidx]
-			if pchar == char {
-				// Boost bonus for the first character in the pattern
-				if pidx == 0 {
-					point *= 2
-				}
-				// Bonus to consecutive matching chars
-				if consecutive {
-					point++
-				}
-				bonus += point
-
-				if pidx++; pidx == lenPattern {
-					break
-				}
-				consecutive = true
-			} else {
-				consecutive = false
-			}
-		}
+func posArray(withPos bool, len int) *[]int {
+	if withPos {
+		pos := make([]int, 0, len)
+		return &pos
 	}
-	return bonus
+	return nil
 }
 
-// FuzzyMatch performs fuzzy-match
-func FuzzyMatch(caseSensitive bool, forward bool, text util.Chars, pattern []rune) Result {
-	if len(pattern) == 0 {
-		return Result{0, 0, 0}
+func alloc16(offset int, slab *util.Slab, size int, clear bool) (int, []int16) {
+	if slab != nil && cap(slab.I16) > offset+size {
+		slice := slab.I16[offset : offset+size]
+		if clear {
+			for idx := range slice {
+				slice[idx] = 0
+			}
+		}
+		return offset + size, slice
+	}
+	return offset, make([]int16, size)
+}
+
+func alloc32(offset int, slab *util.Slab, size int, clear bool) (int, []int32) {
+	if slab != nil && cap(slab.I32) > offset+size {
+		slice := slab.I32[offset : offset+size]
+		if clear {
+			for idx := range slice {
+				slice[idx] = 0
+			}
+		}
+		return offset + size, slice
+	}
+	return offset, make([]int32, size)
+}
+
+func charClassOfAscii(char rune) charClass {
+	if char >= 'a' && char <= 'z' {
+		return charLower
+	} else if char >= 'A' && char <= 'Z' {
+		return charUpper
+	} else if char >= '0' && char <= '9' {
+		return charNumber
+	}
+	return charNonWord
+}
+
+func charClassOfNonAscii(char rune) charClass {
+	if unicode.IsLower(char) {
+		return charLower
+	} else if unicode.IsUpper(char) {
+		return charUpper
+	} else if unicode.IsNumber(char) {
+		return charNumber
+	} else if unicode.IsLetter(char) {
+		return charLetter
+	}
+	return charNonWord
+}
+
+func charClassOf(char rune) charClass {
+	if char <= unicode.MaxASCII {
+		return charClassOfAscii(char)
+	}
+	return charClassOfNonAscii(char)
+}
+
+func bonusFor(prevClass charClass, class charClass) int16 {
+	if prevClass == charNonWord && class != charNonWord {
+		// Word boundary
+		return bonusBoundary
+	} else if prevClass == charLower && class == charUpper ||
+		prevClass != charNumber && class == charNumber {
+		// camelCase letter123
+		return bonusCamel123
+	} else if class == charNonWord {
+		return bonusNonWord
+	}
+	return 0
+}
+
+func bonusAt(input util.Chars, idx int) int16 {
+	if idx == 0 {
+		return bonusBoundary
+	}
+	return bonusFor(charClassOf(input.Get(idx-1)), charClassOf(input.Get(idx)))
+}
+
+type Algo func(caseSensitive bool, forward bool, input util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int)
+
+func FuzzyMatchV2(caseSensitive bool, forward bool, input util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+	// Assume that pattern is given in lowercase if case-insensitive.
+	// First check if there's a match and calculate bonus for each position.
+	// If the input string is too long, consider finding the matching chars in
+	// this phase as well (non-optimal alignment).
+	N := input.Length()
+	M := len(pattern)
+	switch M {
+	case 0:
+		return Result{0, 0, 0}, posArray(withPos, M)
+	case 1:
+		return ExactMatchNaive(caseSensitive, forward, input, pattern[0:1], withPos, slab)
+	}
+
+	// Since O(nm) algorithm can be prohibitively expensive for large input,
+	// we fall back to the greedy algorithm.
+	if slab != nil && N*M > cap(slab.I16) {
+		return FuzzyMatchV1(caseSensitive, forward, input, pattern, withPos, slab)
+	}
+
+	// Reuse pre-allocated integer slice to avoid unnecessary sweeping of garbages
+	offset16 := 0
+	offset32 := 0
+	// Bonus point for each position
+	offset16, B := alloc16(offset16, slab, N, false)
+	// The first occurrence of each character in the pattern
+	offset32, F := alloc32(offset32, slab, M, false)
+	// Rune array
+	offset32, T := alloc32(offset32, slab, N, false)
+
+	// Phase 1. Check if there's a match and calculate bonus for each point
+	pidx, lastIdx, prevClass := 0, 0, charNonWord
+	for idx := 0; idx < N; idx++ {
+		char := input.Get(idx)
+		var class charClass
+		if char <= unicode.MaxASCII {
+			class = charClassOfAscii(char)
+		} else {
+			class = charClassOfNonAscii(char)
+		}
+
+		if !caseSensitive && class == charUpper {
+			if char <= unicode.MaxASCII {
+				char += 32
+			} else {
+				char = unicode.To(unicode.LowerCase, char)
+			}
+		}
+
+		T[idx] = char
+		B[idx] = bonusFor(prevClass, class)
+		prevClass = class
+
+		if pidx < M {
+			if char == pattern[pidx] {
+				lastIdx = idx
+				F[pidx] = int32(idx)
+				pidx++
+			}
+		} else {
+			if char == pattern[M-1] {
+				lastIdx = idx
+			}
+		}
+	}
+	if pidx != M {
+		return Result{-1, -1, 0}, nil
+	}
+
+	// Phase 2. Fill in score matrix (H)
+	// Unlike the original algorithm, we do not allow omission.
+	width := lastIdx - int(F[0]) + 1
+	offset16, H := alloc16(offset16, slab, width*M, false)
+
+	// Possible length of consecutive chunk at each position.
+	offset16, C := alloc16(offset16, slab, width*M, false)
+
+	maxScore, maxScorePos := int16(0), 0
+	for i := 0; i < M; i++ {
+		I := i * width
+		inGap := false
+		for j := int(F[i]); j <= lastIdx; j++ {
+			j0 := j - int(F[0])
+			var s1, s2, consecutive int16
+
+			if j > int(F[i]) {
+				if inGap {
+					s2 = H[I+j0-1] + scoreGapExtention
+				} else {
+					s2 = H[I+j0-1] + scoreGapStart
+				}
+			}
+
+			if pattern[i] == T[j] {
+				var diag int16
+				if i > 0 && j0 > 0 {
+					diag = H[I-width+j0-1]
+				}
+				s1 = diag + scoreMatch
+				b := B[j]
+				if i > 0 {
+					// j > 0 if i > 0
+					consecutive = C[I-width+j0-1] + 1
+					// Break consecutive chunk
+					if b == bonusBoundary {
+						consecutive = 1
+					} else if consecutive > 1 {
+						b = util.Max16(b, util.Max16(bonusConsecutive, B[j-int(consecutive)+1]))
+					}
+				} else {
+					consecutive = 1
+					b *= bonusFirstCharMultiplier
+				}
+				if s1+b < s2 {
+					s1 += B[j]
+					consecutive = 0
+				} else {
+					s1 += b
+				}
+			}
+			C[I+j0] = consecutive
+
+			inGap = s1 < s2
+			score := util.Max16(util.Max16(s1, s2), 0)
+			if i == M-1 && (forward && score > maxScore || !forward && score >= maxScore) {
+				maxScore, maxScorePos = score, j
+			}
+			H[I+j0] = score
+		}
+
+		if DEBUG {
+			if i == 0 {
+				fmt.Print("  ")
+				for j := int(F[i]); j <= lastIdx; j++ {
+					fmt.Printf(" " + string(input.Get(j)) + " ")
+				}
+				fmt.Println()
+			}
+			fmt.Print(string(pattern[i]) + " ")
+			for idx := int(F[0]); idx < int(F[i]); idx++ {
+				fmt.Print(" 0 ")
+			}
+			for idx := int(F[i]); idx <= lastIdx; idx++ {
+				fmt.Printf("%2d ", H[i*width+idx-int(F[0])])
+			}
+			fmt.Println()
+
+			fmt.Print("  ")
+			for idx, p := range C[I : I+width] {
+				if idx+int(F[0]) < int(F[i]) {
+					p = 0
+				}
+				fmt.Printf("%2d ", p)
+			}
+			fmt.Println()
+		}
+	}
+
+	// Phase 3. (Optional) Backtrace to find character positions
+	pos := posArray(withPos, M)
+	j := int(F[0])
+	if withPos {
+		i := M - 1
+		j = maxScorePos
+		preferMatch := true
+		for {
+			I := i * width
+			j0 := j - int(F[0])
+			s := H[I+j0]
+
+			var s1, s2 int16
+			if i > 0 && j >= int(F[i]) {
+				s1 = H[I-width+j0-1]
+			}
+			if j > int(F[i]) {
+				s2 = H[I+j0-1]
+			}
+
+			if s > s1 && (s > s2 || s == s2 && preferMatch) {
+				*pos = append(*pos, j)
+				if i == 0 {
+					break
+				}
+				i--
+			}
+			preferMatch = C[I+j0] > 1 || I+width+j0+1 < len(C) && C[I+width+j0+1] > 0
+			j--
+		}
+	}
+	// Start offset we return here is only relevant when begin tiebreak is used.
+	// However finding the accurate offset requires backtracking, and we don't
+	// want to pay extra cost for the option that has lost its importance.
+	return Result{j, maxScorePos + 1, int(maxScore)}, pos
+}
+
+// Implement the same sorting criteria as V2
+func calculateScore(caseSensitive bool, text util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
+	pidx, score, inGap, consecutive, firstBonus := 0, 0, false, 0, int16(0)
+	pos := posArray(withPos, len(pattern))
+	prevClass := charNonWord
+	if sidx > 0 {
+		prevClass = charClassOf(text.Get(sidx - 1))
+	}
+	for idx := sidx; idx < eidx; idx++ {
+		char := text.Get(idx)
+		class := charClassOf(char)
+		if !caseSensitive {
+			if char >= 'A' && char <= 'Z' {
+				char += 32
+			} else if char > unicode.MaxASCII {
+				char = unicode.To(unicode.LowerCase, char)
+			}
+		}
+		if char == pattern[pidx] {
+			if withPos {
+				*pos = append(*pos, idx)
+			}
+			score += scoreMatch
+			bonus := bonusFor(prevClass, class)
+			if consecutive == 0 {
+				firstBonus = bonus
+			} else {
+				// Break consecutive chunk
+				if bonus == bonusBoundary {
+					firstBonus = bonus
+				}
+				bonus = util.Max16(util.Max16(bonus, firstBonus), bonusConsecutive)
+			}
+			if pidx == 0 {
+				score += int(bonus * bonusFirstCharMultiplier)
+			} else {
+				score += int(bonus)
+			}
+			inGap = false
+			consecutive++
+			pidx++
+		} else {
+			if inGap {
+				score += scoreGapExtention
+			} else {
+				score += scoreGapStart
+			}
+			inGap = true
+			consecutive = 0
+			firstBonus = 0
+		}
+		prevClass = class
+	}
+	return score, pos
+}
+
+// FuzzyMatchV1 performs fuzzy-match
+func FuzzyMatchV1(caseSensitive bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+	if len(pattern) == 0 {
+		return Result{0, 0, 0}, nil
 	}
 
-	// 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
@@ -136,7 +501,7 @@ func FuzzyMatch(caseSensitive bool, forward bool, text util.Chars, pattern []run
 	lenPattern := len(pattern)
 
 	for index := 0; index < lenRunes; index++ {
-		char := runeAt(text, index, lenRunes, forward)
+		char := text.Get(indexAt(index, lenRunes, forward))
 		// This is considerably faster than blindly applying strings.ToLower to the
 		// whole string
 		if !caseSensitive {
@@ -164,7 +529,8 @@ func FuzzyMatch(caseSensitive bool, forward bool, text util.Chars, pattern []run
 	if sidx >= 0 && eidx >= 0 {
 		pidx--
 		for index := eidx - 1; index >= sidx; index-- {
-			char := runeAt(text, index, lenRunes, forward)
+			tidx := indexAt(index, lenRunes, forward)
+			char := text.Get(tidx)
 			if !caseSensitive {
 				if char >= 'A' && char <= 'Z' {
 					char += 32
@@ -173,7 +539,8 @@ func FuzzyMatch(caseSensitive bool, forward bool, text util.Chars, pattern []run
 				}
 			}
 
-			pchar := pattern[indexAt(pidx, lenPattern, forward)]
+			pidx_ := indexAt(pidx, lenPattern, forward)
+			pchar := pattern[pidx_]
 			if char == pchar {
 				if pidx--; pidx < 0 {
 					sidx = index
@@ -182,16 +549,14 @@ func FuzzyMatch(caseSensitive bool, forward bool, text util.Chars, pattern []run
 			}
 		}
 
-		// Calculate the bonus. This can't be done at the same time as the
-		// pattern scan above because 'forward' may be false.
 		if !forward {
 			sidx, eidx = lenRunes-eidx, lenRunes-sidx
 		}
 
-		return Result{int32(sidx), int32(eidx),
-			evaluateBonus(caseSensitive, text, pattern, sidx, eidx)}
+		score, pos := calculateScore(caseSensitive, text, pattern, sidx, eidx, withPos)
+		return Result{sidx, eidx, score}, pos
 	}
-	return Result{-1, -1, 0}
+	return Result{-1, -1, 0}, nil
 }
 
 // ExactMatchNaive is a basic string searching algorithm that handles case
@@ -199,23 +564,28 @@ func FuzzyMatch(caseSensitive bool, forward bool, text util.Chars, pattern []run
 // 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, forward bool, text util.Chars, pattern []rune) Result {
+// Since 0.15.0, this function searches for the match with the highest
+// bonus point, instead of stopping immediately after finding the first match.
+// The solution is much cheaper since there is only one possible alignment of
+// the pattern.
+func ExactMatchNaive(caseSensitive bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
-		return Result{0, 0, 0}
+		return Result{0, 0, 0}, nil
 	}
 
 	lenRunes := text.Length()
 	lenPattern := len(pattern)
 
 	if lenRunes < lenPattern {
-		return Result{-1, -1, 0}
+		return Result{-1, -1, 0}, nil
 	}
 
+	// For simplicity, only look at the bonus at the first character position
 	pidx := 0
+	bestPos, bonus, bestBonus := -1, int16(0), int16(-1)
 	for index := 0; index < lenRunes; index++ {
-		char := runeAt(text, index, lenRunes, forward)
+		index_ := indexAt(index, lenRunes, forward)
+		char := text.Get(index_)
 		if !caseSensitive {
 			if char >= 'A' && char <= 'Z' {
 				char += 32
@@ -223,33 +593,51 @@ func ExactMatchNaive(caseSensitive bool, forward bool, text util.Chars, pattern
 				char = unicode.To(unicode.LowerCase, char)
 			}
 		}
-		pchar := pattern[indexAt(pidx, lenPattern, forward)]
+		pidx_ := indexAt(pidx, lenPattern, forward)
+		pchar := pattern[pidx_]
 		if pchar == char {
+			if pidx_ == 0 {
+				bonus = bonusAt(text, index_)
+			}
 			pidx++
 			if pidx == lenPattern {
-				var sidx, eidx int
-				if forward {
-					sidx = index - lenPattern + 1
-					eidx = index + 1
-				} else {
-					sidx = lenRunes - (index + 1)
-					eidx = lenRunes - (index - lenPattern + 1)
+				if bonus > bestBonus {
+					bestPos, bestBonus = index, bonus
 				}
-				return Result{int32(sidx), int32(eidx),
-					evaluateBonus(caseSensitive, text, pattern, sidx, eidx)}
+				if bonus == bonusBoundary {
+					break
+				}
+				index -= pidx - 1
+				pidx, bonus = 0, 0
 			}
 		} else {
 			index -= pidx
-			pidx = 0
+			pidx, bonus = 0, 0
 		}
 	}
-	return Result{-1, -1, 0}
+	if bestPos >= 0 {
+		var sidx, eidx int
+		if forward {
+			sidx = bestPos - lenPattern + 1
+			eidx = bestPos + 1
+		} else {
+			sidx = lenRunes - (bestPos + 1)
+			eidx = lenRunes - (bestPos - lenPattern + 1)
+		}
+		score, _ := calculateScore(caseSensitive, text, pattern, sidx, eidx, false)
+		return Result{sidx, eidx, score}, nil
+	}
+	return Result{-1, -1, 0}, nil
 }
 
 // PrefixMatch performs prefix-match
-func PrefixMatch(caseSensitive bool, forward bool, text util.Chars, pattern []rune) Result {
+func PrefixMatch(caseSensitive bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+	if len(pattern) == 0 {
+		return Result{0, 0, 0}, nil
+	}
+
 	if text.Length() < len(pattern) {
-		return Result{-1, -1, 0}
+		return Result{-1, -1, 0}, nil
 	}
 
 	for index, r := range pattern {
@@ -258,20 +646,24 @@ func PrefixMatch(caseSensitive bool, forward bool, text util.Chars, pattern []ru
 			char = unicode.ToLower(char)
 		}
 		if char != r {
-			return Result{-1, -1, 0}
+			return Result{-1, -1, 0}, nil
 		}
 	}
 	lenPattern := len(pattern)
-	return Result{0, int32(lenPattern),
-		evaluateBonus(caseSensitive, text, pattern, 0, lenPattern)}
+	score, _ := calculateScore(caseSensitive, text, pattern, 0, lenPattern, false)
+	return Result{0, lenPattern, score}, nil
 }
 
 // SuffixMatch performs suffix-match
-func SuffixMatch(caseSensitive bool, forward bool, text util.Chars, pattern []rune) Result {
-	trimmedLen := text.Length() - text.TrailingWhitespaces()
+func SuffixMatch(caseSensitive bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+	lenRunes := text.Length()
+	trimmedLen := lenRunes - text.TrailingWhitespaces()
+	if len(pattern) == 0 {
+		return Result{trimmedLen, trimmedLen, 0}, nil
+	}
 	diff := trimmedLen - len(pattern)
 	if diff < 0 {
-		return Result{-1, -1, 0}
+		return Result{-1, -1, 0}, nil
 	}
 
 	for index, r := range pattern {
@@ -280,28 +672,29 @@ func SuffixMatch(caseSensitive bool, forward bool, text util.Chars, pattern []ru
 			char = unicode.ToLower(char)
 		}
 		if char != r {
-			return Result{-1, -1, 0}
+			return Result{-1, -1, 0}, nil
 		}
 	}
 	lenPattern := len(pattern)
 	sidx := trimmedLen - lenPattern
 	eidx := trimmedLen
-	return Result{int32(sidx), int32(eidx),
-		evaluateBonus(caseSensitive, text, pattern, sidx, eidx)}
+	score, _ := calculateScore(caseSensitive, text, pattern, sidx, eidx, false)
+	return Result{sidx, eidx, score}, nil
 }
 
 // EqualMatch performs equal-match
-func EqualMatch(caseSensitive bool, forward bool, text util.Chars, pattern []rune) Result {
-	// Note: EqualMatch always return a zero bonus.
-	if text.Length() != len(pattern) {
-		return Result{-1, -1, 0}
+func EqualMatch(caseSensitive bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+	lenPattern := len(pattern)
+	if text.Length() != lenPattern {
+		return Result{-1, -1, 0}, nil
 	}
 	runesStr := text.ToString()
 	if !caseSensitive {
 		runesStr = strings.ToLower(runesStr)
 	}
 	if runesStr == string(pattern) {
-		return Result{0, int32(len(pattern)), 0}
+		return Result{0, lenPattern, (scoreMatch+bonusBoundary)*lenPattern +
+			(bonusFirstCharMultiplier-1)*bonusBoundary}, nil
 	}
-	return Result{-1, -1, 0}
+	return Result{-1, -1, 0}, nil
 }

src/algo/algo_test.go

@@ -1,97 +1,166 @@
 package algo
 
 import (
+	"math"
+	"sort"
 	"strings"
 	"testing"
 
 	"github.com/junegunn/fzf/src/util"
 )
 
-func assertMatch(t *testing.T, fun func(bool, bool, util.Chars, []rune) Result, caseSensitive, forward bool, input, pattern string, sidx int32, eidx int32, bonus int32) {
+func assertMatch(t *testing.T, fun Algo, caseSensitive, forward bool, input, pattern string, sidx int, eidx int, score int) {
 	if !caseSensitive {
 		pattern = strings.ToLower(pattern)
 	}
-	res := fun(caseSensitive, forward, util.RunesToChars([]rune(input)), []rune(pattern))
-	if res.Start != sidx {
-		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", res.Start, sidx, input, pattern)
+	res, pos := fun(caseSensitive, forward, util.RunesToChars([]rune(input)), []rune(pattern), true, nil)
+	var start, end int
+	if pos == nil || len(*pos) == 0 {
+		start = res.Start
+		end = res.End
+	} else {
+		sort.Ints(*pos)
+		start = (*pos)[0]
+		end = (*pos)[len(*pos)-1] + 1
 	}
-	if res.End != eidx {
-		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", res.End, eidx, input, pattern)
+	if start != sidx {
+		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", start, sidx, input, pattern)
 	}
-	if res.Bonus != bonus {
-		t.Errorf("Invalid bonus: %d (expected: %d, %s / %s)", res.Bonus, bonus, input, pattern)
+	if end != eidx {
+		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", end, eidx, input, pattern)
+	}
+	if res.Score != score {
+		t.Errorf("Invalid score: %d (expected: %d, %s / %s)", res.Score, score, input, pattern)
 	}
 }
 
 func TestFuzzyMatch(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, true, "fooBarbaz", "oBZ", 2, 9, 2)
-	assertMatch(t, FuzzyMatch, false, true, "foo bar baz", "fbb", 0, 9, 8)
-	assertMatch(t, FuzzyMatch, false, true, "/AutomatorDocument.icns", "rdoc", 9, 13, 4)
-	assertMatch(t, FuzzyMatch, false, true, "/man1/zshcompctl.1", "zshc", 6, 10, 7)
-	assertMatch(t, FuzzyMatch, false, true, "/.oh-my-zsh/cache", "zshc", 8, 13, 8)
-	assertMatch(t, FuzzyMatch, false, true, "ab0123 456", "12356", 3, 10, 3)
-	assertMatch(t, FuzzyMatch, false, true, "abc123 456", "12356", 3, 10, 5)
+	for _, fn := range []Algo{FuzzyMatchV1, FuzzyMatchV2} {
+		for _, forward := range []bool{true, false} {
+			assertMatch(t, fn, false, forward, "fooBarbaz1", "oBZ", 2, 9,
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtention*3)
+			assertMatch(t, fn, false, forward, "foo bar baz", "fbb", 0, 9,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
+					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtention)
+			assertMatch(t, fn, false, forward, "/AutomatorDocument.icns", "rdoc", 9, 13,
+				scoreMatch*4+bonusCamel123+bonusConsecutive*2)
+			assertMatch(t, fn, false, forward, "/man1/zshcompctl.1", "zshc", 6, 10,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
+			assertMatch(t, fn, false, forward, "/.oh-my-zsh/cache", "zshc", 8, 13,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3+scoreGapStart)
+			assertMatch(t, fn, false, forward, "ab0123 456", "12356", 3, 10,
+				scoreMatch*5+bonusConsecutive*3+scoreGapStart+scoreGapExtention)
+			assertMatch(t, fn, false, forward, "abc123 456", "12356", 3, 10,
+				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+bonusConsecutive+scoreGapStart+scoreGapExtention)
+			assertMatch(t, fn, false, forward, "foo/bar/baz", "fbb", 0, 9,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
+					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtention)
+			assertMatch(t, fn, false, forward, "fooBarBaz", "fbb", 0, 7,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
+					bonusCamel123*2+2*scoreGapStart+2*scoreGapExtention)
+			assertMatch(t, fn, false, forward, "foo barbaz", "fbb", 0, 8,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary+
+					scoreGapStart*2+scoreGapExtention*3)
+			assertMatch(t, fn, false, forward, "fooBar Baz", "foob", 0, 4,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
+			assertMatch(t, fn, false, forward, "xFoo-Bar Baz", "foo-b", 1, 6,
+				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+
+					bonusNonWord+bonusBoundary)
 
-	assertMatch(t, FuzzyMatch, false, true, "foo/bar/baz", "fbb", 0, 9, 8)
-	assertMatch(t, FuzzyMatch, false, true, "fooBarBaz", "fbb", 0, 7, 6)
-	assertMatch(t, FuzzyMatch, false, true, "foo barbaz", "fbb", 0, 8, 6)
-	assertMatch(t, FuzzyMatch, false, true, "fooBar Baz", "foob", 0, 4, 8)
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBZ", -1, -1, 0)
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBz", 2, 9, 2)
-	assertMatch(t, FuzzyMatch, true, true, "Foo Bar Baz", "fbb", -1, -1, 0)
-	assertMatch(t, FuzzyMatch, true, true, "Foo/Bar/Baz", "FBB", 0, 9, 8)
-	assertMatch(t, FuzzyMatch, true, true, "FooBarBaz", "FBB", 0, 7, 6)
-	assertMatch(t, FuzzyMatch, true, true, "foo BarBaz", "fBB", 0, 8, 7)
-	assertMatch(t, FuzzyMatch, true, true, "FooBar Baz", "FooB", 0, 4, 8)
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+			assertMatch(t, fn, true, forward, "fooBarbaz", "oBz", 2, 9,
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtention*3)
+			assertMatch(t, fn, true, forward, "Foo/Bar/Baz", "FBB", 0, 9,
+				scoreMatch*3+bonusBoundary*(bonusFirstCharMultiplier+2)+
+					scoreGapStart*2+scoreGapExtention*4)
+			assertMatch(t, fn, true, forward, "FooBarBaz", "FBB", 0, 7,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusCamel123*2+
+					scoreGapStart*2+scoreGapExtention*2)
+			assertMatch(t, fn, true, forward, "FooBar Baz", "FooB", 0, 4,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*2+
+					util.Max(bonusCamel123, bonusBoundary))
+
+			// Consecutive bonus updated
+			assertMatch(t, fn, true, forward, "foo-bar", "o-ba", 2, 6,
+				scoreMatch*4+bonusBoundary*3)
+
+			// Non-match
+			assertMatch(t, fn, true, forward, "fooBarbaz", "oBZ", -1, -1, 0)
+			assertMatch(t, fn, true, forward, "Foo Bar Baz", "fbb", -1, -1, 0)
+			assertMatch(t, fn, true, forward, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+		}
+	}
 }
 
 func TestFuzzyMatchBackward(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, true, "foobar fb", "fb", 0, 4, 4)
-	assertMatch(t, FuzzyMatch, false, false, "foobar fb", "fb", 7, 9, 5)
+	assertMatch(t, FuzzyMatchV1, false, true, "foobar fb", "fb", 0, 4,
+		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+
+			scoreGapStart+scoreGapExtention)
+	assertMatch(t, FuzzyMatchV1, false, false, "foobar fb", "fb", 7, 9,
+		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary)
 }
 
 func TestExactMatchNaive(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5, 3)
 		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "oBA", -1, -1, 0)
 		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "fooBarbazz", -1, -1, 0)
 
-		assertMatch(t, ExactMatchNaive, false, dir, "/AutomatorDocument.icns", "rdoc", 9, 13, 4)
-		assertMatch(t, ExactMatchNaive, false, dir, "/man1/zshcompctl.1", "zshc", 6, 10, 7)
-		assertMatch(t, ExactMatchNaive, false, dir, "/.oh-my-zsh/cache", "zsh/c", 8, 13, 10)
+		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5,
+			scoreMatch*3+bonusCamel123+bonusConsecutive)
+		assertMatch(t, ExactMatchNaive, false, dir, "/AutomatorDocument.icns", "rdoc", 9, 13,
+			scoreMatch*4+bonusCamel123+bonusConsecutive*2)
+		assertMatch(t, ExactMatchNaive, false, dir, "/man1/zshcompctl.1", "zshc", 6, 10,
+			scoreMatch*4+bonusBoundary*(bonusFirstCharMultiplier+3))
+		assertMatch(t, ExactMatchNaive, false, dir, "/.oh-my-zsh/cache", "zsh/c", 8, 13,
+			scoreMatch*5+bonusBoundary*(bonusFirstCharMultiplier+4))
 	}
 }
 
 func TestExactMatchNaiveBackward(t *testing.T) {
-	assertMatch(t, ExactMatchNaive, false, true, "foobar foob", "oo", 1, 3, 1)
-	assertMatch(t, ExactMatchNaive, false, false, "foobar foob", "oo", 8, 10, 1)
+	assertMatch(t, ExactMatchNaive, false, true, "foobar foob", "oo", 1, 3,
+		scoreMatch*2+bonusConsecutive)
+	assertMatch(t, ExactMatchNaive, false, false, "foobar foob", "oo", 8, 10,
+		scoreMatch*2+bonusConsecutive)
 }
 
 func TestPrefixMatch(t *testing.T) {
+	score := (scoreMatch+bonusBoundary)*3 + bonusBoundary*(bonusFirstCharMultiplier-1)
+
 	for _, dir := range []bool{true, false} {
 		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1, 0)
 		assertMatch(t, PrefixMatch, false, dir, "fooBarBaz", "baz", -1, -1, 0)
-		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, 6)
-		assertMatch(t, PrefixMatch, false, dir, "foOBarBaZ", "foo", 0, 3, 7)
-		assertMatch(t, PrefixMatch, false, dir, "f-oBarbaz", "f-o", 0, 3, 8)
+		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, score)
+		assertMatch(t, PrefixMatch, false, dir, "foOBarBaZ", "foo", 0, 3, score)
+		assertMatch(t, PrefixMatch, false, dir, "f-oBarbaz", "f-o", 0, 3, score)
 	}
 }
 
 func TestSuffixMatch(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1, 0)
-		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9, 2)
-		assertMatch(t, SuffixMatch, false, dir, "fooBarBaZ", "baz", 6, 9, 5)
 		assertMatch(t, SuffixMatch, true, dir, "fooBarbaz", "Baz", -1, -1, 0)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1, 0)
+
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9,
+			scoreMatch*3+bonusConsecutive*2)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarBaZ", "baz", 6, 9,
+			(scoreMatch+bonusCamel123)*3+bonusCamel123*(bonusFirstCharMultiplier-1))
 	}
 }
 
 func TestEmptyPattern(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, FuzzyMatch, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, FuzzyMatchV1, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, FuzzyMatchV2, true, dir, "foobar", "", 0, 0, 0)
 		assertMatch(t, ExactMatchNaive, true, dir, "foobar", "", 0, 0, 0)
 		assertMatch(t, PrefixMatch, true, dir, "foobar", "", 0, 0, 0)
 		assertMatch(t, SuffixMatch, true, dir, "foobar", "", 6, 6, 0)
 	}
 }
+
+func TestLongString(t *testing.T) {
+	bytes := make([]byte, math.MaxUint16*2)
+	for i := range bytes {
+		bytes[i] = 'x'
+	}
+	bytes[math.MaxUint16] = 'z'
+	assertMatch(t, FuzzyMatchV2, true, true, string(bytes), "zx", math.MaxUint16, math.MaxUint16+2, scoreMatch*2+bonusConsecutive)
+}

src/ansi.go

@@ -6,6 +6,8 @@ import (
 	"strconv"
 	"strings"
 	"unicode/utf8"
+
+	"github.com/junegunn/fzf/src/tui"
 )
 
 type ansiOffset struct {
@@ -14,29 +16,38 @@ type ansiOffset struct {
 }
 
 type ansiState struct {
-	fg   int
-	bg   int
-	bold bool
+	fg   tui.Color
+	bg   tui.Color
+	attr tui.Attr
 }
 
 func (s *ansiState) colored() bool {
-	return s.fg != -1 || s.bg != -1 || s.bold
+	return s.fg != -1 || s.bg != -1 || s.attr > 0
 }
 
 func (s *ansiState) equals(t *ansiState) bool {
 	if t == nil {
 		return !s.colored()
 	}
-	return s.fg == t.fg && s.bg == t.bg && s.bold == t.bold
+	return s.fg == t.fg && s.bg == t.bg && s.attr == t.attr
 }
 
 var ansiRegex *regexp.Regexp
 
 func init() {
-	ansiRegex = regexp.MustCompile("\x1b\\[[0-9;]*[mK]")
+	/*
+		References:
+		- https://github.com/gnachman/iTerm2
+		- http://ascii-table.com/ansi-escape-sequences.php
+		- http://ascii-table.com/ansi-escape-sequences-vt-100.php
+		- http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
+	*/
+	// The following regular expression will include not all but most of the
+	// frequently used ANSI sequences
+	ansiRegex = regexp.MustCompile("\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b.|[\x08\x0e\x0f]")
 }
 
-func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, []ansiOffset, *ansiState) {
+func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, *[]ansiOffset, *ansiState) {
 	var offsets []ansiOffset
 	var output bytes.Buffer
 
@@ -84,18 +95,21 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 	if proc != nil {
 		proc(rest, state)
 	}
-	return output.String(), offsets, state
+	if len(offsets) == 0 {
+		return output.String(), nil, state
+	}
+	return output.String(), &offsets, state
 }
 
 func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
 	// State
 	var state *ansiState
 	if prevState == nil {
-		state = &ansiState{-1, -1, false}
+		state = &ansiState{-1, -1, 0}
 	} else {
-		state = &ansiState{prevState.fg, prevState.bg, prevState.bold}
+		state = &ansiState{prevState.fg, prevState.bg, prevState.attr}
 	}
-	if ansiCode[len(ansiCode)-1] == 'K' {
+	if ansiCode[0] != '\x1b' || ansiCode[1] != '[' || ansiCode[len(ansiCode)-1] != 'm' {
 		return state
 	}
 
@@ -105,7 +119,7 @@ func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
 	init := func() {
 		state.fg = -1
 		state.bg = -1
-		state.bold = false
+		state.attr = 0
 		state256 = 0
 	}
 
@@ -129,28 +143,56 @@ func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
 				case 49:
 					state.bg = -1
 				case 1:
-					state.bold = true
+					state.attr = state.attr | tui.Bold
+				case 2:
+					state.attr = state.attr | tui.Dim
+				case 3:
+					state.attr = state.attr | tui.Italic
+				case 4:
+					state.attr = state.attr | tui.Underline
+				case 5:
+					state.attr = state.attr | tui.Blink
+				case 7:
+					state.attr = state.attr | tui.Reverse
 				case 0:
 					init()
 				default:
 					if num >= 30 && num <= 37 {
-						state.fg = num - 30
+						state.fg = tui.Color(num - 30)
 					} else if num >= 40 && num <= 47 {
-						state.bg = num - 40
+						state.bg = tui.Color(num - 40)
+					} else if num >= 90 && num <= 97 {
+						state.fg = tui.Color(num - 90 + 8)
+					} else if num >= 100 && num <= 107 {
+						state.bg = tui.Color(num - 100 + 8)
 					}
 				}
 			case 1:
 				switch num {
+				case 2:
+					state256 = 10 // MAGIC
 				case 5:
 					state256++
 				default:
 					state256 = 0
 				}
 			case 2:
-				*ptr = num
+				*ptr = tui.Color(num)
+				state256 = 0
+			case 10:
+				*ptr = tui.Color(1<<24) | tui.Color(num<<16)
+				state256++
+			case 11:
+				*ptr = *ptr | tui.Color(num<<8)
+				state256++
+			case 12:
+				*ptr = *ptr | tui.Color(num)
 				state256 = 0
 			}
 		}
 	}
+	if state256 > 0 {
+		*ptr = -1
+	}
 	return state
 }

src/ansi_test.go

@@ -3,150 +3,156 @@ package fzf
 import (
 	"fmt"
 	"testing"
+
+	"github.com/junegunn/fzf/src/tui"
 )
 
 func TestExtractColor(t *testing.T) {
-	assert := func(offset ansiOffset, b int32, e int32, fg int, bg int, bold bool) {
+	assert := func(offset ansiOffset, b int32, e int32, fg tui.Color, bg tui.Color, bold bool) {
+		var attr tui.Attr
+		if bold {
+			attr = tui.Bold
+		}
 		if offset.offset[0] != b || offset.offset[1] != e ||
-			offset.color.fg != fg || offset.color.bg != bg || offset.color.bold != bold {
-			t.Error(offset, b, e, fg, bg, bold)
+			offset.color.fg != fg || offset.color.bg != bg || offset.color.attr != attr {
+			t.Error(offset, b, e, fg, bg, attr)
 		}
 	}
 
 	src := "hello world"
 	var state *ansiState
 	clean := "\x1b[0m"
-	check := func(assertion func(ansiOffsets []ansiOffset, state *ansiState)) {
+	check := func(assertion func(ansiOffsets *[]ansiOffset, state *ansiState)) {
 		output, ansiOffsets, newState := extractColor(src, state, nil)
 		state = newState
 		if output != "hello world" {
-			t.Errorf("Invalid output: {}", output)
+			t.Errorf("Invalid output: %s %s", output, []rune(output))
 		}
 		fmt.Println(src, ansiOffsets, clean)
 		assertion(ansiOffsets, state)
 	}
 
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) > 0 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if offsets != nil {
 			t.Fail()
 		}
 	})
 
 	state = nil
 	src = "\x1b[0mhello world"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) > 0 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if offsets != nil {
 			t.Fail()
 		}
 	})
 
 	state = nil
 	src = "\x1b[1mhello world"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 11, -1, -1, true)
+		assert((*offsets)[0], 0, 11, -1, -1, true)
 	})
 
 	state = nil
-	src = "\x1b[1mhello \x1b[mworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	src = "\x1b[1mhello \x1b[mw\x1b7o\x1b8r\x1b(Bl\x1b[2@d"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 6, -1, -1, true)
+		assert((*offsets)[0], 0, 6, -1, -1, true)
 	})
 
 	state = nil
 	src = "\x1b[1mhello \x1b[Kworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 11, -1, -1, true)
+		assert((*offsets)[0], 0, 11, -1, -1, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;45;1mworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 11, 4, 5, true)
+		assert((*offsets)[0], 6, 11, 4, 5, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;45;1mwor\x1b[34;45;1mld"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 11, 4, 5, true)
+		assert((*offsets)[0], 6, 11, 4, 5, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;45;1mwor\x1b[0mld"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 9, 4, 5, true)
+		assert((*offsets)[0], 6, 9, 4, 5, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 3 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 3 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 8, 4, 233, true)
-		assert(offsets[1], 8, 9, 161, 233, true)
-		assert(offsets[2], 10, 11, 161, -1, false)
+		assert((*offsets)[0], 6, 8, 4, 233, true)
+		assert((*offsets)[1], 8, 9, 161, 233, true)
+		assert((*offsets)[2], 10, 11, 161, -1, false)
 	})
 
 	// {38,48};5;{38,48}
 	state = nil
 	src = "hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 2 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 2 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 9, 38, 48, true)
-		assert(offsets[1], 9, 10, 48, 38, true)
+		assert((*offsets)[0], 6, 9, 38, 48, true)
+		assert((*offsets)[1], 9, 10, 48, 38, true)
 	})
 
 	src = "hello \x1b[32;1mworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		if state.fg != 2 || state.bg != -1 || !state.bold {
+		if state.fg != 2 || state.bg != -1 || state.attr == 0 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 11, 2, -1, true)
+		assert((*offsets)[0], 6, 11, 2, -1, true)
 	})
 
 	src = "hello world"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		if state.fg != 2 || state.bg != -1 || !state.bold {
+		if state.fg != 2 || state.bg != -1 || state.attr == 0 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 11, 2, -1, true)
+		assert((*offsets)[0], 0, 11, 2, -1, true)
 	})
 
 	src = "hello \x1b[0;38;5;200;48;5;100mworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
-		if len(offsets) != 2 {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 2 {
 			t.Fail()
 		}
-		if state.fg != 200 || state.bg != 100 || state.bold {
+		if state.fg != 200 || state.bg != 100 || state.attr > 0 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 6, 2, -1, true)
-		assert(offsets[1], 6, 11, 200, 100, false)
+		assert((*offsets)[0], 0, 6, 2, -1, true)
+		assert((*offsets)[1], 6, 11, 200, 100, false)
 	})
 }

src/cache.go

@@ -3,7 +3,7 @@ package fzf
 import "sync"
 
 // queryCache associates strings to lists of items
-type queryCache map[string][]*Item
+type queryCache map[string][]*Result
 
 // ChunkCache associates Chunk and query string to lists of items
 type ChunkCache struct {
@@ -17,7 +17,7 @@ func NewChunkCache() ChunkCache {
 }
 
 // Add adds the list to the cache
-func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Item) {
+func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Result) {
 	if len(key) == 0 || !chunk.IsFull() || len(list) > queryCacheMax {
 		return
 	}
@@ -34,7 +34,7 @@ func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Item) {
 }
 
 // Find is called to lookup ChunkCache
-func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Item, bool) {
+func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Result, bool) {
 	if len(key) == 0 || !chunk.IsFull() {
 		return nil, false
 	}

src/cache_test.go

@@ -7,8 +7,8 @@ func TestChunkCache(t *testing.T) {
 	chunk2 := make(Chunk, chunkSize)
 	chunk1p := &Chunk{}
 	chunk2p := &chunk2
-	items1 := []*Item{&Item{}}
-	items2 := []*Item{&Item{}, &Item{}}
+	items1 := []*Result{&Result{}}
+	items2 := []*Result{&Result{}, &Result{}}
 	cache.Add(chunk1p, "foo", items1)
 	cache.Add(chunk2p, "foo", items1)
 	cache.Add(chunk2p, "bar", items2)

src/chunklist_test.go

@@ -9,10 +9,10 @@ import (
 
 func TestChunkList(t *testing.T) {
 	// FIXME global
-	sortCriteria = []criterion{byMatchLen, byLength}
+	sortCriteria = []criterion{byScore, byLength}
 
 	cl := NewChunkList(func(s []byte, i int) *Item {
-		return &Item{text: util.ToChars(s), rank: buildEmptyRank(int32(i * 2))}
+		return &Item{text: util.ToChars(s), index: int32(i * 2)}
 	})
 
 	// Snapshot
@@ -41,11 +41,8 @@ func TestChunkList(t *testing.T) {
 	if len(*chunk1) != 2 {
 		t.Error("Snapshot should contain only two items")
 	}
-	last := func(arr [5]int32) int32 {
-		return arr[len(arr)-1]
-	}
-	if (*chunk1)[0].text.ToString() != "hello" || last((*chunk1)[0].rank) != 0 ||
-		(*chunk1)[1].text.ToString() != "world" || last((*chunk1)[1].rank) != 2 {
+	if (*chunk1)[0].text.ToString() != "hello" || (*chunk1)[0].index != 0 ||
+		(*chunk1)[1].text.ToString() != "world" || (*chunk1)[1].index != 2 {
 		t.Error("Invalid data")
 	}
 	if chunk1.IsFull() {

src/constants.go

@@ -8,26 +8,33 @@ import (
 
 const (
 	// Current version
-	version = "0.13.4"
+	version = "0.15.9"
 
 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
 	coordinatorDelayStep time.Duration = 10 * time.Millisecond
 
 	// Reader
-	defaultCommand = `find . -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | sed s/^..//`
+	readerBufferSize = 64 * 1024
 
 	// Terminal
-	initialDelay    = 20 * time.Millisecond
-	initialDelayTac = 100 * time.Millisecond
-	spinnerDuration = 200 * time.Millisecond
+	initialDelay     = 20 * time.Millisecond
+	initialDelayTac  = 100 * time.Millisecond
+	spinnerDuration  = 200 * time.Millisecond
+	maxPatternLength = 100
 
 	// Matcher
-	progressMinDuration = 200 * time.Millisecond
+	numPartitionsMultiplier = 8
+	maxPartitions           = 32
+	progressMinDuration     = 200 * time.Millisecond
 
 	// Capacity of each chunk
 	chunkSize int = 100
 
+	// Pre-allocated memory slices to minimize GC
+	slab16Size int = 100 * 1024 // 200KB * 32 = 12.8MB
+	slab32Size int = 2048       // 8KB * 32 = 256KB
+
 	// Do not cache results of low selectivity queries
 	queryCacheMax int = chunkSize / 5
 

src/constants_unix.go

@@ -0,0 +1,8 @@
+// +build !windows
+
+package fzf
+
+const (
+	// Reader
+	defaultCommand = `find . -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | sed s/^..//`
+)

src/constants_windows.go

@@ -0,0 +1,8 @@
+// +build windows
+
+package fzf
+
+const (
+	// Reader
+	defaultCommand = `dir /s/b`
+)

src/core.go

@@ -28,16 +28,11 @@ package fzf
 import (
 	"fmt"
 	"os"
-	"runtime"
 	"time"
 
 	"github.com/junegunn/fzf/src/util"
 )
 
-func initProcs() {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-}
-
 /*
 Reader   -> EvtReadFin
 Reader   -> EvtReadNew        -> Matcher  (restart)
@@ -49,8 +44,6 @@ Matcher  -> EvtHeader         -> Terminal (update header)
 
 // Run starts fzf
 func Run(opts *Options) {
-	initProcs()
-
 	sort := opts.Sort > 0
 	sortCriteria = opts.Criteria
 
@@ -63,16 +56,16 @@ func Run(opts *Options) {
 	eventBox := util.NewEventBox()
 
 	// ANSI code processor
-	ansiProcessor := func(data []byte) (util.Chars, []ansiOffset) {
+	ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
 		return util.ToChars(data), nil
 	}
-	ansiProcessorRunes := func(data []rune) (util.Chars, []ansiOffset) {
+	ansiProcessorRunes := func(data []rune) (util.Chars, *[]ansiOffset) {
 		return util.RunesToChars(data), nil
 	}
 	if opts.Ansi {
 		if opts.Theme != nil {
 			var state *ansiState
-			ansiProcessor = func(data []byte) (util.Chars, []ansiOffset) {
+			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				trimmed, offsets, newState := extractColor(string(data), state, nil)
 				state = newState
 				return util.RunesToChars([]rune(trimmed)), offsets
@@ -80,12 +73,12 @@ func Run(opts *Options) {
 		} else {
 			// When color is disabled but ansi option is given,
 			// we simply strip out ANSI codes from the input
-			ansiProcessor = func(data []byte) (util.Chars, []ansiOffset) {
+			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				trimmed, _, _ := extractColor(string(data), nil, nil)
 				return util.RunesToChars([]rune(trimmed)), nil
 			}
 		}
-		ansiProcessorRunes = func(data []rune) (util.Chars, []ansiOffset) {
+		ansiProcessorRunes = func(data []rune) (util.Chars, *[]ansiOffset) {
 			return ansiProcessor([]byte(string(data)))
 		}
 	}
@@ -102,14 +95,13 @@ func Run(opts *Options) {
 			}
 			chars, colors := ansiProcessor(data)
 			return &Item{
+				index:  int32(index),
 				text:   chars,
-				colors: colors,
-				rank:   buildEmptyRank(int32(index))}
+				colors: colors}
 		})
 	} else {
 		chunkList = NewChunkList(func(data []byte, index int) *Item {
-			chars := util.ToChars(data)
-			tokens := Tokenize(chars, opts.Delimiter)
+			tokens := Tokenize(util.ToChars(data), opts.Delimiter)
 			trans := Transform(tokens, opts.WithNth)
 			if len(header) < opts.HeaderLines {
 				header = append(header, string(joinTokens(trans)))
@@ -118,10 +110,9 @@ func Run(opts *Options) {
 			}
 			textRunes := joinTokens(trans)
 			item := Item{
-				text:     util.RunesToChars(textRunes),
+				index:    int32(index),
 				origText: &data,
-				colors:   nil,
-				rank:     buildEmptyRank(int32(index))}
+				colors:   nil}
 
 			trimmed, colors := ansiProcessorRunes(textRunes)
 			item.text = trimmed
@@ -152,27 +143,30 @@ func Run(opts *Options) {
 	}
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
-			opts.Fuzzy, opts.Extended, opts.Case, forward,
-			opts.Nth, opts.Delimiter, runes)
+			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, forward,
+			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
 	}
 	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)
 
 	// Filtering mode
 	if opts.Filter != nil {
 		if opts.PrintQuery {
-			fmt.Println(*opts.Filter)
+			opts.Printer(*opts.Filter)
 		}
 
 		pattern := patternBuilder([]rune(*opts.Filter))
 
 		found := false
 		if streamingFilter {
+			slab := util.MakeSlab(slab16Size, slab32Size)
 			reader := Reader{
 				func(runes []byte) bool {
 					item := chunkList.trans(runes, 0)
-					if item != nil && pattern.MatchItem(item) {
-						fmt.Println(item.text.ToString())
-						found = true
+					if item != nil {
+						if result, _, _ := pattern.MatchItem(item, false, slab); result != nil {
+							opts.Printer(item.text.ToString())
+							found = true
+						}
 					}
 					return false
 				}, eventBox, opts.ReadZero}
@@ -186,7 +180,7 @@ func Run(opts *Options) {
 				chunks:  snapshot,
 				pattern: pattern})
 			for i := 0; i < merger.Length(); i++ {
-				fmt.Println(merger.Get(i).AsString(opts.Ansi))
+				opts.Printer(merger.Get(i).item.AsString(opts.Ansi))
 				found = true
 			}
 		}
@@ -260,13 +254,13 @@ func Run(opts *Options) {
 							} else if val.final {
 								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
 									if opts.PrintQuery {
-										fmt.Println(opts.Query)
+										opts.Printer(opts.Query)
 									}
 									if len(opts.Expect) > 0 {
-										fmt.Println()
+										opts.Printer("")
 									}
 									for i := 0; i < count; i++ {
-										fmt.Println(val.Get(i).AsString(opts.Ansi))
+										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
 									}
 									if count > 0 {
 										os.Exit(exitOk)

src/curses/curses.go

@@ -1,704 +0,0 @@
-package curses
-
-/*
-#include <ncurses.h>
-#include <locale.h>
-#cgo !static LDFLAGS: -lncurses
-#cgo static LDFLAGS: -l:libncursesw.a -l:libtinfo.a -l:libgpm.a -ldl
-#cgo android static LDFLAGS: -l:libncurses.a -fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch
-
-SCREEN *c_newterm () {
-	return newterm(NULL, stderr, stdin);
-}
-
-*/
-import "C"
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"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
-	DoubleClick
-
-	BTab
-	BSpace
-
-	Del
-	PgUp
-	PgDn
-
-	Up
-	Down
-	Left
-	Right
-	Home
-	End
-
-	SLeft
-	SRight
-
-	F1
-	F2
-	F3
-	F4
-	F5
-	F6
-	F7
-	F8
-	F9
-	F10
-
-	AltEnter
-	AltSpace
-	AltSlash
-	AltBS
-	AltA
-	AltB
-	AltC
-	AltD
-	AltE
-	AltF
-
-	AltZ = AltA + 'z' - 'a'
-)
-
-// Pallete
-const (
-	ColNormal = iota
-	ColPrompt
-	ColMatch
-	ColCurrent
-	ColCurrentMatch
-	ColSpinner
-	ColInfo
-	ColCursor
-	ColSelected
-	ColHeader
-	ColBorder
-	ColUser // Should be the last entry
-)
-
-const (
-	doubleClickDuration = 500 * time.Millisecond
-	colDefault          = -1
-	colUndefined        = -2
-)
-
-type ColorTheme struct {
-	UseDefault   bool
-	Fg           int16
-	Bg           int16
-	DarkBg       int16
-	Prompt       int16
-	Match        int16
-	Current      int16
-	CurrentMatch int16
-	Spinner      int16
-	Info         int16
-	Cursor       int16
-	Selected     int16
-	Header       int16
-	Border       int16
-}
-
-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
-	_colorMap     map[int]int
-	_prevDownTime time.Time
-	_clickY       []int
-	_screen       *C.SCREEN
-	Default16     *ColorTheme
-	Dark256       *ColorTheme
-	Light256      *ColorTheme
-	FG            int
-	CurrentFG     int
-	BG            int
-	DarkBG        int
-)
-
-type Window struct {
-	win    *C.WINDOW
-	Top    int
-	Left   int
-	Width  int
-	Height int
-}
-
-func NewWindow(top int, left int, width int, height int, border bool) *Window {
-	win := C.newwin(C.int(height), C.int(width), C.int(top), C.int(left))
-	if border {
-		attr := _color(ColBorder, false)
-		C.wattron(win, attr)
-		C.box(win, 0, 0)
-		C.wattroff(win, attr)
-	}
-	return &Window{
-		win:    win,
-		Top:    top,
-		Left:   left,
-		Width:  width,
-		Height: height,
-	}
-}
-
-func EmptyTheme() *ColorTheme {
-	return &ColorTheme{
-		UseDefault:   true,
-		Fg:           colUndefined,
-		Bg:           colUndefined,
-		DarkBg:       colUndefined,
-		Prompt:       colUndefined,
-		Match:        colUndefined,
-		Current:      colUndefined,
-		CurrentMatch: colUndefined,
-		Spinner:      colUndefined,
-		Info:         colUndefined,
-		Cursor:       colUndefined,
-		Selected:     colUndefined,
-		Header:       colUndefined,
-		Border:       colUndefined}
-}
-
-func init() {
-	_prevDownTime = time.Unix(0, 0)
-	_clickY = []int{}
-	_colorMap = make(map[int]int)
-	Default16 = &ColorTheme{
-		UseDefault:   true,
-		Fg:           15,
-		Bg:           0,
-		DarkBg:       C.COLOR_BLACK,
-		Prompt:       C.COLOR_BLUE,
-		Match:        C.COLOR_GREEN,
-		Current:      C.COLOR_YELLOW,
-		CurrentMatch: C.COLOR_GREEN,
-		Spinner:      C.COLOR_GREEN,
-		Info:         C.COLOR_WHITE,
-		Cursor:       C.COLOR_RED,
-		Selected:     C.COLOR_MAGENTA,
-		Header:       C.COLOR_CYAN,
-		Border:       C.COLOR_BLACK}
-	Dark256 = &ColorTheme{
-		UseDefault:   true,
-		Fg:           15,
-		Bg:           0,
-		DarkBg:       236,
-		Prompt:       110,
-		Match:        108,
-		Current:      254,
-		CurrentMatch: 151,
-		Spinner:      148,
-		Info:         144,
-		Cursor:       161,
-		Selected:     168,
-		Header:       109,
-		Border:       59}
-	Light256 = &ColorTheme{
-		UseDefault:   true,
-		Fg:           15,
-		Bg:           0,
-		DarkBg:       251,
-		Prompt:       25,
-		Match:        66,
-		Current:      237,
-		CurrentMatch: 23,
-		Spinner:      65,
-		Info:         101,
-		Cursor:       161,
-		Selected:     168,
-		Header:       31,
-		Border:       145}
-}
-
-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(theme *ColorTheme, 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.setlocale(C.LC_ALL, C.CString(""))
-	_screen = C.c_newterm()
-	if _screen == nil {
-		fmt.Println("Invalid $TERM: " + os.Getenv("TERM"))
-		os.Exit(2)
-	}
-	C.set_term(_screen)
-	if mouse {
-		C.mousemask(C.ALL_MOUSE_EVENTS, nil)
-	}
-	C.noecho()
-	C.raw() // stty dsusp undef
-
-	if theme != nil {
-		C.start_color()
-		var baseTheme *ColorTheme
-		if C.tigetnum(C.CString("colors")) >= 256 {
-			baseTheme = Dark256
-		} else {
-			baseTheme = Default16
-		}
-		initPairs(baseTheme, theme, black)
-		_color = attrColored
-	} else {
-		_color = attrMono
-	}
-}
-
-func override(a int16, b int16) C.short {
-	if b == colUndefined {
-		return C.short(a)
-	}
-	return C.short(b)
-}
-
-func initPairs(baseTheme *ColorTheme, theme *ColorTheme, black bool) {
-	fg := override(baseTheme.Fg, theme.Fg)
-	bg := override(baseTheme.Bg, theme.Bg)
-	if black {
-		bg = C.COLOR_BLACK
-	} else if theme.UseDefault {
-		fg = colDefault
-		bg = colDefault
-		C.use_default_colors()
-	}
-	if theme.UseDefault {
-		FG = colDefault
-		BG = colDefault
-	} else {
-		FG = int(fg)
-		BG = int(bg)
-		C.assume_default_colors(C.int(override(baseTheme.Fg, theme.Fg)), C.int(bg))
-	}
-
-	currentFG := override(baseTheme.Current, theme.Current)
-	darkBG := override(baseTheme.DarkBg, theme.DarkBg)
-	CurrentFG = int(currentFG)
-	DarkBG = int(darkBG)
-	C.init_pair(ColPrompt, override(baseTheme.Prompt, theme.Prompt), bg)
-	C.init_pair(ColMatch, override(baseTheme.Match, theme.Match), bg)
-	C.init_pair(ColCurrent, currentFG, darkBG)
-	C.init_pair(ColCurrentMatch, override(baseTheme.CurrentMatch, theme.CurrentMatch), darkBG)
-	C.init_pair(ColSpinner, override(baseTheme.Spinner, theme.Spinner), bg)
-	C.init_pair(ColInfo, override(baseTheme.Info, theme.Info), bg)
-	C.init_pair(ColCursor, override(baseTheme.Cursor, theme.Cursor), darkBG)
-	C.init_pair(ColSelected, override(baseTheme.Selected, theme.Selected), darkBG)
-	C.init_pair(ColHeader, override(baseTheme.Header, theme.Header), bg)
-	C.init_pair(ColBorder, override(baseTheme.Border, theme.Border), bg)
-}
-
-func Close() {
-	C.endwin()
-	C.delscreen(_screen)
-}
-
-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
-		x := int(_buf[4] - 33)
-		y := int(_buf[5] - 33)
-		return Event{Mouse, 0, &MouseEvent{y, x, 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 13:
-		return Event{AltEnter, 0, nil}
-	case 32:
-		return Event{AltSpace, 0, nil}
-	case 47:
-		return Event{AltSlash, 0, nil}
-	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{Left, 0, nil}
-		case 67:
-			return Event{Right, 0, nil}
-		case 66:
-			return Event{Down, 0, nil}
-		case 65:
-			return Event{Up, 0, nil}
-		case 90:
-			return Event{BTab, 0, nil}
-		case 72:
-			return Event{Home, 0, nil}
-		case 70:
-			return Event{End, 0, nil}
-		case 77:
-			return mouseSequence(sz)
-		case 80:
-			return Event{F1, 0, nil}
-		case 81:
-			return Event{F2, 0, nil}
-		case 82:
-			return Event{F3, 0, nil}
-		case 83:
-			return Event{F4, 0, nil}
-		case 49, 50, 51, 52, 53, 54:
-			if len(_buf) < 4 {
-				return Event{Invalid, 0, nil}
-			}
-			*sz = 4
-			switch _buf[2] {
-			case 50:
-				if len(_buf) == 5 && _buf[4] == 126 {
-					*sz = 5
-					switch _buf[3] {
-					case 48:
-						return Event{F9, 0, nil}
-					case 49:
-						return Event{F10, 0, nil}
-					}
-				}
-				// Bracketed paste mode \e[200~ / \e[201
-				if _buf[3] == 48 && (_buf[4] == 48 || _buf[4] == 49) && _buf[5] == 126 {
-					*sz = 6
-					return Event{Invalid, 0, nil}
-				}
-				return Event{Invalid, 0, nil} // INS
-			case 51:
-				return Event{Del, 0, nil}
-			case 52:
-				return Event{End, 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{Home, 0, nil}
-				case 53, 55, 56, 57:
-					if len(_buf) == 5 && _buf[4] == 126 {
-						*sz = 5
-						switch _buf[3] {
-						case 53:
-							return Event{F5, 0, nil}
-						case 55:
-							return Event{F6, 0, nil}
-						case 56:
-							return Event{F7, 0, nil}
-						case 57:
-							return Event{F8, 0, nil}
-						}
-					}
-					return Event{Invalid, 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{Home, 0, nil}
-						case 67:
-							return Event{End, 0, nil}
-						}
-					case 53:
-						switch _buf[5] {
-						case 68:
-							return Event{SLeft, 0, nil}
-						case 67:
-							return Event{SRight, 0, nil}
-						}
-					} // _buf[4]
-				} // _buf[3]
-			} // _buf[2]
-		} // _buf[2]
-	} // _buf[1]
-	if _buf[1] >= 'a' && _buf[1] <= 'z' {
-		return Event{AltA + int(_buf[1]) - 'a', 0, nil}
-	}
-	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:
-		return Event{CtrlC, 0, nil}
-	case CtrlG:
-		return Event{CtrlG, 0, nil}
-	case CtrlQ:
-		return Event{CtrlQ, 0, nil}
-	case 127:
-		return Event{BSpace, 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)
-	if r == utf8.RuneError {
-		return Event{ESC, 0, nil}
-	}
-	sz = rsz
-	return Event{Rune, r, nil}
-}
-
-func (w *Window) Close() {
-	C.delwin(w.win)
-}
-
-func (w *Window) Enclose(y int, x int) bool {
-	return bool(C.wenclose(w.win, C.int(y), C.int(x)))
-}
-
-func (w *Window) Move(y int, x int) {
-	C.wmove(w.win, C.int(y), C.int(x))
-}
-
-func (w *Window) MoveAndClear(y int, x int) {
-	w.Move(y, x)
-	C.wclrtoeol(w.win)
-}
-
-func (w *Window) Print(text string) {
-	C.waddstr(w.win, C.CString(strings.Map(func(r rune) rune {
-		if r < 32 {
-			return -1
-		}
-		return r
-	}, text)))
-}
-
-func (w *Window) CPrint(pair int, bold bool, text string) {
-	attr := _color(pair, bold)
-	C.wattron(w.win, attr)
-	w.Print(text)
-	C.wattroff(w.win, attr)
-}
-
-func Clear() {
-	C.clear()
-}
-
-func Endwin() {
-	C.endwin()
-}
-
-func Refresh() {
-	C.refresh()
-}
-
-func (w *Window) Erase() {
-	C.werase(w.win)
-}
-
-func (w *Window) Fill(str string) bool {
-	return C.waddstr(w.win, C.CString(str)) == C.OK
-}
-
-func (w *Window) CFill(str string, fg int, bg int, bold bool) bool {
-	attr := _color(PairFor(fg, bg), bold)
-	C.wattron(w.win, attr)
-	ret := w.Fill(str)
-	C.wattroff(w.win, attr)
-	return ret
-}
-
-func (w *Window) Refresh() {
-	C.wnoutrefresh(w.win)
-}
-
-func DoUpdate() {
-	C.doupdate()
-}
-
-func PairFor(fg int, bg int) int {
-	key := (fg << 8) + bg
-	if found, prs := _colorMap[key]; prs {
-		return found
-	}
-
-	id := len(_colorMap) + ColUser
-	C.init_pair(C.short(id), C.short(fg), C.short(bg))
-	_colorMap[key] = id
-	return id
-}

src/history_test.go

@@ -1,7 +1,10 @@
 package fzf
 
 import (
+	"io/ioutil"
+	"os"
 	"os/user"
+	"runtime"
 	"testing"
 )
 
@@ -10,23 +13,34 @@ func TestHistory(t *testing.T) {
 
 	// Invalid arguments
 	user, _ := user.Current()
-	paths := []string{"/etc", "/proc"}
-	if user.Name != "root" {
-		paths = append(paths, "/etc/sudoers")
+	var paths []string
+	if runtime.GOOS == "windows" {
+		// GOPATH should exist, so we shouldn't be able to override it
+		paths = []string{os.Getenv("GOPATH")}
+	} else {
+		paths = []string{"/etc", "/proc"}
+		if user.Name != "root" {
+			paths = append(paths, "/etc/sudoers")
+		}
 	}
+
 	for _, path := range paths {
 		if _, e := NewHistory(path, maxHistory); e == nil {
 			t.Error("Error expected for: " + path)
 		}
 	}
+
+	f, _ := ioutil.TempFile("", "fzf-history")
+	f.Close()
+
 	{ // Append lines
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		for i := 0; i < maxHistory+10; i++ {
 			h.append("foobar")
 		}
 	}
 	{ // Read lines
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		if len(h.lines) != maxHistory+1 {
 			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
 		}
@@ -37,13 +51,13 @@ func TestHistory(t *testing.T) {
 		}
 	}
 	{ // Append lines
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		h.append("barfoo")
 		h.append("")
 		h.append("foobarbaz")
 	}
 	{ // Read lines again
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		if len(h.lines) != maxHistory+1 {
 			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
 		}

src/item.go

@@ -1,295 +1,39 @@
 package fzf
 
 import (
-	"math"
-
-	"github.com/junegunn/fzf/src/curses"
 	"github.com/junegunn/fzf/src/util"
 )
 
-// Offset holds three 32-bit integers denoting the offsets of a matched substring
-type Offset [3]int32
-
-type colorOffset struct {
-	offset [2]int32
-	color  int
-	bold   bool
-}
-
 // Item represents each input line
 type Item struct {
+	index       int32
 	text        util.Chars
 	origText    *[]byte
+	colors      *[]ansiOffset
 	transformed []Token
-	offsets     []Offset
-	colors      []ansiOffset
-	rank        [5]int32
-	bonus       int32
-}
-
-// Sort criteria to use. Never changes once fzf is started.
-var sortCriteria []criterion
-
-func isRankValid(rank [5]int32) bool {
-	// Exclude ordinal index
-	for _, r := range rank[:4] {
-		if r > 0 {
-			return true
-		}
-	}
-	return false
-}
-
-func buildEmptyRank(index int32) [5]int32 {
-	return [5]int32{0, 0, 0, 0, index}
 }
 
 // Index returns ordinal index of the Item
 func (item *Item) Index() int32 {
-	return item.rank[4]
+	return item.index
 }
 
-// Rank calculates rank of the Item
-func (item *Item) Rank(cache bool) [5]int32 {
-	if cache && isRankValid(item.rank) {
-		return item.rank
+// Colors returns ansiOffsets of the Item
+func (item *Item) Colors() []ansiOffset {
+	if item.colors == nil {
+		return []ansiOffset{}
 	}
-	matchlen := 0
-	prevEnd := 0
-	lenSum := 0
-	minBegin := math.MaxInt32
-	for _, offset := range item.offsets {
-		begin := int(offset[0])
-		end := int(offset[1])
-		trimLen := int(offset[2])
-		lenSum += trimLen
-		if prevEnd > begin {
-			begin = prevEnd
-		}
-		if end > prevEnd {
-			prevEnd = end
-		}
-		if end > begin {
-			if begin < minBegin {
-				minBegin = begin
-			}
-			matchlen += end - begin
-		}
-	}
-	rank := buildEmptyRank(item.Index())
-	for idx, criterion := range sortCriteria {
-		var val int32
-		switch criterion {
-		case byMatchLen:
-			if matchlen == 0 {
-				val = math.MaxInt32
-			} else {
-				// It is extremely unlikely that bonus exceeds 128
-				val = 128*int32(matchlen) - item.bonus
-			}
-		case byLength:
-			// It is guaranteed that .transformed in not null in normal execution
-			if item.transformed != nil {
-				// If offsets is empty, lenSum will be 0, but we don't care
-				val = int32(lenSum)
-			} else {
-				val = int32(item.text.Length())
-			}
-		case byBegin:
-			// We can't just look at item.offsets[0][0] because it can be an inverse term
-			whitePrefixLen := 0
-			numChars := item.text.Length()
-			for idx := 0; idx < numChars; idx++ {
-				r := item.text.Get(idx)
-				whitePrefixLen = idx
-				if idx == minBegin || r != ' ' && r != '\t' {
-					break
-				}
-			}
-			val = int32(minBegin - whitePrefixLen)
-		case byEnd:
-			if prevEnd > 0 {
-				val = int32(1 + item.text.Length() - prevEnd)
-			} else {
-				// Empty offsets due to inverse terms.
-				val = 1
-			}
-		}
-		rank[idx] = val
-	}
-	if cache {
-		item.rank = rank
-	}
-	return rank
+	return *item.colors
 }
 
 // AsString returns the original string
 func (item *Item) AsString(stripAnsi bool) string {
-	return *item.StringPtr(stripAnsi)
-}
-
-// StringPtr returns the pointer to the original string
-func (item *Item) StringPtr(stripAnsi bool) *string {
 	if item.origText != nil {
 		if stripAnsi {
 			trimmed, _, _ := extractColor(string(*item.origText), nil, nil)
-			return &trimmed
+			return trimmed
 		}
-		orig := string(*item.origText)
-		return &orig
+		return string(*item.origText)
 	}
-	str := item.text.ToString()
-	return &str
-}
-
-func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset {
-	if len(item.colors) == 0 {
-		var offsets []colorOffset
-		for _, off := range item.offsets {
-
-			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: color, bold: bold})
-		}
-		return offsets
-	}
-
-	// Find max column
-	var maxCol int32
-	for _, off := range item.offsets {
-		if off[1] > maxCol {
-			maxCol = off[1]
-		}
-	}
-	for _, ansi := range item.colors {
-		if ansi.offset[1] > maxCol {
-			maxCol = ansi.offset[1]
-		}
-	}
-	cols := make([]int, maxCol)
-
-	for colorIndex, ansi := range item.colors {
-		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
-			cols[i] = colorIndex + 1 // XXX
-		}
-	}
-
-	for _, off := range item.offsets {
-		for i := off[0]; i < off[1]; i++ {
-			cols[i] = -1
-		}
-	}
-
-	// sort.Sort(ByOrder(offsets))
-
-	// Merge offsets
-	// ------------  ----  --  ----
-	//   ++++++++      ++++++++++
-	// --++++++++--  --++++++++++---
-	curr := 0
-	start := 0
-	var offsets []colorOffset
-	add := func(idx int) {
-		if curr != 0 && idx > start {
-			if curr == -1 {
-				offsets = append(offsets, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)}, color: color, bold: bold})
-			} else {
-				ansi := item.colors[curr-1]
-				fg := ansi.color.fg
-				if fg == -1 {
-					if current {
-						fg = curses.CurrentFG
-					} else {
-						fg = curses.FG
-					}
-				}
-				bg := ansi.color.bg
-				if bg == -1 {
-					if current {
-						bg = curses.DarkBG
-					} else {
-						bg = curses.BG
-					}
-				}
-				offsets = append(offsets, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)},
-					color:  curses.PairFor(fg, bg),
-					bold:   ansi.color.bold || bold})
-			}
-		}
-	}
-	for idx, col := range cols {
-		if col != curr {
-			add(idx)
-			start = idx
-			curr = col
-		}
-	}
-	add(int(maxCol))
-	return offsets
-}
-
-// 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, false)
-}
-
-// ByRelevanceTac is for sorting Items
-type ByRelevanceTac []*Item
-
-func (a ByRelevanceTac) Len() int {
-	return len(a)
-}
-
-func (a ByRelevanceTac) Swap(i, j int) {
-	a[i], a[j] = a[j], a[i]
-}
-
-func (a ByRelevanceTac) Less(i, j int) bool {
-	irank := a[i].Rank(true)
-	jrank := a[j].Rank(true)
-
-	return compareRanks(irank, jrank, true)
-}
-
-func compareRanks(irank [5]int32, jrank [5]int32, tac bool) bool {
-	for idx := 0; idx < 4; idx++ {
-		left := irank[idx]
-		right := jrank[idx]
-		if left < right {
-			return true
-		} else if left > right {
-			return false
-		}
-	}
-	return (irank[4] <= jrank[4]) != tac
+	return item.text.ToString()
 }

src/item_test.go

@@ -1,109 +1,23 @@
 package fzf
 
 import (
-	"math"
-	"sort"
 	"testing"
 
-	"github.com/junegunn/fzf/src/curses"
 	"github.com/junegunn/fzf/src/util"
 )
 
-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 TestStringPtr(t *testing.T) {
+	orig := []byte("\x1b[34mfoo")
+	text := []byte("\x1b[34mbar")
+	item := Item{origText: &orig, text: util.ToChars(text)}
+	if item.AsString(true) != "foo" || item.AsString(false) != string(orig) {
+		t.Fail()
+	}
+	if item.AsString(true) != "foo" {
+		t.Fail()
+	}
+	item.origText = nil
+	if item.AsString(true) != string(text) || item.AsString(false) != string(text) {
+		t.Fail()
 	}
 }
-
-func TestRankComparison(t *testing.T) {
-	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, false) ||
-		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
-		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, false) ||
-		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
-		t.Error("Invalid order")
-	}
-
-	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, true) ||
-		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
-		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, true) ||
-		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
-		t.Error("Invalid order (tac)")
-	}
-}
-
-// Match length, string length, index
-func TestItemRank(t *testing.T) {
-	// FIXME global
-	sortCriteria = []criterion{byMatchLen, byLength}
-
-	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
-	item1 := Item{text: util.RunesToChars(strs[0]), offsets: []Offset{}, rank: [5]int32{0, 0, 0, 0, 1}}
-	rank1 := item1.Rank(true)
-	if rank1[0] != math.MaxInt32 || rank1[1] != 3 || rank1[4] != 1 {
-		t.Error(item1.Rank(true))
-	}
-	// Only differ in index
-	item2 := Item{text: util.RunesToChars(strs[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: util.RunesToChars(strs[1]), rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item4 := Item{text: util.RunesToChars(strs[1]), rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
-	item5 := Item{text: util.RunesToChars(strs[2]), rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item6 := Item{text: util.RunesToChars(strs[2]), rank: [5]int32{0, 0, 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] != &item6 || items[1] != &item4 ||
-		items[2] != &item5 || items[3] != &item3 ||
-		items[4] != &item2 || items[5] != &item1 {
-		t.Error(items)
-	}
-}
-
-func TestColorOffset(t *testing.T) {
-	// ------------ 20 ----  --  ----
-	//   ++++++++        ++++++++++
-	// --++++++++--    --++++++++++---
-	item := Item{
-		offsets: []Offset{Offset{5, 15}, Offset{25, 35}},
-		colors: []ansiOffset{
-			ansiOffset{[2]int32{0, 20}, ansiState{1, 5, false}},
-			ansiOffset{[2]int32{22, 27}, ansiState{2, 6, true}},
-			ansiOffset{[2]int32{30, 32}, ansiState{3, 7, false}},
-			ansiOffset{[2]int32{33, 40}, ansiState{4, 8, true}}}}
-	// [{[0 5] 9 false} {[5 15] 99 false} {[15 20] 9 false} {[22 25] 10 true} {[25 35] 99 false} {[35 40] 11 true}]
-
-	offsets := item.colorOffsets(99, false, true)
-	assert := func(idx int, b int32, e int32, c int, bold bool) {
-		o := offsets[idx]
-		if o.offset[0] != b || o.offset[1] != e || o.color != c || o.bold != bold {
-			t.Error(o)
-		}
-	}
-	assert(0, 0, 5, curses.ColUser, false)
-	assert(1, 5, 15, 99, false)
-	assert(2, 15, 20, curses.ColUser, false)
-	assert(3, 22, 25, curses.ColUser+1, true)
-	assert(4, 25, 35, 99, false)
-	assert(5, 35, 40, curses.ColUser+2, true)
-}

src/matcher.go

@@ -26,6 +26,7 @@ type Matcher struct {
 	eventBox       *util.EventBox
 	reqBox         *util.EventBox
 	partitions     int
+	slab           []*util.Slab
 	mergerCache    map[string]*Merger
 }
 
@@ -37,13 +38,15 @@ const (
 // NewMatcher returns a new Matcher
 func NewMatcher(patternBuilder func([]rune) *Pattern,
 	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
+	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
 		patternBuilder: patternBuilder,
 		sort:           sort,
 		tac:            tac,
 		eventBox:       eventBox,
 		reqBox:         util.NewEventBox(),
-		partitions:     runtime.NumCPU(),
+		partitions:     partitions,
+		slab:           make([]*util.Slab, partitions),
 		mergerCache:    make(map[string]*Merger)}
 }
 
@@ -106,18 +109,19 @@ func (m *Matcher) Loop() {
 }
 
 func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
-	perSlice := len(chunks) / m.partitions
+	partitions := m.partitions
+	perSlice := len(chunks) / partitions
 
-	// No need to parallelize
 	if perSlice == 0 {
-		return [][]*Chunk{chunks}
+		partitions = len(chunks)
+		perSlice = 1
 	}
 
-	slices := make([][]*Chunk, m.partitions)
-	for i := 0; i < m.partitions; i++ {
+	slices := make([][]*Chunk, partitions)
+	for i := 0; i < partitions; i++ {
 		start := i * perSlice
 		end := start + perSlice
-		if i == m.partitions-1 {
+		if i == partitions-1 {
 			end = len(chunks)
 		}
 		slices[i] = chunks[start:end]
@@ -127,7 +131,7 @@ func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
 
 type partialResult struct {
 	index   int
-	matches []*Item
+	matches []*Result
 }
 
 func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
@@ -152,17 +156,26 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 
 	for idx, chunks := range slices {
 		waitGroup.Add(1)
-		go func(idx int, chunks []*Chunk) {
+		if m.slab[idx] == nil {
+			m.slab[idx] = util.MakeSlab(slab16Size, slab32Size)
+		}
+		go func(idx int, slab *util.Slab, chunks []*Chunk) {
 			defer func() { waitGroup.Done() }()
-			sliceMatches := []*Item{}
-			for _, chunk := range chunks {
-				matches := request.pattern.Match(chunk)
-				sliceMatches = append(sliceMatches, matches...)
+			count := 0
+			allMatches := make([][]*Result, len(chunks))
+			for idx, chunk := range chunks {
+				matches := request.pattern.Match(chunk, slab)
+				allMatches[idx] = matches
+				count += len(matches)
 				if cancelled.Get() {
 					return
 				}
 				countChan <- len(matches)
 			}
+			sliceMatches := make([]*Result, 0, count)
+			for _, matches := range allMatches {
+				sliceMatches = append(sliceMatches, matches...)
+			}
 			if m.sort {
 				if m.tac {
 					sort.Sort(ByRelevanceTac(sliceMatches))
@@ -171,7 +184,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 				}
 			}
 			resultChan <- partialResult{idx, sliceMatches}
-		}(idx, chunks)
+		}(idx, m.slab[idx], chunks)
 	}
 
 	wait := func() bool {
@@ -199,12 +212,12 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		}
 	}
 
-	partialResults := make([][]*Item, numSlices)
+	partialResults := make([][]*Result, numSlices)
 	for _ = range slices {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
-	return NewMerger(partialResults, m.sort, m.tac), false
+	return NewMerger(pattern, partialResults, m.sort, m.tac), false
 }
 
 // Reset is called to interrupt/signal the ongoing search

src/merger.go

@@ -3,13 +3,14 @@ package fzf
 import "fmt"
 
 // EmptyMerger is a Merger with no data
-var EmptyMerger = NewMerger([][]*Item{}, false, false)
+var EmptyMerger = NewMerger(nil, [][]*Result{}, false, 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
+	pattern *Pattern
+	lists   [][]*Result
+	merged  []*Result
 	chunks  *[]*Chunk
 	cursors []int
 	sorted  bool
@@ -22,9 +23,10 @@ type Merger struct {
 // original order
 func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 	mg := Merger{
-		chunks: chunks,
-		tac:    tac,
-		count:  0}
+		pattern: nil,
+		chunks:  chunks,
+		tac:     tac,
+		count:   0}
 
 	for _, chunk := range *mg.chunks {
 		mg.count += len(*chunk)
@@ -33,10 +35,11 @@ func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 }
 
 // NewMerger returns a new Merger
-func NewMerger(lists [][]*Item, sorted bool, tac bool) *Merger {
+func NewMerger(pattern *Pattern, lists [][]*Result, sorted bool, tac bool) *Merger {
 	mg := Merger{
+		pattern: pattern,
 		lists:   lists,
-		merged:  []*Item{},
+		merged:  []*Result{},
 		chunks:  nil,
 		cursors: make([]int, len(lists)),
 		sorted:  sorted,
@@ -55,14 +58,14 @@ 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 {
+// Get returns the pointer to the Result object indexed by the given integer
+func (mg *Merger) Get(idx int) *Result {
 	if mg.chunks != nil {
 		if mg.tac {
 			idx = mg.count - idx - 1
 		}
 		chunk := (*mg.chunks)[idx/chunkSize]
-		return (*chunk)[idx%chunkSize]
+		return &Result{item: (*chunk)[idx%chunkSize]}
 	}
 
 	if mg.sorted {
@@ -86,9 +89,9 @@ func (mg *Merger) cacheable() bool {
 	return mg.count < mergerCacheMax
 }
 
-func (mg *Merger) mergedGet(idx int) *Item {
+func (mg *Merger) mergedGet(idx int) *Result {
 	for i := len(mg.merged); i <= idx; i++ {
-		minRank := buildEmptyRank(0)
+		minRank := minRank()
 		minIdx := -1
 		for listIdx, list := range mg.lists {
 			cursor := mg.cursors[listIdx]
@@ -97,7 +100,7 @@ func (mg *Merger) mergedGet(idx int) *Item {
 				continue
 			}
 			if cursor >= 0 {
-				rank := list[cursor].Rank(false)
+				rank := list[cursor].rank
 				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
 					minRank = rank
 					minIdx = listIdx

src/merger_test.go

@@ -15,18 +15,11 @@ func assert(t *testing.T, cond bool, msg ...string) {
 	}
 }
 
-func randItem() *Item {
+func randResult() *Result {
 	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:    util.RunesToChars([]rune(str)),
-		rank:    buildEmptyRank(rand.Int31()),
-		offsets: offsets}
+	return &Result{
+		item: &Item{text: util.RunesToChars([]rune(str))},
+		rank: rank{index: rand.Int31()}}
 }
 
 func TestEmptyMerger(t *testing.T) {
@@ -36,23 +29,23 @@ func TestEmptyMerger(t *testing.T) {
 	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
 }
 
-func buildLists(partiallySorted bool) ([][]*Item, []*Item) {
+func buildLists(partiallySorted bool) ([][]*Result, []*Result) {
 	numLists := 4
-	lists := make([][]*Item, numLists)
+	lists := make([][]*Result, 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()
+		numResults := rand.Int() % 20
+		cnt += numResults
+		lists[i] = make([]*Result, numResults)
+		for j := 0; j < numResults; j++ {
+			item := randResult()
 			lists[i][j] = item
 		}
 		if partiallySorted {
 			sort.Sort(ByRelevance(lists[i]))
 		}
 	}
-	items := []*Item{}
+	items := []*Result{}
 	for _, list := range lists {
 		items = append(items, list...)
 	}
@@ -64,7 +57,7 @@ func TestMergerUnsorted(t *testing.T) {
 	cnt := len(items)
 
 	// Not sorted: same order
-	mg := NewMerger(lists, false, false)
+	mg := NewMerger(nil, lists, false, false)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	for i := 0; i < cnt; i++ {
 		assert(t, items[i] == mg.Get(i), "Invalid Get")
@@ -76,7 +69,7 @@ func TestMergerSorted(t *testing.T) {
 	cnt := len(items)
 
 	// Sorted sorted order
-	mg := NewMerger(lists, true, false)
+	mg := NewMerger(nil, lists, true, false)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	sort.Sort(ByRelevance(items))
 	for i := 0; i < cnt; i++ {
@@ -86,7 +79,7 @@ func TestMergerSorted(t *testing.T) {
 	}
 
 	// Inverse order
-	mg2 := NewMerger(lists, true, false)
+	mg2 := NewMerger(nil, lists, true, false)
 	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

@@ -8,7 +8,8 @@ import (
 	"strings"
 	"unicode/utf8"
 
-	"github.com/junegunn/fzf/src/curses"
+	"github.com/junegunn/fzf/src/algo"
+	"github.com/junegunn/fzf/src/tui"
 
 	"github.com/junegunn/go-shellwords"
 )
@@ -19,6 +20,7 @@ const usage = `usage: fzf [options]
     -x, --extended        Extended-search mode
                           (enabled by default; +x or --no-extended to disable)
     -e, --exact           Enable Exact-match
+    --algo=TYPE           Fuzzy matching algorithm: [v1|v2] (default: v2)
     -i                    Case-insensitive match (default: smart-case match)
     +i                    Case-sensitive match
     -n, --nth=N[,..]      Comma-separated list of field index expressions
@@ -55,6 +57,7 @@ const usage = `usage: fzf [options]
     --ansi                Enable processing of ANSI color codes
     --tabstop=SPACES      Number of spaces for a tab character (default: 8)
     --color=COLSPEC       Base scheme (dark|light|16|bw) and/or custom colors
+    --no-bold             Do not use bold text
 
   History
     --history=FILE        History file
@@ -94,7 +97,7 @@ const (
 type criterion int
 
 const (
-	byMatchLen criterion = iota
+	byScore criterion = iota
 	byLength
 	byBegin
 	byEnd
@@ -128,6 +131,7 @@ type previewOpts struct {
 // Options stores the values of command-line options
 type Options struct {
 	Fuzzy       bool
+	FuzzyAlgo   algo.Algo
 	Extended    bool
 	Case        Case
 	Nth         []Range
@@ -139,8 +143,9 @@ type Options struct {
 	Multi       bool
 	Ansi        bool
 	Mouse       bool
-	Theme       *curses.ColorTheme
+	Theme       *tui.ColorTheme
 	Black       bool
+	Bold        bool
 	Reverse     bool
 	Cycle       bool
 	Hscroll     bool
@@ -159,6 +164,7 @@ type Options struct {
 	Preview     previewOpts
 	PrintQuery  bool
 	ReadZero    bool
+	Printer     func(string)
 	Sync        bool
 	History     *History
 	Header      []string
@@ -171,6 +177,7 @@ type Options struct {
 func defaultOptions() *Options {
 	return &Options{
 		Fuzzy:       true,
+		FuzzyAlgo:   algo.FuzzyMatchV2,
 		Extended:    true,
 		Case:        CaseSmart,
 		Nth:         make([]Range, 0),
@@ -178,12 +185,13 @@ func defaultOptions() *Options {
 		Delimiter:   Delimiter{},
 		Sort:        1000,
 		Tac:         false,
-		Criteria:    []criterion{byMatchLen, byLength},
+		Criteria:    []criterion{byScore, byLength},
 		Multi:       false,
 		Ansi:        false,
 		Mouse:       true,
-		Theme:       curses.EmptyTheme(),
+		Theme:       tui.EmptyTheme(),
 		Black:       false,
+		Bold:        true,
 		Reverse:     false,
 		Cycle:       false,
 		Hscroll:     true,
@@ -202,6 +210,7 @@ func defaultOptions() *Options {
 		Preview:     previewOpts{"", posRight, sizeSpec{50, true}, false},
 		PrintQuery:  false,
 		ReadZero:    false,
+		Printer:     func(str string) { fmt.Println(str) },
 		Sync:        false,
 		History:     nil,
 		Header:      make([]string, 0),
@@ -240,7 +249,7 @@ func nextString(args []string, i *int, message string) string {
 }
 
 func optionalNextString(args []string, i *int) string {
-	if len(args) > *i+1 {
+	if len(args) > *i+1 && !strings.HasPrefix(args[*i+1], "-") {
 		*i++
 		return args[*i]
 	}
@@ -321,6 +330,22 @@ func isAlphabet(char uint8) bool {
 	return char >= 'a' && char <= 'z'
 }
 
+func isNumeric(char uint8) bool {
+	return char >= '0' && char <= '9'
+}
+
+func parseAlgo(str string) algo.Algo {
+	switch str {
+	case "v1":
+		return algo.FuzzyMatchV1
+	case "v2":
+		return algo.FuzzyMatchV2
+	default:
+		errorExit("invalid algorithm (expected: v1 or v2)")
+	}
+	return algo.FuzzyMatchV2
+}
+
 func parseKeyChords(str string, message string) map[int]string {
 	if len(str) == 0 {
 		errorExit(message)
@@ -340,60 +365,66 @@ func parseKeyChords(str string, message string) map[int]string {
 		chord := 0
 		switch lkey {
 		case "up":
-			chord = curses.Up
+			chord = tui.Up
 		case "down":
-			chord = curses.Down
+			chord = tui.Down
 		case "left":
-			chord = curses.Left
+			chord = tui.Left
 		case "right":
-			chord = curses.Right
+			chord = tui.Right
 		case "enter", "return":
-			chord = curses.CtrlM
+			chord = tui.CtrlM
 		case "space":
-			chord = curses.AltZ + int(' ')
+			chord = tui.AltZ + int(' ')
 		case "bspace", "bs":
-			chord = curses.BSpace
+			chord = tui.BSpace
 		case "alt-enter", "alt-return":
-			chord = curses.AltEnter
+			chord = tui.AltEnter
 		case "alt-space":
-			chord = curses.AltSpace
+			chord = tui.AltSpace
 		case "alt-/":
-			chord = curses.AltSlash
+			chord = tui.AltSlash
 		case "alt-bs", "alt-bspace":
-			chord = curses.AltBS
+			chord = tui.AltBS
 		case "tab":
-			chord = curses.Tab
+			chord = tui.Tab
 		case "btab", "shift-tab":
-			chord = curses.BTab
+			chord = tui.BTab
 		case "esc":
-			chord = curses.ESC
+			chord = tui.ESC
 		case "del":
-			chord = curses.Del
+			chord = tui.Del
 		case "home":
-			chord = curses.Home
+			chord = tui.Home
 		case "end":
-			chord = curses.End
+			chord = tui.End
 		case "pgup", "page-up":
-			chord = curses.PgUp
+			chord = tui.PgUp
 		case "pgdn", "page-down":
-			chord = curses.PgDn
+			chord = tui.PgDn
 		case "shift-left":
-			chord = curses.SLeft
+			chord = tui.SLeft
 		case "shift-right":
-			chord = curses.SRight
+			chord = tui.SRight
 		case "double-click":
-			chord = curses.DoubleClick
+			chord = tui.DoubleClick
 		case "f10":
-			chord = curses.F10
+			chord = tui.F10
+		case "f11":
+			chord = tui.F11
+		case "f12":
+			chord = tui.F12
 		default:
 			if len(key) == 6 && strings.HasPrefix(lkey, "ctrl-") && isAlphabet(lkey[5]) {
-				chord = curses.CtrlA + int(lkey[5]) - 'a'
+				chord = tui.CtrlA + int(lkey[5]) - 'a'
 			} else if len(key) == 5 && strings.HasPrefix(lkey, "alt-") && isAlphabet(lkey[4]) {
-				chord = curses.AltA + int(lkey[4]) - 'a'
+				chord = tui.AltA + int(lkey[4]) - 'a'
+			} else if len(key) == 5 && strings.HasPrefix(lkey, "alt-") && isNumeric(lkey[4]) {
+				chord = tui.Alt0 + int(lkey[4]) - '0'
 			} else if len(key) == 2 && strings.HasPrefix(lkey, "f") && key[1] >= '1' && key[1] <= '9' {
-				chord = curses.F1 + int(key[1]) - '1'
+				chord = tui.F1 + int(key[1]) - '1'
 			} else if utf8.RuneCountInString(key) == 1 {
-				chord = curses.AltZ + int([]rune(key)[0])
+				chord = tui.AltZ + int([]rune(key)[0])
 			} else {
 				errorExit("unsupported key: " + key)
 			}
@@ -406,7 +437,7 @@ func parseKeyChords(str string, message string) map[int]string {
 }
 
 func parseTiebreak(str string) []criterion {
-	criteria := []criterion{byMatchLen}
+	criteria := []criterion{byScore}
 	hasIndex := false
 	hasLength := false
 	hasBegin := false
@@ -440,7 +471,7 @@ func parseTiebreak(str string) []criterion {
 	return criteria
 }
 
-func dupeTheme(theme *curses.ColorTheme) *curses.ColorTheme {
+func dupeTheme(theme *tui.ColorTheme) *tui.ColorTheme {
 	if theme != nil {
 		dupe := *theme
 		return &dupe
@@ -448,16 +479,16 @@ func dupeTheme(theme *curses.ColorTheme) *curses.ColorTheme {
 	return nil
 }
 
-func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme {
+func parseTheme(defaultTheme *tui.ColorTheme, str string) *tui.ColorTheme {
 	theme := dupeTheme(defaultTheme)
 	for _, str := range strings.Split(strings.ToLower(str), ",") {
 		switch str {
 		case "dark":
-			theme = dupeTheme(curses.Dark256)
+			theme = dupeTheme(tui.Dark256)
 		case "light":
-			theme = dupeTheme(curses.Light256)
+			theme = dupeTheme(tui.Light256)
 		case "16":
-			theme = dupeTheme(curses.Default16)
+			theme = dupeTheme(tui.Default16)
 		case "bw", "no":
 			theme = nil
 		default:
@@ -477,14 +508,12 @@ func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme
 			if err != nil || ansi32 < -1 || ansi32 > 255 {
 				fail()
 			}
-			ansi := int16(ansi32)
+			ansi := tui.Color(ansi32)
 			switch pair[0] {
 			case "fg":
 				theme.Fg = ansi
-				theme.UseDefault = theme.UseDefault && ansi < 0
 			case "bg":
 				theme.Bg = ansi
-				theme.UseDefault = theme.UseDefault && ansi < 0
 			case "fg+":
 				theme.Current = ansi
 			case "bg+":
@@ -556,9 +585,9 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, str string)
 		}
 		var key int
 		if len(pair[0]) == 1 && pair[0][0] == escapedColon {
-			key = ':' + curses.AltZ
+			key = ':' + tui.AltZ
 		} else if len(pair[0]) == 1 && pair[0][0] == escapedComma {
-			key = ',' + curses.AltZ
+			key = ',' + tui.AltZ
 		} else {
 			keys := parseKeyChords(pair[0], "key name required")
 			key = firstKey(keys)
@@ -645,6 +674,14 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, str string)
 			keymap[key] = actTogglePreview
 		case "toggle-sort":
 			keymap[key] = actToggleSort
+		case "preview-up":
+			keymap[key] = actPreviewUp
+		case "preview-down":
+			keymap[key] = actPreviewDown
+		case "preview-page-up":
+			keymap[key] = actPreviewPageUp
+		case "preview-page-down":
+			keymap[key] = actPreviewPageDown
 		default:
 			if isExecuteAction(actLower) {
 				var offset int
@@ -833,6 +870,8 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "-f", "--filter":
 			filter := nextString(allArgs, &i, "query string required")
 			opts.Filter = &filter
+		case "--algo":
+			opts.FuzzyAlgo = parseAlgo(nextString(allArgs, &i, "algorithm required (v1|v2)"))
 		case "--expect":
 			opts.Expect = parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required")
 		case "--tiebreak":
@@ -842,7 +881,7 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--color":
 			spec := optionalNextString(allArgs, &i)
 			if len(spec) == 0 {
-				opts.Theme = curses.EmptyTheme()
+				opts.Theme = tui.EmptyTheme()
 			} else {
 				opts.Theme = parseTheme(opts.Theme, spec)
 			}
@@ -879,11 +918,15 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "+c", "--no-color":
 			opts.Theme = nil
 		case "+2", "--no-256":
-			opts.Theme = curses.Default16
+			opts.Theme = tui.Default16
 		case "--black":
 			opts.Black = true
 		case "--no-black":
 			opts.Black = false
+		case "--bold":
+			opts.Bold = true
+		case "--no-bold":
+			opts.Bold = false
 		case "--reverse":
 			opts.Reverse = true
 		case "--no-reverse":
@@ -917,6 +960,10 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.ReadZero = true
 		case "--no-read0":
 			opts.ReadZero = false
+		case "--print0":
+			opts.Printer = func(str string) { fmt.Print(str, "\x00") }
+		case "--no-print0":
+			opts.Printer = func(str string) { fmt.Println(str) }
 		case "--print-query":
 			opts.PrintQuery = true
 		case "--no-print-query":
@@ -961,7 +1008,9 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--version":
 			opts.Version = true
 		default:
-			if match, value := optString(arg, "-q", "--query="); match {
+			if match, value := optString(arg, "--algo="); match {
+				opts.FuzzyAlgo = parseAlgo(value)
+			} else if match, value := optString(arg, "-q", "--query="); match {
 				opts.Query = value
 			} else if match, value := optString(arg, "-f", "--filter="); match {
 				opts.Filter = &value
@@ -1039,11 +1088,11 @@ func parseOptions(opts *Options, allArgs []string) {
 func postProcessOptions(opts *Options) {
 	// Default actions for CTRL-N / CTRL-P when --history is set
 	if opts.History != nil {
-		if _, prs := opts.Keymap[curses.CtrlP]; !prs {
-			opts.Keymap[curses.CtrlP] = actPreviousHistory
+		if _, prs := opts.Keymap[tui.CtrlP]; !prs {
+			opts.Keymap[tui.CtrlP] = actPreviousHistory
 		}
-		if _, prs := opts.Keymap[curses.CtrlN]; !prs {
-			opts.Keymap[curses.CtrlN] = actNextHistory
+		if _, prs := opts.Keymap[tui.CtrlN]; !prs {
+			opts.Keymap[tui.CtrlN] = actNextHistory
 		}
 	}
 

src/options_test.go

@@ -2,9 +2,10 @@ package fzf
 
 import (
 	"fmt"
+	"io/ioutil"
 	"testing"
 
-	"github.com/junegunn/fzf/src/curses"
+	"github.com/junegunn/fzf/src/tui"
 	"github.com/junegunn/fzf/src/util"
 )
 
@@ -133,48 +134,48 @@ func TestParseKeys(t *testing.T) {
 	if len(pairs) != 11 {
 		t.Error(11)
 	}
-	check(curses.CtrlZ, "ctrl-z")
-	check(curses.AltZ, "alt-z")
-	check(curses.F2, "f2")
-	check(curses.AltZ+'@', "@")
-	check(curses.AltA, "Alt-a")
-	check(curses.AltZ+'!', "!")
-	check(curses.CtrlA+'g'-'a', "ctrl-G")
-	check(curses.AltZ+'J', "J")
-	check(curses.AltZ+'g', "g")
-	check(curses.AltEnter, "ALT-enter")
-	check(curses.AltSpace, "alt-SPACE")
+	check(tui.CtrlZ, "ctrl-z")
+	check(tui.AltZ, "alt-z")
+	check(tui.F2, "f2")
+	check(tui.AltZ+'@', "@")
+	check(tui.AltA, "Alt-a")
+	check(tui.AltZ+'!', "!")
+	check(tui.CtrlA+'g'-'a', "ctrl-G")
+	check(tui.AltZ+'J', "J")
+	check(tui.AltZ+'g', "g")
+	check(tui.AltEnter, "ALT-enter")
+	check(tui.AltSpace, "alt-SPACE")
 
 	// Synonyms
 	pairs = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
 	if len(pairs) != 9 {
 		t.Error(9)
 	}
-	check(curses.CtrlM, "Return")
-	check(curses.AltZ+' ', "space")
-	check(curses.Tab, "tab")
-	check(curses.BTab, "btab")
-	check(curses.ESC, "esc")
-	check(curses.Up, "up")
-	check(curses.Down, "down")
-	check(curses.Left, "left")
-	check(curses.Right, "right")
+	check(tui.CtrlM, "Return")
+	check(tui.AltZ+' ', "space")
+	check(tui.Tab, "tab")
+	check(tui.BTab, "btab")
+	check(tui.ESC, "esc")
+	check(tui.Up, "up")
+	check(tui.Down, "down")
+	check(tui.Left, "left")
+	check(tui.Right, "right")
 
 	pairs = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
 	if len(pairs) != 11 {
 		t.Error(11)
 	}
-	check(curses.Tab, "Ctrl-I")
-	check(curses.PgUp, "page-up")
-	check(curses.PgDn, "Page-Down")
-	check(curses.Home, "Home")
-	check(curses.End, "End")
-	check(curses.AltBS, "Alt-BSpace")
-	check(curses.SLeft, "shift-left")
-	check(curses.SRight, "shift-right")
-	check(curses.BTab, "shift-tab")
-	check(curses.CtrlM, "Enter")
-	check(curses.BSpace, "bspace")
+	check(tui.Tab, "Ctrl-I")
+	check(tui.PgUp, "page-up")
+	check(tui.PgDn, "Page-Down")
+	check(tui.Home, "Home")
+	check(tui.End, "End")
+	check(tui.AltBS, "Alt-BSpace")
+	check(tui.SLeft, "shift-left")
+	check(tui.SRight, "shift-right")
+	check(tui.BTab, "shift-tab")
+	check(tui.CtrlM, "Enter")
+	check(tui.BSpace, "bspace")
 }
 
 func TestParseKeysWithComma(t *testing.T) {
@@ -191,36 +192,36 @@ func TestParseKeysWithComma(t *testing.T) {
 
 	pairs := parseKeyChords(",", "")
 	checkN(len(pairs), 1)
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.AltZ+',', ",")
 
 	pairs = parseKeyChords(",,a,b", "")
 	checkN(len(pairs), 3)
-	check(pairs, curses.AltZ+'a', "a")
-	check(pairs, curses.AltZ+'b', "b")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.AltZ+'a', "a")
+	check(pairs, tui.AltZ+'b', "b")
+	check(pairs, tui.AltZ+',', ",")
 
 	pairs = parseKeyChords("a,b,,", "")
 	checkN(len(pairs), 3)
-	check(pairs, curses.AltZ+'a', "a")
-	check(pairs, curses.AltZ+'b', "b")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.AltZ+'a', "a")
+	check(pairs, tui.AltZ+'b', "b")
+	check(pairs, tui.AltZ+',', ",")
 
 	pairs = parseKeyChords("a,,,b", "")
 	checkN(len(pairs), 3)
-	check(pairs, curses.AltZ+'a', "a")
-	check(pairs, curses.AltZ+'b', "b")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.AltZ+'a', "a")
+	check(pairs, tui.AltZ+'b', "b")
+	check(pairs, tui.AltZ+',', ",")
 
 	pairs = parseKeyChords("a,,,b,c", "")
 	checkN(len(pairs), 4)
-	check(pairs, curses.AltZ+'a', "a")
-	check(pairs, curses.AltZ+'b', "b")
-	check(pairs, curses.AltZ+'c', "c")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.AltZ+'a', "a")
+	check(pairs, tui.AltZ+'b', "b")
+	check(pairs, tui.AltZ+'c', "c")
+	check(pairs, tui.AltZ+',', ",")
 
 	pairs = parseKeyChords(",,,", "")
 	checkN(len(pairs), 1)
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.AltZ+',', ",")
 }
 
 func TestBind(t *testing.T) {
@@ -236,41 +237,41 @@ func TestBind(t *testing.T) {
 	}
 	keymap := defaultKeymap()
 	execmap := make(map[int]string)
-	check(actBeginningOfLine, keymap[curses.CtrlA])
+	check(actBeginningOfLine, keymap[tui.CtrlA])
 	parseKeymap(keymap, execmap,
 		"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down,"+
 			"f1:execute(ls {}),f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
 			"alt-a:execute@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};"+
 			",,:abort,::accept,X:execute:\nfoobar,Y:execute(baz)")
-	check(actKillLine, keymap[curses.CtrlA])
-	check(actToggleSort, keymap[curses.CtrlB])
-	check(actPageUp, keymap[curses.AltZ+'c'])
-	check(actAbort, keymap[curses.AltZ+','])
-	check(actAccept, keymap[curses.AltZ+':'])
-	check(actPageDown, keymap[curses.AltZ])
-	check(actExecute, keymap[curses.F1])
-	check(actExecute, keymap[curses.F2])
-	check(actExecute, keymap[curses.F3])
-	check(actExecute, keymap[curses.F4])
-	checkString("ls {}", execmap[curses.F1])
-	checkString("echo {}, {}, {}", execmap[curses.F2])
-	checkString("echo '({})'", execmap[curses.F3])
-	checkString("less {}", execmap[curses.F4])
-	checkString("echo (,),[,],/,:,;,%,{}", execmap[curses.AltA])
-	checkString("echo (,),[,],/,:,@,%,{}", execmap[curses.AltB])
-	checkString("\nfoobar,Y:execute(baz)", execmap[curses.AltZ+'X'])
+	check(actKillLine, keymap[tui.CtrlA])
+	check(actToggleSort, keymap[tui.CtrlB])
+	check(actPageUp, keymap[tui.AltZ+'c'])
+	check(actAbort, keymap[tui.AltZ+','])
+	check(actAccept, keymap[tui.AltZ+':'])
+	check(actPageDown, keymap[tui.AltZ])
+	check(actExecute, keymap[tui.F1])
+	check(actExecute, keymap[tui.F2])
+	check(actExecute, keymap[tui.F3])
+	check(actExecute, keymap[tui.F4])
+	checkString("ls {}", execmap[tui.F1])
+	checkString("echo {}, {}, {}", execmap[tui.F2])
+	checkString("echo '({})'", execmap[tui.F3])
+	checkString("less {}", execmap[tui.F4])
+	checkString("echo (,),[,],/,:,;,%,{}", execmap[tui.AltA])
+	checkString("echo (,),[,],/,:,@,%,{}", execmap[tui.AltB])
+	checkString("\nfoobar,Y:execute(baz)", execmap[tui.AltZ+'X'])
 
 	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
 		parseKeymap(keymap, execmap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
-		checkString("foobar", execmap[curses.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0])])
+		checkString("foobar", execmap[tui.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0])])
 	}
 
 	parseKeymap(keymap, execmap, "f1:abort")
-	check(actAbort, keymap[curses.F1])
+	check(actAbort, keymap[tui.F1])
 }
 
 func TestColorSpec(t *testing.T) {
-	theme := curses.Dark256
+	theme := tui.Dark256
 	dark := parseTheme(theme, "dark")
 	if *dark != *theme {
 		t.Errorf("colors should be equivalent")
@@ -283,7 +284,7 @@ func TestColorSpec(t *testing.T) {
 	if *light == *theme {
 		t.Errorf("should not be equivalent")
 	}
-	if *light != *curses.Light256 {
+	if *light != *tui.Light256 {
 		t.Errorf("colors should be equivalent")
 	}
 	if light == theme {
@@ -294,29 +295,23 @@ func TestColorSpec(t *testing.T) {
 	if customized.Fg != 231 || customized.Bg != 232 {
 		t.Errorf("color not customized")
 	}
-	if *curses.Dark256 == *customized {
+	if *tui.Dark256 == *customized {
 		t.Errorf("colors should not be equivalent")
 	}
-	customized.Fg = curses.Dark256.Fg
-	customized.Bg = curses.Dark256.Bg
-	if *curses.Dark256 == *customized {
-		t.Errorf("colors should now be equivalent")
+	customized.Fg = tui.Dark256.Fg
+	customized.Bg = tui.Dark256.Bg
+	if *tui.Dark256 != *customized {
+		t.Errorf("colors should now be equivalent: %v, %v", tui.Dark256, customized)
 	}
 
 	customized = parseTheme(theme, "fg:231,dark,bg:232")
-	if customized.Fg != curses.Dark256.Fg || customized.Bg == curses.Dark256.Bg {
+	if customized.Fg != tui.Dark256.Fg || customized.Bg == tui.Dark256.Bg {
 		t.Errorf("color not customized")
 	}
-	if customized.UseDefault {
-		t.Errorf("not using default colors")
-	}
-	if !curses.Dark256.UseDefault {
-		t.Errorf("using default colors")
-	}
 }
 
 func TestParseNilTheme(t *testing.T) {
-	var theme *curses.ColorTheme
+	var theme *tui.ColorTheme
 	newTheme := parseTheme(theme, "prompt:12")
 	if newTheme != nil {
 		t.Errorf("color is disabled. keep it that way.")
@@ -336,21 +331,23 @@ func TestDefaultCtrlNP(t *testing.T) {
 			t.Error()
 		}
 	}
-	check([]string{}, curses.CtrlN, actDown)
-	check([]string{}, curses.CtrlP, actUp)
+	check([]string{}, tui.CtrlN, actDown)
+	check([]string{}, tui.CtrlP, actUp)
 
-	check([]string{"--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
-	check([]string{"--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+	check([]string{"--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
+	check([]string{"--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
 
-	hist := "--history=/tmp/foo"
-	check([]string{hist}, curses.CtrlN, actNextHistory)
-	check([]string{hist}, curses.CtrlP, actPreviousHistory)
+	f, _ := ioutil.TempFile("", "fzf-history")
+	f.Close()
+	hist := "--history=" + f.Name()
+	check([]string{hist}, tui.CtrlN, actNextHistory)
+	check([]string{hist}, tui.CtrlP, actPreviousHistory)
 
-	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
-	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlP, actPreviousHistory)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPreviousHistory)
 
-	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlN, actNextHistory)
-	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlN, actNextHistory)
+	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
 }
 
 func optsFor(words ...string) *Options {

src/pattern.go

@@ -2,7 +2,6 @@ package fzf
 
 import (
 	"regexp"
-	"sort"
 	"strings"
 
 	"github.com/junegunn/fzf/src/algo"
@@ -41,6 +40,7 @@ type termSet []term
 // Pattern represents search pattern
 type Pattern struct {
 	fuzzy         bool
+	fuzzyAlgo     algo.Algo
 	extended      bool
 	caseSensitive bool
 	forward       bool
@@ -49,7 +49,7 @@ type Pattern struct {
 	cacheable     bool
 	delimiter     Delimiter
 	nth           []Range
-	procFun       map[termType]func(bool, bool, util.Chars, []rune) algo.Result
+	procFun       map[termType]algo.Algo
 }
 
 var (
@@ -75,8 +75,8 @@ func clearChunkCache() {
 }
 
 // BuildPattern builds Pattern object from the given arguments
-func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
-	nth []Range, delimiter Delimiter, runes []rune) *Pattern {
+func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, forward bool,
+	cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
 
 	var asString string
 	if extended {
@@ -90,7 +90,7 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 		return cached
 	}
 
-	caseSensitive, cacheable := true, true
+	caseSensitive := true
 	termSets := []termSet{}
 
 	if extended {
@@ -100,7 +100,7 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 			for idx, term := range termSet {
 				// If the query contains inverse search terms or OR operators,
 				// we cannot cache the search scope
-				if idx > 0 || term.inv {
+				if !cacheable || idx > 0 || term.inv {
 					cacheable = false
 					break Loop
 				}
@@ -117,6 +117,7 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 
 	ptr := &Pattern{
 		fuzzy:         fuzzy,
+		fuzzyAlgo:     fuzzyAlgo,
 		extended:      extended,
 		caseSensitive: caseSensitive,
 		forward:       forward,
@@ -125,9 +126,9 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
-		procFun:       make(map[termType]func(bool, bool, util.Chars, []rune) algo.Result)}
+		procFun:       make(map[termType]algo.Algo)}
 
-	ptr.procFun[termFuzzy] = algo.FuzzyMatch
+	ptr.procFun[termFuzzy] = fuzzyAlgo
 	ptr.procFun[termEqual] = algo.EqualMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
 	ptr.procFun[termPrefix] = algo.PrefixMatch
@@ -162,12 +163,13 @@ func parseTerms(fuzzy bool, caseMode Case, str string) []termSet {
 
 		if strings.HasPrefix(text, "!") {
 			inv = true
+			typ = termExact
 			text = text[1:]
 		}
 
 		if strings.HasPrefix(text, "'") {
 			// Flip exactness
-			if fuzzy {
+			if fuzzy && !inv {
 				typ = termExact
 				text = text[1:]
 			} else {
@@ -235,9 +237,7 @@ func (p *Pattern) CacheKey() string {
 }
 
 // Match returns the list of matches Items in the given Chunk
-func (p *Pattern) Match(chunk *Chunk) []*Item {
-	space := chunk
-
+func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []*Result {
 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
 	if p.cacheable {
@@ -246,7 +246,8 @@ func (p *Pattern) Match(chunk *Chunk) []*Item {
 		}
 	}
 
-	// ChunkCache: Prefix/suffix match
+	// Prefix/suffix cache
+	var space []*Result
 Loop:
 	for idx := 1; idx < len(cacheKey); idx++ {
 		// [---------| ] | [ |---------]
@@ -256,14 +257,13 @@ Loop:
 		suffix := cacheKey[idx:]
 		for _, substr := range [2]*string{&prefix, &suffix} {
 			if cached, found := _cache.Find(chunk, *substr); found {
-				cachedChunk := Chunk(cached)
-				space = &cachedChunk
+				space = cached
 				break Loop
 			}
 		}
 	}
 
-	matches := p.matchChunk(space)
+	matches := p.matchChunk(chunk, space, slab)
 
 	if p.cacheable {
 		_cache.Add(chunk, cacheKey, matches)
@@ -271,20 +271,19 @@ Loop:
 	return matches
 }
 
-func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
-	matches := []*Item{}
-	if !p.extended {
+func (p *Pattern) matchChunk(chunk *Chunk, space []*Result, slab *util.Slab) []*Result {
+	matches := []*Result{}
+
+	if space == nil {
 		for _, item := range *chunk {
-			offset, bonus := p.basicMatch(item)
-			if sidx := offset[0]; sidx >= 0 {
-				matches = append(matches,
-					dupItem(item, []Offset{offset}, bonus))
+			if match, _, _ := p.MatchItem(item, false, slab); match != nil {
+				matches = append(matches, match)
 			}
 		}
 	} else {
-		for _, item := range *chunk {
-			if offsets, bonus := p.extendedMatch(item); len(offsets) == len(p.termSets) {
-				matches = append(matches, dupItem(item, offsets, bonus))
+		for _, result := range space {
+			if match, _, _ := p.MatchItem(result.item, false, slab); match != nil {
+				matches = append(matches, match)
 			}
 		}
 	}
@@ -292,63 +291,75 @@ func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 }
 
 // MatchItem returns true if the Item is a match
-func (p *Pattern) MatchItem(item *Item) bool {
-	if !p.extended {
-		offset, _ := p.basicMatch(item)
-		sidx := offset[0]
-		return sidx >= 0
+func (p *Pattern) MatchItem(item *Item, withPos bool, slab *util.Slab) (*Result, []Offset, *[]int) {
+	if p.extended {
+		if offsets, bonus, trimLen, pos := p.extendedMatch(item, withPos, slab); len(offsets) == len(p.termSets) {
+			return buildResult(item, offsets, bonus, trimLen), offsets, pos
+		}
+		return nil, nil, nil
 	}
-	offsets, _ := p.extendedMatch(item)
-	return len(offsets) == len(p.termSets)
+	offset, bonus, trimLen, pos := p.basicMatch(item, withPos, slab)
+	if sidx := offset[0]; sidx >= 0 {
+		offsets := []Offset{offset}
+		return buildResult(item, offsets, bonus, trimLen), offsets, pos
+	}
+	return nil, nil, nil
 }
 
-func dupItem(item *Item, offsets []Offset, bonus int32) *Item {
-	sort.Sort(ByOrder(offsets))
-	return &Item{
-		text:        item.text,
-		origText:    item.origText,
-		transformed: item.transformed,
-		offsets:     offsets,
-		bonus:       bonus,
-		colors:      item.colors,
-		rank:        buildEmptyRank(item.Index())}
-}
-
-func (p *Pattern) basicMatch(item *Item) (Offset, int32) {
+func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset, int, int, *[]int) {
 	input := p.prepareInput(item)
 	if p.fuzzy {
-		return p.iter(algo.FuzzyMatch, input, p.caseSensitive, p.forward, p.text)
+		return p.iter(p.fuzzyAlgo, input, p.caseSensitive, p.forward, p.text, withPos, slab)
 	}
-	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.forward, p.text)
+	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.forward, p.text, withPos, slab)
 }
 
-func (p *Pattern) extendedMatch(item *Item) ([]Offset, int32) {
+func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Offset, int, int, *[]int) {
 	input := p.prepareInput(item)
 	offsets := []Offset{}
-	var totalBonus int32
+	var totalScore int
+	var totalTrimLen int
+	var allPos *[]int
+	if withPos {
+		allPos = &[]int{}
+	}
 	for _, termSet := range p.termSets {
-		var offset *Offset
-		var bonus int32
+		var offset Offset
+		var currentScore int
+		var trimLen int
+		matched := false
 		for _, term := range termSet {
 			pfun := p.procFun[term.typ]
-			off, pen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text)
+			off, score, tLen, pos := p.iter(pfun, input, term.caseSensitive, p.forward, term.text, withPos, slab)
 			if sidx := off[0]; sidx >= 0 {
 				if term.inv {
 					continue
 				}
-				offset, bonus = &off, pen
+				offset, currentScore, trimLen = off, score, tLen
+				matched = true
+				if withPos {
+					if pos != nil {
+						*allPos = append(*allPos, *pos...)
+					} else {
+						for idx := off[0]; idx < off[1]; idx++ {
+							*allPos = append(*allPos, int(idx))
+						}
+					}
+				}
 				break
 			} else if term.inv {
-				offset, bonus = &Offset{0, 0, 0}, 0
+				offset, currentScore, trimLen = Offset{0, 0}, 0, 0
+				matched = true
 				continue
 			}
 		}
-		if offset != nil {
-			offsets = append(offsets, *offset)
-			totalBonus += bonus
+		if matched {
+			offsets = append(offsets, offset)
+			totalScore += currentScore
+			totalTrimLen += trimLen
 		}
 	}
-	return offsets, totalBonus
+	return offsets, totalScore, totalTrimLen, allPos
 }
 
 func (p *Pattern) prepareInput(item *Item) []Token {
@@ -357,26 +368,28 @@ func (p *Pattern) prepareInput(item *Item) []Token {
 	}
 
 	var ret []Token
-	if len(p.nth) > 0 {
+	if len(p.nth) == 0 {
+		ret = []Token{Token{text: &item.text, prefixLength: 0, trimLength: int32(item.text.TrimLength())}}
+	} else {
 		tokens := Tokenize(item.text, p.delimiter)
 		ret = Transform(tokens, p.nth)
-	} else {
-		ret = []Token{Token{text: item.text, prefixLength: 0, trimLength: item.text.TrimLength()}}
 	}
 	item.transformed = ret
 	return ret
 }
 
-func (p *Pattern) iter(pfun func(bool, bool, util.Chars, []rune) algo.Result,
-	tokens []Token, caseSensitive bool, forward bool, pattern []rune) (Offset, int32) {
+func (p *Pattern) iter(pfun algo.Algo, tokens []Token, caseSensitive bool, forward bool, pattern []rune, withPos bool, slab *util.Slab) (Offset, int, int, *[]int) {
 	for _, part := range tokens {
-		prefixLength := int32(part.prefixLength)
-		if res := pfun(caseSensitive, forward, part.text, pattern); res.Start >= 0 {
-			sidx := res.Start + prefixLength
-			eidx := res.End + prefixLength
-			return Offset{sidx, eidx, int32(part.trimLength)}, res.Bonus
+		if res, pos := pfun(caseSensitive, forward, *part.text, pattern, withPos, slab); res.Start >= 0 {
+			sidx := int32(res.Start) + part.prefixLength
+			eidx := int32(res.End) + part.prefixLength
+			if pos != nil {
+				for idx := range *pos {
+					(*pos)[idx] += int(part.prefixLength)
+				}
+			}
+			return Offset{sidx, eidx}, res.Score, int(part.trimLength), pos
 		}
 	}
-	// TODO: math.MaxUint16
-	return Offset{-1, -1, -1}, 0.0
+	return Offset{-1, -1}, 0, -1, nil
 }

src/pattern_test.go

@@ -8,6 +8,12 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
+var slab *util.Slab
+
+func init() {
+	slab = util.MakeSlab(slab16Size, slab32Size)
+}
+
 func TestParseTermsExtended(t *testing.T) {
 	terms := parseTerms(true, CaseSmart,
 		"| aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | | zzz$ | !ZZZ |")
@@ -16,15 +22,15 @@ func TestParseTermsExtended(t *testing.T) {
 		terms[1][0].typ != termExact || terms[1][0].inv ||
 		terms[2][0].typ != termPrefix || terms[2][0].inv ||
 		terms[3][0].typ != termSuffix || terms[3][0].inv ||
-		terms[4][0].typ != termFuzzy || !terms[4][0].inv ||
-		terms[5][0].typ != termExact || !terms[5][0].inv ||
+		terms[4][0].typ != termExact || !terms[4][0].inv ||
+		terms[5][0].typ != termFuzzy || !terms[5][0].inv ||
 		terms[6][0].typ != termPrefix || !terms[6][0].inv ||
 		terms[7][0].typ != termSuffix || !terms[7][0].inv ||
 		terms[7][1].typ != termEqual || terms[7][1].inv ||
 		terms[8][0].typ != termPrefix || terms[8][0].inv ||
 		terms[8][1].typ != termExact || terms[8][1].inv ||
 		terms[8][2].typ != termSuffix || terms[8][2].inv ||
-		terms[8][3].typ != termFuzzy || !terms[8][3].inv {
+		terms[8][3].typ != termExact || !terms[8][3].inv {
 		t.Errorf("%s", terms)
 	}
 	for idx, termSet := range terms[:8] {
@@ -69,26 +75,32 @@ func TestParseTermsEmpty(t *testing.T) {
 func TestExact(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, true, CaseSmart, true,
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, true, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
-	res := algo.ExactMatchNaive(
-		pattern.caseSensitive, pattern.forward, util.RunesToChars([]rune("aabbcc abc")), pattern.termSets[0][0].text)
+	res, pos := algo.ExactMatchNaive(
+		pattern.caseSensitive, pattern.forward, util.RunesToChars([]rune("aabbcc abc")), pattern.termSets[0][0].text, true, nil)
 	if res.Start != 7 || res.End != 10 {
 		t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 	}
+	if pos != nil {
+		t.Errorf("pos is expected to be nil")
+	}
 }
 
 func TestEqual(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, true, true, []Range{}, Delimiter{}, []rune("^AbC$"))
 
-	match := func(str string, sidxExpected int32, eidxExpected int32) {
-		res := algo.EqualMatch(
-			pattern.caseSensitive, pattern.forward, util.RunesToChars([]rune(str)), pattern.termSets[0][0].text)
+	match := func(str string, sidxExpected int, eidxExpected int) {
+		res, pos := algo.EqualMatch(
+			pattern.caseSensitive, pattern.forward, util.RunesToChars([]rune(str)), pattern.termSets[0][0].text, true, nil)
 		if res.Start != sidxExpected || res.End != eidxExpected {
 			t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 		}
+		if pos != nil {
+			t.Errorf("pos is expected to be nil")
+		}
 	}
 	match("ABC", -1, -1)
 	match("AbC", 0, 3)
@@ -97,17 +109,17 @@ func TestEqual(t *testing.T) {
 func TestCaseSensitivity(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pat1 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat1 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat2 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat3 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat4 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat5 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat6 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 
 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -120,7 +132,7 @@ func TestCaseSensitivity(t *testing.T) {
 }
 
 func TestOrigTextAndTransformed(t *testing.T) {
-	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("jg"))
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, true, true, []Range{}, Delimiter{}, []rune("jg"))
 	tokens := Tokenize(util.RunesToChars([]rune("junegunn")), Delimiter{})
 	trans := Transform(tokens, []Range{Range{1, 1}})
 
@@ -133,18 +145,29 @@ func TestOrigTextAndTransformed(t *testing.T) {
 				transformed: trans},
 		}
 		pattern.extended = extended
-		matches := pattern.matchChunk(&chunk)
-		if matches[0].text.ToString() != "junegunn" || string(*matches[0].origText) != "junegunn.choi" ||
-			matches[0].offsets[0][0] != 0 || matches[0].offsets[0][1] != 5 ||
-			!reflect.DeepEqual(matches[0].transformed, trans) {
+		matches := pattern.matchChunk(&chunk, nil, slab) // No cache
+		if !(matches[0].item.text.ToString() == "junegunn" &&
+			string(*matches[0].item.origText) == "junegunn.choi" &&
+			reflect.DeepEqual(matches[0].item.transformed, trans)) {
 			t.Error("Invalid match result", matches)
 		}
+
+		match, offsets, pos := pattern.MatchItem(chunk[0], true, slab)
+		if !(match.item.text.ToString() == "junegunn" &&
+			string(*match.item.origText) == "junegunn.choi" &&
+			offsets[0][0] == 0 && offsets[0][1] == 5 &&
+			reflect.DeepEqual(match.item.transformed, trans)) {
+			t.Error("Invalid match result", match, offsets, extended)
+		}
+		if !((*pos)[0] == 4 && (*pos)[1] == 0) {
+			t.Error("Invalid pos array", *pos)
+		}
 	}
 }
 
 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
-		pat := BuildPattern(true, extended, CaseSmart, true, []Range{}, Delimiter{}, []rune(patStr))
+		pat := BuildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, true, true, []Range{}, Delimiter{}, []rune(patStr))
 		if pat.CacheKey() != expected {
 			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
 		}

src/reader.go

@@ -34,14 +34,20 @@ func (r *Reader) feed(src io.Reader) {
 	if r.delimNil {
 		delim = '\000'
 	}
-	reader := bufio.NewReader(src)
+	reader := bufio.NewReaderSize(src, readerBufferSize)
 	for {
 		// ReadBytes returns err != nil if and only if the returned data does not
 		// end in delim.
 		bytea, err := reader.ReadBytes(delim)
+		byteaLen := len(bytea)
 		if len(bytea) > 0 {
 			if err == nil {
-				bytea = bytea[:len(bytea)-1]
+				// get rid of carriage return if under Windows:
+				if util.IsWindows() && byteaLen >= 2 && bytea[byteaLen-2] == byte('\r') {
+					bytea = bytea[:byteaLen-2]
+				} else {
+					bytea = bytea[:byteaLen-1]
+				}
 			}
 			if r.pusher(bytea) {
 				r.eventBox.Set(EvtReadNew, nil)

src/result.go

@@ -0,0 +1,243 @@
+package fzf
+
+import (
+	"math"
+	"sort"
+	"unicode"
+
+	"github.com/junegunn/fzf/src/tui"
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Offset holds two 32-bit integers denoting the offsets of a matched substring
+type Offset [2]int32
+
+type colorOffset struct {
+	offset [2]int32
+	color  tui.ColorPair
+	attr   tui.Attr
+	index  int32
+}
+
+type rank struct {
+	points [4]uint16
+	index  int32
+}
+
+type Result struct {
+	item *Item
+	rank rank
+}
+
+func buildResult(item *Item, offsets []Offset, score int, trimLen int) *Result {
+	if len(offsets) > 1 {
+		sort.Sort(ByOrder(offsets))
+	}
+
+	result := Result{item: item, rank: rank{index: item.index}}
+	numChars := item.text.Length()
+	minBegin := math.MaxUint16
+	maxEnd := 0
+	validOffsetFound := false
+	for _, offset := range offsets {
+		b, e := int(offset[0]), int(offset[1])
+		if b < e {
+			minBegin = util.Min(b, minBegin)
+			maxEnd = util.Max(e, maxEnd)
+			validOffsetFound = true
+		}
+	}
+
+	for idx, criterion := range sortCriteria {
+		val := uint16(math.MaxUint16)
+		switch criterion {
+		case byScore:
+			// Higher is better
+			val = math.MaxUint16 - util.AsUint16(score)
+		case byLength:
+			// If offsets is empty, trimLen will be 0, but we don't care
+			val = util.AsUint16(trimLen)
+		case byBegin, byEnd:
+			if validOffsetFound {
+				whitePrefixLen := 0
+				for idx := 0; idx < numChars; idx++ {
+					r := item.text.Get(idx)
+					whitePrefixLen = idx
+					if idx == minBegin || !unicode.IsSpace(r) {
+						break
+					}
+				}
+				if criterion == byBegin {
+					val = util.AsUint16(minBegin - whitePrefixLen)
+				} else {
+					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/trimLen)
+				}
+			}
+		}
+		result.rank.points[idx] = val
+	}
+
+	return &result
+}
+
+// Sort criteria to use. Never changes once fzf is started.
+var sortCriteria []criterion
+
+// Index returns ordinal index of the Item
+func (result *Result) Index() int32 {
+	return result.item.index
+}
+
+func minRank() rank {
+	return rank{index: 0, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
+}
+
+func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, color tui.ColorPair, attr tui.Attr, current bool) []colorOffset {
+	itemColors := result.item.Colors()
+
+	// No ANSI code, or --color=no
+	if len(itemColors) == 0 {
+		var offsets []colorOffset
+		for _, off := range matchOffsets {
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: color, attr: attr})
+		}
+		return offsets
+	}
+
+	// Find max column
+	var maxCol int32
+	for _, off := range matchOffsets {
+		if off[1] > maxCol {
+			maxCol = off[1]
+		}
+	}
+	for _, ansi := range itemColors {
+		if ansi.offset[1] > maxCol {
+			maxCol = ansi.offset[1]
+		}
+	}
+	cols := make([]int, maxCol)
+
+	for colorIndex, ansi := range itemColors {
+		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
+			cols[i] = colorIndex + 1 // XXX
+		}
+	}
+
+	for _, off := range matchOffsets {
+		for i := off[0]; i < off[1]; i++ {
+			cols[i] = -1
+		}
+	}
+
+	// sort.Sort(ByOrder(offsets))
+
+	// Merge offsets
+	// ------------  ----  --  ----
+	//   ++++++++      ++++++++++
+	// --++++++++--  --++++++++++---
+	curr := 0
+	start := 0
+	var colors []colorOffset
+	add := func(idx int) {
+		if curr != 0 && idx > start {
+			if curr == -1 {
+				colors = append(colors, colorOffset{
+					offset: [2]int32{int32(start), int32(idx)}, color: color, attr: attr})
+			} else {
+				ansi := itemColors[curr-1]
+				fg := ansi.color.fg
+				bg := ansi.color.bg
+				if theme != nil {
+					if fg == -1 {
+						if current {
+							fg = theme.Current
+						} else {
+							fg = theme.Fg
+						}
+					}
+					if bg == -1 {
+						if current {
+							bg = theme.DarkBg
+						} else {
+							bg = theme.Bg
+						}
+					}
+				}
+				colors = append(colors, colorOffset{
+					offset: [2]int32{int32(start), int32(idx)},
+					color:  tui.PairFor(fg, bg),
+					attr:   ansi.color.attr.Merge(attr)})
+			}
+		}
+	}
+	for idx, col := range cols {
+		if col != curr {
+			add(idx)
+			start = idx
+			curr = col
+		}
+	}
+	add(int(maxCol))
+	return colors
+}
+
+// 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 []*Result
+
+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 {
+	return compareRanks((*a[i]).rank, (*a[j]).rank, false)
+}
+
+// ByRelevanceTac is for sorting Items
+type ByRelevanceTac []*Result
+
+func (a ByRelevanceTac) Len() int {
+	return len(a)
+}
+
+func (a ByRelevanceTac) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevanceTac) Less(i, j int) bool {
+	return compareRanks((*a[i]).rank, (*a[j]).rank, true)
+}
+
+func compareRanks(irank rank, jrank rank, tac bool) bool {
+	for idx := 0; idx < 4; idx++ {
+		left := irank.points[idx]
+		right := jrank.points[idx]
+		if left < right {
+			return true
+		} else if left > right {
+			return false
+		}
+	}
+	return (irank.index <= jrank.index) != tac
+}

src/result_test.go

@@ -0,0 +1,125 @@
+// +build !tcell
+
+package fzf
+
+import (
+	"math"
+	"sort"
+	"testing"
+
+	"github.com/junegunn/fzf/src/tui"
+	"github.com/junegunn/fzf/src/util"
+)
+
+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) {
+	rank := func(vals ...uint16) rank {
+		return rank{
+			points: [4]uint16{vals[0], vals[1], vals[2], vals[3]},
+			index:  int32(vals[4])}
+	}
+	if compareRanks(rank(3, 0, 0, 0, 5), rank(2, 0, 0, 0, 7), false) ||
+		!compareRanks(rank(3, 0, 0, 0, 5), rank(3, 0, 0, 0, 6), false) ||
+		!compareRanks(rank(1, 2, 0, 0, 3), rank(1, 3, 0, 0, 2), false) ||
+		!compareRanks(rank(0, 0, 0, 0, 0), rank(0, 0, 0, 0, 0), false) {
+		t.Error("Invalid order")
+	}
+
+	if compareRanks(rank(3, 0, 0, 0, 5), rank(2, 0, 0, 0, 7), true) ||
+		!compareRanks(rank(3, 0, 0, 0, 5), rank(3, 0, 0, 0, 6), false) ||
+		!compareRanks(rank(1, 2, 0, 0, 3), rank(1, 3, 0, 0, 2), true) ||
+		!compareRanks(rank(0, 0, 0, 0, 0), rank(0, 0, 0, 0, 0), false) {
+		t.Error("Invalid order (tac)")
+	}
+}
+
+// Match length, string length, index
+func TestResultRank(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byScore, byLength}
+
+	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
+	item1 := buildResult(&Item{text: util.RunesToChars(strs[0]), index: 1}, []Offset{}, 2, 3)
+	if item1.rank.points[0] != math.MaxUint16-2 || // Bonus
+		item1.rank.points[1] != 3 || // Length
+		item1.rank.points[2] != 0 || // Unused
+		item1.rank.points[3] != 0 || // Unused
+		item1.item.index != 1 {
+		t.Error(item1.rank)
+	}
+	// Only differ in index
+	item2 := buildResult(&Item{text: util.RunesToChars(strs[0])}, []Offset{}, 2, 3)
+
+	items := []*Result{item1, item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != item2 || items[1] != item1 {
+		t.Error(items)
+	}
+
+	items = []*Result{item2, item1, item1, item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != item2 || items[1] != item2 ||
+		items[2] != item1 || items[3] != item1 {
+		t.Error(items, item1, item1.item.index, item2, item2.item.index)
+	}
+
+	// Sort by relevance
+	item3 := buildResult(&Item{index: 2}, []Offset{Offset{1, 3}, Offset{5, 7}}, 3, 0)
+	item4 := buildResult(&Item{index: 2}, []Offset{Offset{1, 2}, Offset{6, 7}}, 4, 0)
+	item5 := buildResult(&Item{index: 2}, []Offset{Offset{1, 3}, Offset{5, 7}}, 5, 0)
+	item6 := buildResult(&Item{index: 2}, []Offset{Offset{1, 2}, Offset{6, 7}}, 6, 0)
+	items = []*Result{item1, item2, item3, item4, item5, item6}
+	sort.Sort(ByRelevance(items))
+	if !(items[0] == item6 && items[1] == item5 &&
+		items[2] == item4 && items[3] == item3 &&
+		items[4] == item2 && items[5] == item1) {
+		t.Error(items, item1, item2, item3, item4, item5, item6)
+	}
+}
+
+func TestColorOffset(t *testing.T) {
+	// ------------ 20 ----  --  ----
+	//   ++++++++        ++++++++++
+	// --++++++++--    --++++++++++---
+
+	offsets := []Offset{Offset{5, 15}, Offset{25, 35}}
+	item := Result{
+		item: &Item{
+			colors: &[]ansiOffset{
+				ansiOffset{[2]int32{0, 20}, ansiState{1, 5, 0}},
+				ansiOffset{[2]int32{22, 27}, ansiState{2, 6, tui.Bold}},
+				ansiOffset{[2]int32{30, 32}, ansiState{3, 7, 0}},
+				ansiOffset{[2]int32{33, 40}, ansiState{4, 8, tui.Bold}}}}}
+	// [{[0 5] 9 false} {[5 15] 99 false} {[15 20] 9 false} {[22 25] 10 true} {[25 35] 99 false} {[35 40] 11 true}]
+
+	colors := item.colorOffsets(offsets, tui.Dark256, 99, 0, true)
+	assert := func(idx int, b int32, e int32, c tui.ColorPair, bold bool) {
+		var attr tui.Attr
+		if bold {
+			attr = tui.Bold
+		}
+		o := colors[idx]
+		if o.offset[0] != b || o.offset[1] != e || o.color != c || o.attr != attr {
+			t.Error(o)
+		}
+	}
+	assert(0, 0, 5, tui.ColUser, false)
+	assert(1, 5, 15, 99, false)
+	assert(2, 15, 20, tui.ColUser, false)
+	assert(3, 22, 25, tui.ColUser+1, true)
+	assert(4, 25, 35, 99, false)
+	assert(5, 35, 40, tui.ColUser+2, true)
+}

src/terminal.go

@@ -7,17 +7,26 @@ import (
 	"os/signal"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"syscall"
 	"time"
 
-	C "github.com/junegunn/fzf/src/curses"
+	"github.com/junegunn/fzf/src/tui"
 	"github.com/junegunn/fzf/src/util"
 
 	"github.com/junegunn/go-runewidth"
 )
 
+// import "github.com/pkg/profile"
+
+var placeholder *regexp.Regexp
+
+func init() {
+	placeholder = regexp.MustCompile("\\\\?(?:{[0-9,-.]*}|{q})")
+}
+
 type jumpMode int
 
 const (
@@ -26,6 +35,13 @@ const (
 	jumpAcceptEnabled
 )
 
+type previewer struct {
+	text    string
+	lines   int
+	offset  int
+	enabled bool
+}
+
 // Terminal represents terminal input/output
 type Terminal struct {
 	initDelay  time.Duration
@@ -42,6 +58,7 @@ type Terminal struct {
 	multi      bool
 	sort       bool
 	toggleSort bool
+	delimiter  Delimiter
 	expect     map[int]string
 	keymap     map[int]actionType
 	execmap    map[int]string
@@ -53,40 +70,38 @@ type Terminal struct {
 	header0    []string
 	ansi       bool
 	margin     [4]sizeSpec
-	window     *C.Window
-	bwindow    *C.Window
-	pwindow    *C.Window
+	strong     tui.Attr
+	window     *tui.Window
+	bwindow    *tui.Window
+	pwindow    *tui.Window
 	count      int
 	progress   int
 	reading    bool
 	jumping    jumpMode
 	jumpLabels string
+	printer    func(string)
 	merger     *Merger
 	selected   map[int32]selectedItem
 	reqBox     *util.EventBox
 	preview    previewOpts
-	previewing bool
-	previewTxt string
+	previewer  previewer
 	previewBox *util.EventBox
 	eventBox   *util.EventBox
 	mutex      sync.Mutex
 	initFunc   func()
 	suppress   bool
 	startChan  chan bool
+	slab       *util.Slab
+	theme      *tui.ColorTheme
 }
 
 type selectedItem struct {
 	at   time.Time
-	text *string
+	item *Item
 }
 
 type byTimeOrder []selectedItem
 
-type previewRequest struct {
-	ok  bool
-	str string
-}
-
 func (a byTimeOrder) Len() int {
 	return len(a)
 }
@@ -115,6 +130,7 @@ const (
 	reqPrintQuery
 	reqPreviewEnqueue
 	reqPreviewDisplay
+	reqPreviewRefresh
 	reqQuit
 )
 
@@ -161,6 +177,10 @@ const (
 	actPrintQuery
 	actToggleSort
 	actTogglePreview
+	actPreviewUp
+	actPreviewDown
+	actPreviewPageUp
+	actPreviewPageDown
 	actPreviousHistory
 	actNextHistory
 	actExecute
@@ -169,51 +189,52 @@ const (
 
 func defaultKeymap() map[int]actionType {
 	keymap := make(map[int]actionType)
-	keymap[C.Invalid] = actInvalid
-	keymap[C.CtrlA] = actBeginningOfLine
-	keymap[C.CtrlB] = actBackwardChar
-	keymap[C.CtrlC] = actAbort
-	keymap[C.CtrlG] = actAbort
-	keymap[C.CtrlQ] = actAbort
-	keymap[C.ESC] = actAbort
-	keymap[C.CtrlD] = actDeleteCharEOF
-	keymap[C.CtrlE] = actEndOfLine
-	keymap[C.CtrlF] = actForwardChar
-	keymap[C.CtrlH] = actBackwardDeleteChar
-	keymap[C.BSpace] = actBackwardDeleteChar
-	keymap[C.Tab] = actToggleDown
-	keymap[C.BTab] = actToggleUp
-	keymap[C.CtrlJ] = actDown
-	keymap[C.CtrlK] = actUp
-	keymap[C.CtrlL] = actClearScreen
-	keymap[C.CtrlM] = actAccept
-	keymap[C.CtrlN] = actDown
-	keymap[C.CtrlP] = actUp
-	keymap[C.CtrlU] = actUnixLineDiscard
-	keymap[C.CtrlW] = actUnixWordRubout
-	keymap[C.CtrlY] = actYank
+	keymap[tui.Invalid] = actInvalid
+	keymap[tui.Resize] = actClearScreen
+	keymap[tui.CtrlA] = actBeginningOfLine
+	keymap[tui.CtrlB] = actBackwardChar
+	keymap[tui.CtrlC] = actAbort
+	keymap[tui.CtrlG] = actAbort
+	keymap[tui.CtrlQ] = actAbort
+	keymap[tui.ESC] = actAbort
+	keymap[tui.CtrlD] = actDeleteCharEOF
+	keymap[tui.CtrlE] = actEndOfLine
+	keymap[tui.CtrlF] = actForwardChar
+	keymap[tui.CtrlH] = actBackwardDeleteChar
+	keymap[tui.BSpace] = actBackwardDeleteChar
+	keymap[tui.Tab] = actToggleDown
+	keymap[tui.BTab] = actToggleUp
+	keymap[tui.CtrlJ] = actDown
+	keymap[tui.CtrlK] = actUp
+	keymap[tui.CtrlL] = actClearScreen
+	keymap[tui.CtrlM] = actAccept
+	keymap[tui.CtrlN] = actDown
+	keymap[tui.CtrlP] = actUp
+	keymap[tui.CtrlU] = actUnixLineDiscard
+	keymap[tui.CtrlW] = actUnixWordRubout
+	keymap[tui.CtrlY] = actYank
 
-	keymap[C.AltB] = actBackwardWord
-	keymap[C.SLeft] = actBackwardWord
-	keymap[C.AltF] = actForwardWord
-	keymap[C.SRight] = actForwardWord
-	keymap[C.AltD] = actKillWord
-	keymap[C.AltBS] = actBackwardKillWord
+	keymap[tui.AltB] = actBackwardWord
+	keymap[tui.SLeft] = actBackwardWord
+	keymap[tui.AltF] = actForwardWord
+	keymap[tui.SRight] = actForwardWord
+	keymap[tui.AltD] = actKillWord
+	keymap[tui.AltBS] = actBackwardKillWord
 
-	keymap[C.Up] = actUp
-	keymap[C.Down] = actDown
-	keymap[C.Left] = actBackwardChar
-	keymap[C.Right] = actForwardChar
+	keymap[tui.Up] = actUp
+	keymap[tui.Down] = actDown
+	keymap[tui.Left] = actBackwardChar
+	keymap[tui.Right] = actForwardChar
 
-	keymap[C.Home] = actBeginningOfLine
-	keymap[C.End] = actEndOfLine
-	keymap[C.Del] = actDeleteChar
-	keymap[C.PgUp] = actPageUp
-	keymap[C.PgDn] = actPageDown
+	keymap[tui.Home] = actBeginningOfLine
+	keymap[tui.End] = actEndOfLine
+	keymap[tui.Del] = actDeleteChar
+	keymap[tui.PgUp] = actPageUp
+	keymap[tui.PgDn] = actPageDown
 
-	keymap[C.Rune] = actRune
-	keymap[C.Mouse] = actMouse
-	keymap[C.DoubleClick] = actAccept
+	keymap[tui.Rune] = actRune
+	keymap[tui.Mouse] = actMouse
+	keymap[tui.DoubleClick] = actAccept
 	return keymap
 }
 
@@ -237,6 +258,10 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 	if len(opts.Preview.command) > 0 {
 		previewBox = util.NewEventBox()
 	}
+	strongAttr := tui.Bold
+	if !opts.Bold {
+		strongAttr = tui.AttrRegular
+	}
 	return &Terminal{
 		initDelay:  delay,
 		inlineInfo: opts.InlineInfo,
@@ -252,6 +277,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		multi:      opts.Multi,
 		sort:       opts.Sort > 0,
 		toggleSort: opts.ToggleSort,
+		delimiter:  opts.Delimiter,
 		expect:     opts.Expect,
 		keymap:     opts.Keymap,
 		execmap:    opts.Execmap,
@@ -259,6 +285,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		printQuery: opts.PrintQuery,
 		history:    opts.History,
 		margin:     opts.Margin,
+		strong:     strongAttr,
 		cycle:      opts.Cycle,
 		header:     header,
 		header0:    header,
@@ -266,19 +293,21 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		reading:    true,
 		jumping:    jumpDisabled,
 		jumpLabels: opts.JumpLabels,
+		printer:    opts.Printer,
 		merger:     EmptyMerger,
 		selected:   make(map[int32]selectedItem),
 		reqBox:     util.NewEventBox(),
 		preview:    opts.Preview,
-		previewing: previewBox != nil && !opts.Preview.hidden,
-		previewTxt: "",
+		previewer:  previewer{"", 0, 0, previewBox != nil && !opts.Preview.hidden},
 		previewBox: previewBox,
 		eventBox:   eventBox,
 		mutex:      sync.Mutex{},
 		suppress:   true,
+		slab:       util.MakeSlab(slab16Size, slab32Size),
+		theme:      opts.Theme,
 		startChan:  make(chan bool, 1),
 		initFunc: func() {
-			C.Init(opts.Theme, opts.Black, opts.Mouse)
+			tui.Init(opts.Theme, opts.Black, opts.Mouse)
 		}}
 }
 
@@ -343,21 +372,21 @@ func (t *Terminal) UpdateList(merger *Merger) {
 
 func (t *Terminal) output() bool {
 	if t.printQuery {
-		fmt.Println(string(t.input))
+		t.printer(string(t.input))
 	}
 	if len(t.expect) > 0 {
-		fmt.Println(t.pressed)
+		t.printer(t.pressed)
 	}
 	found := len(t.selected) > 0
 	if !found {
 		cnt := t.merger.Length()
 		if cnt > 0 && cnt > t.cy {
-			fmt.Println(t.current())
+			t.printer(t.current())
 			found = true
 		}
 	} else {
 		for _, sel := range t.sortSelected() {
-			fmt.Println(*sel.text)
+			t.printer(sel.item.AsString(t.ansi))
 		}
 	}
 	return found
@@ -395,6 +424,8 @@ func displayWidth(runes []rune) int {
 const (
 	minWidth  = 16
 	minHeight = 4
+
+	maxDisplayWidthCalc = 1024
 )
 
 func calculateSize(base int, size sizeSpec, margin int, minSize int) int {
@@ -406,8 +437,8 @@ func calculateSize(base int, size sizeSpec, margin int, minSize int) int {
 }
 
 func (t *Terminal) resizeWindows() {
-	screenWidth := C.MaxX()
-	screenHeight := C.MaxY()
+	screenWidth := tui.MaxX()
+	screenHeight := tui.MaxY()
 	marginInt := [4]int{}
 	for idx, sizeSpec := range t.margin {
 		if sizeSpec.percent {
@@ -456,33 +487,33 @@ func (t *Terminal) resizeWindows() {
 	height := screenHeight - marginInt[0] - marginInt[2]
 	if t.isPreviewEnabled() {
 		createPreviewWindow := func(y int, x int, w int, h int) {
-			t.bwindow = C.NewWindow(y, x, w, h, true)
-			t.pwindow = C.NewWindow(y+1, x+2, w-4, h-2, false)
+			t.bwindow = tui.NewWindow(y, x, w, h, true)
+			t.pwindow = tui.NewWindow(y+1, x+2, w-4, h-2, false)
 		}
 		switch t.preview.position {
 		case posUp:
 			pheight := calculateSize(height, t.preview.size, minHeight, 3)
-			t.window = C.NewWindow(
+			t.window = tui.NewWindow(
 				marginInt[0]+pheight, marginInt[3], width, height-pheight, false)
 			createPreviewWindow(marginInt[0], marginInt[3], width, pheight)
 		case posDown:
 			pheight := calculateSize(height, t.preview.size, minHeight, 3)
-			t.window = C.NewWindow(
+			t.window = tui.NewWindow(
 				marginInt[0], marginInt[3], width, height-pheight, false)
 			createPreviewWindow(marginInt[0]+height-pheight, marginInt[3], width, pheight)
 		case posLeft:
 			pwidth := calculateSize(width, t.preview.size, minWidth, 5)
-			t.window = C.NewWindow(
+			t.window = tui.NewWindow(
 				marginInt[0], marginInt[3]+pwidth, width-pwidth, height, false)
 			createPreviewWindow(marginInt[0], marginInt[3], pwidth, height)
 		case posRight:
 			pwidth := calculateSize(width, t.preview.size, minWidth, 5)
-			t.window = C.NewWindow(
+			t.window = tui.NewWindow(
 				marginInt[0], marginInt[3], width-pwidth, height, false)
 			createPreviewWindow(marginInt[0], marginInt[3]+width-pwidth, pwidth, height)
 		}
 	} else {
-		t.window = C.NewWindow(
+		t.window = tui.NewWindow(
 			marginInt[0],
 			marginInt[3],
 			width,
@@ -508,24 +539,24 @@ func (t *Terminal) placeCursor() {
 
 func (t *Terminal) printPrompt() {
 	t.move(0, 0, true)
-	t.window.CPrint(C.ColPrompt, true, t.prompt)
-	t.window.CPrint(C.ColNormal, true, string(t.input))
+	t.window.CPrint(tui.ColPrompt, t.strong, t.prompt)
+	t.window.CPrint(tui.ColNormal, t.strong, string(t.input))
 }
 
 func (t *Terminal) printInfo() {
 	if t.inlineInfo {
 		t.move(0, displayWidth([]rune(t.prompt))+displayWidth(t.input)+1, true)
 		if t.reading {
-			t.window.CPrint(C.ColSpinner, true, " < ")
+			t.window.CPrint(tui.ColSpinner, t.strong, " < ")
 		} else {
-			t.window.CPrint(C.ColPrompt, true, " < ")
+			t.window.CPrint(tui.ColPrompt, t.strong, " < ")
 		}
 	} else {
 		t.move(1, 0, true)
 		if t.reading {
 			duration := int64(spinnerDuration)
 			idx := (time.Now().UnixNano() % (duration * int64(len(_spinner)))) / duration
-			t.window.CPrint(C.ColSpinner, true, _spinner[idx])
+			t.window.CPrint(tui.ColSpinner, t.strong, _spinner[idx])
 		}
 		t.move(1, 2, false)
 	}
@@ -544,7 +575,7 @@ func (t *Terminal) printInfo() {
 	if t.progress > 0 && t.progress < 100 {
 		output += fmt.Sprintf(" (%d%%)", t.progress)
 	}
-	t.window.CPrint(C.ColInfo, false, output)
+	t.window.CPrint(tui.ColInfo, 0, output)
 }
 
 func (t *Terminal) printHeader() {
@@ -565,11 +596,11 @@ func (t *Terminal) printHeader() {
 		state = newState
 		item := &Item{
 			text:   util.RunesToChars([]rune(trimmed)),
-			colors: colors,
-			rank:   buildEmptyRank(0)}
+			colors: colors}
 
 		t.move(line, 2, true)
-		t.printHighlighted(item, false, C.ColHeader, 0, false)
+		t.printHighlighted(&Result{item: item},
+			tui.AttrRegular, tui.ColHeader, tui.ColDefault, false)
 	}
 }
 
@@ -590,7 +621,8 @@ func (t *Terminal) printList() {
 	}
 }
 
-func (t *Terminal) printItem(item *Item, i int, current bool) {
+func (t *Terminal) printItem(result *Result, i int, current bool) {
+	item := result.item
 	_, selected := t.selected[item.Index()]
 	label := " "
 	if t.jumping != jumpDisabled {
@@ -602,21 +634,21 @@ func (t *Terminal) printItem(item *Item, i int, current bool) {
 	} else if current {
 		label = ">"
 	}
-	t.window.CPrint(C.ColCursor, true, label)
+	t.window.CPrint(tui.ColCursor, t.strong, label)
 	if current {
 		if selected {
-			t.window.CPrint(C.ColSelected, true, ">")
+			t.window.CPrint(tui.ColSelected, t.strong, ">")
 		} else {
-			t.window.CPrint(C.ColCurrent, true, " ")
+			t.window.CPrint(tui.ColCurrent, t.strong, " ")
 		}
-		t.printHighlighted(item, true, C.ColCurrent, C.ColCurrentMatch, true)
+		t.printHighlighted(result, t.strong, tui.ColCurrent, tui.ColCurrentMatch, true)
 	} else {
 		if selected {
-			t.window.CPrint(C.ColSelected, true, ">")
+			t.window.CPrint(tui.ColSelected, t.strong, ">")
 		} else {
 			t.window.Print(" ")
 		}
-		t.printHighlighted(item, false, 0, C.ColMatch, false)
+		t.printHighlighted(result, 0, tui.ColNormal, tui.ColMatch, false)
 	}
 }
 
@@ -645,6 +677,11 @@ func displayWidthWithLimit(runes []rune, prefixWidth int, limit int) int {
 }
 
 func trimLeft(runes []rune, width int) ([]rune, int32) {
+	if len(runes) > maxDisplayWidthCalc && len(runes) > width {
+		trimmed := len(runes) - width
+		return runes[trimmed:], int32(trimmed)
+	}
+
 	currentWidth := displayWidth(runes)
 	var trimmed int32
 
@@ -667,16 +704,32 @@ func overflow(runes []rune, max int) bool {
 	return false
 }
 
-func (t *Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, current bool) {
-	var maxe int
-	for _, offset := range item.offsets {
-		maxe = util.Max(maxe, int(offset[1]))
-	}
+func (t *Terminal) printHighlighted(result *Result, attr tui.Attr, col1 tui.ColorPair, col2 tui.ColorPair, current bool) {
+	item := result.item
 
 	// Overflow
 	text := make([]rune, item.text.Length())
 	copy(text, item.text.ToRunes())
-	offsets := item.colorOffsets(col2, bold, current)
+	matchOffsets := []Offset{}
+	var pos *[]int
+	if t.merger.pattern != nil {
+		_, matchOffsets, pos = t.merger.pattern.MatchItem(item, true, t.slab)
+	}
+	charOffsets := matchOffsets
+	if pos != nil {
+		charOffsets = make([]Offset, len(*pos))
+		for idx, p := range *pos {
+			offset := Offset{int32(p), int32(p + 1)}
+			charOffsets[idx] = offset
+		}
+		sort.Sort(ByOrder(charOffsets))
+	}
+	var maxe int
+	for _, offset := range charOffsets {
+		maxe = util.Max(maxe, int(offset[1]))
+	}
+
+	offsets := result.colorOffsets(charOffsets, t.theme, col2, attr, current)
 	maxWidth := t.window.Width - 3
 	maxe = util.Constrain(maxe+util.Min(maxWidth/2-2, t.hscrollOff), 0, len(text))
 	if overflow(text, maxWidth) {
@@ -725,11 +778,11 @@ func (t *Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, c
 		e := util.Constrain32(offset.offset[1], index, maxOffset)
 
 		substr, prefixWidth = processTabs(text[index:b], prefixWidth)
-		t.window.CPrint(col1, bold, substr)
+		t.window.CPrint(col1, attr, substr)
 
 		if b < e {
 			substr, prefixWidth = processTabs(text[b:e], prefixWidth)
-			t.window.CPrint(offset.color, offset.bold, substr)
+			t.window.CPrint(offset.color, offset.attr, substr)
 		}
 
 		index = e
@@ -739,18 +792,52 @@ func (t *Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, c
 	}
 	if index < maxOffset {
 		substr, _ = processTabs(text[index:], prefixWidth)
-		t.window.CPrint(col1, bold, substr)
+		t.window.CPrint(col1, attr, substr)
 	}
 }
 
+func numLinesMax(str string, max int) int {
+	lines := 0
+	for lines < max {
+		idx := strings.Index(str, "\n")
+		if idx < 0 {
+			break
+		}
+		str = str[idx+1:]
+		lines++
+	}
+	return lines
+}
+
 func (t *Terminal) printPreview() {
+	if !t.isPreviewEnabled() {
+		return
+	}
 	t.pwindow.Erase()
-	extractColor(t.previewTxt, nil, func(str string, ansi *ansiState) bool {
+	skip := t.previewer.offset
+	extractColor(t.previewer.text, nil, func(str string, ansi *ansiState) bool {
+		if skip > 0 {
+			newlines := numLinesMax(str, skip)
+			if skip <= newlines {
+				for i := 0; i < skip; i++ {
+					str = str[strings.Index(str, "\n")+1:]
+				}
+				skip = 0
+			} else {
+				skip -= newlines
+				return true
+			}
+		}
 		if ansi != nil && ansi.colored() {
-			return t.pwindow.CFill(str, ansi.fg, ansi.bg, ansi.bold)
+			return t.pwindow.CFill(str, ansi.fg, ansi.bg, ansi.attr)
 		}
 		return t.pwindow.Fill(str)
 	})
+	if t.previewer.lines > t.pwindow.Height {
+		offset := fmt.Sprintf("%d/%d", t.previewer.offset+1, t.previewer.lines)
+		t.pwindow.Move(0, t.pwindow.Width-len(offset))
+		t.pwindow.CPrint(tui.ColInfo, tui.Reverse, offset)
+	}
 }
 
 func processTabs(runes []rune, prefixWidth int) (string, int) {
@@ -774,19 +861,16 @@ func (t *Terminal) printAll() {
 	t.printPrompt()
 	t.printInfo()
 	t.printHeader()
-	if t.isPreviewEnabled() {
-		t.printPreview()
-	}
+	t.printPreview()
 }
 
 func (t *Terminal) refresh() {
 	if !t.suppress {
 		if t.isPreviewEnabled() {
-			t.bwindow.Refresh()
-			t.pwindow.Refresh()
+			tui.RefreshWindows([]*tui.Window{t.bwindow, t.pwindow, t.window})
+		} else {
+			tui.RefreshWindows([]*tui.Window{t.window})
 		}
-		t.window.Refresh()
-		C.DoUpdate()
 	}
 }
 
@@ -836,24 +920,82 @@ func (t *Terminal) rubout(pattern string) {
 	t.input = append(t.input[:t.cx], after...)
 }
 
-func keyMatch(key int, event C.Event) bool {
+func keyMatch(key int, event tui.Event) bool {
 	return event.Type == key ||
-		event.Type == C.Rune && int(event.Char) == key-C.AltZ ||
-		event.Type == C.Mouse && key == C.DoubleClick && event.MouseEvent.Double
+		event.Type == tui.Rune && int(event.Char) == key-tui.AltZ ||
+		event.Type == tui.Mouse && key == tui.DoubleClick && event.MouseEvent.Double
 }
 
 func quoteEntry(entry string) string {
+	if util.IsWindows() {
+		return strconv.Quote(strings.Replace(entry, "\"", "\\\"", -1))
+	}
 	return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
 }
 
-func (t *Terminal) executeCommand(template string, replacement string) {
-	command := strings.Replace(template, "{}", replacement, -1)
+func replacePlaceholder(template string, stripAnsi bool, delimiter Delimiter, query string, items []*Item) string {
+	return placeholder.ReplaceAllStringFunc(template, func(match string) string {
+		// Escaped pattern
+		if match[0] == '\\' {
+			return match[1:]
+		}
+
+		// Current query
+		if match == "{q}" {
+			return quoteEntry(query)
+		}
+
+		replacements := make([]string, len(items))
+
+		if match == "{}" {
+			for idx, item := range items {
+				replacements[idx] = quoteEntry(item.AsString(stripAnsi))
+			}
+			return strings.Join(replacements, " ")
+		}
+
+		tokens := strings.Split(match[1:len(match)-1], ",")
+		ranges := make([]Range, len(tokens))
+		for idx, s := range tokens {
+			r, ok := ParseRange(&s)
+			if !ok {
+				// Invalid expression, just return the original string in the template
+				return match
+			}
+			ranges[idx] = r
+		}
+
+		for idx, item := range items {
+			chars := util.RunesToChars([]rune(item.AsString(stripAnsi)))
+			tokens := Tokenize(chars, delimiter)
+			trans := Transform(tokens, ranges)
+			str := string(joinTokens(trans))
+			if delimiter.str != nil {
+				str = strings.TrimSuffix(str, *delimiter.str)
+			} else if delimiter.regex != nil {
+				delims := delimiter.regex.FindAllStringIndex(str, -1)
+				if len(delims) > 0 && delims[len(delims)-1][1] == len(str) {
+					str = str[:delims[len(delims)-1][0]]
+				}
+			}
+			str = strings.TrimSpace(str)
+			replacements[idx] = quoteEntry(str)
+		}
+		return strings.Join(replacements, " ")
+	})
+}
+
+func (t *Terminal) executeCommand(template string, items []*Item) {
+	command := replacePlaceholder(template, t.ansi, t.delimiter, string(t.input), items)
 	cmd := util.ExecCommand(command)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	C.Endwin()
+	tui.Pause()
 	cmd.Run()
+	if tui.Resume() {
+		t.printAll()
+	}
 	t.refresh()
 }
 
@@ -862,15 +1004,20 @@ func (t *Terminal) hasPreviewWindow() bool {
 }
 
 func (t *Terminal) isPreviewEnabled() bool {
-	return t.previewBox != nil && t.previewing
+	return t.previewBox != nil && t.previewer.enabled
+}
+
+func (t *Terminal) currentItem() *Item {
+	return t.merger.Get(t.cy).item
 }
 
 func (t *Terminal) current() string {
-	return t.merger.Get(t.cy).AsString(t.ansi)
+	return t.currentItem().AsString(t.ansi)
 }
 
 // Loop is called to start Terminal I/O
 func (t *Terminal) Loop() {
+	// prof := profile.Start(profile.ProfilePath("/tmp/"))
 	<-t.startChan
 	{ // Late initialization
 		intChan := make(chan os.Signal, 1)
@@ -881,7 +1028,7 @@ func (t *Terminal) Loop() {
 		}()
 
 		resizeChan := make(chan os.Signal, 1)
-		signal.Notify(resizeChan, syscall.SIGWINCH)
+		notifyOnResize(resizeChan) // Non-portable
 		go func() {
 			for {
 				<-resizeChan
@@ -922,18 +1069,19 @@ func (t *Terminal) Loop() {
 	if t.hasPreviewWindow() {
 		go func() {
 			for {
-				request := previewRequest{false, ""}
+				var request *Item
 				t.previewBox.Wait(func(events *util.Events) {
 					for req, value := range *events {
 						switch req {
 						case reqPreviewEnqueue:
-							request = value.(previewRequest)
+							request = value.(*Item)
 						}
 					}
 					events.Clear()
 				})
-				if request.ok {
-					command := strings.Replace(t.preview.command, "{}", quoteEntry(request.str), -1)
+				if request != nil {
+					command := replacePlaceholder(t.preview.command,
+						t.ansi, t.delimiter, string(t.input), []*Item{request})
 					cmd := util.ExecCommand(command)
 					out, _ := cmd.CombinedOutput()
 					t.reqBox.Set(reqPreviewDisplay, string(out))
@@ -948,11 +1096,12 @@ func (t *Terminal) Loop() {
 		if code <= exitNoMatch && t.history != nil {
 			t.history.append(string(t.input))
 		}
+		// prof.Stop()
 		os.Exit(code)
 	}
 
 	go func() {
-		focused := previewRequest{false, ""}
+		var focused *Item
 		for {
 			t.reqBox.Wait(func(events *util.Events) {
 				defer events.Clear()
@@ -969,11 +1118,11 @@ func (t *Terminal) Loop() {
 					case reqList:
 						t.printList()
 						cnt := t.merger.Length()
-						var currentFocus previewRequest
+						var currentFocus *Item
 						if cnt > 0 && cnt > t.cy {
-							currentFocus = previewRequest{true, t.current()}
+							currentFocus = t.currentItem()
 						} else {
-							currentFocus = previewRequest{false, ""}
+							currentFocus = nil
 						}
 						if currentFocus != focused {
 							focused = currentFocus
@@ -991,25 +1140,28 @@ func (t *Terminal) Loop() {
 					case reqRefresh:
 						t.suppress = false
 					case reqRedraw:
-						C.Clear()
-						C.Endwin()
-						C.Refresh()
+						tui.Clear()
+						tui.Refresh()
 						t.printAll()
 					case reqClose:
-						C.Close()
+						tui.Close()
 						if t.output() {
 							exit(exitOk)
 						}
 						exit(exitNoMatch)
 					case reqPreviewDisplay:
-						t.previewTxt = value.(string)
+						t.previewer.text = value.(string)
+						t.previewer.lines = strings.Count(t.previewer.text, "\n")
+						t.previewer.offset = 0
+						t.printPreview()
+					case reqPreviewRefresh:
 						t.printPreview()
 					case reqPrintQuery:
-						C.Close()
-						fmt.Println(string(t.input))
+						tui.Close()
+						t.printer(string(t.input))
 						exit(exitOk)
 					case reqQuit:
-						C.Close()
+						tui.Close()
 						exit(exitInterrupt)
 					}
 				}
@@ -1022,7 +1174,7 @@ func (t *Terminal) Loop() {
 
 	looping := true
 	for looping {
-		event := C.GetChar()
+		event := tui.GetChar()
 
 		t.mutex.Lock()
 		previousInput := t.input
@@ -1037,13 +1189,13 @@ func (t *Terminal) Loop() {
 		}
 		selectItem := func(item *Item) bool {
 			if _, found := t.selected[item.Index()]; !found {
-				t.selected[item.Index()] = selectedItem{time.Now(), item.StringPtr(t.ansi)}
+				t.selected[item.Index()] = selectedItem{time.Now(), item}
 				return true
 			}
 			return false
 		}
 		toggleY := func(y int) {
-			item := t.merger.Get(y)
+			item := t.merger.Get(y).item
 			if !selectItem(item) {
 				delete(t.selected, item.Index())
 			}
@@ -1054,11 +1206,17 @@ func (t *Terminal) Loop() {
 				req(reqInfo)
 			}
 		}
+		scrollPreview := func(amount int) {
+			t.previewer.offset = util.Constrain(
+				t.previewer.offset+amount, 0, t.previewer.lines-1)
+			req(reqPreviewRefresh)
+		}
 		for key, ret := range t.expect {
 			if keyMatch(key, event) {
 				t.pressed = ret
-				req(reqClose)
-				break
+				t.reqBox.Set(reqClose, nil)
+				t.mutex.Unlock()
+				return
 			}
 		}
 
@@ -1068,16 +1226,15 @@ func (t *Terminal) Loop() {
 			case actIgnore:
 			case actExecute:
 				if t.cy >= 0 && t.cy < t.merger.Length() {
-					item := t.merger.Get(t.cy)
-					t.executeCommand(t.execmap[mapkey], quoteEntry(item.AsString(t.ansi)))
+					t.executeCommand(t.execmap[mapkey], []*Item{t.currentItem()})
 				}
 			case actExecuteMulti:
 				if len(t.selected) > 0 {
-					sels := make([]string, len(t.selected))
+					sels := make([]*Item, len(t.selected))
 					for i, sel := range t.sortSelected() {
-						sels[i] = quoteEntry(*sel.text)
+						sels[i] = sel.item
 					}
-					t.executeCommand(t.execmap[mapkey], strings.Join(sels, " "))
+					t.executeCommand(t.execmap[mapkey], sels)
 				} else {
 					return doAction(actExecute, mapkey)
 				}
@@ -1086,19 +1243,35 @@ func (t *Terminal) Loop() {
 				return false
 			case actTogglePreview:
 				if t.hasPreviewWindow() {
-					t.previewing = !t.previewing
+					t.previewer.enabled = !t.previewer.enabled
 					t.resizeWindows()
 					cnt := t.merger.Length()
-					if t.previewing && cnt > 0 && cnt > t.cy {
-						t.previewBox.Set(reqPreviewEnqueue, previewRequest{true, t.current()})
+					if t.previewer.enabled && cnt > 0 && cnt > t.cy {
+						t.previewBox.Set(reqPreviewEnqueue, t.currentItem())
 					}
-					req(reqList, reqInfo)
+					req(reqList, reqInfo, reqHeader)
 				}
 			case actToggleSort:
 				t.sort = !t.sort
 				t.eventBox.Set(EvtSearchNew, t.sort)
 				t.mutex.Unlock()
 				return false
+			case actPreviewUp:
+				if t.isPreviewEnabled() {
+					scrollPreview(-1)
+				}
+			case actPreviewDown:
+				if t.isPreviewEnabled() {
+					scrollPreview(1)
+				}
+			case actPreviewPageUp:
+				if t.isPreviewEnabled() {
+					scrollPreview(-t.pwindow.Height)
+				}
+			case actPreviewPageDown:
+				if t.isPreviewEnabled() {
+					scrollPreview(t.pwindow.Height)
+				}
 			case actBeginningOfLine:
 				t.cx = 0
 			case actBackwardChar:
@@ -1137,7 +1310,7 @@ func (t *Terminal) Loop() {
 			case actSelectAll:
 				if t.multi {
 					for i := 0; i < t.merger.Length(); i++ {
-						item := t.merger.Get(i)
+						item := t.merger.Get(i).item
 						selectItem(item)
 					}
 					req(reqList, reqInfo)
@@ -1267,6 +1440,8 @@ func (t *Terminal) Loop() {
 						}
 						t.vmove(me.S)
 						req(reqList)
+					} else if t.isPreviewEnabled() && t.pwindow.Enclose(my, mx) {
+						scrollPreview(-me.S)
 					}
 				} else if t.window.Enclose(my, mx) {
 					mx -= t.window.Left
@@ -1283,7 +1458,7 @@ func (t *Terminal) Loop() {
 						// Double-click
 						if my >= min {
 							if t.vset(t.offset+my-min) && t.cy < t.merger.Length() {
-								return doAction(t.keymap[C.DoubleClick], C.DoubleClick)
+								return doAction(t.keymap[tui.DoubleClick], tui.DoubleClick)
 							}
 						}
 					} else if me.Down {
@@ -1306,8 +1481,8 @@ func (t *Terminal) Loop() {
 		mapkey := event.Type
 		if t.jumping == jumpDisabled {
 			action := t.keymap[mapkey]
-			if mapkey == C.Rune {
-				mapkey = int(event.Char) + int(C.AltZ)
+			if mapkey == tui.Rune {
+				mapkey = int(event.Char) + int(tui.AltZ)
 				if act, prs := t.keymap[mapkey]; prs {
 					action = act
 				}
@@ -1315,9 +1490,14 @@ func (t *Terminal) Loop() {
 			if !doAction(action, mapkey) {
 				continue
 			}
+			// Truncate the query if it's too long
+			if len(t.input) > maxPatternLength {
+				t.input = t.input[:maxPatternLength]
+				t.cx = util.Constrain(t.cx, 0, maxPatternLength)
+			}
 			changed = string(previousInput) != string(t.input)
 		} else {
-			if mapkey == C.Rune {
+			if mapkey == tui.Rune {
 				if idx := strings.IndexRune(t.jumpLabels, event.Char); idx >= 0 && idx < t.maxItems() && idx < t.merger.Length() {
 					t.cy = idx + t.offset
 					if t.jumping == jumpAcceptEnabled {

src/terminal_test.go

@@ -0,0 +1,73 @@
+package fzf
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func newItem(str string) *Item {
+	bytes := []byte(str)
+	trimmed, _, _ := extractColor(str, nil, nil)
+	return &Item{origText: &bytes, text: util.RunesToChars([]rune(trimmed))}
+}
+
+func TestReplacePlaceholder(t *testing.T) {
+	items1 := []*Item{newItem("  foo'bar \x1b[31mbaz\x1b[m")}
+	items2 := []*Item{
+		newItem("foo'bar \x1b[31mbaz\x1b[m"),
+		newItem("FOO'BAR \x1b[31mBAZ\x1b[m")}
+
+	var result string
+	check := func(expected string) {
+		if result != expected {
+			t.Errorf("expected: %s, actual: %s", expected, result)
+		}
+	}
+
+	// {}, preserve ansi
+	result = replacePlaceholder("echo {}", false, Delimiter{}, "query", items1)
+	check("echo '  foo'\\''bar \x1b[31mbaz\x1b[m'")
+
+	// {}, strip ansi
+	result = replacePlaceholder("echo {}", true, Delimiter{}, "query", items1)
+	check("echo '  foo'\\''bar baz'")
+
+	// {}, with multiple items
+	result = replacePlaceholder("echo {}", true, Delimiter{}, "query", items2)
+	check("echo 'foo'\\''bar baz' 'FOO'\\''BAR BAZ'")
+
+	// {..}, strip leading whitespaces, preserve ansi
+	result = replacePlaceholder("echo {..}", false, Delimiter{}, "query", items1)
+	check("echo 'foo'\\''bar \x1b[31mbaz\x1b[m'")
+
+	// {..}, strip leading whitespaces, strip ansi
+	result = replacePlaceholder("echo {..}", true, Delimiter{}, "query", items1)
+	check("echo 'foo'\\''bar baz'")
+
+	// {q}
+	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, "query", items1)
+	check("echo '  foo'\\''bar baz' 'query'")
+
+	// {q}, multiple items
+	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, "query 'string'", items2)
+	check("echo 'foo'\\''bar baz' 'FOO'\\''BAR BAZ''query '\\''string'\\''''foo'\\''bar baz' 'FOO'\\''BAR BAZ'")
+
+	result = replacePlaceholder("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, "query", items1)
+	check("echo 'foo'\\''bar'/'baz'/'bazfoo'\\''bar'/'baz'/'foo'\\''bar'/'  foo'\\''bar baz'/'foo'\\''bar baz'/{n.t}/{}/{1}/{q}/''")
+
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, "query", items2)
+	check("echo 'foo'\\''bar' 'FOO'\\''BAR'/'baz' 'BAZ'/'baz' 'BAZ'/'foo'\\''bar' 'FOO'\\''BAR'/'foo'\\''bar baz' 'FOO'\\''BAR BAZ'/{n.t}/{}/{1}/{q}/'' ''")
+
+	// String delimiter
+	delim := "'"
+	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, "query", items1)
+	check("echo '  foo'\\''bar baz'/'foo'/'bar baz'")
+
+	// Regex delimiter
+	regex := regexp.MustCompile("[oa]+")
+	// foo'bar baz
+	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, "query", items1)
+	check("echo '  foo'\\''bar baz'/'f'/'r b'/''\\''bar b'")
+}

src/terminal_unix.go

@@ -0,0 +1,13 @@
+// +build !windows
+
+package fzf
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func notifyOnResize(resizeChan chan<- os.Signal) {
+	signal.Notify(resizeChan, syscall.SIGWINCH)
+}

src/terminal_windows.go

@@ -0,0 +1,11 @@
+// +build windows
+
+package fzf
+
+import (
+	"os"
+)
+
+func notifyOnResize(resizeChan chan<- os.Signal) {
+	// TODO
+}

src/tokenizer.go

@@ -18,9 +18,9 @@ type Range struct {
 
 // Token contains the tokenized part of the strings and its prefix length
 type Token struct {
-	text         util.Chars
-	prefixLength int
-	trimLength   int
+	text         *util.Chars
+	prefixLength int32
+	trimLength   int32
 }
 
 // Delimiter for tokenizing the input
@@ -80,9 +80,8 @@ func withPrefixLengths(tokens []util.Chars, begin int) []Token {
 
 	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
-		ret[idx] = Token{token, prefixLength, token.TrimLength()}
+		// NOTE: &tokens[idx] instead of &tokens
+		ret[idx] = Token{&tokens[idx], int32(prefixLength), int32(token.TrimLength())}
 		prefixLength += token.Length()
 	}
 	return ret
@@ -173,25 +172,18 @@ func joinTokens(tokens []Token) []rune {
 	return ret
 }
 
-func joinTokensAsRunes(tokens []Token) []rune {
-	ret := []rune{}
-	for _, token := range tokens {
-		ret = append(ret, token.text.ToRunes()...)
-	}
-	return ret
-}
-
 // Transform is used to transform the input when --with-nth option is given
 func Transform(tokens []Token, withNth []Range) []Token {
 	transTokens := make([]Token, len(withNth))
 	numTokens := len(tokens)
 	for idx, r := range withNth {
-		parts := []util.Chars{}
+		parts := []*util.Chars{}
 		minIdx := 0
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				parts = append(parts, util.RunesToChars(joinTokensAsRunes(tokens)))
+				chars := util.RunesToChars(joinTokens(tokens))
+				parts = append(parts, &chars)
 			} else {
 				if idx < 0 {
 					idx += numTokens + 1
@@ -235,7 +227,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		case 0:
 			merged = util.RunesToChars([]rune{})
 		case 1:
-			merged = parts[0]
+			merged = *parts[0]
 		default:
 			runes := []rune{}
 			for _, part := range parts {
@@ -244,13 +236,13 @@ func Transform(tokens []Token, withNth []Range) []Token {
 			merged = util.RunesToChars(runes)
 		}
 
-		var prefixLength int
+		var prefixLength int32
 		if minIdx < numTokens {
 			prefixLength = tokens[minIdx].prefixLength
 		} else {
 			prefixLength = 0
 		}
-		transTokens[idx] = Token{merged, prefixLength, merged.TrimLength()}
+		transTokens[idx] = Token{&merged, prefixLength, int32(merged.TrimLength())}
 	}
 	return transTokens
 }

src/tui/ncurses.go

@@ -0,0 +1,478 @@
+// +build !windows
+// +build !tcell
+
+package tui
+
+/*
+#include <ncurses.h>
+#include <locale.h>
+#cgo !static LDFLAGS: -lncurses
+#cgo static LDFLAGS: -l:libncursesw.a -l:libtinfo.a -l:libgpm.a -ldl
+#cgo android static LDFLAGS: -l:libncurses.a -fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch
+
+FILE* c_tty() {
+	return fopen("/dev/tty", "r");
+}
+
+SCREEN* c_newterm(FILE* tty) {
+	return newterm(NULL, stderr, tty);
+}
+*/
+import "C"
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+type ColorPair int16
+type Attr C.uint
+type WindowImpl C.WINDOW
+
+const (
+	Bold      Attr = C.A_BOLD
+	Dim            = C.A_DIM
+	Blink          = C.A_BLINK
+	Reverse        = C.A_REVERSE
+	Underline      = C.A_UNDERLINE
+)
+
+var Italic Attr = C.A_VERTICAL << 1 // FIXME
+
+const (
+	AttrRegular Attr = 0
+)
+
+// Pallete
+const (
+	ColDefault ColorPair = iota
+	ColNormal
+	ColPrompt
+	ColMatch
+	ColCurrent
+	ColCurrentMatch
+	ColSpinner
+	ColInfo
+	ColCursor
+	ColSelected
+	ColHeader
+	ColBorder
+	ColUser // Should be the last entry
+)
+
+var (
+	_screen   *C.SCREEN
+	_colorMap map[int]ColorPair
+	_colorFn  func(ColorPair, Attr) (C.short, C.int)
+)
+
+func init() {
+	_colorMap = make(map[int]ColorPair)
+	if strings.HasPrefix(C.GoString(C.curses_version()), "ncurses 5") {
+		Italic = C.A_NORMAL
+	}
+}
+
+func (a Attr) Merge(b Attr) Attr {
+	return a | b
+}
+
+func DefaultTheme() *ColorTheme {
+	if C.tigetnum(C.CString("colors")) >= 256 {
+		return Dark256
+	}
+	return Default16
+}
+
+func Init(theme *ColorTheme, black bool, mouse bool) {
+	C.setlocale(C.LC_ALL, C.CString(""))
+	tty := C.c_tty()
+	if tty == nil {
+		fmt.Println("Failed to open /dev/tty")
+		os.Exit(2)
+	}
+	_screen = C.c_newterm(tty)
+	if _screen == nil {
+		fmt.Println("Invalid $TERM: " + os.Getenv("TERM"))
+		os.Exit(2)
+	}
+	C.set_term(_screen)
+	if mouse {
+		C.mousemask(C.ALL_MOUSE_EVENTS, nil)
+		C.mouseinterval(0)
+	}
+	C.noecho()
+	C.raw() // stty dsusp undef
+	C.nonl()
+	C.keypad(C.stdscr, true)
+
+	delay := 50
+	delayEnv := os.Getenv("ESCDELAY")
+	if len(delayEnv) > 0 {
+		num, err := strconv.Atoi(delayEnv)
+		if err == nil && num >= 0 {
+			delay = num
+		}
+	}
+	C.set_escdelay(C.int(delay))
+
+	_color = theme != nil
+	if _color {
+		C.start_color()
+		InitTheme(theme, black)
+		initPairs(theme)
+		C.bkgd(C.chtype(C.COLOR_PAIR(C.int(ColNormal))))
+		_colorFn = attrColored
+	} else {
+		_colorFn = attrMono
+	}
+
+	C.nodelay(C.stdscr, true)
+	ch := C.getch()
+	if ch != C.ERR {
+		C.ungetch(ch)
+	}
+	C.nodelay(C.stdscr, false)
+}
+
+func initPairs(theme *ColorTheme) {
+	C.assume_default_colors(C.int(theme.Fg), C.int(theme.Bg))
+	initPair := func(group ColorPair, fg Color, bg Color) {
+		C.init_pair(C.short(group), C.short(fg), C.short(bg))
+	}
+	initPair(ColNormal, theme.Fg, theme.Bg)
+	initPair(ColPrompt, theme.Prompt, theme.Bg)
+	initPair(ColMatch, theme.Match, theme.Bg)
+	initPair(ColCurrent, theme.Current, theme.DarkBg)
+	initPair(ColCurrentMatch, theme.CurrentMatch, theme.DarkBg)
+	initPair(ColSpinner, theme.Spinner, theme.Bg)
+	initPair(ColInfo, theme.Info, theme.Bg)
+	initPair(ColCursor, theme.Cursor, theme.DarkBg)
+	initPair(ColSelected, theme.Selected, theme.DarkBg)
+	initPair(ColHeader, theme.Header, theme.Bg)
+	initPair(ColBorder, theme.Border, theme.Bg)
+}
+
+func Pause() {
+	C.endwin()
+}
+
+func Resume() bool {
+	return false
+}
+
+func Close() {
+	C.endwin()
+	C.delscreen(_screen)
+}
+
+func NewWindow(top int, left int, width int, height int, border bool) *Window {
+	win := C.newwin(C.int(height), C.int(width), C.int(top), C.int(left))
+	if _color {
+		C.wbkgd(win, C.chtype(C.COLOR_PAIR(C.int(ColNormal))))
+	}
+	if border {
+		pair, attr := _colorFn(ColBorder, 0)
+		C.wcolor_set(win, pair, nil)
+		C.wattron(win, attr)
+		C.box(win, 0, 0)
+		C.wattroff(win, attr)
+		C.wcolor_set(win, 0, nil)
+	}
+
+	return &Window{
+		impl:   (*WindowImpl)(win),
+		Top:    top,
+		Left:   left,
+		Width:  width,
+		Height: height,
+	}
+}
+
+func attrColored(pair ColorPair, a Attr) (C.short, C.int) {
+	return C.short(pair), C.int(a)
+}
+
+func attrMono(pair ColorPair, a Attr) (C.short, C.int) {
+	var attr C.int
+	switch pair {
+	case ColCurrent:
+		attr = C.A_REVERSE
+	case ColMatch:
+		attr = C.A_UNDERLINE
+	case ColCurrentMatch:
+		attr = C.A_UNDERLINE | C.A_REVERSE
+	}
+	if C.int(a)&C.A_BOLD == C.A_BOLD {
+		attr = attr | C.A_BOLD
+	}
+	return 0, attr
+}
+
+func MaxX() int {
+	return int(C.COLS)
+}
+
+func MaxY() int {
+	return int(C.LINES)
+}
+
+func (w *Window) win() *C.WINDOW {
+	return (*C.WINDOW)(w.impl)
+}
+
+func (w *Window) Close() {
+	C.delwin(w.win())
+}
+
+func (w *Window) Enclose(y int, x int) bool {
+	return bool(C.wenclose(w.win(), C.int(y), C.int(x)))
+}
+
+func (w *Window) Move(y int, x int) {
+	C.wmove(w.win(), C.int(y), C.int(x))
+}
+
+func (w *Window) MoveAndClear(y int, x int) {
+	w.Move(y, x)
+	C.wclrtoeol(w.win())
+}
+
+func (w *Window) Print(text string) {
+	C.waddstr(w.win(), C.CString(strings.Map(func(r rune) rune {
+		if r < 32 {
+			return -1
+		}
+		return r
+	}, text)))
+}
+
+func (w *Window) CPrint(pair ColorPair, attr Attr, text string) {
+	p, a := _colorFn(pair, attr)
+	C.wcolor_set(w.win(), p, nil)
+	C.wattron(w.win(), a)
+	w.Print(text)
+	C.wattroff(w.win(), a)
+	C.wcolor_set(w.win(), 0, nil)
+}
+
+func Clear() {
+	C.clear()
+	C.endwin()
+}
+
+func Refresh() {
+	C.refresh()
+}
+
+func (w *Window) Erase() {
+	C.werase(w.win())
+}
+
+func (w *Window) Fill(str string) bool {
+	return C.waddstr(w.win(), C.CString(str)) == C.OK
+}
+
+func (w *Window) CFill(str string, fg Color, bg Color, attr Attr) bool {
+	pair := PairFor(fg, bg)
+	C.wcolor_set(w.win(), C.short(pair), nil)
+	C.wattron(w.win(), C.int(attr))
+	ret := w.Fill(str)
+	C.wattroff(w.win(), C.int(attr))
+	C.wcolor_set(w.win(), 0, nil)
+	return ret
+}
+
+func RefreshWindows(windows []*Window) {
+	for _, w := range windows {
+		C.wnoutrefresh(w.win())
+	}
+	C.doupdate()
+}
+
+func PairFor(fg Color, bg Color) ColorPair {
+	// ncurses does not support 24-bit colors
+	if fg.is24() || bg.is24() {
+		return ColDefault
+	}
+	key := (int(fg) << 8) + int(bg)
+	if found, prs := _colorMap[key]; prs {
+		return found
+	}
+
+	id := ColorPair(len(_colorMap) + int(ColUser))
+	C.init_pair(C.short(id), C.short(fg), C.short(bg))
+	_colorMap[key] = id
+	return id
+}
+
+func consume(expects ...rune) bool {
+	for _, r := range expects {
+		if int(C.getch()) != int(r) {
+			return false
+		}
+	}
+	return true
+}
+
+func escSequence() Event {
+	C.nodelay(C.stdscr, true)
+	defer func() {
+		C.nodelay(C.stdscr, false)
+	}()
+	c := C.getch()
+	switch c {
+	case C.ERR:
+		return Event{ESC, 0, nil}
+	case CtrlM:
+		return Event{AltEnter, 0, nil}
+	case '/':
+		return Event{AltSlash, 0, nil}
+	case ' ':
+		return Event{AltSpace, 0, nil}
+	case 127, C.KEY_BACKSPACE:
+		return Event{AltBS, 0, nil}
+	case '[':
+		// Bracketed paste mode (printf "\e[?2004h")
+		// \e[200~ TEXT \e[201~
+		if consume('2', '0', '0', '~') {
+			return Event{Invalid, 0, nil}
+		}
+	}
+	if c >= 'a' && c <= 'z' {
+		return Event{AltA + int(c) - 'a', 0, nil}
+	}
+
+	if c >= '0' && c <= '9' {
+		return Event{Alt0 + int(c) - '0', 0, nil}
+	}
+
+	// Don't care. Ignore the rest.
+	for ; c != C.ERR; c = C.getch() {
+	}
+	return Event{Invalid, 0, nil}
+}
+
+func GetChar() Event {
+	c := C.getch()
+	switch c {
+	case C.ERR:
+		return Event{Invalid, 0, nil}
+	case C.KEY_UP:
+		return Event{Up, 0, nil}
+	case C.KEY_DOWN:
+		return Event{Down, 0, nil}
+	case C.KEY_LEFT:
+		return Event{Left, 0, nil}
+	case C.KEY_RIGHT:
+		return Event{Right, 0, nil}
+	case C.KEY_HOME:
+		return Event{Home, 0, nil}
+	case C.KEY_END:
+		return Event{End, 0, nil}
+	case C.KEY_BACKSPACE:
+		return Event{BSpace, 0, nil}
+	case C.KEY_F0 + 1:
+		return Event{F1, 0, nil}
+	case C.KEY_F0 + 2:
+		return Event{F2, 0, nil}
+	case C.KEY_F0 + 3:
+		return Event{F3, 0, nil}
+	case C.KEY_F0 + 4:
+		return Event{F4, 0, nil}
+	case C.KEY_F0 + 5:
+		return Event{F5, 0, nil}
+	case C.KEY_F0 + 6:
+		return Event{F6, 0, nil}
+	case C.KEY_F0 + 7:
+		return Event{F7, 0, nil}
+	case C.KEY_F0 + 8:
+		return Event{F8, 0, nil}
+	case C.KEY_F0 + 9:
+		return Event{F9, 0, nil}
+	case C.KEY_F0 + 10:
+		return Event{F10, 0, nil}
+	case C.KEY_F0 + 11:
+		return Event{F11, 0, nil}
+	case C.KEY_F0 + 12:
+		return Event{F12, 0, nil}
+	case C.KEY_DC:
+		return Event{Del, 0, nil}
+	case C.KEY_PPAGE:
+		return Event{PgUp, 0, nil}
+	case C.KEY_NPAGE:
+		return Event{PgDn, 0, nil}
+	case C.KEY_BTAB:
+		return Event{BTab, 0, nil}
+	case C.KEY_ENTER:
+		return Event{CtrlM, 0, nil}
+	case C.KEY_SLEFT:
+		return Event{SLeft, 0, nil}
+	case C.KEY_SRIGHT:
+		return Event{SRight, 0, nil}
+	case C.KEY_MOUSE:
+		var me C.MEVENT
+		if C.getmouse(&me) != C.ERR {
+			mod := ((me.bstate & C.BUTTON_SHIFT) | (me.bstate & C.BUTTON_CTRL) | (me.bstate & C.BUTTON_ALT)) > 0
+			x := int(me.x)
+			y := int(me.y)
+			/* Cannot use BUTTON1_DOUBLE_CLICKED due to mouseinterval(0) */
+			if (me.bstate & C.BUTTON1_PRESSED) > 0 {
+				now := time.Now()
+				if now.Sub(_prevDownTime) < doubleClickDuration {
+					_clickY = append(_clickY, y)
+				} else {
+					_clickY = []int{y}
+					_prevDownTime = now
+				}
+				return Event{Mouse, 0, &MouseEvent{y, x, 0, true, false, mod}}
+			} else if (me.bstate & C.BUTTON1_RELEASED) > 0 {
+				double := false
+				if len(_clickY) > 1 && _clickY[0] == _clickY[1] &&
+					time.Now().Sub(_prevDownTime) < doubleClickDuration {
+					double = true
+				}
+				return Event{Mouse, 0, &MouseEvent{y, x, 0, false, double, mod}}
+			} else if (me.bstate&0x8000000) > 0 || (me.bstate&0x80) > 0 {
+				return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, mod}}
+			} else if (me.bstate & C.BUTTON4_PRESSED) > 0 {
+				return Event{Mouse, 0, &MouseEvent{y, x, 1, false, false, mod}}
+			}
+		}
+		return Event{Invalid, 0, nil}
+	case C.KEY_RESIZE:
+		return Event{Resize, 0, nil}
+	case ESC:
+		return escSequence()
+	case 127:
+		return Event{BSpace, 0, nil}
+	}
+	// CTRL-A ~ CTRL-Z
+	if c >= CtrlA && c <= CtrlZ {
+		return Event{int(c), 0, nil}
+	}
+
+	// Multi-byte character
+	buffer := []byte{byte(c)}
+	for {
+		r, _ := utf8.DecodeRune(buffer)
+		if r != utf8.RuneError {
+			return Event{Rune, r, nil}
+		}
+
+		c := C.getch()
+		if c == C.ERR {
+			break
+		}
+		if c >= C.KEY_CODE_YES {
+			C.ungetch(c)
+			break
+		}
+		buffer = append(buffer, byte(c))
+	}
+	return Event{Invalid, 0, nil}
+}

src/tui/tcell.go

@@ -0,0 +1,580 @@
+// +build tcell windows
+
+package tui
+
+import (
+	"time"
+	"unicode/utf8"
+
+	"fmt"
+	"os"
+
+	"runtime"
+
+	// https://github.com/gdamore/tcell/pull/135
+	"github.com/junegunn/tcell"
+	"github.com/junegunn/tcell/encoding"
+
+	"github.com/junegunn/go-runewidth"
+)
+
+type ColorPair [2]Color
+
+func (p ColorPair) fg() Color {
+	return p[0]
+}
+
+func (p ColorPair) bg() Color {
+	return p[1]
+}
+
+func (p ColorPair) style() tcell.Style {
+	style := tcell.StyleDefault
+	return style.Foreground(tcell.Color(p.fg())).Background(tcell.Color(p.bg()))
+}
+
+type Attr tcell.Style
+
+type WindowTcell struct {
+	LastX      int
+	LastY      int
+	MoveCursor bool
+	Border     bool
+}
+type WindowImpl WindowTcell
+
+const (
+	Bold      Attr = Attr(tcell.AttrBold)
+	Dim            = Attr(tcell.AttrDim)
+	Blink          = Attr(tcell.AttrBlink)
+	Reverse        = Attr(tcell.AttrReverse)
+	Underline      = Attr(tcell.AttrUnderline)
+	Italic         = Attr(tcell.AttrNone) // Not supported
+)
+
+const (
+	AttrRegular Attr = 0
+)
+
+var (
+	ColDefault      = ColorPair{colDefault, colDefault}
+	ColNormal       ColorPair
+	ColPrompt       ColorPair
+	ColMatch        ColorPair
+	ColCurrent      ColorPair
+	ColCurrentMatch ColorPair
+	ColSpinner      ColorPair
+	ColInfo         ColorPair
+	ColCursor       ColorPair
+	ColSelected     ColorPair
+	ColHeader       ColorPair
+	ColBorder       ColorPair
+	ColUser         ColorPair
+)
+
+func DefaultTheme() *ColorTheme {
+	if _screen.Colors() >= 256 {
+		return Dark256
+	}
+	return Default16
+}
+
+func PairFor(fg Color, bg Color) ColorPair {
+	return [2]Color{fg, bg}
+}
+
+var (
+	_colorToAttribute = []tcell.Color{
+		tcell.ColorBlack,
+		tcell.ColorRed,
+		tcell.ColorGreen,
+		tcell.ColorYellow,
+		tcell.ColorBlue,
+		tcell.ColorDarkMagenta,
+		tcell.ColorLightCyan,
+		tcell.ColorWhite,
+	}
+)
+
+func (c Color) Style() tcell.Color {
+	if c <= colDefault {
+		return tcell.ColorDefault
+	} else if c >= colBlack && c <= colWhite {
+		return _colorToAttribute[int(c)]
+	} else {
+		return tcell.Color(c)
+	}
+}
+
+func (a Attr) Merge(b Attr) Attr {
+	return a | b
+}
+
+var (
+	_screen tcell.Screen
+	_mouse  bool
+)
+
+func initScreen() {
+	s, e := tcell.NewScreen()
+	if e != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", e)
+		os.Exit(2)
+	}
+	if e = s.Init(); e != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", e)
+		os.Exit(2)
+	}
+	if _mouse {
+		s.EnableMouse()
+	} else {
+		s.DisableMouse()
+	}
+	_screen = s
+}
+
+func Init(theme *ColorTheme, black bool, mouse bool) {
+	encoding.Register()
+
+	_mouse = mouse
+	initScreen()
+
+	_color = theme != nil
+	if _color {
+		InitTheme(theme, black)
+	} else {
+		theme = DefaultTheme()
+	}
+	ColNormal = ColorPair{theme.Fg, theme.Bg}
+	ColPrompt = ColorPair{theme.Prompt, theme.Bg}
+	ColMatch = ColorPair{theme.Match, theme.Bg}
+	ColCurrent = ColorPair{theme.Current, theme.DarkBg}
+	ColCurrentMatch = ColorPair{theme.CurrentMatch, theme.DarkBg}
+	ColSpinner = ColorPair{theme.Spinner, theme.Bg}
+	ColInfo = ColorPair{theme.Info, theme.Bg}
+	ColCursor = ColorPair{theme.Cursor, theme.DarkBg}
+	ColSelected = ColorPair{theme.Selected, theme.DarkBg}
+	ColHeader = ColorPair{theme.Header, theme.Bg}
+	ColBorder = ColorPair{theme.Border, theme.Bg}
+}
+
+func MaxX() int {
+	ncols, _ := _screen.Size()
+	return int(ncols)
+}
+
+func MaxY() int {
+	_, nlines := _screen.Size()
+	return int(nlines)
+}
+
+func (w *Window) win() *WindowTcell {
+	return (*WindowTcell)(w.impl)
+}
+
+func Clear() {
+	_screen.Sync()
+	_screen.Clear()
+}
+
+func Refresh() {
+	// noop
+}
+
+func GetChar() Event {
+	ev := _screen.PollEvent()
+	switch ev := ev.(type) {
+	case *tcell.EventResize:
+		return Event{Resize, 0, nil}
+
+	// process mouse events:
+	case *tcell.EventMouse:
+		x, y := ev.Position()
+		button := ev.Buttons()
+		mod := ev.Modifiers() != 0
+		if button&tcell.WheelDown != 0 {
+			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, mod}}
+		} else if button&tcell.WheelUp != 0 {
+			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, mod}}
+		} else if runtime.GOOS != "windows" {
+			// double and single taps on Windows don't quite work due to
+			// the console acting on the events and not allowing us
+			// to consume them.
+
+			down := button&tcell.Button1 != 0 // left
+			double := false
+			if down {
+				now := time.Now()
+				if now.Sub(_prevDownTime) < doubleClickDuration {
+					_clickY = append(_clickY, x)
+				} else {
+					_clickY = []int{x}
+					_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}}
+		}
+
+		// process keyboard:
+	case *tcell.EventKey:
+		alt := (ev.Modifiers() & tcell.ModAlt) > 0
+		switch ev.Key() {
+		case tcell.KeyCtrlA:
+			return Event{CtrlA, 0, nil}
+		case tcell.KeyCtrlB:
+			return Event{CtrlB, 0, nil}
+		case tcell.KeyCtrlC:
+			return Event{CtrlC, 0, nil}
+		case tcell.KeyCtrlD:
+			return Event{CtrlD, 0, nil}
+		case tcell.KeyCtrlE:
+			return Event{CtrlE, 0, nil}
+		case tcell.KeyCtrlF:
+			return Event{CtrlF, 0, nil}
+		case tcell.KeyCtrlG:
+			return Event{CtrlG, 0, nil}
+		case tcell.KeyCtrlJ:
+			return Event{CtrlJ, 0, nil}
+		case tcell.KeyCtrlK:
+			return Event{CtrlK, 0, nil}
+		case tcell.KeyCtrlL:
+			return Event{CtrlL, 0, nil}
+		case tcell.KeyCtrlM:
+			if alt {
+				return Event{AltEnter, 0, nil}
+			}
+			return Event{CtrlM, 0, nil}
+		case tcell.KeyCtrlN:
+			return Event{CtrlN, 0, nil}
+		case tcell.KeyCtrlO:
+			return Event{CtrlO, 0, nil}
+		case tcell.KeyCtrlP:
+			return Event{CtrlP, 0, nil}
+		case tcell.KeyCtrlQ:
+			return Event{CtrlQ, 0, nil}
+		case tcell.KeyCtrlR:
+			return Event{CtrlR, 0, nil}
+		case tcell.KeyCtrlS:
+			return Event{CtrlS, 0, nil}
+		case tcell.KeyCtrlT:
+			return Event{CtrlT, 0, nil}
+		case tcell.KeyCtrlU:
+			return Event{CtrlU, 0, nil}
+		case tcell.KeyCtrlV:
+			return Event{CtrlV, 0, nil}
+		case tcell.KeyCtrlW:
+			return Event{CtrlW, 0, nil}
+		case tcell.KeyCtrlX:
+			return Event{CtrlX, 0, nil}
+		case tcell.KeyCtrlY:
+			return Event{CtrlY, 0, nil}
+		case tcell.KeyCtrlZ:
+			return Event{CtrlZ, 0, nil}
+		case tcell.KeyBackspace, tcell.KeyBackspace2:
+			if alt {
+				return Event{AltBS, 0, nil}
+			}
+			return Event{BSpace, 0, nil}
+
+		case tcell.KeyUp:
+			return Event{Up, 0, nil}
+		case tcell.KeyDown:
+			return Event{Down, 0, nil}
+		case tcell.KeyLeft:
+			return Event{Left, 0, nil}
+		case tcell.KeyRight:
+			return Event{Right, 0, nil}
+
+		case tcell.KeyHome:
+			return Event{Home, 0, nil}
+		case tcell.KeyDelete:
+			return Event{Del, 0, nil}
+		case tcell.KeyEnd:
+			return Event{End, 0, nil}
+		case tcell.KeyPgUp:
+			return Event{PgUp, 0, nil}
+		case tcell.KeyPgDn:
+			return Event{PgDn, 0, nil}
+
+		case tcell.KeyTab:
+			return Event{Tab, 0, nil}
+		case tcell.KeyBacktab:
+			return Event{BTab, 0, nil}
+
+		case tcell.KeyF1:
+			return Event{F1, 0, nil}
+		case tcell.KeyF2:
+			return Event{F2, 0, nil}
+		case tcell.KeyF3:
+			return Event{F3, 0, nil}
+		case tcell.KeyF4:
+			return Event{F4, 0, nil}
+		case tcell.KeyF5:
+			return Event{F5, 0, nil}
+		case tcell.KeyF6:
+			return Event{F6, 0, nil}
+		case tcell.KeyF7:
+			return Event{F7, 0, nil}
+		case tcell.KeyF8:
+			return Event{F8, 0, nil}
+		case tcell.KeyF9:
+			return Event{F9, 0, nil}
+		case tcell.KeyF10:
+			return Event{F10, 0, nil}
+		case tcell.KeyF11:
+			return Event{F11, 0, nil}
+		case tcell.KeyF12:
+			return Event{F12, 0, nil}
+
+		// ev.Ch doesn't work for some reason for space:
+		case tcell.KeyRune:
+			r := ev.Rune()
+			if alt {
+				switch r {
+				case ' ':
+					return Event{AltSpace, 0, nil}
+				case '/':
+					return Event{AltSlash, 0, nil}
+				}
+				if r >= 'a' && r <= 'z' {
+					return Event{AltA + int(r) - 'a', 0, nil}
+				}
+				if r >= '0' && r <= '9' {
+					return Event{Alt0 + int(r) - '0', 0, nil}
+				}
+			}
+			return Event{Rune, r, nil}
+
+		case tcell.KeyEsc:
+			return Event{ESC, 0, nil}
+
+		}
+	}
+
+	return Event{Invalid, 0, nil}
+}
+
+func Pause() {
+	_screen.Fini()
+}
+
+func Resume() bool {
+	initScreen()
+	return true
+}
+
+func Close() {
+	_screen.Fini()
+}
+
+func RefreshWindows(windows []*Window) {
+	// TODO
+	for _, w := range windows {
+		if w.win().MoveCursor {
+			_screen.ShowCursor(w.Left+w.win().LastX, w.Top+w.win().LastY)
+			w.win().MoveCursor = false
+		}
+		w.win().LastX = 0
+		w.win().LastY = 0
+		if w.win().Border {
+			w.DrawBorder()
+		}
+	}
+	_screen.Show()
+}
+
+func NewWindow(top int, left int, width int, height int, border bool) *Window {
+	// TODO
+	win := new(WindowTcell)
+	win.Border = border
+	return &Window{
+		impl:   (*WindowImpl)(win),
+		Top:    top,
+		Left:   left,
+		Width:  width,
+		Height: height,
+	}
+}
+
+func (w *Window) Close() {
+	// TODO
+}
+
+func fill(x, y, w, h int, r rune) {
+	for ly := 0; ly <= h; ly++ {
+		for lx := 0; lx <= w; lx++ {
+			_screen.SetContent(x+lx, y+ly, r, nil, ColDefault.style())
+		}
+	}
+}
+
+func (w *Window) Erase() {
+	// TODO
+	fill(w.Left, w.Top, w.Width, w.Height, ' ')
+}
+
+func (w *Window) Enclose(y int, x int) bool {
+	return x >= w.Left && x <= (w.Left+w.Width) &&
+		y >= w.Top && y <= (w.Top+w.Height)
+}
+
+func (w *Window) Move(y int, x int) {
+	w.win().LastX = x
+	w.win().LastY = y
+	w.win().MoveCursor = true
+}
+
+func (w *Window) MoveAndClear(y int, x int) {
+	w.Move(y, x)
+	for i := w.win().LastX; i < w.Width; i++ {
+		_screen.SetContent(i+w.Left, w.win().LastY+w.Top, rune(' '), nil, ColDefault.style())
+	}
+	w.win().LastX = x
+}
+
+func (w *Window) Print(text string) {
+	w.PrintString(text, ColDefault, 0)
+}
+
+func (w *Window) PrintString(text string, pair ColorPair, a Attr) {
+	t := text
+	lx := 0
+
+	var style tcell.Style
+	if _color {
+		style = pair.style().
+			Reverse(a&Attr(tcell.AttrReverse) != 0).
+			Underline(a&Attr(tcell.AttrUnderline) != 0)
+	} else {
+		style = ColDefault.style().
+			Reverse(a&Attr(tcell.AttrReverse) != 0 || pair == ColCurrent || pair == ColCurrentMatch).
+			Underline(a&Attr(tcell.AttrUnderline) != 0 || pair == ColMatch || pair == ColCurrentMatch)
+	}
+	style = style.
+		Blink(a&Attr(tcell.AttrBlink) != 0).
+		Bold(a&Attr(tcell.AttrBold) != 0).
+		Dim(a&Attr(tcell.AttrDim) != 0)
+
+	for {
+		if len(t) == 0 {
+			break
+		}
+		r, size := utf8.DecodeRuneInString(t)
+		t = t[size:]
+
+		if r < rune(' ') { // ignore control characters
+			continue
+		}
+
+		if r == '\n' {
+			w.win().LastY++
+			lx = 0
+		} else {
+
+			if r == '\u000D' { // skip carriage return
+				continue
+			}
+
+			var xPos = w.Left + w.win().LastX + lx
+			var yPos = w.Top + w.win().LastY
+			if xPos < (w.Left+w.Width) && yPos < (w.Top+w.Height) {
+				_screen.SetContent(xPos, yPos, r, nil, style)
+			}
+			lx += runewidth.RuneWidth(r)
+		}
+	}
+	w.win().LastX += lx
+}
+
+func (w *Window) CPrint(pair ColorPair, a Attr, text string) {
+	w.PrintString(text, pair, a)
+}
+
+func (w *Window) FillString(text string, pair ColorPair, a Attr) bool {
+	lx := 0
+
+	var style tcell.Style
+	if _color {
+		style = pair.style()
+	} else {
+		style = ColDefault.style()
+	}
+	style = style.
+		Blink(a&Attr(tcell.AttrBlink) != 0).
+		Bold(a&Attr(tcell.AttrBold) != 0).
+		Dim(a&Attr(tcell.AttrDim) != 0).
+		Reverse(a&Attr(tcell.AttrReverse) != 0).
+		Underline(a&Attr(tcell.AttrUnderline) != 0)
+
+	for _, r := range text {
+		if r == '\n' {
+			w.win().LastY++
+			w.win().LastX = 0
+			lx = 0
+		} else {
+			var xPos = w.Left + w.win().LastX + lx
+
+			// word wrap:
+			if xPos > (w.Left + w.Width) {
+				w.win().LastY++
+				w.win().LastX = 0
+				lx = 0
+				xPos = w.Left
+			}
+			var yPos = w.Top + w.win().LastY
+
+			if yPos >= (w.Top + w.Height) {
+				return false
+			}
+
+			_screen.SetContent(xPos, yPos, r, nil, style)
+			lx += runewidth.RuneWidth(r)
+		}
+	}
+	w.win().LastX += lx
+
+	return true
+}
+
+func (w *Window) Fill(str string) bool {
+	return w.FillString(str, ColDefault, 0)
+}
+
+func (w *Window) CFill(str string, fg Color, bg Color, a Attr) bool {
+	return w.FillString(str, ColorPair{fg, bg}, a)
+}
+
+func (w *Window) DrawBorder() {
+	left := w.Left
+	right := left + w.Width
+	top := w.Top
+	bot := top + w.Height
+
+	var style tcell.Style
+	if _color {
+		style = ColBorder.style()
+	} else {
+		style = ColDefault.style()
+	}
+
+	for x := left; x < right; x++ {
+		_screen.SetContent(x, top, tcell.RuneHLine, nil, style)
+		_screen.SetContent(x, bot-1, tcell.RuneHLine, nil, style)
+	}
+
+	for y := top; y < bot; y++ {
+		_screen.SetContent(left, y, tcell.RuneVLine, nil, style)
+		_screen.SetContent(right-1, y, tcell.RuneVLine, nil, style)
+	}
+
+	_screen.SetContent(left, top, tcell.RuneULCorner, nil, style)
+	_screen.SetContent(right-1, top, tcell.RuneURCorner, nil, style)
+	_screen.SetContent(left, bot-1, tcell.RuneLLCorner, nil, style)
+	_screen.SetContent(right-1, bot-1, tcell.RuneLRCorner, nil, style)
+}

src/tui/tui.go

@@ -0,0 +1,260 @@
+package tui
+
+import (
+	"time"
+)
+
+// 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
+	Resize
+	Mouse
+	DoubleClick
+
+	BTab
+	BSpace
+
+	Del
+	PgUp
+	PgDn
+
+	Up
+	Down
+	Left
+	Right
+	Home
+	End
+
+	SLeft
+	SRight
+
+	F1
+	F2
+	F3
+	F4
+	F5
+	F6
+	F7
+	F8
+	F9
+	F10
+	F11
+	F12
+
+	AltEnter
+	AltSpace
+	AltSlash
+	AltBS
+
+	Alt0
+)
+
+const ( // Reset iota
+	AltA = Alt0 + 'a' - '0' + iota
+	AltB
+	AltC
+	AltD
+	AltE
+	AltF
+	AltZ = AltA + 'z' - 'a'
+)
+
+const (
+	doubleClickDuration = 500 * time.Millisecond
+)
+
+type Color int32
+
+func (c Color) is24() bool {
+	return c > 0 && (c&(1<<24)) > 0
+}
+
+const (
+	colUndefined Color = -2
+	colDefault         = -1
+)
+
+const (
+	colBlack Color = iota
+	colRed
+	colGreen
+	colYellow
+	colBlue
+	colMagenta
+	colCyan
+	colWhite
+)
+
+type ColorTheme struct {
+	Fg           Color
+	Bg           Color
+	DarkBg       Color
+	Prompt       Color
+	Match        Color
+	Current      Color
+	CurrentMatch Color
+	Spinner      Color
+	Info         Color
+	Cursor       Color
+	Selected     Color
+	Header       Color
+	Border       Color
+}
+
+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 (
+	_color        bool
+	_prevDownTime time.Time
+	_clickY       []int
+	Default16     *ColorTheme
+	Dark256       *ColorTheme
+	Light256      *ColorTheme
+)
+
+type Window struct {
+	impl   *WindowImpl
+	Top    int
+	Left   int
+	Width  int
+	Height int
+}
+
+func EmptyTheme() *ColorTheme {
+	return &ColorTheme{
+		Fg:           colUndefined,
+		Bg:           colUndefined,
+		DarkBg:       colUndefined,
+		Prompt:       colUndefined,
+		Match:        colUndefined,
+		Current:      colUndefined,
+		CurrentMatch: colUndefined,
+		Spinner:      colUndefined,
+		Info:         colUndefined,
+		Cursor:       colUndefined,
+		Selected:     colUndefined,
+		Header:       colUndefined,
+		Border:       colUndefined}
+}
+
+func init() {
+	_prevDownTime = time.Unix(0, 0)
+	_clickY = []int{}
+	Default16 = &ColorTheme{
+		Fg:           colDefault,
+		Bg:           colDefault,
+		DarkBg:       colBlack,
+		Prompt:       colBlue,
+		Match:        colGreen,
+		Current:      colYellow,
+		CurrentMatch: colGreen,
+		Spinner:      colGreen,
+		Info:         colWhite,
+		Cursor:       colRed,
+		Selected:     colMagenta,
+		Header:       colCyan,
+		Border:       colBlack}
+	Dark256 = &ColorTheme{
+		Fg:           colDefault,
+		Bg:           colDefault,
+		DarkBg:       236,
+		Prompt:       110,
+		Match:        108,
+		Current:      254,
+		CurrentMatch: 151,
+		Spinner:      148,
+		Info:         144,
+		Cursor:       161,
+		Selected:     168,
+		Header:       109,
+		Border:       59}
+	Light256 = &ColorTheme{
+		Fg:           colDefault,
+		Bg:           colDefault,
+		DarkBg:       251,
+		Prompt:       25,
+		Match:        66,
+		Current:      237,
+		CurrentMatch: 23,
+		Spinner:      65,
+		Info:         101,
+		Cursor:       161,
+		Selected:     168,
+		Header:       31,
+		Border:       145}
+}
+
+func InitTheme(theme *ColorTheme, black bool) {
+	_color = theme != nil
+	if !_color {
+		return
+	}
+
+	baseTheme := DefaultTheme()
+	if black {
+		theme.Bg = colBlack
+	}
+
+	o := func(a Color, b Color) Color {
+		if b == colUndefined {
+			return a
+		}
+		return b
+	}
+	theme.Fg = o(baseTheme.Fg, theme.Fg)
+	theme.Bg = o(baseTheme.Bg, theme.Bg)
+	theme.DarkBg = o(baseTheme.DarkBg, theme.DarkBg)
+	theme.Prompt = o(baseTheme.Prompt, theme.Prompt)
+	theme.Match = o(baseTheme.Match, theme.Match)
+	theme.Current = o(baseTheme.Current, theme.Current)
+	theme.CurrentMatch = o(baseTheme.CurrentMatch, theme.CurrentMatch)
+	theme.Spinner = o(baseTheme.Spinner, theme.Spinner)
+	theme.Info = o(baseTheme.Info, theme.Info)
+	theme.Cursor = o(baseTheme.Cursor, theme.Cursor)
+	theme.Selected = o(baseTheme.Selected, theme.Selected)
+	theme.Header = o(baseTheme.Header, theme.Header)
+	theme.Border = o(baseTheme.Border, theme.Border)
+}

src/tui/tui_test.go

@@ -1,4 +1,4 @@
-package curses
+package tui
 
 import (
 	"testing"

src/update_assets.rb

@@ -2,6 +2,7 @@
 
 # http://www.rubydoc.info/github/rest-client/rest-client/RestClient
 require 'rest_client'
+require 'json'
 
 if ARGV.length < 3
   puts "usage: #$0 <token> <version> <files...>"

src/util/chars.go

@@ -1,6 +1,7 @@
 package util
 
 import (
+	"unicode"
 	"unicode/utf8"
 )
 
@@ -63,7 +64,7 @@ func (chars *Chars) TrimLength() int {
 	len := chars.Length()
 	for i = len - 1; i >= 0; i-- {
 		char := chars.Get(i)
-		if char != ' ' && char != '\t' {
+		if !unicode.IsSpace(char) {
 			break
 		}
 	}
@@ -75,7 +76,7 @@ func (chars *Chars) TrimLength() int {
 	var j int
 	for j = 0; j < len; j++ {
 		char := chars.Get(j)
-		if char != ' ' && char != '\t' {
+		if !unicode.IsSpace(char) {
 			break
 		}
 	}
@@ -86,7 +87,7 @@ func (chars *Chars) TrailingWhitespaces() int {
 	whitespaces := 0
 	for i := chars.Length() - 1; i >= 0; i-- {
 		char := chars.Get(i)
-		if char != ' ' && char != '\t' {
+		if !unicode.IsSpace(char) {
 			break
 		}
 		whitespaces++

src/util/slab.go

@@ -0,0 +1,12 @@
+package util
+
+type Slab struct {
+	I16 []int16
+	I32 []int32
+}
+
+func MakeSlab(size16 int, size32 int) *Slab {
+	return &Slab{
+		I16: make([]int16, size16),
+		I32: make([]int32, size32)}
+}

src/util/util.go

@@ -1,12 +1,11 @@
 package util
 
-// #include <unistd.h>
-import "C"
-
 import (
+	"math"
 	"os"
-	"os/exec"
 	"time"
+
+	"github.com/junegunn/go-isatty"
 )
 
 // Max returns the largest integer
@@ -17,6 +16,22 @@ func Max(first int, second int) int {
 	return second
 }
 
+// Max16 returns the largest integer
+func Max16(first int16, second int16) int16 {
+	if first >= second {
+		return first
+	}
+	return second
+}
+
+// Max32 returns the largest 32-bit integer
+func Max32(first int32, second int32) int32 {
+	if first > second {
+		return first
+	}
+	return second
+}
+
 // Min returns the smallest integer
 func Min(first int, second int) int {
 	if first <= second {
@@ -33,14 +48,6 @@ func Min32(first int32, second int32) int32 {
 	return second
 }
 
-// Max32 returns the largest 32-bit integer
-func Max32(first int32, second int32) int32 {
-	if first > second {
-		return first
-	}
-	return second
-}
-
 // Constrain32 limits the given 32-bit integer with the upper and lower bounds
 func Constrain32(val int32, min int32, max int32) int32 {
 	if val < min {
@@ -63,6 +70,15 @@ func Constrain(val int, min int, max int) int {
 	return val
 }
 
+func AsUint16(val int) uint16 {
+	if val > math.MaxUint16 {
+		return math.MaxUint16
+	} else if val < 0 {
+		return 0
+	}
+	return uint16(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 {
@@ -77,14 +93,5 @@ func DurWithin(
 
 // IsTty returns true is stdin is a terminal
 func IsTty() bool {
-	return int(C.isatty(C.int(os.Stdin.Fd()))) != 0
-}
-
-// ExecCommand executes the given command with $SHELL
-func ExecCommand(command string) *exec.Cmd {
-	shell := os.Getenv("SHELL")
-	if len(shell) == 0 {
-		shell = "sh"
-	}
-	return exec.Command(shell, "-c", command)
+	return isatty.IsTerminal(os.Stdin.Fd())
 }

src/util/util_unix.go

@@ -0,0 +1,22 @@
+// +build !windows
+
+package util
+
+import (
+	"os"
+	"os/exec"
+)
+
+// ExecCommand executes the given command with $SHELL
+func ExecCommand(command string) *exec.Cmd {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "sh"
+	}
+	return exec.Command(shell, "-c", command)
+}
+
+// IsWindows returns true on Windows
+func IsWindows() bool {
+	return false
+}

src/util/util_windows.go

@@ -0,0 +1,28 @@
+// +build windows
+
+package util
+
+import (
+	"os"
+	"os/exec"
+
+	"github.com/junegunn/go-shellwords"
+)
+
+// ExecCommand executes the given command with $SHELL
+func ExecCommand(command string) *exec.Cmd {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "cmd"
+	}
+	args, _ := shellwords.Parse(command)
+	allArgs := make([]string, len(args)+1)
+	allArgs[0] = "/c"
+	copy(allArgs[1:], args)
+	return exec.Command(shell, allArgs...)
+}
+
+// IsWindows returns true on Windows
+func IsWindows() bool {
+	return true
+}

test/fzf.vader

@@ -143,6 +143,10 @@ Execute (fzf#wrap):
   Assert opts.options =~ '--history /tmp/foobar'
   Assert opts.options =~ '--color light'
 
+  let g:fzf_colors = { 'fg': ['fg', 'Error'] }
+  let opts = fzf#wrap({})
+  Assert opts.options =~ '^--color=fg:'
+
 Execute (Cleanup):
   unlet g:dir
   Restore

test/test_go.rb

@@ -136,8 +136,10 @@ class Tmux
   def prepare
     tries = 0
     begin
-      self.send_keys 'C-u', 'hello', 'Right'
-      self.until { |lines| lines[-1].end_with?('hello') }
+      self.until do |lines|
+        self.send_keys 'C-u', 'hello'
+        lines[-1].end_with?('hello')
+      end
     rescue Exception
       (tries += 1) < 5 ? retry : raise
     end
@@ -452,6 +454,15 @@ class TestGoFZF < TestBase
     assert_equal ['55', 'alt-z', '55'], readonce.split($/)
   end
 
+  def test_expect_printable_character_print_query
+    tmux.send_keys "seq 1 100 | #{fzf '--expect=z --print-query'}", :Enter
+    tmux.until { |lines| lines[-2].include? '100/100' }
+    tmux.send_keys '55'
+    tmux.until { |lines| lines[-2].include? '1/100' }
+    tmux.send_keys 'z'
+    assert_equal ['55', 'z', '55'], readonce.split($/)
+  end
+
   def test_expect_print_query_select_1
     tmux.send_keys "seq 1 100 | #{fzf '-q55 -1 --expect=alt-z --print-query'}", :Enter
     assert_equal ['55', '', '55'], readonce.split($/)
@@ -517,162 +528,91 @@ class TestGoFZF < TestBase
     assert_equal input, `#{FZF} -f"!z" -x --tiebreak end < #{tempname}`.split($/)
   end
 
-  # Since 0.11.2
-  def test_tiebreak_list
-    input = %w[
-      f-o-o-b-a-r
-      foobar----
-      --foobar
-      ----foobar
-      foobar--
-      --foobar--
-      foobar
+  def test_tiebreak_index_begin
+    writelines tempname, [
+      'xoxxxxxoxx',
+      'xoxxxxxox',
+      'xxoxxxoxx',
+      'xxxoxoxxx',
+      'xxxxoxox',
+      '  xxoxoxxx',
     ]
-    writelines tempname, input
 
-    assert_equal %w[
-      foobar----
-      --foobar
-      ----foobar
-      foobar--
-      --foobar--
-      foobar
-      f-o-o-b-a-r
-    ], `#{FZF} -ffb --tiebreak=index < #{tempname}`.split($/)
+    assert_equal [
+      'xxxxoxox',
+      '  xxoxoxxx',
+      'xxxoxoxxx',
+      'xxoxxxoxx',
+      'xoxxxxxox',
+      'xoxxxxxoxx',
+    ], `#{FZF} -foo < #{tempname}`.split($/)
 
-    by_length = %w[
-      foobar
-      --foobar
-      foobar--
-      foobar----
-      ----foobar
-      --foobar--
-      f-o-o-b-a-r
-    ]
-    assert_equal by_length, `#{FZF} -ffb < #{tempname}`.split($/)
-    assert_equal by_length, `#{FZF} -ffb --tiebreak=length < #{tempname}`.split($/)
+    assert_equal [
+      'xxxoxoxxx',
+      'xxxxoxox',
+      '  xxoxoxxx',
+      'xxoxxxoxx',
+      'xoxxxxxoxx',
+      'xoxxxxxox',
+    ], `#{FZF} -foo --tiebreak=index < #{tempname}`.split($/)
 
-    assert_equal %w[
-      foobar
-      foobar--
-      --foobar
-      foobar----
-      --foobar--
-      ----foobar
-      f-o-o-b-a-r
-    ], `#{FZF} -ffb --tiebreak=length,begin < #{tempname}`.split($/)
+    # Note that --tiebreak=begin is now based on the first occurrence of the
+    # first character on the pattern
+    assert_equal [
+      '  xxoxoxxx',
+      'xxxoxoxxx',
+      'xxxxoxox',
+      'xxoxxxoxx',
+      'xoxxxxxoxx',
+      'xoxxxxxox',
+    ], `#{FZF} -foo --tiebreak=begin < #{tempname}`.split($/)
 
-    assert_equal %w[
-      foobar
-      --foobar
-      foobar--
-      ----foobar
-      --foobar--
-      foobar----
-      f-o-o-b-a-r
-    ], `#{FZF} -ffb --tiebreak=length,end < #{tempname}`.split($/)
-
-    assert_equal %w[
-      foobar----
-      foobar--
-      foobar
-      --foobar
-      --foobar--
-      ----foobar
-      f-o-o-b-a-r
-    ], `#{FZF} -ffb --tiebreak=begin < #{tempname}`.split($/)
-
-    by_begin_end = %w[
-      foobar
-      foobar--
-      foobar----
-      --foobar
-      --foobar--
-      ----foobar
-      f-o-o-b-a-r
-    ]
-    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=begin,length < #{tempname}`.split($/)
-    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=begin,end < #{tempname}`.split($/)
-
-    assert_equal %w[
-      --foobar
-      ----foobar
-      foobar
-      foobar--
-      --foobar--
-      foobar----
-      f-o-o-b-a-r
-    ], `#{FZF} -ffb --tiebreak=end < #{tempname}`.split($/)
-
-    by_begin_end = %w[
-      foobar
-      --foobar
-      ----foobar
-      foobar--
-      --foobar--
-      foobar----
-      f-o-o-b-a-r
-    ]
-    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=end,begin < #{tempname}`.split($/)
-    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=end,length < #{tempname}`.split($/)
+    assert_equal [
+      '  xxoxoxxx',
+      'xxxoxoxxx',
+      'xxxxoxox',
+      'xxoxxxoxx',
+      'xoxxxxxox',
+      'xoxxxxxoxx',
+    ], `#{FZF} -foo --tiebreak=begin,length < #{tempname}`.split($/)
   end
 
-  def test_tiebreak_white_prefix
+  def test_tiebreak_end
     writelines tempname, [
-      'f o o b a r',
-      '    foo bar',
-      '    foobar',
-      '----foo bar',
-      '----foobar',
-      '  foo bar',
-      '  foobar--',
-      '  foobar',
-      '--foo bar',
-      '--foobar',
-      'foobar',
+      'xoxxxxxxxx',
+      'xxoxxxxxxx',
+      'xxxoxxxxxx',
+      'xxxxoxxxx',
+      'xxxxxoxxx',
+      '  xxxxoxxx',
     ]
 
     assert_equal [
-      '    foobar',
-      '  foobar',
-      'foobar',
-      '  foobar--',
-      '--foobar',
-      '----foobar',
-      '    foo bar',
-      '  foo bar',
-      '--foo bar',
-      '----foo bar',
-      'f o o b a r',
-    ], `#{FZF} -ffb < #{tempname}`.split($/)
+      '  xxxxoxxx',
+      'xxxxoxxxx',
+      'xxxxxoxxx',
+      'xoxxxxxxxx',
+      'xxoxxxxxxx',
+      'xxxoxxxxxx',
+    ], `#{FZF} -fo < #{tempname}`.split($/)
 
     assert_equal [
-      '    foobar',
-      '  foobar--',
-      '  foobar',
-      'foobar',
-      '--foobar',
-      '----foobar',
-      '    foo bar',
-      '  foo bar',
-      '--foo bar',
-      '----foo bar',
-      'f o o b a r',
-    ], `#{FZF} -ffb --tiebreak=begin < #{tempname}`.split($/)
+      'xxxxxoxxx',
+      '  xxxxoxxx',
+      'xxxxoxxxx',
+      'xxxoxxxxxx',
+      'xxoxxxxxxx',
+      'xoxxxxxxxx',
+    ], `#{FZF} -fo --tiebreak=end < #{tempname}`.split($/)
 
     assert_equal [
-      '    foobar',
-      '  foobar',
-      'foobar',
-      '  foobar--',
-      '--foobar',
-      '----foobar',
-      '    foo bar',
-      '  foo bar',
-      '--foo bar',
-      '----foo bar',
-      'f o o b a r',
-    ], `#{FZF} -ffb --tiebreak=begin,length < #{tempname}`.split($/)
+      'xxxxxoxxx',
+      '  xxxxoxxx',
+      'xxxxoxxxx',
+      'xxxoxxxxxx',
+      'xxoxxxxxxx',
+      'xoxxxxxxxx',
+    ], `#{FZF} -fo --tiebreak=end,length,begin < #{tempname}`.split($/)
   end
 
   def test_tiebreak_length_with_nth
@@ -748,17 +688,6 @@ class TestGoFZF < TestBase
     assert_equal output, `#{FZF} -fi -n2,1..2 < #{tempname}`.split($/)
   end
 
-  def test_tiebreak_end_backward_scan
-    input = %w[
-      foobar-fb
-      fubar
-    ]
-    writelines tempname, input
-
-    assert_equal input.reverse, `#{FZF} -f fb < #{tempname}`.split($/)
-    assert_equal input, `#{FZF} -f fb --tiebreak=end < #{tempname}`.split($/)
-  end
-
   def test_invalid_cache
     tmux.send_keys "(echo d; echo D; echo x) | #{fzf '-q d'}", :Enter
     tmux.until { |lines| lines[-2].include? '2/3' }
@@ -1129,7 +1058,7 @@ class TestGoFZF < TestBase
   def test_invalid_term
     lines = `TERM=xxx #{FZF}`
     assert_equal 2, $?.exitstatus
-    assert lines.include?('Invalid $TERM: xxx')
+    assert lines.include?('Invalid $TERM: xxx') || lines.include?('terminal entry not found')
   end
 
   def test_invalid_option
@@ -1324,24 +1253,29 @@ module TestShell
     tmux.send_keys 'cat ', 'C-t', pane: 0
     tmux.until(1) { |lines| lines.item_count >= 1 }
     tmux.send_keys 'fzf-unicode', pane: 1
-    tmux.until(1) { |lines| lines[-2].start_with? '  2/' }
+    redraw = ->() { tmux.send_keys 'C-l', pane: 1 }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *2/) }
 
     tmux.send_keys '1', pane: 1
-    tmux.until(1) { |lines| lines[-2].start_with? '  1/' }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *1/) }
     tmux.send_keys :BTab, pane: 1
-    tmux.until(1) { |lines| lines[-2].include? '(1)' }
+    tmux.until(1) { |lines| redraw.(); lines[-2].include? '(1)' }
 
     tmux.send_keys :BSpace, pane: 1
-    tmux.until(1) { |lines| lines[-2].start_with? '  2/' }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *2/) }
 
     tmux.send_keys '2', pane: 1
-    tmux.until(1) { |lines| lines[-2].start_with? '  1/' }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *1/) }
     tmux.send_keys :BTab, pane: 1
-    tmux.until(1) { |lines| lines[-2].include? '(2)' }
+    tmux.until(1) { |lines| redraw.(); lines[-2].include? '(2)' }
 
     tmux.send_keys :Enter, pane: 1
-    tmux.until { |lines| lines[-1].include?('cat') || lines[-2].include?('cat') }
-    tmux.until { |lines| lines[-1].include?('fzf-unicode') || lines[-2].include?('fzf-unicode') }
+    tmux.until do |lines|
+      tmux.send_keys 'C-l'
+      [-1, -2].map { |offset| lines[offset] }.any? do |line|
+        line.start_with?('cat') && line.include?('fzf-unicode')
+      end
+    end
     tmux.send_keys :Enter
     tmux.until { |lines| lines[-1].include? 'test1test2' }
   end
@@ -1552,23 +1486,27 @@ module CompletionTest
     tmux.paste 'cd /tmp/fzf-test; echo -n test3 > "fzf-unicode 테스트1"; echo -n test4 > "fzf-unicode 테스트2"'
     tmux.prepare
     tmux.send_keys 'cat fzf-unicode**', :Tab, pane: 0
-    tmux.until(1) { |lines| lines[-2].start_with? '  2/' }
+    redraw = ->() { tmux.send_keys 'C-l', pane: 1 }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *2/) }
 
     tmux.send_keys '1', pane: 1
-    tmux.until(1) { |lines| lines[-2].start_with? '  1/' }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *1/) }
     tmux.send_keys :BTab, pane: 1
-    tmux.until(1) { |lines| lines[-2].include? '(1)' }
+    tmux.until(1) { |lines| redraw.(); lines[-2].include? '(1)' }
 
     tmux.send_keys :BSpace, pane: 1
-    tmux.until(1) { |lines| lines[-2].start_with? '  2/' }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *2/) }
 
     tmux.send_keys '2', pane: 1
-    tmux.until(1) { |lines| lines[-2].start_with? '  1/' }
+    tmux.until(1) { |lines| redraw.(); lines[-2] =~ %r(^ *1/) }
     tmux.send_keys :BTab, pane: 1
-    tmux.until(1) { |lines| lines[-2].include? '(2)' }
+    tmux.until(1) { |lines| redraw.(); lines[-2].include? '(2)' }
 
     tmux.send_keys :Enter, pane: 1
-    tmux.until { |lines| lines[-1].include?('cat') || lines[-2].include?('cat') }
+    tmux.until do |lines|
+      tmux.send_keys 'C-l'
+      lines[-1].include?('cat') || lines[-2].include?('cat')
+    end
     tmux.send_keys :Enter
     tmux.until { |lines| lines[-1].include? 'test3test4' }
   end