0.9.2

Related: 8bead4a

.travis.yml

@@ -1,10 +1,23 @@
 language: ruby
-sudo: false
-rvm:
-  - "1.8.7"
-  - "1.9.3"
-  - "2.0.0"
-  - "2.1.1"
 
-install: gem install curses minitest
+install:
+- sudo apt-get install -y libncurses-dev lib32ncurses5-dev
+- sudo add-apt-repository -y ppa:pi-rho/dev
+- sudo apt-get update
+- sudo apt-get install -y tmux=1.9a-1~ppa1~p
 
+script: |
+  export GOROOT=~/go1.4
+  export GOPATH=~/go
+  export FZF_BASE=~/go/src/github.com/junegunn/fzf
+
+  mkdir -p ~/go/src/github.com/junegunn
+  ln -s $(pwd) $FZF_BASE
+
+  curl https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | tar -xz
+  mv go $GOROOT
+
+  cd $FZF_BASE/src && make test fzf/fzf-linux_amd64 install &&
+  cd $FZF_BASE/bin && ln -sf fzf-linux_amd64 fzf-$(./fzf --version)-linux_amd64 &&
+  cd $FZF_BASE && yes | ./install &&
+  tmux new "rake test > out && touch ok" && cat out && [ -e ok ]

Rakefile

@@ -2,8 +2,11 @@ require "bundler/gem_tasks"
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |test|
-  test.pattern = 'test/**/test_*.rb'
+  test.pattern = 'test/test_go.rb'
-  test.verbose = true
+end
+
+Rake::TestTask.new(:testall) do |test|
+  test.pattern = 'test/test_*.rb'
 end
 
 task :default => :test

install

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-version=0.9.0
+version=0.9.2
 
 cd $(dirname $BASH_SOURCE)
 fzf_base=$(pwd)
@@ -16,6 +16,7 @@ check_binary() {
   local output=$("$fzf_base"/bin/fzf --version 2>&1)
   if [ "$version" = "$output" ]; then
     echo "$output"
+    binary_error=""
   else
     echo "$output != $version"
     rm -f "$fzf_base"/bin/fzf
@@ -27,18 +28,21 @@ check_binary() {
 symlink() {
   echo "  - Creating symlink: bin/$1 -> bin/fzf"
   (cd "$fzf_base"/bin &&
-   rm -f fzf
+   rm -f fzf &&
    ln -sf $1 fzf)
+  if [ $? -ne 0 ]; then
+    binary_error="Failed to create symlink"
+    return 1
+  fi
 }
 
 download() {
   echo "Downloading bin/fzf ..."
-  if [ -x "$fzf_base"/bin/fzf ]; then
+  if [[ ! $1 =~ dev && -x "$fzf_base"/bin/fzf ]]; then
     echo "  - Already exists"
     check_binary && return
   elif [ -x "$fzf_base"/bin/$1 ]; then
-    symlink $1
+    symlink $1 && check_binary && return
-    check_binary && return
   fi
   mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
   if [ $? -ne 0 ]; then

src/Dockerfile.arch

@@ -6,7 +6,7 @@ RUN pacman-db-upgrade && pacman -Syu --noconfirm base-devel git
 
 # Install Go 1.4
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz | \
+    https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
 ENV GOPATH /go

src/Dockerfile.centos

@@ -6,7 +6,7 @@ RUN yum install -y git gcc make tar ncurses-devel
 
 # Install Go 1.4
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz | \
+    https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
 ENV GOPATH /go

src/Dockerfile.ubuntu

@@ -7,7 +7,7 @@ RUN apt-get update && apt-get -y upgrade && \
 
 # Install Go 1.4
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz | \
+    https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
 ENV GOPATH /go

src/Makefile

@@ -21,31 +21,16 @@ BINARY64  := fzf-$(GOOS)_amd64
 VERSION    = $(shell fzf/$(BINARY64) --version)
 RELEASE32  = fzf-$(VERSION)-$(GOOS)_386
 RELEASE64  = fzf-$(VERSION)-$(GOOS)_amd64
-BREW       = fzf-$(VERSION)-homebrew.tgz
 
-all: test release
+all: release
-
-brew: ../$(BREW)
-
-../$(BREW): release
-ifneq ($(UNAME_S),Darwin)
-$(error brew package must be built on OS X)
-endif
-	mkdir -p ../bin && \
-	cp fzf/$(RELEASE64) fzf/$(RELEASE32) ../bin && \
-	cd .. && ln -sf . fzf-$(VERSION) && \
-	tar -cvzf $(BREW) \
-		fzf-$(VERSION)/{{,un}install,fzf-completion.{ba,z}sh,LICENSE} \
-		fzf-$(VERSION)/{plugin/fzf.vim,bin/{$(RELEASE64),$(RELEASE32)}} && \
-	rm fzf-$(VERSION) && \
-	openssl sha1 $(notdir $@)
 
 release: build
 	cd fzf && \
 	cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32) && \
-	cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64)
+	cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
+	rm $(RELEASE32) $(RELEASE64)
 
-build: fzf/$(BINARY32) fzf/$(BINARY64)
+build: test fzf/$(BINARY32) fzf/$(BINARY64)
 
 test:
 	go get
@@ -86,4 +71,4 @@ $(DISTRO): docker
 	docker run -i -t -v $(GOPATH):/go junegunn/$(DISTRO)-sandbox \
 		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
 
-.PHONY: all brew build release test install uninstall clean docker linux $(DISTRO)
+.PHONY: all build release test install uninstall clean docker linux $(DISTRO)

src/README.md

@@ -1,6 +1,8 @@
 fzf in Go
 =========
 
+<img src="https://cloud.githubusercontent.com/assets/700826/5725028/028ea834-9b93-11e4-9198-43088c3f295d.gif" height="463" alt="fzf in go">
+
 This directory contains the source code for the new fzf implementation in
 [Go][go].
 
@@ -17,6 +19,9 @@ git pull
 ./install
 ```
 
+Otherwise, follow [the instruction][install] as before. You can also install
+fzf using Homebrew if you prefer that way.
+
 Motivations
 -----------
 
@@ -81,9 +86,6 @@ make install
 
 # Build executables and tarballs for Linux using Docker
 make linux
-
-# Build tarball for Homebrew release
-make brew
 ```
 
 Contribution
@@ -111,6 +113,7 @@ License
 
 [MIT](LICENSE)
 
+[install]: https://github.com/junegunn/fzf#installation
 [go]:      https://golang.org/
 [gil]:     http://en.wikipedia.org/wiki/Global_Interpreter_Lock
 [ncurses]: https://www.gnu.org/software/ncurses/

src/constants.go

@@ -5,7 +5,7 @@ import (
 )
 
 // Current version
-const Version = "0.9.0"
+const Version = "0.9.2"
 
 // fzf events
 const (

src/curses/curses.go

@@ -421,6 +421,10 @@ func Clear() {
 	C.clear()
 }
 
+func Endwin() {
+	C.endwin()
+}
+
 func Refresh() {
 	C.refresh()
 }

src/options.go

@@ -266,6 +266,17 @@ func parseOptions(opts *Options, allArgs []string) {
 			}
 		}
 	}
+
+	// If we're not using extended search mode, --nth option becomes irrelevant
+	// if it contains the whole range
+	if opts.Mode == ModeFuzzy || len(opts.Nth) == 1 {
+		for _, r := range opts.Nth {
+			if r.begin == rangeEllipsis && r.end == rangeEllipsis {
+				opts.Nth = make([]Range, 0)
+				return
+			}
+		}
+	}
 }
 
 // ParseOptions parses command-line options

src/options_test.go

@@ -21,17 +21,47 @@ func TestSplitNth(t *testing.T) {
 		}
 	}
 	{
-		ranges := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2")
+		ranges := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
-		if len(ranges) != 8 ||
+		if len(ranges) != 10 ||
 			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
-			ranges[1].begin != 1 || ranges[1].end != rangeEllipsis ||
+			ranges[1].begin != rangeEllipsis || ranges[1].end != rangeEllipsis ||
 			ranges[2].begin != 2 || ranges[2].end != 3 ||
-			ranges[3].begin != 4 || ranges[3].end != -1 ||
+			ranges[3].begin != 4 || ranges[3].end != rangeEllipsis ||
 			ranges[4].begin != -3 || ranges[4].end != -2 ||
 			ranges[5].begin != rangeEllipsis || ranges[5].end != rangeEllipsis ||
 			ranges[6].begin != 2 || ranges[6].end != 2 ||
-			ranges[7].begin != -2 || ranges[7].end != -2 {
+			ranges[7].begin != -2 || ranges[7].end != -2 ||
+			ranges[8].begin != 2 || ranges[8].end != -2 ||
+			ranges[9].begin != rangeEllipsis || ranges[9].end != rangeEllipsis {
 			t.Errorf("%s", ranges)
 		}
 	}
 }
+
+func TestIrrelevantNth(t *testing.T) {
+	{
+		opts := defaultOptions()
+		words := []string{"--nth", "..", "-x"}
+		parseOptions(opts, words)
+		if len(opts.Nth) != 0 {
+			t.Errorf("nth should be empty: %s", opts.Nth)
+		}
+	}
+	for _, words := range [][]string{[]string{"--nth", "..,3"}, []string{"--nth", "3,1.."}, []string{"--nth", "..-1,1"}} {
+		{
+			opts := defaultOptions()
+			parseOptions(opts, words)
+			if len(opts.Nth) != 0 {
+				t.Errorf("nth should be empty: %s", opts.Nth)
+			}
+		}
+		{
+			opts := defaultOptions()
+			words = append(words, "-x")
+			parseOptions(opts, words)
+			if len(opts.Nth) != 2 {
+				t.Errorf("nth should not be empty: %s", opts.Nth)
+			}
+		}
+	}
+}

src/terminal.go

@@ -1,11 +1,15 @@
 package fzf
 
 import (
+	"bytes"
 	"fmt"
 	"os"
+	"os/signal"
 	"regexp"
 	"sort"
+	"strings"
 	"sync"
+	"syscall"
 	"time"
 
 	C "github.com/junegunn/fzf/src/curses"
@@ -30,7 +34,7 @@ type Terminal struct {
 	progress   int
 	reading    bool
 	merger     *Merger
-	selected   map[*string]*string
+	selected   map[*string]selectedItem
 	reqBox     *util.EventBox
 	eventBox   *util.EventBox
 	mutex      sync.Mutex
@@ -38,7 +42,27 @@ type Terminal struct {
 	suppress   bool
 }
 
+type selectedItem struct {
+	at   time.Time
+	text *string
+}
+
+type ByTimeOrder []selectedItem
+
+func (a ByTimeOrder) Len() int {
+	return len(a)
+}
+
+func (a ByTimeOrder) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByTimeOrder) Less(i, j int) bool {
+	return a[i].at.Before(a[j].at)
+}
+
 var _spinner = []string{`-`, `\`, `|`, `/`, `-`, `\`, `|`, `/`}
+var _runeWidths = make(map[rune]int)
 
 const (
 	reqPrompt util.EventType = iota
@@ -62,7 +86,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		prompt:     opts.Prompt,
 		tac:        opts.Sort == 0,
 		reverse:    opts.Reverse,
-		cx:         displayWidth(input),
+		cx:         len(input),
 		cy:         0,
 		offset:     0,
 		yanked:     []rune{},
@@ -70,7 +94,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		multi:      opts.Multi,
 		printQuery: opts.PrintQuery,
 		merger:     EmptyMerger,
-		selected:   make(map[*string]*string),
+		selected:   make(map[*string]selectedItem),
 		reqBox:     util.NewEventBox(),
 		eventBox:   eventBox,
 		mutex:      sync.Mutex{},
@@ -134,24 +158,38 @@ func (t *Terminal) output() {
 		fmt.Println(string(t.input))
 	}
 	if len(t.selected) == 0 {
-		if t.merger.Length() > t.cy {
+		cnt := t.merger.Length()
+		if cnt > 0 && cnt > t.cy {
 			fmt.Println(t.merger.Get(t.listIndex(t.cy)).AsString())
 		}
 	} else {
-		for ptr, orig := range t.selected {
+		sels := make([]selectedItem, 0, len(t.selected))
-			if orig != nil {
+		for _, sel := range t.selected {
-				fmt.Println(*orig)
+			sels = append(sels, sel)
+		}
+		sort.Sort(ByTimeOrder(sels))
+		for _, sel := range sels {
+			fmt.Println(*sel.text)
+		}
+	}
+}
+
+func runeWidth(r rune, prefixWidth int) int {
+	if r == '\t' {
+		return 8 - prefixWidth%8
+	} else if w, found := _runeWidths[r]; found {
+		return w
 	} else {
-				fmt.Println(*ptr)
+		w := runewidth.RuneWidth(r)
-			}
+		_runeWidths[r] = w
-		}
+		return w
 	}
 }
 
 func displayWidth(runes []rune) int {
 	l := 0
 	for _, r := range runes {
-		l += runewidth.RuneWidth(r)
+		l += runeWidth(r, l)
 	}
 	return l
 }
@@ -233,16 +271,27 @@ func (t *Terminal) printItem(item *Item, current bool) {
 }
 
 func trimRight(runes []rune, width int) ([]rune, int) {
-	currentWidth := displayWidth(runes)
+	// We start from the beginning to handle tab characters
-	trimmed := 0
+	l := 0
-
+	for idx, r := range runes {
-	for currentWidth > width && len(runes) > 0 {
+		l += runeWidth(r, l)
-		sz := len(runes)
+		if idx > 0 && l > width {
-		currentWidth -= runewidth.RuneWidth(runes[sz-1])
+			return runes[:idx], len(runes) - idx
-		runes = runes[:sz-1]
-		trimmed++
 		}
-	return runes, trimmed
+	}
+	return runes, 0
+}
+
+func displayWidthWithLimit(runes []rune, prefixWidth int, limit int) int {
+	l := 0
+	for _, r := range runes {
+		l += runeWidth(r, l+prefixWidth)
+		if l > limit {
+			// Early exit
+			return l
+		}
+	}
+	return l
 }
 
 func trimLeft(runes []rune, width int) ([]rune, int32) {
@@ -250,9 +299,9 @@ func trimLeft(runes []rune, width int) ([]rune, int32) {
 	var trimmed int32
 
 	for currentWidth > width && len(runes) > 0 {
-		currentWidth -= runewidth.RuneWidth(runes[0])
 		runes = runes[1:]
 		trimmed++
+		currentWidth = displayWidthWithLimit(runes, 2, width)
 	}
 	return runes, trimmed
 }
@@ -302,18 +351,41 @@ func (*Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int) {
 
 	sort.Sort(ByOrder(offsets))
 	var index int32
+	var substr string
+	var prefixWidth int
 	for _, offset := range offsets {
 		b := util.Max32(index, offset[0])
 		e := util.Max32(index, offset[1])
-		C.CPrint(col1, bold, string(text[index:b]))
+
-		C.CPrint(col2, bold, string(text[b:e]))
+		substr, prefixWidth = processTabs(text[index:b], prefixWidth)
+		C.CPrint(col1, bold, substr)
+
+		substr, prefixWidth = processTabs(text[b:e], prefixWidth)
+		C.CPrint(col2, bold, substr)
+
 		index = e
 	}
 	if index < int32(len(text)) {
-		C.CPrint(col1, bold, string(text[index:]))
+		substr, _ = processTabs(text[index:], prefixWidth)
+		C.CPrint(col1, bold, substr)
 	}
 }
 
+func processTabs(runes []rune, prefixWidth int) (string, int) {
+	var strbuf bytes.Buffer
+	l := prefixWidth
+	for _, r := range runes {
+		w := runeWidth(r, l)
+		l += w
+		if r == '\t' {
+			strbuf.WriteString(strings.Repeat(" ", w))
+		} else {
+			strbuf.WriteRune(r)
+		}
+	}
+	return strbuf.String(), l
+}
+
 func (t *Terminal) printAll() {
 	t.printList()
 	t.printInfo()
@@ -387,6 +459,15 @@ func (t *Terminal) Loop() {
 			<-timer.C
 			t.reqBox.Set(reqRefresh, nil)
 		}()
+
+		resizeChan := make(chan os.Signal, 1)
+		signal.Notify(resizeChan, syscall.SIGWINCH)
+		go func() {
+			for {
+				<-resizeChan
+				t.reqBox.Set(reqRedraw, nil)
+			}
+		}()
 	}
 
 	go func() {
@@ -406,6 +487,8 @@ func (t *Terminal) Loop() {
 						t.suppress = false
 					case reqRedraw:
 						C.Clear()
+						C.Endwin()
+						C.Refresh()
 						t.printAll()
 					case reqClose:
 						C.Close()
@@ -443,7 +526,13 @@ func (t *Terminal) Loop() {
 			if idx < t.merger.Length() {
 				item := t.merger.Get(idx)
 				if _, found := t.selected[item.text]; !found {
-					t.selected[item.text] = item.origText
+					var strptr *string
+					if item.origText != nil {
+						strptr = item.origText
+					} else {
+						strptr = item.text
+					}
+					t.selected[item.text] = selectedItem{time.Now(), strptr}
 				} else {
 					delete(t.selected, item.text)
 				}
@@ -514,7 +603,8 @@ func (t *Terminal) Loop() {
 				t.rubout("[^[:alnum:]][[:alnum:]]")
 			}
 		case C.CtrlY:
-			t.input = append(append(t.input[:t.cx], t.yanked...), t.input[t.cx:]...)
+			suffix := copySlice(t.input[t.cx:])
+			t.input = append(append(t.input[:t.cx], t.yanked...), suffix...)
 			t.cx += len(t.yanked)
 		case C.Del:
 			t.delChar()

src/tokenizer.go

@@ -28,22 +28,32 @@ type Token struct {
 	prefixLength int
 }
 
+func newRange(begin int, end int) Range {
+	if begin == 1 {
+		begin = rangeEllipsis
+	}
+	if end == -1 {
+		end = rangeEllipsis
+	}
+	return Range{begin, end}
+}
+
 // ParseRange parses nth-expression and returns the corresponding Range object
 func ParseRange(str *string) (Range, bool) {
 	if (*str) == ".." {
-		return Range{rangeEllipsis, rangeEllipsis}, true
+		return newRange(rangeEllipsis, rangeEllipsis), true
 	} else if strings.HasPrefix(*str, "..") {
 		end, err := strconv.Atoi((*str)[2:])
 		if err != nil || end == 0 {
 			return Range{}, false
 		}
-		return Range{rangeEllipsis, end}, true
+		return newRange(rangeEllipsis, end), true
 	} else if strings.HasSuffix(*str, "..") {
 		begin, err := strconv.Atoi((*str)[:len(*str)-2])
 		if err != nil || begin == 0 {
 			return Range{}, false
 		}
-		return Range{begin, rangeEllipsis}, true
+		return newRange(begin, rangeEllipsis), true
 	} else if strings.Contains(*str, "..") {
 		ns := strings.Split(*str, "..")
 		if len(ns) != 2 {
@@ -51,17 +61,17 @@ func ParseRange(str *string) (Range, bool) {
 		}
 		begin, err1 := strconv.Atoi(ns[0])
 		end, err2 := strconv.Atoi(ns[1])
-		if err1 != nil || err2 != nil {
+		if err1 != nil || err2 != nil || begin == 0 || end == 0 {
 			return Range{}, false
 		}
-		return Range{begin, end}, true
+		return newRange(begin, end), true
 	}
 
 	n, err := strconv.Atoi(*str)
 	if err != nil || n == 0 {
 		return Range{}, false
 	}
-	return Range{n, n}, true
+	return newRange(n, n), true
 }
 
 func withPrefixLengths(tokens []string, begin int) []Token {

src/update_assets.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+# http://www.rubydoc.info/github/rest-client/rest-client/RestClient
+require 'rest_client'
+
+if ARGV.length < 3
+  puts "usage: #$0 <token> <version> <files...>"
+  exit 1
+end
+
+token, version, *files = ARGV
+base = "https://api.github.com/repos/junegunn/fzf-bin/releases"
+
+# List releases
+rels = JSON.parse(RestClient.get(base, :authorization => "token #{token}"))
+rel = rels.find { |r| r['tag_name'] == version }
+unless rel
+  puts "#{version} not found"
+  exit 1
+end
+
+# List assets
+assets = Hash[rel['assets'].map { |a| a.values_at *%w[name id] }]
+
+files.select { |f| File.exists? f }.each do |file|
+  name = File.basename file
+
+  if asset_id = assets[name]
+    puts "#{name} found. Deleting asset id #{asset_id}."
+    RestClient.delete "#{base}/assets/#{asset_id}",
+      :authorization => "token #{token}"
+  else
+    puts "#{name} not found"
+  end
+
+  puts "Uploading #{name}"
+  RestClient.post(
+    "#{base.sub 'api', 'uploads'}/#{rel['id']}/assets?name=#{name}",
+    File.read(file),
+    :authorization => "token #{token}",
+    :content_type  => "application/octet-stream")
+end

test/test_go.rb

@@ -0,0 +1,285 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'minitest/autorun'
+
+class NilClass
+  def include? str
+    false
+  end
+end
+
+module Temp
+  def readonce
+    name = self.class::TEMPNAME
+    waited = 0
+    while waited < 5
+      begin
+        data = File.read(name)
+        return data unless data.empty?
+      rescue
+        sleep 0.1
+        waited += 0.1
+      end
+    end
+    raise "failed to read tempfile"
+  ensure
+    while File.exists? name
+      File.unlink name rescue nil
+    end
+  end
+end
+
+class Tmux
+  include Temp
+
+  TEMPNAME = '/tmp/fzf-test.txt'
+
+  attr_reader :win
+
+  def initialize shell = 'bash'
+    @win = go("new-window -d -P -F '#I' 'PS1=FIN PROMPT_COMMAND= bash --rcfile ~/.fzf.#{shell}'").first
+    @lines = `tput lines`.chomp.to_i
+  end
+
+  def closed?
+    !go("list-window -F '#I'").include?(win)
+  end
+
+  def close timeout = 1
+    send_keys 'C-c', 'C-u', 'exit', :Enter
+    wait(timeout) { closed? }
+  end
+
+  def kill
+    go("kill-window -t #{win} 2> /dev/null")
+  end
+
+  def send_keys *args
+    args = args.map { |a| %{"#{a}"} }.join ' '
+    go("send-keys -t #{win} #{args}")
+  end
+
+  def capture
+    go("capture-pane -t #{win} \\; save-buffer #{TEMPNAME}")
+    raise "Window not found" if $?.exitstatus != 0
+    readonce.split($/)[0, @lines].reverse.drop_while(&:empty?).reverse
+  end
+
+  def until timeout = 1
+    wait(timeout) { yield capture }
+  end
+
+private
+  def wait timeout = 1
+    waited = 0
+    until yield
+      waited += 0.1
+      sleep 0.1
+      if waited > timeout
+        hl = '=' * 10
+        puts hl
+        capture.each_with_index do |line, idx|
+          puts [idx.to_s.rjust(2), line].join(': ')
+        end
+        puts hl
+        raise "timeout"
+      end
+    end
+  end
+
+  def go *args
+    %x[tmux #{args.join ' '}].split($/)
+  end
+end
+
+class TestGoFZF < MiniTest::Unit::TestCase
+  include Temp
+
+  TEMPNAME = '/tmp/output'
+
+  attr_reader :tmux
+
+  def setup
+    ENV.delete 'FZF_DEFAULT_OPTS'
+    ENV.delete 'FZF_DEFAULT_COMMAND'
+    @tmux = Tmux.new
+  end
+
+  def teardown
+    @tmux.kill
+  end
+
+  def test_vanilla
+    tmux.send_keys "seq 1 100000 | fzf > #{TEMPNAME}", :Enter
+    tmux.until(10) { |lines| lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
+    lines = tmux.capture
+    assert_equal '  2',             lines[-4]
+    assert_equal '> 1',             lines[-3]
+    assert_equal '  100000/100000', lines[-2]
+    assert_equal '>',               lines[-1]
+
+    # Testing basic key bindings
+    tmux.send_keys '99', 'C-a', '1', 'C-f', '3', 'C-b', 'C-h', 'C-u', 'C-e', 'C-y', 'C-k', 'Tab', 'BTab'
+    tmux.until { |lines| lines[-2] == '  856/100000' }
+    lines = tmux.capture
+    assert_equal '> 1391',       lines[-4]
+    assert_equal '  391',        lines[-3]
+    assert_equal '  856/100000', lines[-2]
+    assert_equal '> 391',        lines[-1]
+
+    tmux.send_keys :Enter
+    tmux.close
+    assert_equal '1391', readonce.chomp
+  end
+
+  def test_fzf_default_command
+    tmux.send_keys "FZF_DEFAULT_COMMAND='echo hello' fzf > #{TEMPNAME}", :Enter
+    tmux.until { |lines| lines.last =~ /^>/ }
+
+    tmux.send_keys :Enter
+    tmux.close
+    assert_equal 'hello', readonce.chomp
+  end
+
+  def test_key_bindings
+    tmux.send_keys "fzf -q 'foo bar foo-bar'", :Enter
+    tmux.until { |lines| lines.last =~ /^>/ }
+
+    # CTRL-A
+    tmux.send_keys "C-A", "("
+    tmux.until { |lines| lines.last == '> (foo bar foo-bar' }
+
+    # META-F
+    tmux.send_keys :Escape, :f, ")"
+    tmux.until { |lines| lines.last == '> (foo) bar foo-bar' }
+
+    # CTRL-B
+    tmux.send_keys "C-B", "var"
+    tmux.until { |lines| lines.last == '> (foovar) bar foo-bar' }
+
+    # Left, CTRL-D
+    tmux.send_keys :Left, :Left, "C-D"
+    tmux.until { |lines| lines.last == '> (foovr) bar foo-bar' }
+
+    # META-BS
+    tmux.send_keys :Escape, :BSpace
+    tmux.until { |lines| lines.last == '> (r) bar foo-bar' }
+
+    # CTRL-Y
+    tmux.send_keys "C-Y", "C-Y"
+    tmux.until { |lines| lines.last == '> (foovfoovr) bar foo-bar' }
+
+    # META-B
+    tmux.send_keys :Escape, :b, :Space, :Space
+    tmux.until { |lines| lines.last == '> (  foovfoovr) bar foo-bar' }
+
+    # CTRL-F / Right
+    tmux.send_keys 'C-F', :Right, '/'
+    tmux.until { |lines| lines.last == '> (  fo/ovfoovr) bar foo-bar' }
+
+    # CTRL-H / BS
+    tmux.send_keys 'C-H', :BSpace
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar foo-bar' }
+
+    # CTRL-E
+    tmux.send_keys "C-E", 'baz'
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar foo-barbaz' }
+
+    # CTRL-U
+    tmux.send_keys "C-U"
+    tmux.until { |lines| lines.last == '>' }
+
+    # CTRL-Y
+    tmux.send_keys "C-Y"
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar foo-barbaz' }
+
+    # CTRL-W
+    tmux.send_keys "C-W", "bar-foo"
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar bar-foo' }
+
+    # META-D
+    tmux.send_keys :Escape, :b, :Escape, :b, :Escape, :d, "C-A", "C-Y"
+    tmux.until { |lines| lines.last == '> bar(  fovfoovr) bar -foo' }
+
+    # CTRL-M
+    tmux.send_keys "C-M"
+    tmux.until { |lines| lines.last !~ /^>/ }
+    tmux.close
+  end
+
+  def test_multi_order
+    tmux.send_keys "seq 1 10 | fzf --multi > #{TEMPNAME}", :Enter
+    tmux.until { |lines| lines.last =~ /^>/ }
+
+    tmux.send_keys :Tab, :Up, :Up, :Tab, :Tab, :Tab, # 3, 2
+                   'C-K', 'C-K', 'C-K', 'C-K', :BTab, :BTab, # 5, 6
+                   :PgUp, 'C-J', :Down, :Tab, :Tab # 8, 7
+    tmux.until { |lines| lines[-2].include? '(6)' }
+    tmux.send_keys "C-M"
+    tmux.until { |lines| lines[-1].include?('FIN') }
+    assert_equal %w[3 2 5 6 8 7], readonce.split($/)
+    tmux.close
+  end
+
+  def test_with_nth
+    [true, false].each do |multi|
+      tmux.send_keys "(echo '  1st 2nd 3rd/';
+                       echo '  first second third/') |
+                      fzf #{"--multi" if multi} -x --nth 2 --with-nth 2,-1,1 > #{TEMPNAME}",
+                      :Enter
+      tmux.until { |lines| lines[-2].include?('2/2') }
+
+      # Transformed list
+      lines = tmux.capture
+      assert_equal '  second third/first', lines[-4]
+      assert_equal '> 2nd 3rd/1st',        lines[-3]
+
+      # However, the output must not be transformed
+      if multi
+        tmux.send_keys :BTab, :BTab, :Enter
+        tmux.until { |lines| lines[-1].include?('FIN') }
+        assert_equal ['  1st 2nd 3rd/', '  first second third/'], readonce.split($/)
+      else
+        tmux.send_keys '^', '3'
+        tmux.until { |lines| lines[-2].include?('1/2') }
+        tmux.send_keys :Enter
+        tmux.until { |lines| lines[-1].include?('FIN') }
+        assert_equal ['  1st 2nd 3rd/'], readonce.split($/)
+      end
+    end
+  end
+
+  def test_scroll
+    [true, false].each do |rev|
+      tmux.send_keys "seq 1 100 | fzf #{'--reverse' if rev} > #{TEMPNAME}", :Enter
+      tmux.until { |lines| lines.include? '  100/100' }
+      tmux.send_keys *110.times.map { rev ? :Down : :Up }
+      tmux.until { |lines| lines.include? '> 100' }
+      tmux.send_keys :Enter
+      tmux.until { |lines| lines[-1].include?('FIN') }
+      assert_equal '100', readonce.chomp
+    end
+  end
+
+  def test_select_1
+    tmux.send_keys "seq 1 100 | fzf --with-nth ..,.. --print-query -q 5555 -1 > #{TEMPNAME}", :Enter
+    tmux.until { |lines| lines[-1].include?('FIN') }
+    assert_equal ['5555', '55'], readonce.split($/)
+  end
+
+  def test_exit_0
+    tmux.send_keys "seq 1 100 | fzf --with-nth ..,.. --print-query -q 555555 -0 > #{TEMPNAME}", :Enter
+    tmux.until { |lines| lines[-1].include?('FIN') }
+    assert_equal ['555555'], readonce.split($/)
+  end
+
+  def test_query_unicode
+    tmux.send_keys "(echo abc; echo 가나다) | fzf --query 가다 > #{TEMPNAME}", :Enter
+    tmux.until { |lines| lines.last.start_with? '>' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-1].include?('FIN') }
+    assert_equal ['가나다'], readonce.split($/)
+  end
+end
+

test/test_ruby.rb

@@ -54,7 +54,7 @@ class MockTTY
   end
 end
 
-class TestFZF < MiniTest::Unit::TestCase
+class TestRubyFZF < MiniTest::Unit::TestCase
   def setup
     ENV.delete 'FZF_DEFAULT_SORT'
     ENV.delete 'FZF_DEFAULT_OPTS'