mirror of
https://github.com/junegunn/fzf.git
synced 2025-07-31 20:22:01 -07:00
Compare commits
109 Commits
Author | SHA1 | Date | |
---|---|---|---|
|
ae84d8c7a4 | ||
|
dbd627c38a | ||
|
d172c3ce03 | ||
|
9904f5354e | ||
|
f345bf7983 | ||
|
875f9b6534 | ||
|
871dfb709d | ||
|
19e24bd644 | ||
|
457a240457 | ||
|
bbf4567dd8 | ||
|
27d3b52843 | ||
|
dcb4694ec1 | ||
|
2fb8ae010f | ||
|
65ae6cabb5 | ||
|
86a66da04d | ||
|
d66b02b0cd | ||
|
b3182c3304 | ||
|
2dbca00bfb | ||
|
b22fd6de6d | ||
|
245ee42763 | ||
|
98bef4600c | ||
|
f5d53b94fe | ||
|
00c8a68430 | ||
|
c1be834ff9 | ||
|
2c0dc2f3b1 | ||
|
1c94fef720 | ||
|
b711d76b8e | ||
|
4396ab7548 | ||
|
2b8c2b9f2a | ||
|
426284c87e | ||
|
089691faaf | ||
|
301290663d | ||
|
1155da7e1c | ||
|
eca0a99fb4 | ||
|
96215c4619 | ||
|
b2d2be55ef | ||
|
7280e8ebc2 | ||
|
c7e86ad4f1 | ||
|
f2b2c022be | ||
|
7747daa9ec | ||
|
c2943e7681 | ||
|
d5fc03d867 | ||
|
b0eca20dc2 | ||
|
aad335475c | ||
|
c3676bf986 | ||
|
6fb4b6d097 | ||
|
6aa168833b | ||
|
0d83cae2ec | ||
|
773d9976a0 | ||
|
3723829b0a | ||
|
13cb198b5c | ||
|
79f645aa6c | ||
|
42d479d071 | ||
|
d7f50b1e41 | ||
|
39eb85596c | ||
|
bff7e9edf5 | ||
|
98ccc03a21 | ||
|
3b668ed448 | ||
|
33b28be941 | ||
|
76fe23b928 | ||
|
622c54f4a3 | ||
|
e09993f919 | ||
|
7ee6fd1f6d | ||
|
2dca6f0cb2 | ||
|
159dd7f069 | ||
|
b30f21e074 | ||
|
636c86cf6f | ||
|
5483e41b2a | ||
|
1c89994c94 | ||
|
e1bc4b983e | ||
|
cb3645ea95 | ||
|
04ebaddf5e | ||
|
45e1f1ae57 | ||
|
c1d5f7cef7 | ||
|
df663c4e41 | ||
|
d3742782f3 | ||
|
faff17b2a9 | ||
|
9a3cddc92e | ||
|
bd2763d863 | ||
|
b2bb22d883 | ||
|
ad8ec7f387 | ||
|
cf0ca8578c | ||
|
07aee79bd8 | ||
|
344b57fe33 | ||
|
18a2fbf54a | ||
|
39af56cf8f | ||
|
2d3a0a1034 | ||
|
655fa5d9aa | ||
|
9a49a29c7f | ||
|
89ae45cda4 | ||
|
f660ad35b2 | ||
|
c61738ae43 | ||
|
c4dec4d34b | ||
|
a797604255 | ||
|
25840d3bc7 | ||
|
4745d50931 | ||
|
04bf3abe99 | ||
|
57f7963eee | ||
|
2fa21e5dd6 | ||
|
9c4c37aa36 | ||
|
2540c9062f | ||
|
f28274109f | ||
|
724724bd8c | ||
|
64541cb5f8 | ||
|
179b00ed6c | ||
|
a9fd496691 | ||
|
b14c57e656 | ||
|
fa5617e076 | ||
|
e52a1d5fad |
330
README.md
330
README.md
@@ -16,54 +16,30 @@ fzf requires Ruby (>= 1.8.5).
|
||||
Installation
|
||||
------------
|
||||
|
||||
Download [fzf executable](https://raw.github.com/junegunn/fzf/master/fzf) and
|
||||
put it somewhere in your search $PATH.
|
||||
|
||||
```sh
|
||||
mkdir -p ~/bin
|
||||
wget https://raw.github.com/junegunn/fzf/master/fzf -O ~/bin/fzf
|
||||
chmod +x ~/bin/fzf
|
||||
```
|
||||
|
||||
Or you can just clone this repository and run
|
||||
Clone this repository and run
|
||||
[install](https://github.com/junegunn/fzf/blob/master/install) script.
|
||||
|
||||
```sh
|
||||
git clone https://github.com/junegunn/fzf.git
|
||||
fzf/install
|
||||
git clone https://github.com/junegunn/fzf.git ~/.fzf
|
||||
~/.fzf/install
|
||||
```
|
||||
|
||||
Make sure that ~/bin is included in $PATH.
|
||||
The script will setup:
|
||||
|
||||
```sh
|
||||
export PATH=$PATH:~/bin
|
||||
```
|
||||
|
||||
### Install as Ruby gem
|
||||
|
||||
fzf can be installed as a Ruby gem
|
||||
|
||||
```
|
||||
gem install fzf
|
||||
```
|
||||
|
||||
It's a bit easier to install and update the script but the Ruby gem version
|
||||
takes slightly longer to start.
|
||||
- `fzf` executable
|
||||
- Key bindings (`CTRL-T`, `CTRL-R`, etc.)
|
||||
- Fuzzy auto-completion for bash
|
||||
|
||||
### Install as Vim plugin
|
||||
|
||||
You can use any Vim plugin manager to install fzf for Vim. If you don't use one,
|
||||
I recommend you try [vim-plug](https://github.com/junegunn/vim-plug).
|
||||
Once you have cloned the repository, add the following line to your .vimrc.
|
||||
|
||||
1. [Install vim-plug](https://github.com/junegunn/vim-plug#usage)
|
||||
2. Edit your .vimrc
|
||||
```vim
|
||||
set rtp+=~/.fzf
|
||||
```
|
||||
|
||||
call plug#begin()
|
||||
Plug 'junegunn/fzf'
|
||||
" ...
|
||||
call plug#end()
|
||||
|
||||
3. Run `:PlugInstall`
|
||||
Or you may use any Vim plugin manager, such as
|
||||
[vim-plug](https://github.com/junegunn/vim-plug).
|
||||
|
||||
Usage
|
||||
-----
|
||||
@@ -71,12 +47,24 @@ Usage
|
||||
```
|
||||
usage: fzf [options]
|
||||
|
||||
-m, --multi Enable multi-select
|
||||
-x, --extended Extended-search mode
|
||||
-s, --sort=MAX Maximum number of matched items to sort. Default: 1000
|
||||
+s, --no-sort Do not sort the result. Keep the sequence unchanged.
|
||||
+i Case-sensitive match
|
||||
+c, --no-color Disable colors
|
||||
Options
|
||||
-m, --multi Enable multi-select
|
||||
-x, --extended Extended-search mode
|
||||
-e, --extended-exact Extended-search mode (exact match)
|
||||
-q, --query=STR Initial query
|
||||
-f, --filter=STR Filter mode. Do not start interactive finder.
|
||||
-s, --sort=MAX Maximum number of matched items to sort (default: 1000)
|
||||
+s, --no-sort Do not sort the result. Keep the sequence unchanged.
|
||||
-i Case-insensitive match (default: smart-case match)
|
||||
+i Case-sensitive match
|
||||
+c, --no-color Disable colors
|
||||
+2, --no-256 Disable 256-color
|
||||
--black Use black background
|
||||
--no-mouse Disable mouse
|
||||
|
||||
Environment variables
|
||||
FZF_DEFAULT_COMMAND Default command to use when input is tty
|
||||
FZF_DEFAULT_OPTS Defaults options. (e.g. "-x -m --sort 10000")
|
||||
```
|
||||
|
||||
fzf will launch curses-based finder, read the list from STDIN, and write the
|
||||
@@ -104,7 +92,7 @@ history | fzf +s
|
||||
### Key binding
|
||||
|
||||
Use CTRL-J and CTRL-K (or CTRL-N and CTRL-P) to change the selection, press
|
||||
enter key to select the item. CTRL-C will terminate the finder.
|
||||
enter key to select the item. CTRL-C, CTRL-G, or ESC will terminate the finder.
|
||||
|
||||
The following readline key bindings should also work as expected.
|
||||
|
||||
@@ -116,6 +104,10 @@ The following readline key bindings should also work as expected.
|
||||
If you enable multi-select mode with `-m` option, you can select multiple items
|
||||
with TAB or Shift-TAB key.
|
||||
|
||||
You can also use mouse. Double-click on an item to select it or shift-click (or
|
||||
ctrl-click) to select multiple items. Use mouse wheel to move the cursor up and
|
||||
down.
|
||||
|
||||
### Extended-search mode
|
||||
|
||||
With `-x` or `--extended` option, fzf will start in "extended-search mode".
|
||||
@@ -132,14 +124,146 @@ such as: `^music .mp3$ sbtrkt !rmx`
|
||||
| `'wild` | Items that include `wild` | exact-match (quoted) |
|
||||
| `!'fire` | Items that do not include `fire` | inverse-exact-match |
|
||||
|
||||
If you don't need fuzzy matching and do not wish to "quote" every word, start
|
||||
fzf with `-e` or `--extended-exact` option.
|
||||
|
||||
Useful examples
|
||||
---------------
|
||||
|
||||
```sh
|
||||
# vimf - Open selected file in Vim
|
||||
vimf() {
|
||||
FILE=$(fzf) && vim "$FILE"
|
||||
}
|
||||
|
||||
# fd - cd to selected directory
|
||||
fd() {
|
||||
DIR=$(find ${1:-*} -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf) && cd "$DIR"
|
||||
}
|
||||
|
||||
# fda - including hidden directories
|
||||
fda() {
|
||||
DIR=$(find ${1:-.} -type d 2> /dev/null | fzf) && cd "$DIR"
|
||||
}
|
||||
|
||||
# fh - repeat history
|
||||
fh() {
|
||||
eval $(history | fzf +s | sed 's/ *[0-9]* *//')
|
||||
}
|
||||
|
||||
# fkill - kill process
|
||||
fkill() {
|
||||
ps -ef | sed 1d | fzf -m | awk '{print $2}' | xargs kill -${1:-9}
|
||||
}
|
||||
```
|
||||
|
||||
Key bindings for command line
|
||||
-----------------------------
|
||||
|
||||
The install script will setup the following key bindings.
|
||||
|
||||
### bash
|
||||
|
||||
- `CTRL-T` - Paste the selected file path(s) into the command line
|
||||
- `CTRL-R` - Paste the selected command from history into the command line
|
||||
|
||||
The source code can be found in `~/.fzf.bash`.
|
||||
|
||||
### zsh
|
||||
|
||||
- `CTRL-T` - Paste the selected file path(s) into the command line
|
||||
- `CTRL-R` - Paste the selected command from history into the command line
|
||||
- `ALT-C` - cd into the selected directory
|
||||
|
||||
The source code can be found in `~/.fzf.zsh`.
|
||||
|
||||
Auto-completion
|
||||
---------------
|
||||
|
||||
Disclaimer: *Auto-completion feature is currently experimental, it can change
|
||||
over time*
|
||||
|
||||
### bash
|
||||
|
||||
#### Files and directories
|
||||
|
||||
Fuzzy completion for files and directories can be triggered if the word before
|
||||
the cursor ends with the trigger sequence which is by default `**`.
|
||||
|
||||
- `COMMAND [DIRECTORY/][FUZZY_PATTERN]**<TAB>`
|
||||
|
||||
```sh
|
||||
# Files under current directory
|
||||
# - You can select multiple items with TAB key
|
||||
vim **<TAB>
|
||||
|
||||
# Files under parent directory
|
||||
vim ../**<TAB>
|
||||
|
||||
# Files under parent directory that match `fzf`
|
||||
vim ../fzf**<TAB>
|
||||
|
||||
# Files under your home directory
|
||||
vim ~/**<TAB>
|
||||
|
||||
|
||||
# Directories under current directory (single-selection)
|
||||
cd **<TAB>
|
||||
|
||||
# Directories under ~/github that match `fzf`
|
||||
cd ~/github/fzf**<TAB>
|
||||
```
|
||||
|
||||
#### Process IDs
|
||||
|
||||
Fuzzy completion for PIDs is provided for kill command. In this case
|
||||
there is no trigger sequence, just press tab key after kill command.
|
||||
|
||||
```sh
|
||||
# Can select multiple processes with <TAB> or <Shift-TAB> keys
|
||||
kill -9 <TAB>
|
||||
```
|
||||
|
||||
#### Host names
|
||||
|
||||
For ssh and telnet commands, fuzzy completion for host names is provided. The
|
||||
names are extracted from /etc/hosts and ~/.ssh/config.
|
||||
|
||||
```sh
|
||||
ssh **<TAB>
|
||||
telnet **<TAB>
|
||||
```
|
||||
|
||||
#### Settings
|
||||
|
||||
```sh
|
||||
# Use ~~ as the trigger sequence instead of the default **
|
||||
export FZF_COMPLETION_TRIGGER='~~'
|
||||
|
||||
# Options to fzf command
|
||||
export FZF_COMPLETION_OPTS='+c -x'
|
||||
```
|
||||
|
||||
### zsh
|
||||
|
||||
TODO :smiley:
|
||||
|
||||
(Pull requests are appreciated.)
|
||||
|
||||
Usage as Vim plugin
|
||||
-------------------
|
||||
|
||||
If you install fzf as a Vim plugin, `:FZF` command will be added.
|
||||
|
||||
```vim
|
||||
" Look for files under current directory
|
||||
:FZF
|
||||
:FZF --no-sort -m
|
||||
|
||||
" Look for files under your home directory
|
||||
:FZF ~
|
||||
|
||||
" With options
|
||||
:FZF --no-sort -m /tmp
|
||||
```
|
||||
|
||||
You can override the source command which produces input to fzf.
|
||||
@@ -164,110 +288,38 @@ Most of the time, you will prefer native Vim plugins with better integration
|
||||
with Vim. The only reason one might consider using fzf in Vim is its speed. For
|
||||
a very large list of files, fzf is significantly faster and it does not block.
|
||||
|
||||
Useful bash examples
|
||||
--------------------
|
||||
|
||||
```sh
|
||||
# vimf - Open selected file in Vim
|
||||
vimf() {
|
||||
FILE=$(fzf) && vim "$FILE"
|
||||
}
|
||||
|
||||
# fd - cd to selected directory
|
||||
fd() {
|
||||
DIR=$(find ${1:-*} -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf) && cd "$DIR"
|
||||
}
|
||||
|
||||
# fda - including hidden directories
|
||||
fda() {
|
||||
DIR=$(find ${1:-*} -type d 2> /dev/null | fzf) && cd "$DIR"
|
||||
}
|
||||
|
||||
# fh - repeat history
|
||||
fh() {
|
||||
eval $(history | fzf +s | sed 's/ *[0-9]* *//')
|
||||
}
|
||||
|
||||
# fkill - kill process
|
||||
fkill() {
|
||||
ps -ef | sed 1d | fzf -m | awk '{print $2}' | xargs kill -${1:-9}
|
||||
}
|
||||
|
||||
# (Assuming you don't use the default CTRL-T and CTRL-R)
|
||||
|
||||
# CTRL-T - Paste the selected file path into the command line
|
||||
bind '"\er": redraw-current-line'
|
||||
bind '"\C-t": " \C-u \C-a\C-k$(fzf)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er"'
|
||||
|
||||
# CTRL-R - Paste the selected command from history into the command line
|
||||
bind '"\C-r": " \C-e\C-u$(history | fzf +s | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
|
||||
```
|
||||
|
||||
zsh widgets
|
||||
-----------
|
||||
|
||||
```sh
|
||||
# CTRL-T - Paste the selected file(s) path into the command line
|
||||
fzf-file-widget() {
|
||||
local FILES
|
||||
local IFS="
|
||||
"
|
||||
FILES=($(
|
||||
find * -path '*/\.*' -prune \
|
||||
-o -type f -print \
|
||||
-o -type l -print 2> /dev/null | fzf -m))
|
||||
unset IFS
|
||||
FILES=$FILES:q
|
||||
LBUFFER="${LBUFFER%% #} $FILES"
|
||||
zle redisplay
|
||||
}
|
||||
zle -N fzf-file-widget
|
||||
bindkey '^T' fzf-file-widget
|
||||
|
||||
# ALT-C - cd into the selected directory
|
||||
fzf-cd-widget() {
|
||||
cd "${$(find * -path '*/\.*' -prune \
|
||||
-o -type d -print 2> /dev/null | fzf):-.}"
|
||||
zle reset-prompt
|
||||
}
|
||||
zle -N fzf-cd-widget
|
||||
bindkey '\ec' fzf-cd-widget
|
||||
|
||||
# CTRL-R - Paste the selected command from history into the command line
|
||||
fzf-history-widget() {
|
||||
LBUFFER=$(history | fzf +s | sed "s/ *[0-9]* *//")
|
||||
zle redisplay
|
||||
}
|
||||
zle -N fzf-history-widget
|
||||
bindkey '^R' fzf-history-widget
|
||||
```
|
||||
|
||||
Tips
|
||||
----
|
||||
|
||||
### Faster startup with `--disable-gems` options
|
||||
### Rendering issues
|
||||
|
||||
If you're running Ruby 1.9 or above, you can improve the startup time with
|
||||
`--disable-gems` option to Ruby.
|
||||
If you have any rendering issues, check the followings:
|
||||
|
||||
- `time ruby ~/bin/fzf -h`
|
||||
- 0.077 sec
|
||||
- `time ruby --disable-gems ~/bin/fzf -h`
|
||||
- 0.025 sec
|
||||
1. Make sure `$TERM` is correctly set. fzf will use 256-color only if it
|
||||
contains `256` (e.g. `xterm-256color`)
|
||||
2. If you're on screen or tmux, `$TERM` should be either `screen` or
|
||||
`screen-256color`
|
||||
3. Some terminal emulators (e.g. mintty) have problem displaying default
|
||||
background color and make some text unable to read. In that case, try `--black`
|
||||
option. And if it solves your problem, I recommend including it in
|
||||
`FZF_DEFAULT_OPTS` for further convenience.
|
||||
4. If you still have problem, try `--no-256` option or even `--no-color`.
|
||||
5. Ruby 1.9 or above is required for correctly displaying unicode characters.
|
||||
|
||||
Define fzf alias with the option as follows:
|
||||
### Ranking algorithm
|
||||
|
||||
fzf sorts the result first by the length of the matched substring, then by the
|
||||
length of the whole string. However it only does so when the number of matches
|
||||
is less than the limit which is by default 1000, in order to avoid the cost of
|
||||
sorting a large list and limit the response time of the query.
|
||||
|
||||
This limit can be adjusted with `-s` option, or with the environment variable
|
||||
`FZF_DEFAULT_OPTS`.
|
||||
|
||||
```sh
|
||||
alias fzf='ruby --disable-gems ~/bin/fzf'
|
||||
export FZF_DEFAULT_OPTS="--sort 20000"
|
||||
```
|
||||
|
||||
### Incorrect display on Ruby 1.8
|
||||
|
||||
It is reported that the output of fzf can become unreadable on some terminals
|
||||
when it's running on Ruby 1.8. If you experience the problem, upgrade your Ruby
|
||||
to 1.9 or above. Ruby 1.9 or above is also required for displaying Unicode
|
||||
characters.
|
||||
|
||||
License
|
||||
-------
|
||||
|
||||
|
563
fzf
563
fzf
@@ -7,12 +7,13 @@
|
||||
# / __/ / /_/ __/
|
||||
# /_/ /___/_/ Fuzzy finder for your shell
|
||||
#
|
||||
# URL: https://github.com/junegunn/fzf
|
||||
# Author: Junegunn Choi
|
||||
# License: MIT
|
||||
# Last update: November 17, 2013
|
||||
# Version: 0.8.1 (March 9, 2014)
|
||||
#
|
||||
# Copyright (c) 2013 Junegunn Choi
|
||||
# Author: Junegunn Choi
|
||||
# URL: https://github.com/junegunn/fzf
|
||||
# License: MIT
|
||||
#
|
||||
# Copyright (c) 2014 Junegunn Choi
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
@@ -39,9 +40,17 @@ require 'thread'
|
||||
require 'curses'
|
||||
require 'set'
|
||||
|
||||
unless String.method_defined? :force_encoding
|
||||
class String
|
||||
def force_encoding *arg
|
||||
self
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class FZF
|
||||
C = Curses
|
||||
attr_reader :rxflag, :sort, :color, :multi
|
||||
attr_reader :rxflag, :sort, :color, :black, :ansi256, :mouse, :multi, :query, :filter, :extended
|
||||
|
||||
class AtomicVar
|
||||
def initialize value
|
||||
@@ -54,10 +63,8 @@ class FZF
|
||||
end
|
||||
|
||||
def set value = nil
|
||||
if block_given?
|
||||
@mutex.synchronize { @value = yield @value }
|
||||
else
|
||||
@mutex.synchronize { @value = value }
|
||||
@mutex.synchronize do
|
||||
@value = block_given? ? yield(@value) : value
|
||||
end
|
||||
end
|
||||
|
||||
@@ -67,59 +74,152 @@ class FZF
|
||||
end
|
||||
|
||||
def initialize argv, source = $stdin
|
||||
usage 0 unless (%w[--help -h] & argv).empty?
|
||||
@rxflag = argv.delete('+i') ? 0 : Regexp::IGNORECASE
|
||||
@sort = %w[+s --no-sort].map { |e| argv.delete e }.compact.empty? ?
|
||||
ENV.fetch('FZF_DEFAULT_SORT', 1000).to_i : nil
|
||||
@color = %w[+c --no-color].map { |e| argv.delete e }.compact.empty?
|
||||
@multi = !%w[-m --multi].map { |e| argv.delete e }.compact.empty?
|
||||
@xmode = !%w[-x --extended].map { |e| argv.delete e }.compact.empty?
|
||||
rest = argv.join ' '
|
||||
if sort = rest.match(/(-s|--sort=?) ?([0-9]+)/)
|
||||
usage 1 unless @sort
|
||||
@sort = sort[2].to_i
|
||||
rest = rest.delete sort[0]
|
||||
end
|
||||
usage 1 unless rest.empty?
|
||||
@rxflag = nil
|
||||
@sort = ENV.fetch('FZF_DEFAULT_SORT', 1000).to_i
|
||||
@color = true
|
||||
@ansi256 = true
|
||||
@black = false
|
||||
@multi = false
|
||||
@mouse = true
|
||||
@extended = nil
|
||||
@filter = nil
|
||||
|
||||
@source = source
|
||||
argv =
|
||||
if opts = ENV['FZF_DEFAULT_OPTS']
|
||||
require 'shellwords'
|
||||
Shellwords.shellwords(opts) + argv
|
||||
else
|
||||
argv.dup
|
||||
end
|
||||
while o = argv.shift
|
||||
case o
|
||||
when '--version' then version
|
||||
when '-h', '--help' then usage 0
|
||||
when '-m', '--multi' then @multi = true
|
||||
when '+m', '--no-multi' then @multi = false
|
||||
when '-x', '--extended' then @extended = :fuzzy
|
||||
when '+x', '--no-extended' then @extended = nil
|
||||
when '-i' then @rxflag = Regexp::IGNORECASE
|
||||
when '+i' then @rxflag = 0
|
||||
when '-c', '--color' then @color = true
|
||||
when '+c', '--no-color' then @color = false
|
||||
when '-2', '--256' then @ansi256 = true
|
||||
when '+2', '--no-256' then @ansi256 = false
|
||||
when '--black' then @black = true
|
||||
when '--no-black' then @black = false
|
||||
when '--mouse' then @mouse = true
|
||||
when '--no-mouse' then @mouse = false
|
||||
when '+s', '--no-sort' then @sort = nil
|
||||
when '-q', '--query'
|
||||
usage 1, 'query string required' unless query = argv.shift
|
||||
@query = AtomicVar.new query.dup
|
||||
when /^-q(.*)$/, /^--query=(.*)$/
|
||||
@query = AtomicVar.new($1)
|
||||
when '-f', '--filter'
|
||||
usage 1, 'query string required' unless query = argv.shift
|
||||
@filter = query
|
||||
when /^-f(.*)$/, /^--filter=(.*)$/
|
||||
@filter = $1
|
||||
when '-s', '--sort'
|
||||
usage 1, 'sort size required' unless sort = argv.shift
|
||||
usage 1, 'invalid sort size' unless sort =~ /^[0-9]+$/
|
||||
@sort = sort.to_i
|
||||
when /^-s([0-9]+)$/, /^--sort=([0-9]+)$/
|
||||
@sort = $1.to_i
|
||||
when '-e', '--extended-exact' then @extended = :exact
|
||||
when '+e', '--no-extended-exact' then @extended = nil
|
||||
else
|
||||
usage 1, "illegal option: #{o}"
|
||||
end
|
||||
end
|
||||
|
||||
@source = source.clone
|
||||
@mtx = Mutex.new
|
||||
@cv = ConditionVariable.new
|
||||
@events = {}
|
||||
@new = []
|
||||
@queue = Queue.new
|
||||
@cursor_x = AtomicVar.new(0)
|
||||
@query = AtomicVar.new('')
|
||||
@matches = AtomicVar.new([])
|
||||
@count = AtomicVar.new(0)
|
||||
@vcursor = AtomicVar.new(0)
|
||||
@vcursors = AtomicVar.new(Set.new)
|
||||
@spinner = AtomicVar.new('-\|/-\|/'.split(//))
|
||||
@selects = AtomicVar.new({}) # ordered >= 1.9
|
||||
@main = Thread.current
|
||||
@stdout = $stdout.clone
|
||||
@plcount = 0
|
||||
@pending = nil
|
||||
|
||||
unless @filter
|
||||
@query ||= AtomicVar.new('')
|
||||
@cursor_x = AtomicVar.new(@query.length)
|
||||
@matches = AtomicVar.new([])
|
||||
@count = AtomicVar.new(0)
|
||||
@vcursor = AtomicVar.new(0)
|
||||
@vcursors = AtomicVar.new(Set.new)
|
||||
@spinner = AtomicVar.new('-\|/-\|/'.split(//))
|
||||
@selects = AtomicVar.new({}) # ordered >= 1.9
|
||||
@main = Thread.current
|
||||
@plcount = 0
|
||||
end
|
||||
end
|
||||
|
||||
def start
|
||||
$stdout.reopen($stderr)
|
||||
if @filter
|
||||
start_reader(false).join
|
||||
filter_list @new
|
||||
else
|
||||
@stdout = $stdout.clone
|
||||
$stdout.reopen($stderr)
|
||||
|
||||
init_screen
|
||||
start_reader
|
||||
start_renderer
|
||||
start_search
|
||||
start_loop
|
||||
start_reader true
|
||||
init_screen
|
||||
start_renderer
|
||||
start_search
|
||||
start_loop
|
||||
end
|
||||
end
|
||||
|
||||
def usage x
|
||||
def filter_list list
|
||||
matches = get_matcher.match(list, @filter, '', '')
|
||||
if @sort && matches.length <= @sort
|
||||
matches = sort_by_rank(matches)
|
||||
end
|
||||
matches.each { |m| puts m.first }
|
||||
end
|
||||
|
||||
def get_matcher
|
||||
if @extended
|
||||
ExtendedFuzzyMatcher.new @rxflag, @extended
|
||||
else
|
||||
FuzzyMatcher.new @rxflag
|
||||
end
|
||||
end
|
||||
|
||||
def version
|
||||
File.open(__FILE__, 'r') do |f|
|
||||
f.each_line do |line|
|
||||
if line =~ /Version: (.*)/
|
||||
$stdout.puts "fzf " << $1
|
||||
exit
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def usage x, message = nil
|
||||
$stderr.puts message if message
|
||||
$stderr.puts %[usage: fzf [options]
|
||||
|
||||
-m, --multi Enable multi-select
|
||||
-x, --extended Extended-search mode
|
||||
-s, --sort=MAX Maximum number of matched items to sort. Default: 1000
|
||||
+s, --no-sort Do not sort the result. Keep the sequence unchanged.
|
||||
+i Case-sensitive match
|
||||
+c, --no-color Disable colors]
|
||||
Options
|
||||
-m, --multi Enable multi-select
|
||||
-x, --extended Extended-search mode
|
||||
-e, --extended-exact Extended-search mode (exact match)
|
||||
-q, --query=STR Initial query
|
||||
-f, --filter=STR Filter mode. Do not start interactive finder.
|
||||
-s, --sort=MAX Maximum number of matched items to sort (default: 1000)
|
||||
+s, --no-sort Do not sort the result. Keep the sequence unchanged.
|
||||
-i Case-insensitive match (default: smart-case match)
|
||||
+i Case-sensitive match
|
||||
+c, --no-color Disable colors
|
||||
+2, --no-256 Disable 256-color
|
||||
--black Use black background
|
||||
--no-mouse Disable mouse
|
||||
|
||||
Environment variables
|
||||
FZF_DEFAULT_COMMAND Default command to use when input is tty
|
||||
FZF_DEFAULT_OPTS Defaults options. (e.g. "-x -m --sort 10000")] + $/ + $/
|
||||
exit x
|
||||
end
|
||||
|
||||
@@ -329,7 +429,7 @@ class FZF
|
||||
tokens << [line[b...e], true]
|
||||
index = e
|
||||
end
|
||||
tokens << [line[index..-1], false]
|
||||
tokens << [line[index..-1], false] if index < line.length
|
||||
tokens.reject { |pair| pair.first.empty? }
|
||||
end
|
||||
|
||||
@@ -371,10 +471,12 @@ class FZF
|
||||
}
|
||||
end
|
||||
|
||||
if RUBY_VERSION.split('.').map { |e| e.rjust(3, '0') }.join > '001009'
|
||||
AFTER_1_9 = RUBY_VERSION.split('.').map { |e| e.rjust(3, '0') }.join >= '001009'
|
||||
|
||||
if AFTER_1_9
|
||||
@@wrx = Regexp.new '\p{Han}|\p{Katakana}|\p{Hiragana}|\p{Hangul}'
|
||||
def width str
|
||||
str.gsub(@@wrx, ' ').length
|
||||
str.gsub(@@wrx, ' ').length rescue str.length
|
||||
end
|
||||
|
||||
def trim str, len, left
|
||||
@@ -416,9 +518,10 @@ class FZF
|
||||
|
||||
def init_screen
|
||||
C.init_screen
|
||||
C.mousemask C::ALL_MOUSE_EVENTS if @mouse
|
||||
C.start_color
|
||||
dbg =
|
||||
if C.respond_to?(:use_default_colors)
|
||||
if !@black && C.respond_to?(:use_default_colors)
|
||||
C.use_default_colors
|
||||
-1
|
||||
else
|
||||
@@ -428,7 +531,7 @@ class FZF
|
||||
C.noecho
|
||||
|
||||
if @color
|
||||
if C.can_change_color?
|
||||
if @ansi256 && ENV['TERM'].to_s =~ /256/
|
||||
C.init_pair 1, 110, dbg
|
||||
C.init_pair 2, 108, dbg
|
||||
C.init_pair 3, 254, 236
|
||||
@@ -467,9 +570,11 @@ class FZF
|
||||
end | (bold ? C::A_BOLD : 0)
|
||||
end
|
||||
end
|
||||
|
||||
C.refresh
|
||||
end
|
||||
|
||||
def start_reader
|
||||
def start_reader curses
|
||||
stream =
|
||||
if @source.tty?
|
||||
if default_command = ENV['FZF_DEFAULT_COMMAND']
|
||||
@@ -488,12 +593,12 @@ class FZF
|
||||
emit(:new) { @new << line.chomp }
|
||||
end
|
||||
emit(:loaded) { true }
|
||||
@spinner.clear
|
||||
@spinner.clear if curses
|
||||
end
|
||||
end
|
||||
|
||||
def start_search
|
||||
matcher = (@xmode ? ExtendedFuzzyMatcher : FuzzyMatcher).new @rxflag
|
||||
matcher = get_matcher
|
||||
searcher = Thread.new {
|
||||
lists = []
|
||||
events = {}
|
||||
@@ -536,29 +641,28 @@ class FZF
|
||||
if new_search && !lists.empty?
|
||||
q, cx = events.delete(:key) || [q, 0]
|
||||
empty = matcher.empty?(q)
|
||||
matches = fcache[q] ||=
|
||||
begin
|
||||
found = []
|
||||
skip = false
|
||||
cnt = 0
|
||||
lists.each do |list|
|
||||
cnt += list.length
|
||||
skip = @mtx.synchronize { @events[:key] }
|
||||
break if skip
|
||||
unless matches = fcache[q]
|
||||
found = []
|
||||
skip = false
|
||||
cnt = 0
|
||||
lists.each do |list|
|
||||
cnt += list.length
|
||||
skip = @mtx.synchronize { @events[:key] }
|
||||
break if skip
|
||||
|
||||
if !empty && (progress = 100 * cnt / @count.get) < 100 && Time.now - started_at > 0.5
|
||||
render { print_info " (#{progress}%)" }
|
||||
end
|
||||
|
||||
found.concat(q.empty? ? list :
|
||||
matcher.match(list, q, q[0, cx], q[cx..-1]))
|
||||
if !empty && (progress = 100 * cnt / @count.get) < 100 && Time.now - started_at > 0.5
|
||||
render { print_info " (#{progress}%)" }
|
||||
end
|
||||
next if skip
|
||||
@sort ? found : found.reverse
|
||||
end
|
||||
|
||||
if !empty && @sort && matches.length <= @sort
|
||||
matches = sort_by_rank(matches)
|
||||
found.concat(q.empty? ? list :
|
||||
matcher.match(list, q, q[0, cx], q[cx..-1]))
|
||||
end
|
||||
next if skip
|
||||
matches = @sort ? found : found.reverse
|
||||
if !empty && @sort && matches.length <= @sort
|
||||
matches = sort_by_rank(matches)
|
||||
end
|
||||
fcache[q] = matches
|
||||
end
|
||||
|
||||
# Atomic update
|
||||
@@ -612,6 +716,7 @@ class FZF
|
||||
print_item row, tokens, chosen, selected
|
||||
end
|
||||
print_info
|
||||
print_input
|
||||
end
|
||||
end
|
||||
|
||||
@@ -633,18 +738,179 @@ class FZF
|
||||
nil
|
||||
end
|
||||
|
||||
def vselect &prc
|
||||
@vcursor.set { |v| @vcursors << v; prc.call v }
|
||||
update_list false
|
||||
end
|
||||
|
||||
def num_unicode_bytes chr
|
||||
# http://en.wikipedia.org/wiki/UTF-8
|
||||
if chr & 0b10000000 > 0
|
||||
bytes = 0
|
||||
7.downto(2) do |shift|
|
||||
break if (chr >> shift) & 0x1 == 0
|
||||
bytes += 1
|
||||
end
|
||||
bytes
|
||||
else
|
||||
1
|
||||
end
|
||||
end
|
||||
|
||||
def read_nb chars = 1, default = nil, tries = 10
|
||||
tries.times do |_|
|
||||
begin
|
||||
return @tty.read_nonblock(chars).ord
|
||||
rescue Exception
|
||||
sleep 0.01
|
||||
end
|
||||
end
|
||||
default
|
||||
end
|
||||
|
||||
def read_nbs
|
||||
ords = []
|
||||
while ord = read_nb
|
||||
ords << ord
|
||||
end
|
||||
ords
|
||||
end
|
||||
|
||||
def get_mouse
|
||||
case ord = read_nb
|
||||
when 32, 36, 40, 48, # mouse-down / shift / cmd / ctrl
|
||||
35, 39, 43, 51 # mouse-up / shift / cmd / ctrl
|
||||
x = read_nb - 33
|
||||
y = read_nb - 33
|
||||
{ :event => (ord % 2 == 0 ? :click : :release),
|
||||
:x => x, :y => y, :shift => ord >= 36 }
|
||||
when 96, 100, 104, 112, # scroll-up / shift / cmd / ctrl
|
||||
97, 101, 105, 113 # scroll-down / shift / cmd / ctrl
|
||||
read_nb(2)
|
||||
{ :event => :scroll, :diff => (ord % 2 == 0 ? -1 : 1), :shift => ord >= 100 }
|
||||
else
|
||||
# e.g. 40, 43, 104, 105
|
||||
read_nb(2)
|
||||
nil
|
||||
end
|
||||
end
|
||||
|
||||
def get_input actions
|
||||
@tty ||= IO.open(IO.sysopen('/dev/tty'), 'r')
|
||||
|
||||
if pending = @pending
|
||||
@pending = nil
|
||||
return pending
|
||||
end
|
||||
|
||||
str = ''
|
||||
while true
|
||||
ord =
|
||||
if str.empty?
|
||||
@tty.getc.ord
|
||||
else
|
||||
begin
|
||||
ord = @tty.read_nonblock(1).ord
|
||||
if (nb = num_unicode_bytes(ord)) > 1
|
||||
ords = [ord]
|
||||
(nb - 1).times do |_|
|
||||
ords << @tty.read_nonblock(1).ord
|
||||
end
|
||||
# UTF-8 TODO Ruby 1.8
|
||||
ords.pack('C*').force_encoding('UTF-8')
|
||||
else
|
||||
ord
|
||||
end
|
||||
rescue Exception
|
||||
return str
|
||||
end
|
||||
end
|
||||
|
||||
ord =
|
||||
case read_nb(1, :esc)
|
||||
when 91
|
||||
case read_nb(1, nil)
|
||||
when 68 then ctrl(:b)
|
||||
when 67 then ctrl(:f)
|
||||
when 66 then ctrl(:j)
|
||||
when 65 then ctrl(:k)
|
||||
when 90 then :stab
|
||||
when 50 then read_nb; :ins
|
||||
when 51 then read_nb; :del
|
||||
when 53 then read_nb; :pgup
|
||||
when 54 then read_nb; :pgdn
|
||||
when 49
|
||||
case read_nbs
|
||||
when [59, 50, 68] then ctrl(:a)
|
||||
when [59, 50, 67] then ctrl(:e)
|
||||
when [126] then ctrl(:a)
|
||||
end
|
||||
when 52 then read_nb; ctrl(:e)
|
||||
when 72 then ctrl(:a)
|
||||
when 70 then ctrl(:e)
|
||||
when 77
|
||||
get_mouse
|
||||
end
|
||||
when 'b', 98 then :alt_b
|
||||
when 'f', 102 then :alt_f
|
||||
when :esc then :esc
|
||||
else next
|
||||
end if ord == 27
|
||||
|
||||
return ord if ord.nil? || ord.is_a?(Hash)
|
||||
|
||||
if actions.has_key?(ord)
|
||||
if str.empty?
|
||||
return ord
|
||||
else
|
||||
@pending = ord
|
||||
return str
|
||||
end
|
||||
else
|
||||
unless ord.is_a? String
|
||||
ord = [ord].pack('U*')
|
||||
end
|
||||
str << ord if ord =~ /[[:print:]]/
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class MouseEvent
|
||||
DOUBLE_CLICK_INTERVAL = 0.5
|
||||
|
||||
attr_reader :v
|
||||
|
||||
def initialize v = nil
|
||||
@c = 0
|
||||
@v = v
|
||||
@t = Time.at 0
|
||||
end
|
||||
|
||||
def v= v
|
||||
@c = (@v == v && within?) ? @c + 1 : 0
|
||||
@v = v
|
||||
@t = Time.now
|
||||
end
|
||||
|
||||
def double? v
|
||||
@c == 1 && @v == v && within?
|
||||
end
|
||||
|
||||
def within?
|
||||
(Time.now - @t) < DOUBLE_CLICK_INTERVAL
|
||||
end
|
||||
end
|
||||
|
||||
def start_loop
|
||||
got = nil
|
||||
begin
|
||||
tty = IO.open(IO.sysopen('/dev/tty'), 'r')
|
||||
input = ''
|
||||
cursor = 0
|
||||
input = @query.get.dup
|
||||
cursor = input.length
|
||||
backword = proc {
|
||||
cursor = (input[0, cursor].rindex(/\s\S/) || -1) + 1
|
||||
}
|
||||
actions = {
|
||||
:nop => proc { nil },
|
||||
ctrl(:c) => proc { exit 1 },
|
||||
:esc => proc { exit 1 },
|
||||
ctrl(:d) => proc { exit 1 if input.empty? },
|
||||
ctrl(:m) => proc {
|
||||
got = pick
|
||||
@@ -653,77 +919,90 @@ class FZF
|
||||
ctrl(:u) => proc { input = input[cursor..-1]; cursor = 0 },
|
||||
ctrl(:a) => proc { cursor = 0; nil },
|
||||
ctrl(:e) => proc { cursor = input.length; nil },
|
||||
ctrl(:j) => proc { @vcursor.set { |v| @vcursors << v; v - 1 }; update_list false },
|
||||
ctrl(:k) => proc { @vcursor.set { |v| @vcursors << v; v + 1 }; update_list false },
|
||||
ctrl(:j) => proc { vselect { |v| v - 1 } },
|
||||
ctrl(:k) => proc { vselect { |v| v + 1 } },
|
||||
ctrl(:w) => proc {
|
||||
pcursor = cursor
|
||||
backword.call
|
||||
input = input[0...cursor] + input[pcursor..-1]
|
||||
},
|
||||
127 => proc { input[cursor -= 1] = '' if cursor > 0 },
|
||||
9 => proc { |o|
|
||||
ctrl(:h) => proc { input[cursor -= 1] = '' if cursor > 0 },
|
||||
ctrl(:i) => proc { |o|
|
||||
if @multi && sel = pick
|
||||
if @selects.has_key? sel
|
||||
@selects.delete sel
|
||||
else
|
||||
@selects[sel] = 1
|
||||
end
|
||||
@vcursor.set { |v|
|
||||
@vcursors << v
|
||||
v + (o == :stab ? 1 : -1)
|
||||
}
|
||||
update_list false
|
||||
vselect { |v| v + case o
|
||||
when :stab then 1
|
||||
when :sclick then 0
|
||||
else -1
|
||||
end }
|
||||
end
|
||||
},
|
||||
:left => proc { cursor = [0, cursor - 1].max; nil },
|
||||
:right => proc { cursor = [input.length, cursor + 1].min; nil },
|
||||
ctrl(:b) => proc { cursor = [0, cursor - 1].max; nil },
|
||||
ctrl(:f) => proc { cursor = [input.length, cursor + 1].min; nil },
|
||||
ctrl(:l) => proc { render { C.clear; C.refresh }; update_list true },
|
||||
:del => proc { input[cursor] = '' if input.length > cursor },
|
||||
:pgup => proc { vselect { |_| max_items } },
|
||||
:pgdn => proc { vselect { |_| 0 } },
|
||||
:alt_b => proc { backword.call; nil },
|
||||
:alt_f => proc {
|
||||
cursor += (input[cursor..-1].index(/(\S\s)|(.$)/) || -1) + 1
|
||||
nil
|
||||
},
|
||||
}
|
||||
actions[ctrl(:b)] = actions[:left]
|
||||
actions[ctrl(:f)] = actions[:right]
|
||||
actions[ctrl(:h)] = actions[127]
|
||||
actions[ctrl(:n)] = actions[ctrl(:j)]
|
||||
actions[ctrl(:p)] = actions[ctrl(:k)]
|
||||
actions[:stab] = actions[9]
|
||||
actions[ctrl(:n)] = actions[ctrl(:j)]
|
||||
actions[:stab] = actions[ctrl(:i)]
|
||||
actions[127] = actions[ctrl(:h)]
|
||||
actions[ctrl(:q)] = actions[ctrl(:g)] = actions[ctrl(:c)] = actions[:esc]
|
||||
|
||||
emit(:key) { [@query.get, cursor] } unless @query.empty?
|
||||
mouse = MouseEvent.new
|
||||
while true
|
||||
@cursor_x.set cursor
|
||||
render { print_input }
|
||||
|
||||
ord = tty.getc.ord
|
||||
ord =
|
||||
case ord = tty.getc.ord
|
||||
when 91
|
||||
case tty.getc.ord
|
||||
when 68 then :left
|
||||
when 67 then :right
|
||||
when 66 then ctrl(:j)
|
||||
when 65 then ctrl(:k)
|
||||
when 90 then :stab
|
||||
else :nop
|
||||
if key = get_input(actions)
|
||||
upd = actions.fetch(key, proc { |val|
|
||||
case val
|
||||
when String
|
||||
input.insert cursor, val
|
||||
cursor += val.length
|
||||
when Hash
|
||||
event = val[:event]
|
||||
case event
|
||||
when :click, :release
|
||||
x, y, shift = val.values_at :x, :y, :shift
|
||||
if y == cursor_y
|
||||
cursor = [0, [input.length, x - 2].min].max
|
||||
elsif x > 1 && y <= max_items
|
||||
tv = max_items - y - 1
|
||||
|
||||
case event
|
||||
when :click
|
||||
vselect { |_| tv }
|
||||
actions[ctrl(:i)].call(:sclick) if shift
|
||||
mouse.v = tv
|
||||
when :release
|
||||
if !shift && mouse.double?(tv)
|
||||
actions[ctrl(:m)].call
|
||||
end
|
||||
end
|
||||
end
|
||||
when :scroll
|
||||
diff, shift = val.values_at :diff, :shift
|
||||
actions[ctrl(:i)].call(:sclick) if shift
|
||||
actions[ctrl(diff > 0 ? :j : :k)].call
|
||||
end
|
||||
end
|
||||
when 'b'.ord
|
||||
:alt_b
|
||||
when 'f'.ord
|
||||
:alt_f
|
||||
else
|
||||
ord
|
||||
end if ord == 27
|
||||
}).call(key)
|
||||
|
||||
upd = actions.fetch(ord, proc { |ord|
|
||||
char = [ord].pack('U*')
|
||||
if char =~ /[[:print:]]/
|
||||
input.insert cursor, char
|
||||
cursor += 1
|
||||
end
|
||||
}).call(ord)
|
||||
|
||||
# Dispatch key event
|
||||
emit(:key) { [@query.set(input.dup), cursor] } if upd
|
||||
# Dispatch key event
|
||||
emit(:key) { [@query.set(input.dup), cursor] } if upd
|
||||
end
|
||||
end
|
||||
ensure
|
||||
C.close_screen
|
||||
@@ -752,14 +1031,18 @@ class FZF
|
||||
q.empty?
|
||||
end
|
||||
|
||||
def rxflag_for q
|
||||
@rxflag || (q =~ /[A-Z]/ ? 0 : Regexp::IGNORECASE)
|
||||
end
|
||||
|
||||
def fuzzy_regex q
|
||||
@regexp[q] ||= begin
|
||||
q = q.downcase if @rxflag != 0
|
||||
q = q.downcase if @rxflag == Regexp::IGNORECASE
|
||||
Regexp.new(query_chars(q).inject('') { |sum, e|
|
||||
e = Regexp.escape e
|
||||
sum << (e.length > 1 ? "(?:#{e}).*?" : # FIXME: not equivalent
|
||||
"#{e}[^#{e}]*?")
|
||||
}, @rxflag)
|
||||
}, rxflag_for(q))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -789,9 +1072,10 @@ class FZF
|
||||
end
|
||||
|
||||
class ExtendedFuzzyMatcher < FuzzyMatcher
|
||||
def initialize rxflag
|
||||
super
|
||||
def initialize rxflag, mode = :fuzzy
|
||||
super rxflag
|
||||
@regexps = {}
|
||||
@mode = mode
|
||||
end
|
||||
|
||||
def empty? q
|
||||
@@ -811,21 +1095,30 @@ class FZF
|
||||
case w
|
||||
when ''
|
||||
nil
|
||||
when /^\^(.*)\$$/
|
||||
Regexp.new('^' << sanitize(Regexp.escape($1)) << '$', rxflag_for(w))
|
||||
when /^'/
|
||||
w.length > 1 ?
|
||||
Regexp.new(sanitize(Regexp.escape(w[1..-1])), rxflag) : nil
|
||||
if @mode == :fuzzy && w.length > 1
|
||||
exact_regex w[1..-1]
|
||||
elsif @mode == :exact
|
||||
exact_regex w
|
||||
end
|
||||
when /^\^/
|
||||
w.length > 1 ?
|
||||
Regexp.new('^' << sanitize(Regexp.escape(w[1..-1])), rxflag) : nil
|
||||
Regexp.new('^' << sanitize(Regexp.escape(w[1..-1])), rxflag_for(w)) : nil
|
||||
when /\$$/
|
||||
w.length > 1 ?
|
||||
Regexp.new(sanitize(Regexp.escape(w[0..-2])) << '$', rxflag) : nil
|
||||
Regexp.new(sanitize(Regexp.escape(w[0..-2])) << '$', rxflag_for(w)) : nil
|
||||
else
|
||||
fuzzy_regex w
|
||||
@mode == :fuzzy ? fuzzy_regex(w) : exact_regex(w)
|
||||
end, invert ]
|
||||
}.select { |pair| pair.first }
|
||||
end
|
||||
|
||||
def exact_regex w
|
||||
Regexp.new(sanitize(Regexp.escape(w)), rxflag_for(w))
|
||||
end
|
||||
|
||||
def match list, q, prefix, suffix
|
||||
regexps = parse q
|
||||
# Look for prefix cache
|
||||
|
167
fzf-completion.bash
Normal file
167
fzf-completion.bash
Normal file
@@ -0,0 +1,167 @@
|
||||
#!/bin/bash
|
||||
# ____ ____
|
||||
# / __/___ / __/
|
||||
# / /_/_ / / /_
|
||||
# / __/ / /_/ __/
|
||||
# /_/ /___/_/-completion.bash
|
||||
#
|
||||
# - $FZF_COMPLETION_TRIGGER (default: '**')
|
||||
# - $FZF_COMPLETION_OPTS (default: empty)
|
||||
|
||||
_fzf_opts_completion() {
|
||||
local cur prev opts
|
||||
COMPREPLY=()
|
||||
cur="${COMP_WORDS[COMP_CWORD]}"
|
||||
prev="${COMP_WORDS[COMP_CWORD-1]}"
|
||||
opts="-m --multi -x --extended -s --sort +s +i +c --no-color"
|
||||
|
||||
case "${prev}" in
|
||||
--sort|-s)
|
||||
COMPREPLY=( $(compgen -W "$(seq 2000 1000 10000)" -- ${cur}) )
|
||||
return 0
|
||||
;;
|
||||
esac
|
||||
|
||||
if [[ ${cur} =~ ^-|\+ ]]; then
|
||||
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
|
||||
return 0
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
_fzf_generic_completion() {
|
||||
local cur base dir leftover matches trigger
|
||||
COMPREPLY=()
|
||||
trigger=${FZF_COMPLETION_TRIGGER:-**}
|
||||
cur="${COMP_WORDS[COMP_CWORD]}"
|
||||
if [[ ${cur} == *"$trigger" ]]; then
|
||||
base=${cur:0:${#cur}-${#trigger}}
|
||||
eval base=$base
|
||||
|
||||
dir="$base"
|
||||
while [ 1 ]; do
|
||||
if [ -z "$dir" -o -d "$dir" ]; then
|
||||
leftover=${base/#"$dir"}
|
||||
leftover=${leftover/#\/}
|
||||
[ "$dir" = './' ] && dir=''
|
||||
tput sc
|
||||
matches=$(find "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
|
||||
printf '%q ' "$item"
|
||||
done)
|
||||
matches=${matches% }
|
||||
if [ -n "$matches" ]; then
|
||||
COMPREPLY=( "$matches" )
|
||||
else
|
||||
COMPREPLY=( "$cur" )
|
||||
fi
|
||||
tput rc
|
||||
return 0
|
||||
fi
|
||||
dir=$(dirname "$dir")
|
||||
[[ "$dir" =~ /$ ]] || dir="$dir"/
|
||||
done
|
||||
fi
|
||||
}
|
||||
|
||||
_fzf_all_completion() {
|
||||
_fzf_generic_completion \
|
||||
"-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
|
||||
"-m"
|
||||
}
|
||||
|
||||
_fzf_file_completion() {
|
||||
_fzf_generic_completion \
|
||||
"-name .git -prune -o -name .svn -prune -o -type f -print -o -type l -print" \
|
||||
"-m"
|
||||
}
|
||||
|
||||
_fzf_dir_completion() {
|
||||
_fzf_generic_completion \
|
||||
"-name .git -prune -o -name .svn -prune -o -type d -print" \
|
||||
""
|
||||
}
|
||||
|
||||
_fzf_kill_completion() {
|
||||
[ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
|
||||
|
||||
local selected
|
||||
tput sc
|
||||
selected=$(ps -ef | sed 1d | fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
|
||||
tput rc
|
||||
|
||||
if [ -n "$selected" ]; then
|
||||
COMPREPLY=( "$selected" )
|
||||
return 0
|
||||
fi
|
||||
}
|
||||
|
||||
_fzf_telnet_completion() {
|
||||
local cur selected trigger
|
||||
trigger=${FZF_COMPLETION_TRIGGER:-**}
|
||||
cur="${COMP_WORDS[COMP_CWORD]}"
|
||||
[[ ${cur} == *"$trigger" ]] || return 1
|
||||
cur=${cur:0:${#cur}-${#trigger}}
|
||||
|
||||
tput sc
|
||||
selected=$(grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{print $2}' | sort -u | fzf $FZF_COMPLETION_OPTS -q "$cur")
|
||||
tput rc
|
||||
|
||||
if [ -n "$selected" ]; then
|
||||
COMPREPLY=("$selected")
|
||||
return 0
|
||||
fi
|
||||
}
|
||||
|
||||
_fzf_ssh_completion() {
|
||||
local cur selected trigger
|
||||
trigger=${FZF_COMPLETION_TRIGGER:-**}
|
||||
cur="${COMP_WORDS[COMP_CWORD]}"
|
||||
[[ ${cur} == *"$trigger" ]] || return 1
|
||||
cur=${cur:0:${#cur}-${#trigger}}
|
||||
|
||||
tput sc
|
||||
selected=$(cat \
|
||||
<(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | grep -i ^host) \
|
||||
<(grep -v '^\s*\(#\|$\)' /etc/hosts) | \
|
||||
awk '{print $2}' | sort -u | fzf $FZF_COMPLETION_OPTS -q "$cur")
|
||||
tput rc
|
||||
|
||||
if [ -n "$selected" ]; then
|
||||
COMPREPLY=("$selected")
|
||||
return 0
|
||||
fi
|
||||
}
|
||||
|
||||
complete -F _fzf_opts_completion fzf
|
||||
|
||||
# Directory
|
||||
for cmd in "cd pushd rmdir"; do
|
||||
complete -F _fzf_dir_completion -o default -o bashdefault $cmd
|
||||
done
|
||||
|
||||
# File
|
||||
for cmd in "
|
||||
awk cat diff diff3
|
||||
emacs ex file ftp g++ gcc gvim head hg java
|
||||
javac ld less more mvim patch perl python ruby
|
||||
sed sftp sort source tail tee uniq vi view vim wc"; do
|
||||
complete -F _fzf_file_completion -o default -o bashdefault $cmd
|
||||
done
|
||||
|
||||
# Anything
|
||||
for cmd in "
|
||||
basename bunzip2 bzip2 chmod chown curl cp dirname du
|
||||
find git grep gunzip gzip hg jar
|
||||
ln ls mv open rm rsync scp
|
||||
svn tar unzip zip"; do
|
||||
complete -F _fzf_all_completion -o default -o bashdefault $cmd
|
||||
done
|
||||
|
||||
# Kill completion
|
||||
complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
|
||||
|
||||
# Host completion
|
||||
complete -F _fzf_ssh_completion -o default -o bashdefault ssh
|
||||
complete -F _fzf_telnet_completion -o default -o bashdefault telnet
|
||||
|
9
fzf-completion.zsh
Normal file
9
fzf-completion.zsh
Normal file
@@ -0,0 +1,9 @@
|
||||
#!/bin/zsh
|
||||
# ____ ____
|
||||
# / __/___ / __/
|
||||
# / /_/_ / / /_
|
||||
# / __/ / /_/ __/
|
||||
# /_/ /___/_/-completion.zsh
|
||||
#
|
||||
|
||||
# TODO
|
@@ -1,7 +1,7 @@
|
||||
# coding: utf-8
|
||||
Gem::Specification.new do |spec|
|
||||
spec.name = 'fzf'
|
||||
spec.version = '0.4.2'
|
||||
spec.version = '0.8.1'
|
||||
spec.authors = ['Junegunn Choi']
|
||||
spec.email = ['junegunn.c@gmail.com']
|
||||
spec.description = %q{Fuzzy finder for your shell}
|
||||
@@ -12,4 +12,6 @@ Gem::Specification.new do |spec|
|
||||
spec.bindir = '.'
|
||||
spec.files = %w[fzf.gemspec]
|
||||
spec.executables = 'fzf'
|
||||
|
||||
spec.add_runtime_dependency 'curses', '~> 1.0.0'
|
||||
end
|
||||
|
201
install
201
install
@@ -1,7 +1,202 @@
|
||||
#!/bin/bash
|
||||
|
||||
cd `dirname $BASH_SOURCE`
|
||||
mkdir -p ~/bin
|
||||
ln -sf `pwd`/fzf ~/bin/fzf
|
||||
chmod +x ~/bin/fzf
|
||||
fzf_base=`pwd`
|
||||
|
||||
# ruby executable
|
||||
echo -n "Checking Ruby executable ... "
|
||||
ruby=`which ruby`
|
||||
if [ $? -ne 0 ]; then
|
||||
echo "ruby executable not found!"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# System ruby is preferred
|
||||
curses_check="begin; require 'curses'; rescue Exception; exit 1; end"
|
||||
system_ruby=/usr/bin/ruby
|
||||
if [ -x $system_ruby -a $system_ruby != "$ruby" ]; then
|
||||
$system_ruby --disable-gems -e "$curses_check" 2> /dev/null
|
||||
[ $? -eq 0 ] && ruby=$system_ruby
|
||||
fi
|
||||
|
||||
echo "OK ($ruby)"
|
||||
|
||||
# Curses-support
|
||||
echo -n "Checking Curses support ... "
|
||||
"$ruby" -e "$curses_check"
|
||||
if [ $? -eq 0 ]; then
|
||||
echo "OK"
|
||||
else
|
||||
echo "Not found"
|
||||
echo "Installing 'curses' gem ... "
|
||||
/usr/bin/env gem install curses -v 1.0.0
|
||||
if [ $? -ne 0 ]; then
|
||||
echo "Failed to install 'curses' gem."
|
||||
echo "Try installing it as root: sudo gem install curses"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Ruby version
|
||||
echo -n "Checking Ruby version ... "
|
||||
"$ruby" -e 'exit RUBY_VERSION >= "1.9"'
|
||||
if [ $? -eq 0 ]; then
|
||||
echo ">= 1.9"
|
||||
"$ruby" --disable-gems -e "$curses_check"
|
||||
if [ $? -eq 0 ]; then
|
||||
fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
|
||||
else
|
||||
fzf_cmd="$ruby $fzf_base/fzf"
|
||||
fi
|
||||
else
|
||||
echo "< 1.9"
|
||||
fzf_cmd="$ruby $fzf_base/fzf"
|
||||
fi
|
||||
|
||||
# Auto-completion
|
||||
read -p "Do you want to add auto-completion support? ([y]/n) " -n 1 -r
|
||||
echo
|
||||
[[ ! $REPLY =~ ^[Nn]$ ]]
|
||||
auto_completion=$?
|
||||
|
||||
# Key-bindings
|
||||
read -p "Do you want to add key bindings? ([y]/n) " -n 1 -r
|
||||
echo
|
||||
[[ ! $REPLY =~ ^[Nn]$ ]]
|
||||
key_bindings=$?
|
||||
|
||||
echo
|
||||
for shell in bash zsh; do
|
||||
echo -n "Generate ~/.fzf.$shell ... "
|
||||
src=~/.fzf.${shell}
|
||||
|
||||
fzf_completion="source $fzf_base/fzf-completion.${shell}"
|
||||
if [ $auto_completion -ne 0 ]; then
|
||||
fzf_completion="# $fzf_completion"
|
||||
fi
|
||||
|
||||
cat > $src << EOF
|
||||
# Setup fzf function
|
||||
# ------------------
|
||||
unalias fzf 2> /dev/null
|
||||
fzf() {
|
||||
$fzf_cmd "\$@"
|
||||
}
|
||||
export -f fzf > /dev/null
|
||||
|
||||
# Auto-completion
|
||||
# ---------------
|
||||
$fzf_completion
|
||||
|
||||
EOF
|
||||
|
||||
if [ $key_bindings -eq 0 ]; then
|
||||
if [ $shell = bash ]; then
|
||||
cat >> $src << "EOF"
|
||||
# Key bindings
|
||||
# ------------
|
||||
if [[ $- =~ i ]]; then
|
||||
|
||||
__fsel() {
|
||||
find * -path '*/\.*' -prune \
|
||||
-o -type f -print \
|
||||
-o -type d -print \
|
||||
-o -type l -print 2> /dev/null | fzf -m | while read item; do
|
||||
printf '%q ' "$item"
|
||||
done
|
||||
echo
|
||||
}
|
||||
|
||||
if [ -z "$(set -o | grep '^vi.*on')" ]; then
|
||||
# Required to refresh the prompt after fzf
|
||||
bind '"\er": redraw-current-line'
|
||||
|
||||
# CTRL-T - Paste the selected file path into the command line
|
||||
bind '"\C-t": " \C-u \C-a\C-k$(__fsel)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er"'
|
||||
|
||||
# CTRL-R - Paste the selected command from history into the command line
|
||||
bind '"\C-r": " \C-e\C-u$(HISTTIMEFORMAT= history | fzf +s | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
|
||||
else
|
||||
bind '"\C-x\C-e": shell-expand-line'
|
||||
bind '"\C-x\C-r": redraw-current-line'
|
||||
|
||||
# CTRL-T - Paste the selected file path into the command line
|
||||
# - FIXME: Selected items are attached to the end regardless of cursor position
|
||||
bind '"\C-t": "\eddi$(__fsel)\C-x\C-e\e0P$a \C-x\C-r"'
|
||||
|
||||
# CTRL-R - Paste the selected command from history into the command line
|
||||
bind '"\C-r": "\eddi$(HISTTIMEFORMAT= history | fzf +s | sed \"s/ *[0-9]* *//\")\C-x\C-e\e$a\C-x\C-r"'
|
||||
fi
|
||||
|
||||
fi
|
||||
EOF
|
||||
else
|
||||
cat >> $src << "EOF"
|
||||
# Key bindings
|
||||
# ------------
|
||||
# CTRL-T - Paste the selected file path(s) into the command line
|
||||
fzf-file-widget() {
|
||||
local FILES
|
||||
local IFS="
|
||||
"
|
||||
FILES=($(
|
||||
find * -path '*/\.*' -prune \
|
||||
-o -type f -print \
|
||||
-o -type d -print \
|
||||
-o -type l -print 2> /dev/null | fzf -m))
|
||||
unset IFS
|
||||
FILES=$FILES:q
|
||||
LBUFFER="${LBUFFER%% #} $FILES"
|
||||
zle redisplay
|
||||
}
|
||||
zle -N fzf-file-widget
|
||||
bindkey '^T' fzf-file-widget
|
||||
|
||||
# ALT-C - cd into the selected directory
|
||||
fzf-cd-widget() {
|
||||
cd "${$(find * -path '*/\.*' -prune \
|
||||
-o -type d -print 2> /dev/null | fzf):-.}"
|
||||
zle reset-prompt
|
||||
}
|
||||
zle -N fzf-cd-widget
|
||||
bindkey '\ec' fzf-cd-widget
|
||||
|
||||
# CTRL-R - Paste the selected command from history into the command line
|
||||
fzf-history-widget() {
|
||||
LBUFFER=$(fc -l 1 | fzf +s | sed "s/ *[0-9]* *//")
|
||||
zle redisplay
|
||||
}
|
||||
zle -N fzf-history-widget
|
||||
bindkey '^R' fzf-history-widget
|
||||
|
||||
EOF
|
||||
fi
|
||||
fi
|
||||
|
||||
echo "OK"
|
||||
done
|
||||
|
||||
echo
|
||||
for shell in bash zsh; do
|
||||
rc=~/.${shell}rc
|
||||
src="source ~/.fzf.${shell}"
|
||||
|
||||
echo "Update $rc:"
|
||||
echo " - $src"
|
||||
if [ $(grep -F "$src" $rc | wc -l) -gt 0 ]; then
|
||||
echo " - Not added (already being sourced)"
|
||||
else
|
||||
echo $src >> $rc
|
||||
echo " - Added"
|
||||
fi
|
||||
echo
|
||||
done
|
||||
|
||||
cat << EOF
|
||||
Finished. Reload your .bashrc or .zshrc.
|
||||
source ~/.bashrc # bash
|
||||
source ~/.zshrc # zsh
|
||||
|
||||
To uninstall fzf, simply remove the added line.
|
||||
EOF
|
||||
|
||||
|
@@ -23,25 +23,37 @@
|
||||
|
||||
let s:exec = expand('<sfile>:h:h').'/fzf'
|
||||
|
||||
function! fzf#run(command, args)
|
||||
function! s:escape(path)
|
||||
return substitute(a:path, ' ', '\\ ', 'g')
|
||||
endfunction
|
||||
|
||||
function! fzf#run(command, ...)
|
||||
let cwd = getcwd()
|
||||
try
|
||||
let args = copy(a:000)
|
||||
if len(args) > 0 && isdirectory(expand(args[-1]))
|
||||
let dir = remove(args, -1)
|
||||
execute 'chdir '.s:escape(dir)
|
||||
endif
|
||||
let argstr = join(args)
|
||||
let tf = tempname()
|
||||
let prefix = exists('g:fzf_source') ? g:fzf_source.'|' : ''
|
||||
let fzf = executable(s:exec) ? s:exec : 'fzf'
|
||||
let options = empty(a:args) ? get(g:, 'fzf_options', '') : a:args
|
||||
let options = empty(argstr) ? get(g:, 'fzf_options', '') : argstr
|
||||
execute "silent !".prefix.fzf.' '.options." > ".tf
|
||||
if !v:shell_error
|
||||
for line in readfile(tf)
|
||||
if !empty(line)
|
||||
execute a:command.' '.line
|
||||
execute a:command.' '.s:escape(line)
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
finally
|
||||
execute 'chdir '.s:escape(cwd)
|
||||
redraw!
|
||||
silent! call delete(tf)
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
command! -nargs=* FZF call fzf#run('silent e', <q-args>)
|
||||
command! -nargs=* -complete=dir FZF call fzf#run('silent e', <f-args>)
|
||||
|
||||
|
199
test/test_fzf.rb
199
test/test_fzf.rb
@@ -7,40 +7,104 @@ ENV['FZF_EXECUTABLE'] = '0'
|
||||
load 'fzf'
|
||||
|
||||
class TestFZF < MiniTest::Unit::TestCase
|
||||
def setup
|
||||
ENV.delete 'FZF_DEFAULT_SORT'
|
||||
ENV.delete 'FZF_DEFAULT_OPTS'
|
||||
ENV.delete 'FZF_DEFAULT_COMMAND'
|
||||
end
|
||||
|
||||
def test_default_options
|
||||
fzf = FZF.new []
|
||||
assert_equal 1000, fzf.sort
|
||||
assert_equal 1000, fzf.sort
|
||||
assert_equal false, fzf.multi
|
||||
assert_equal true, fzf.color
|
||||
assert_equal Regexp::IGNORECASE, fzf.rxflag
|
||||
assert_equal true, fzf.color
|
||||
assert_equal nil, fzf.rxflag
|
||||
assert_equal true, fzf.mouse
|
||||
end
|
||||
|
||||
begin
|
||||
ENV['FZF_DEFAULT_SORT'] = '1500'
|
||||
fzf = FZF.new []
|
||||
assert_equal 1500, fzf.sort
|
||||
ensure
|
||||
ENV.delete 'FZF_DEFAULT_SORT'
|
||||
end
|
||||
def test_environment_variables
|
||||
# Deprecated
|
||||
ENV['FZF_DEFAULT_SORT'] = '20000'
|
||||
fzf = FZF.new []
|
||||
assert_equal 20000, fzf.sort
|
||||
|
||||
ENV['FZF_DEFAULT_OPTS'] = '-x -m -s 10000 -q " hello world " +c +2 --no-mouse -f "goodbye world" --black'
|
||||
fzf = FZF.new []
|
||||
assert_equal 10000, fzf.sort
|
||||
assert_equal ' hello world ',
|
||||
fzf.query.get
|
||||
assert_equal 'goodbye world',
|
||||
fzf.filter
|
||||
assert_equal :fuzzy, fzf.extended
|
||||
assert_equal true, fzf.multi
|
||||
assert_equal false, fzf.color
|
||||
assert_equal false, fzf.ansi256
|
||||
assert_equal true, fzf.black
|
||||
assert_equal false, fzf.mouse
|
||||
end
|
||||
|
||||
def test_option_parser
|
||||
# Long opts
|
||||
fzf = FZF.new %w[--sort=2000 --no-color --multi +i]
|
||||
assert_equal 2000, fzf.sort
|
||||
assert_equal true, fzf.multi
|
||||
assert_equal false, fzf.color
|
||||
assert_equal 0, fzf.rxflag
|
||||
fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query hello
|
||||
--filter=howdy --extended-exact --no-mouse --no-256]
|
||||
assert_equal 2000, fzf.sort
|
||||
assert_equal true, fzf.multi
|
||||
assert_equal false, fzf.color
|
||||
assert_equal false, fzf.ansi256
|
||||
assert_equal false, fzf.black
|
||||
assert_equal false, fzf.mouse
|
||||
assert_equal 0, fzf.rxflag
|
||||
assert_equal 'hello', fzf.query.get
|
||||
assert_equal 'howdy', fzf.filter
|
||||
assert_equal :exact, fzf.extended
|
||||
|
||||
fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query hello
|
||||
--filter a --filter b --no-256 --black
|
||||
--no-sort -i --color --no-multi --256]
|
||||
assert_equal nil, fzf.sort
|
||||
assert_equal false, fzf.multi
|
||||
assert_equal true, fzf.color
|
||||
assert_equal true, fzf.ansi256
|
||||
assert_equal true, fzf.black
|
||||
assert_equal true, fzf.mouse
|
||||
assert_equal 1, fzf.rxflag
|
||||
assert_equal 'b', fzf.filter
|
||||
assert_equal 'hello', fzf.query.get
|
||||
assert_equal nil, fzf.extended
|
||||
|
||||
# Short opts
|
||||
fzf = FZF.new %w[-s 2000 +c -m +i]
|
||||
assert_equal 2000, fzf.sort
|
||||
assert_equal true, fzf.multi
|
||||
assert_equal false, fzf.color
|
||||
assert_equal 0, fzf.rxflag
|
||||
fzf = FZF.new %w[-s 2000 +c -m +i -qhello -x -fhowdy +2]
|
||||
assert_equal 2000, fzf.sort
|
||||
assert_equal true, fzf.multi
|
||||
assert_equal false, fzf.color
|
||||
assert_equal false, fzf.ansi256
|
||||
assert_equal 0, fzf.rxflag
|
||||
assert_equal 'hello', fzf.query.get
|
||||
assert_equal 'howdy', fzf.filter
|
||||
assert_equal :fuzzy, fzf.extended
|
||||
|
||||
# Left-to-right
|
||||
fzf = FZF.new %w[-s 2000 +c -m +i -qhello -x -fgoodbye +2
|
||||
-s 3000 -c +m -i -q world +x -fworld -2 --black --no-black]
|
||||
assert_equal 3000, fzf.sort
|
||||
assert_equal false, fzf.multi
|
||||
assert_equal true, fzf.color
|
||||
assert_equal true, fzf.ansi256
|
||||
assert_equal false, fzf.black
|
||||
assert_equal 1, fzf.rxflag
|
||||
assert_equal 'world', fzf.query.get
|
||||
assert_equal 'world', fzf.filter
|
||||
assert_equal nil, fzf.extended
|
||||
|
||||
fzf = FZF.new %w[--query hello +s -s 2000 --query=world]
|
||||
assert_equal 2000, fzf.sort
|
||||
assert_equal 'world', fzf.query.get
|
||||
rescue SystemExit => e
|
||||
assert false, "Exited"
|
||||
end
|
||||
|
||||
def test_invalid_option
|
||||
[%w[-s 2000 +s], %w[yo dawg]].each do |argv|
|
||||
[%w[--unknown], %w[yo dawg]].each do |argv|
|
||||
assert_raises(SystemExit) do
|
||||
fzf = FZF.new argv
|
||||
end
|
||||
@@ -139,15 +203,59 @@ class TestFZF < MiniTest::Unit::TestCase
|
||||
# TODO : partial_cache
|
||||
end
|
||||
|
||||
def test_fuzzy_matcher_rxflag
|
||||
assert_equal nil, FZF::FuzzyMatcher.new(nil).rxflag
|
||||
assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag
|
||||
assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag
|
||||
|
||||
assert_equal 1, FZF::FuzzyMatcher.new(nil).rxflag_for('abc')
|
||||
assert_equal 0, FZF::FuzzyMatcher.new(nil).rxflag_for('Abc')
|
||||
assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('abc')
|
||||
assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('Abc')
|
||||
assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('abc')
|
||||
assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('Abc')
|
||||
end
|
||||
|
||||
def test_fuzzy_matcher_case_sensitive
|
||||
# Smart-case match (Uppercase found)
|
||||
assert_equal [['Fruit', [[0, 5]]]],
|
||||
FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
|
||||
|
||||
# Smart-case match (Uppercase not-found)
|
||||
assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
|
||||
FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'fruit', '', '').sort
|
||||
|
||||
# Case-sensitive match (-i)
|
||||
assert_equal [['Fruit', [[0, 5]]]],
|
||||
FZF::FuzzyMatcher.new(0).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
|
||||
|
||||
# Case-insensitive match (+i)
|
||||
assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
|
||||
FZF::FuzzyMatcher.new(Regexp::IGNORECASE).
|
||||
match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
|
||||
end
|
||||
|
||||
def test_extended_fuzzy_matcher_case_sensitive
|
||||
%w['Fruit Fruit$].each do |q|
|
||||
# Smart-case match (Uppercase found)
|
||||
assert_equal [['Fruit', [[0, 5]]]],
|
||||
FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q, '', '').sort
|
||||
|
||||
# Smart-case match (Uppercase not-found)
|
||||
assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
|
||||
FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q.downcase, '', '').sort
|
||||
|
||||
# Case-sensitive match (-i)
|
||||
assert_equal [['Fruit', [[0, 5]]]],
|
||||
FZF::ExtendedFuzzyMatcher.new(0).match(%w[Fruit Grapefruit], q, '', '').sort
|
||||
|
||||
# Case-insensitive match (+i)
|
||||
assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
|
||||
FZF::ExtendedFuzzyMatcher.new(Regexp::IGNORECASE).
|
||||
match(%w[Fruit Grapefruit], q, '', '').sort
|
||||
end
|
||||
end
|
||||
|
||||
def test_extended_fuzzy_matcher
|
||||
matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
|
||||
list = %w[
|
||||
@@ -184,6 +292,11 @@ class TestFZF < MiniTest::Unit::TestCase
|
||||
assert_equal list.length, match.call('j', '').length
|
||||
assert_equal list.length - 1, match.call('^j', '').length
|
||||
|
||||
# ^ + $
|
||||
assert_equal 0, match.call('^juici$', '').length
|
||||
assert_equal 1, match.call('^juice$', '').length
|
||||
assert_equal 0, match.call('^.*$', '').length
|
||||
|
||||
# !
|
||||
assert_equal 0, match.call('!j', '').length
|
||||
|
||||
@@ -273,6 +386,25 @@ class TestFZF < MiniTest::Unit::TestCase
|
||||
FZF.new([]).sort_by_rank(xmatcher.match(list, '01 __', '', '')))
|
||||
end
|
||||
|
||||
def test_extended_exact_mode
|
||||
exact = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :exact
|
||||
fuzzy = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy
|
||||
list = %w[
|
||||
extended-exact-mode-not-fuzzy
|
||||
extended'-fuzzy-mode
|
||||
]
|
||||
assert_equal 2, fuzzy.match(list, 'extended', '', '').length
|
||||
assert_equal 2, fuzzy.match(list, 'mode extended', '', '').length
|
||||
assert_equal 2, fuzzy.match(list, 'xtndd', '', '').length
|
||||
assert_equal 2, fuzzy.match(list, "'-fuzzy", '', '').length
|
||||
|
||||
assert_equal 2, exact.match(list, 'extended', '', '').length
|
||||
assert_equal 2, exact.match(list, 'mode extended', '', '').length
|
||||
assert_equal 0, exact.match(list, 'xtndd', '', '').length
|
||||
assert_equal 1, exact.match(list, "'-fuzzy", '', '').length
|
||||
assert_equal 2, exact.match(list, "-fuzzy", '', '').length
|
||||
end
|
||||
|
||||
if RUBY_PLATFORM =~ /darwin/
|
||||
NFD = '한글'
|
||||
def test_nfc
|
||||
@@ -319,5 +451,30 @@ class TestFZF < MiniTest::Unit::TestCase
|
||||
assert_equal ["a", "b", "c", "\xFF", "d", "e", "f"],
|
||||
FZF::UConv.split("abc\xFFdef")
|
||||
end
|
||||
|
||||
# ^$ -> matches empty item
|
||||
def test_format_empty_item
|
||||
fzf = FZF.new []
|
||||
item = ['', [[0, 0]]]
|
||||
line, offsets = fzf.convert_item item
|
||||
tokens = fzf.format line, 80, offsets
|
||||
assert_equal [], tokens
|
||||
end
|
||||
|
||||
def test_mouse_event
|
||||
interval = FZF::MouseEvent::DOUBLE_CLICK_INTERVAL
|
||||
me = FZF::MouseEvent.new nil
|
||||
me.v = 10
|
||||
assert_equal false, me.double?(10)
|
||||
assert_equal false, me.double?(20)
|
||||
me.v = 20
|
||||
assert_equal false, me.double?(10)
|
||||
assert_equal false, me.double?(20)
|
||||
me.v = 20
|
||||
assert_equal false, me.double?(10)
|
||||
assert_equal true, me.double?(20)
|
||||
sleep interval
|
||||
assert_equal false, me.double?(20)
|
||||
end
|
||||
end
|
||||
|
||||
|
Reference in New Issue
Block a user