pax_global_header 0000666 0000000 0000000 00000000064 13032173445 0014514 g ustar 00root root 0000000 0000000 52 comment=19dae1c21eacaf5c655d62fe18b147eb13066dd8
fzy-0.8/ 0000775 0000000 0000000 00000000000 13032173445 0012173 5 ustar 00root root 0000000 0000000 fzy-0.8/.clang-format 0000664 0000000 0000000 00000000210 13032173445 0014537 0 ustar 00root root 0000000 0000000 IndentWidth: 8
UseTab: Always
BreakBeforeBraces: Attach
IndentCaseLabels: true
AllowShortFunctionsOnASingleLine: false
ColumnLimit: 100
fzy-0.8/.gitignore 0000664 0000000 0000000 00000000067 13032173445 0014166 0 ustar 00root root 0000000 0000000 fzy
fzytest
*.o
config.h
test/acceptance/vendor/bundle
fzy-0.8/.travis.yml 0000664 0000000 0000000 00000000145 13032173445 0014304 0 ustar 00root root 0000000 0000000 language: c
script: make && make check
compiler:
- clang
- gcc
os:
- linux
- osx
sudo: false
fzy-0.8/ALGORITHM.md 0000664 0000000 0000000 00000015442 13032173445 0014051 0 ustar 00root root 0000000 0000000
This document describes the scoring algorithm of fzy as well as the algorithm
of other similar projects.
# Matching vs Scoring
I like to split the problem a fuzzy matchers into two subproblems: matching and scoring.
Matching determines which results are eligible for the list.
All the projects here consider this to be the same problem, matching the
candidate strings against the search string with any number of gaps.
Scoring determines the order in which the results are sorted.
Since scoring is tasked with finding what the human user intended, there is no
correct solution. As a result there are large variety in scoring strategies.
# fzy's matching
Generally, more time is taken in matching rather than scoring, so it is
important that matching be as fast as possible. If this were case sensitive it
would be a simple loop calling strchr, but since it needs to be case
insensitive.
# fzy's scoring
fzy treats scoring as a modified [edit
distance](https://en.wikipedia.org/wiki/Edit_distance) problem of calculating
the
[Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance).
Edit distance is the measure of how different two strings are in terms of
insertions, deletions, and substitutions. This is the same problems as [DNA
sequence alignment](https://en.wikipedia.org/wiki/Sequence_alignment). Fuzzy
matching is a simpler problem which only accepts insertions, not deletions or
substitutions.
fzy's scoring is a dynamic programming algorithm similar to
[Wagner–Fischer](https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm)
and
[Needleman–Wunsch](https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm).
Dynamic programming requires the observation that the result is based on the
result of subproblems.
Fzy borrows heavily from concepts in bioinformatics to performs scoring.
Fzy builds a `n`-by-`m` matrix, where `n` is the length of the search string
and `m` the length of the candidate string. Each position `(i,j)` in the matrix
stores the score for matching the first `i` characters of the search with the
first `j` characters of the candidate.
Fzy calculates an affine gap penalty, this means simply that we assign a
constant penalty for having a gap and a linear penalty for the length of the
gap.
Inspired by the [Gotoh algorithm
(pdf)](http://www.cs.unibo.it/~dilena/LabBII/Papers/AffineGaps.pdf), fzy
computes a second `D` (for diagonal) matrix in parallel with the score matrix.
The `D` matrix computes the best score which *ends* in a match. This allows
both computation of the penalty for starting a gap and the score for a
consecutive match.
Using [this
algorithm](https://github.com/jhawthorn/fzy/blob/master/src/match.c#L58) fzy
is able to score based on the optimal match.
* Gaps (negative score)
* at the start of the match
* at the end of the match
* within the match
* Matches (positive score)
* consecutive
* following a slash
* following a space, underscore, or dash (the start of a word)
* capital letter (the start of a CamelCase word)
* following a dot (often a file extension)
# Other fuzzy finders
## TextMate
TextMate deserves immense credit for popularizing fuzzy finding from inside
text editors. It's influence can be found in the commant-t project, various
other editors use command-t for file finding, and the 't' command in the github
web interface.
* https://github.com/textmate/textmate/blob/master/Frameworks/text/src/ranker.cc
## command-t, ctrlp-cmatcher
Command is a plugin first released in 2010 intending to bring TextMate's
"Go to File" feature to vim.
Anecdotally, this algorithm works very well. The recursive nature makes it a little hard to
The wy `last_idx` is suspicious.
* https://github.com/wincent/command-t/blob/master/ruby/command-t/match.c
* https://github.com/JazzCore/ctrlp-cmatcher/blob/master/autoload/fuzzycomt.c
## Length of shortest first match: fzf
https://github.com/junegunn/fzf/blob/master/src/algo/algo.go
Fzy scores based on the size of the greedy shortest match. fzf finds it's match
by the first match appearing in the candidate string. It has some cleverness to
find if there is a shorter match contained in that search, but it isn't
guaranteed to find the shortest match in the string.
Example results for the search "abc"
* **AXXBXXC**xxabc
* xxxxxxx**AXBXC**
* xxxxxxxxx**ABC**
## Length of first match: ctrlp, pick, selecta (`<= 0.0.6`)
These score based on the length of the first match in the candidate. This is
probably the simplest useful algorithm. This has the advantage that the heavy
lifting can be performed by the regex engine, which is faster than implementing
anything natively in ruby or Vim script.
## Length of shortest match: pick
Pick has a method, `min_match`, to find the absolute shortest match in a string.
This will find better results than the finders, at the expense of speed, as backtracking is required.
## selecta (latest master)
https://github.com/garybernhardt/selecta/commit/d874c99dd7f0f94225a95da06fc487b0fa5b9edc
https://github.com/garybernhardt/selecta/issues/80
Selecta doesn't compare all possible matches, but only the shortest match from the same start location.
This can lead to inconsistent results.
Example results for the search "abc"
* x**AXXXXBC**
* x**ABXC**x
* x**ABXC**xbc
The third result here shoud have been scored the same as the first, but the
lower scoring but shorter match is what is measured.
## others
* https://github.com/joshaven/string_score/blob/master/coffee/string_score.coffee (first match + heuristics)
* https://github.com/atom/fuzzaldrin/blob/master/src/scorer.coffee (modified version of string_score)
* https://github.com/jeancroy/fuzzaldrin-plus/blob/master/src/scorer.coffee (Smith Waterman)
# Possible fzy Algorithm Improvements
## Multithreading
Currently a single thread is used for finding matches. Using multiple threads
would likely be faster, but require some additional complexity.
## Case sensitivity
fzy currently treats all searches as case-insensitive. However, scoring prefers
matches on uppercase letters to help find CamelCase candidates. It might be
desirable to support a case sensitive flag or "smart case" searching.
## Faster matching
Matching is currently performed using the standard lib's `strpbrk`, which has a
very simple implementation (at least in glibc).
Glibc has an extremely clever `strchr` implementation which searches the haystack
string by [word](https://en.wikipedia.org/wiki/Word_(computer_architecture)), a
4 or 8 byte `long int`, instead of by byte. It tests if a word is likely to
contain either the search char or the null terminator using bit twiddling.
A similar method could probably be written to perform to find a character in a
string case-insensitively.
* https://sourceware.org/git/?p=glibc.git;a=blob;f=string/strchr.c;h=f73891d439dcd8a08954fad4d4615acac4e0eb85;hb=HEAD
fzy-0.8/CHANGELOG.md 0000664 0000000 0000000 00000002167 13032173445 0014012 0 ustar 00root root 0000000 0000000 ## 0.8 (2017-01-01)
Bugfixes:
- Fix cursor position shifing upwards when input has less than 2 items.
## 0.7 (2016-08-03)
Bugfixes:
- Fixed a segfault when encountering non-ascii characters
- Fixed building against musl libc
## 0.6 (2016-07-26)
Performance:
- Use threads to parallelize searching and scoring
- Read all pending input from tty before searching
- Use a lookup table for computing bonuses
Bugfixes:
- Fixed command line parsing on ARM
- Fix error when autocompleting and there are no matches
## 0.5 (2016-06-11)
Bugfixes:
- Made sorting stable on all platforms
## 0.4 (May 19, 2016)
Features:
- Add `-q`/`--query` for specifying initial query
Bugfixes:
- Fixed last line of results not being cleared on exit
- Check errors when opening the TTY device
## 0.3 (April 25, 2016)
Bugfixes:
- Runs properly in a terminal with -icrnl
## 0.2 (October 19, 2014)
Features:
- Allow specifying custom prompt
Performance:
- Reduce memory usage on large sets
Bugfixes:
- Terminal is properly reset on exit
- Fixed make install on OS X
## 0.1 (September 20, 2014)
Initial release
fzy-0.8/LICENSE 0000664 0000000 0000000 00000002070 13032173445 0013177 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2014 John Hawthorn
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
fzy-0.8/Makefile 0000664 0000000 0000000 00000002327 13032173445 0013637 0 ustar 00root root 0000000 0000000 VERSION=0.8
CPPFLAGS=-DVERSION=\"${VERSION}\" -D_GNU_SOURCE
CFLAGS+=-Wall -Wextra -g -std=c99 -O3 -pedantic
PREFIX?=/usr/local
MANDIR?=$(PREFIX)/share/man
BINDIR?=$(PREFIX)/bin
DEBUGGER?=
INSTALL=install
INSTALL_PROGRAM=$(INSTALL)
INSTALL_DATA=${INSTALL} -m 644
LIBS=-lpthread
OBJECTS=src/fzy.o src/match.o src/tty.o src/choices.o src/options.o src/tty_interface.o
TESTOBJECTS=test/fzytest.c src/match.o src/choices.o
all: fzy
test/fzytest: $(TESTOBJECTS)
$(CC) $(CFLAGS) $(CCFLAGS) -Isrc -o $@ $(TESTOBJECTS) $(LIBS)
acceptance: fzy
cd test/acceptance && bundle && bundle exec ruby acceptance_test.rb
test: check
check: test/fzytest
$(DEBUGGER) ./test/fzytest
fzy: $(OBJECTS)
$(CC) $(CFLAGS) $(CCFLAGS) -o $@ $(OBJECTS) $(LIBS)
%.o: %.c config.h
$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<
config.h:
cp src/config.def.h config.h
install: fzy
mkdir -p $(DESTDIR)$(BINDIR)
cp fzy $(DESTDIR)$(BINDIR)/
chmod 755 ${DESTDIR}${BINDIR}/fzy
mkdir -p $(DESTDIR)$(MANDIR)/man1
cp fzy.1 $(DESTDIR)$(MANDIR)/man1/
chmod 644 ${DESTDIR}${MANDIR}/man1/fzy.1
fmt:
clang-format -i src/*.c src/*.h
clean:
rm -f fzy test/fzytest src/*.o
veryclean: clean
rm -f config.h
.PHONY: test check all clean veryclean install fmt acceptance
fzy-0.8/README.md 0000664 0000000 0000000 00000007267 13032173445 0013466 0 ustar 00root root 0000000 0000000 
**fzy** is a fast, simple fuzzy text selector for the terminal with an advanced [scoring
algorithm](#sorting).
It's been kind of life-changing.
-@graygilmore
fzy works great btw
-@alexblackie
[](https://travis-ci.org/jhawthorn/fzy)
## Why use this over fzf, pick, selecta, ctrlp, ...?
fzy is faster and shows better results than other fuzzy finders.
Most other fuzzy matchers sort based on the length of a match. fzy tries to
find the result the user intended. It does this by favouring matches on
consecutive letters and starts of words. This allows matching using acronyms or
different parts of the path.
A gory comparison of the sorting used by fuzzy finders can be found in [ALGORITHM.md](ALGORITHM.md)
fzy is designed to be used both as an editor plugin and on the command line.
Rather than clearing the screen, fzy displays its interface directly below the current cursor position, scrolling the screen if necessary.
## Installation
### From source
make
sudo make install
The `PREFIX` environment variable can be used to specify the install location,
the default is `/usr/local`.
### Ubuntu/Debian 64-bit
wget https://github.com/jhawthorn/fzy/releases/download/0.8/fzy_0.8-1_amd64.deb
sudo dpkg -i fzy_0.8-1_amd64.deb
### Fedora/Redhat/CentOS
sudo yum install https://github.com/jhawthorn/fzy/releases/download/0.8/fzy-0.8-1.x86_64.rpm
### Arch Linux
fzy is available
[in the AUR](https://aur.archlinux.org/packages/fzy/)
with a very simple
[PKGBUILD](https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=fzy)
### OS X via Homebrew
brew tap jhawthorn/fzy
brew install fzy
## Usage
fzy is a drop in replacement for [selecta](https://github.com/garybernhardt/selecta), and can be used with its [usage examples](https://github.com/garybernhardt/selecta#usage-examples).
### Use with Vim
fzy can be integrated very simply in vim. There is also [fzy-vim](https://github.com/Dkendal/fzy-vim), a more fully featured vim plugin.
``` vim
function! FzyCommand(choice_command, vim_command)
try
let output = system(a:choice_command . " | fzy ")
catch /Vim:Interrupt/
" Swallow errors from ^C, allow redraw! below
endtry
redraw!
if v:shell_error == 0 && !empty(output)
exec a:vim_command . ' ' . output
endif
endfunction
nnoremap e :call FzyCommand("find -type f", ":e")
nnoremap v :call FzyCommand("find -type f", ":vs")
nnoremap s :call FzyCommand("find -type f", ":sp")
```
Any program can be used to filter files presented through fzy. [ag (the silver searcher)](https://github.com/ggreer/the_silver_searcher) can be used to ignore files specified by `.gitignore`.
``` vim
nnoremap e :call FzyCommand("ag . -l -g ''", ":e")
nnoremap v :call FzyCommand("ag . -l -g ''", ":vs")
nnoremap s :call FzyCommand("ag . -l -g ''", ":sp")
```
## Sorting
fzy attempts to present the best matches first. The following considerations are weighted when sorting:
It prefers consecutive characters: `file` will match file over filter.
It prefers matching the beginning of words: `amp` is likely to match app/models/posts.rb.
It prefers shorter matches: `abce` matches abcdef over abc de.
It prefers shorter candidates: `test` matches tests over testing.
fzy-0.8/fzy.1 0000664 0000000 0000000 00000004245 13032173445 0013072 0 ustar 00root root 0000000 0000000 .TH FZY 1 "2017-01-01" "fzy 0.8"
.SH NAME
fzy \- A fuzzy text selector menu for the terminal.
.SH SYNOPSIS
.B fzy
.IR [OPTION]...
.SH DESCRIPTION
.B fzy is a fuzzy text selector/file finder for the terminal using a search
similar to that of TextMate or CmdT.
fzy reads a list of newline-separated items from stdin to be displayed as a
menu in the terminal.
Upon pressing ENTER, the currently selected item is printed to stdout.
Entering text narrows the items using fuzzy matching. Results are sorted using
heuristics for the best match.
.SH OPTIONS
.TP
.BR \-l ", " \-\-lines =\fILINES\fR
How many lines of items to display. If unspecified, defaults to 10 lines.
.
.TP
.BR \-p ", " \-\-prompt =\fIPROMPT\fR
Input prompt (default: '> ')
.
.TP
.BR \-s ", " \-\-show-scores
Show the scores for each item.
.
.TP
.BR \-t ", " \-\-tty =\fITTY\fR
Use TTY instead of the default tty device (/dev/tty).
.
.TP
.BR \-q ", " \-\-query =\fIQUERY\fR
Use QUERY as the initial search query.
.
.TP
.BR \-e ", " \-\-show-matches =\fIQUERY\fR
Non-interactive mode. Print the matches in sorted order for QUERY to stdout.
.
.TP
.BR \-h ", " \-\-help
Usage help.
.
.TP
.BR \-v ", " \-\-version
Usage help.
.
.SH KEYS
.
.TP
.BR "ENTER"
Print the selected item to stdout and exit
.TP
.BR "Up Arrow, Ctrl+p"
Select the previous item
.TP
.BR "Down Arrow, Ctrl+n"
Select the next item
.TP
Tab
Replace the current search string with the selected item
.TP
.BR "Backspace, Ctrl+h"
Delete the character before the cursor
.TP
.BR Ctrl+w
Delete the word before the cursor
.TP
.BR Ctrl+u
Delete the entire line
.
.SH USAGE EXAMPLES
.
.TP
.BR "ls | fzy"
Present a menu of items in the current directory
.TP
.BR "ls | fzy -l 25"
Same as above, but show 25 lines of items
.TP
.BR "vi $(find -type f | fzy)"
List files under the current directory and open the one selected in vi.
.TP
.BR "cd $(find -type d | fzy)"
Present all directories under current path, and change to the one selected.
.TP
.BR "ps aux | fzy | awk '{ print $2 }' | xargs kill"
List running processes, kill the selected process
.TP
.BR "git checkout $(git branch | cut -c 3- | fzy)"
Same as above, but switching git branches.
.SH AUTHOR
John Hawthorn
fzy-0.8/src/ 0000775 0000000 0000000 00000000000 13032173445 0012762 5 ustar 00root root 0000000 0000000 fzy-0.8/src/bonus.h 0000664 0000000 0000000 00000003461 13032173445 0014265 0 ustar 00root root 0000000 0000000 #ifndef BONUS_H
#define BONUS_H BONUS_H
#include "../config.h"
#define ASSIGN_LOWER(v) \
['a'] = (v), \
['b'] = (v), \
['c'] = (v), \
['d'] = (v), \
['e'] = (v), \
['f'] = (v), \
['g'] = (v), \
['h'] = (v), \
['i'] = (v), \
['j'] = (v), \
['k'] = (v), \
['l'] = (v), \
['m'] = (v), \
['n'] = (v), \
['o'] = (v), \
['p'] = (v), \
['q'] = (v), \
['r'] = (v), \
['s'] = (v), \
['t'] = (v), \
['u'] = (v), \
['v'] = (v), \
['w'] = (v), \
['x'] = (v), \
['y'] = (v), \
['z'] = (v)
#define ASSIGN_UPPER(v) \
['A'] = (v), \
['B'] = (v), \
['C'] = (v), \
['D'] = (v), \
['E'] = (v), \
['F'] = (v), \
['G'] = (v), \
['H'] = (v), \
['I'] = (v), \
['J'] = (v), \
['K'] = (v), \
['L'] = (v), \
['M'] = (v), \
['N'] = (v), \
['O'] = (v), \
['P'] = (v), \
['Q'] = (v), \
['R'] = (v), \
['S'] = (v), \
['T'] = (v), \
['U'] = (v), \
['V'] = (v), \
['W'] = (v), \
['X'] = (v), \
['Y'] = (v), \
['Z'] = (v)
#define ASSIGN_DIGIT(v) \
['0'] = (v), \
['1'] = (v), \
['2'] = (v), \
['3'] = (v), \
['4'] = (v), \
['5'] = (v), \
['6'] = (v), \
['7'] = (v), \
['8'] = (v), \
['9'] = (v)
const score_t bonus_states[3][256] = {
{ 0 },
{
['/'] = SCORE_MATCH_SLASH,
['-'] = SCORE_MATCH_WORD,
['_'] = SCORE_MATCH_WORD,
[' '] = SCORE_MATCH_WORD,
['.'] = SCORE_MATCH_DOT,
},
{
['/'] = SCORE_MATCH_SLASH,
['-'] = SCORE_MATCH_WORD,
['_'] = SCORE_MATCH_WORD,
[' '] = SCORE_MATCH_WORD,
['.'] = SCORE_MATCH_DOT,
/* ['a' ... 'z'] = SCORE_MATCH_CAPITAL, */
ASSIGN_LOWER(SCORE_MATCH_CAPITAL)
}
};
const size_t bonus_index[256] = {
/* ['A' ... 'Z'] = 2 */
ASSIGN_UPPER(2),
/* ['a' ... 'z'] = 1 */
ASSIGN_LOWER(1),
/* ['0' ... '9'] = 1 */
ASSIGN_DIGIT(1)
};
#define COMPUTE_BONUS(last_ch, ch) (bonus_states[bonus_index[(unsigned char)(ch)]][(unsigned char)(last_ch)])
#endif
fzy-0.8/src/choices.c 0000664 0000000 0000000 00000012755 13032173445 0014555 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
#include
#include "choices.h"
#include "match.h"
/* Initial size of buffer for storing input in memory */
#define INITIAL_BUFFER_CAPACITY 4096
/* Initial size of choices array */
#define INITIAL_CHOICE_CAPACITY 128
static int cmpchoice(const void *_idx1, const void *_idx2) {
const struct scored_result *a = _idx1;
const struct scored_result *b = _idx2;
if (a->score == b->score) {
/* To ensure a stable sort, we must also sort by the string
* pointers. We can do this since we know all the stings are
* from a contiguous memory segment (buffer in choices_t).
*/
if (a->str < b->str) {
return -1;
} else {
return 1;
}
} else if (a->score < b->score) {
return 1;
} else {
return -1;
}
}
static void *safe_realloc(void *buffer, size_t size) {
buffer = realloc(buffer, size);
if (!buffer) {
fprintf(stderr, "Error: Can't allocate memory (%zu bytes)\n", size);
abort();
}
return buffer;
}
void choices_fread(choices_t *c, FILE *file) {
/* Save current position for parsing later */
size_t buffer_start = c->buffer_size;
/* Resize buffer to at least one byte more capacity than our current
* size. This uses a power of two of INITIAL_BUFFER_CAPACITY.
* This must work even when c->buffer is NULL and c->buffer_size is 0
*/
size_t capacity = INITIAL_BUFFER_CAPACITY;
while (capacity <= c->buffer_size)
capacity *= 2;
c->buffer = safe_realloc(c->buffer, capacity);
/* Continue reading until we get a "short" read, indicating EOF */
while ((c->buffer_size += fread(c->buffer + c->buffer_size, 1, capacity - c->buffer_size, file)) == capacity) {
capacity *= 2;
c->buffer = safe_realloc(c->buffer, capacity);
}
c->buffer = safe_realloc(c->buffer, c->buffer_size + 1);
c->buffer[c->buffer_size++] = '\0';
/* Truncate buffer to used size, (maybe) freeing some memory for
* future allocations.
*/
/* Tokenize input and add to choices */
char *line = c->buffer + buffer_start;
do {
char *nl = strchr(line, '\n');
if (nl)
*nl++ = '\0';
/* Skip empty lines */
if (*line)
choices_add(c, line);
line = nl;
} while (line);
}
static void choices_resize(choices_t *c, size_t new_capacity) {
c->strings = safe_realloc(c->strings, new_capacity * sizeof(const char *));
c->capacity = new_capacity;
}
static void choices_reset_search(choices_t *c) {
free(c->results);
c->selection = c->available = 0;
c->results = NULL;
}
void choices_init(choices_t *c) {
c->strings = NULL;
c->results = NULL;
c->buffer_size = 0;
c->buffer = NULL;
c->capacity = c->size = 0;
choices_resize(c, INITIAL_CHOICE_CAPACITY);
c->worker_count = (int)sysconf(_SC_NPROCESSORS_ONLN);
choices_reset_search(c);
}
void choices_destroy(choices_t *c) {
free(c->buffer);
c->buffer = NULL;
c->buffer_size = 0;
free(c->strings);
c->strings = NULL;
c->capacity = c->size = 0;
free(c->results);
c->results = NULL;
c->available = c->selection = 0;
}
void choices_add(choices_t *c, const char *choice) {
/* Previous search is now invalid */
choices_reset_search(c);
if (c->size == c->capacity) {
choices_resize(c, c->capacity * 2);
}
c->strings[c->size++] = choice;
}
size_t choices_available(choices_t *c) {
return c->available;
}
struct worker {
pthread_t thread_id;
choices_t *choices;
const char *search;
size_t worker_count;
size_t worker_num;
struct scored_result *results;
size_t available;
};
static void *choices_search_worker(void *data) {
struct worker *w = (struct worker *)data;
const choices_t *c = w->choices;
size_t start = (w->worker_num) * c->size / c->worker_count;
size_t end = (w->worker_num + 1) * c->size / c->worker_count;
for(size_t i = start; i < end; i++) {
if (has_match(w->search, c->strings[i])) {
w->results[w->available].str = c->strings[i];
w->results[w->available].score = match(w->search, c->strings[i]);
w->available++;
}
}
return w;
}
void choices_search(choices_t *c, const char *search) {
choices_reset_search(c);
/* allocate storage for our results */
c->results = malloc(c->size * sizeof(struct scored_result));
if (!c->results) {
fprintf(stderr, "Error: Can't allocate memory\n");
abort();
}
struct worker *workers = calloc(c->worker_count, sizeof(struct worker));
for (unsigned int i = 0; i < c->worker_count; i++) {
workers[i].choices = c;
workers[i].search = search;
workers[i].worker_num = i;
workers[i].results = malloc(c->size * sizeof(struct scored_result)); /* FIXME: This is overkill */
if (pthread_create(&workers[i].thread_id, NULL, &choices_search_worker, &workers[i])) {
perror("pthread_create");
exit(EXIT_FAILURE);
}
}
for (unsigned int i = 0; i < c->worker_count; i++) {
struct worker *w = &workers[i];
if (pthread_join(w->thread_id, NULL)) {
perror("pthread_join");
exit(EXIT_FAILURE);
}
memcpy(&c->results[c->available], w->results, w->available * sizeof(struct scored_result));
c->available += w->available;
free(w->results);
}
free(workers);
if(*search) {
qsort(c->results, c->available, sizeof(struct scored_result), cmpchoice);
}
}
const char *choices_get(choices_t *c, size_t n) {
if (n < c->available) {
return c->results[n].str;
} else {
return NULL;
}
}
score_t choices_getscore(choices_t *c, size_t n) {
return c->results[n].score;
}
void choices_prev(choices_t *c) {
if (c->available)
c->selection = (c->selection + c->available - 1) % c->available;
}
void choices_next(choices_t *c) {
if (c->available)
c->selection = (c->selection + 1) % c->available;
}
fzy-0.8/src/choices.h 0000664 0000000 0000000 00000001447 13032173445 0014556 0 ustar 00root root 0000000 0000000 #ifndef CHOICES_H
#define CHOICES_H CHOICES_H
#include
#include "match.h"
struct scored_result {
score_t score;
const char *str;
};
typedef struct {
char *buffer;
size_t buffer_size;
size_t capacity;
size_t size;
const char **strings;
struct scored_result *results;
size_t available;
size_t selection;
unsigned int worker_count;
} choices_t;
void choices_init(choices_t *c);
void choices_fread(choices_t *c, FILE *file);
void choices_destroy(choices_t *c);
void choices_add(choices_t *c, const char *choice);
size_t choices_available(choices_t *c);
void choices_search(choices_t *c, const char *search);
const char *choices_get(choices_t *c, size_t n);
score_t choices_getscore(choices_t *c, size_t n);
void choices_prev(choices_t *c);
void choices_next(choices_t *c);
#endif
fzy-0.8/src/config.def.h 0000664 0000000 0000000 00000000452 13032173445 0015136 0 ustar 00root root 0000000 0000000 #define TTY_COLOR_HIGHLIGHT TTY_COLOR_YELLOW
#define SCORE_GAP_LEADING -0.005
#define SCORE_GAP_TRAILING -0.005
#define SCORE_GAP_INNER -0.01
#define SCORE_MATCH_CONSECUTIVE 1.0
#define SCORE_MATCH_SLASH 0.9
#define SCORE_MATCH_WORD 0.8
#define SCORE_MATCH_CAPITAL 0.7
#define SCORE_MATCH_DOT 0.6
fzy-0.8/src/fzy.c 0000664 0000000 0000000 00000002534 13032173445 0013742 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
#include
#include "match.h"
#include "tty.h"
#include "choices.h"
#include "options.h"
#include "tty_interface.h"
#include "../config.h"
int main(int argc, char *argv[]) {
int ret = 0;
options_t options;
options_parse(&options, argc, argv);
choices_t choices;
choices_init(&choices);
choices_fread(&choices, stdin);
if (options.benchmark) {
if (!options.filter) {
fprintf(stderr, "Must specify -e/--show-matches with --benchmark\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < options.benchmark; i++)
choices_search(&choices, options.filter);
} else if (options.filter) {
choices_search(&choices, options.filter);
for (size_t i = 0; i < choices_available(&choices); i++) {
if (options.show_scores)
printf("%f\t", choices_getscore(&choices, i));
printf("%s\n", choices_get(&choices, i));
}
} else {
/* interactive */
tty_t tty;
tty_init(&tty, options.tty_filename);
if (options.num_lines > choices.size)
options.num_lines = choices.size;
if (options.num_lines + 1 > tty_getheight(&tty))
options.num_lines = tty_getheight(&tty) - 1;
tty_interface_t tty_interface;
tty_interface_init(&tty_interface, &tty, &choices, &options);
ret = tty_interface_run(&tty_interface);
}
choices_destroy(&choices);
return ret;
}
fzy-0.8/src/match.c 0000664 0000000 0000000 00000010244 13032173445 0014223 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
#include
#include
#include "match.h"
#include "bonus.h"
#include "../config.h"
char *strcasechr(const char *s, char c) {
const char accept[3] = {c, toupper(c), 0};
return strpbrk(s, accept);
}
int has_match(const char *needle, const char *haystack) {
while (*needle) {
char nch = *needle++;
if (!(haystack = strcasechr(haystack, nch))) {
return 0;
}
haystack++;
}
return 1;
}
#define max(a, b) (((a) > (b)) ? (a) : (b))
#ifdef DEBUG_VERBOSE
/* print one of the internal matrices */
void mat_print(score_t *mat, char name, const char *needle, const char *haystack) {
int n = strlen(needle);
int m = strlen(haystack);
int i, j;
fprintf(stderr, "%c ", name);
for (j = 0; j < m; j++) {
fprintf(stderr, " %c", haystack[j]);
}
fprintf(stderr, "\n");
for (i = 0; i < n; i++) {
fprintf(stderr, " %c |", needle[i]);
for (j = 0; j < m; j++) {
score_t val = mat[i * m + j];
if (val == SCORE_MIN) {
fprintf(stderr, " -\u221E");
} else {
fprintf(stderr, " %.3f", val);
}
}
fprintf(stderr, "\n");
}
fprintf(stderr, "\n\n");
}
#endif
static void precompute_bonus(const char *haystack, score_t *match_bonus) {
/* Which positions are beginning of words */
int m = strlen(haystack);
char last_ch = '/';
for (int i = 0; i < m; i++) {
char ch = haystack[i];
match_bonus[i] = COMPUTE_BONUS(last_ch, ch);
last_ch = ch;
}
}
score_t match_positions(const char *needle, const char *haystack, size_t *positions) {
if (!*needle)
return SCORE_MIN;
int n = strlen(needle);
int m = strlen(haystack);
if (n == m) {
/* Since this method can only be called with a haystack which
* matches needle. If the lengths of the strings are equal the
* strings themselves must also be equal (ignoring case).
*/
if (positions)
for (int i = 0; i < n; i++)
positions[i] = i;
return SCORE_MAX;
}
if (m > 1024) {
/*
* Unreasonably large candidate: return no score
* If it is a valid match it will still be returned, it will
* just be ranked below any reasonably sized candidates
*/
return SCORE_MIN;
}
score_t match_bonus[m];
score_t D[n][m], M[n][m];
/*
* D[][] Stores the best score for this position ending with a match.
* M[][] Stores the best possible score at this position.
*/
precompute_bonus(haystack, match_bonus);
for (int i = 0; i < n; i++) {
score_t prev_score = SCORE_MIN;
score_t gap_score = i == n - 1 ? SCORE_GAP_TRAILING : SCORE_GAP_INNER;
for (int j = 0; j < m; j++) {
if (tolower(needle[i]) == tolower(haystack[j])) {
score_t score = SCORE_MIN;
if (!i) {
score = (j * SCORE_GAP_LEADING) + match_bonus[j];
} else if (j) { /* i > 0 && j > 0*/
score = max(
M[i - 1][j - 1] + match_bonus[j],
/* consecutive match, doesn't stack with match_bonus */
D[i - 1][j - 1] + SCORE_MATCH_CONSECUTIVE);
}
D[i][j] = score;
M[i][j] = prev_score = max(score, prev_score + gap_score);
} else {
D[i][j] = SCORE_MIN;
M[i][j] = prev_score = prev_score + gap_score;
}
}
}
#ifdef DEBUG_VERBOSE
fprintf(stderr, "\"%s\" =~ \"%s\"\n", needle, haystack);
mat_print(&D[0][0], 'D', needle, haystack);
mat_print(&M[0][0], 'M', needle, haystack);
fprintf(stderr, "\n");
#endif
/* backtrace to find the positions of optimal matching */
if (positions) {
int match_required = 0;
for (int i = n - 1, j = m - 1; i >= 0; i--) {
for (; j >= 0; j--) {
/*
* There may be multiple paths which result in
* the optimal weight.
*
* For simplicity, we will pick the first one
* we encounter, the latest in the candidate
* string.
*/
if (D[i][j] != SCORE_MIN &&
(match_required || D[i][j] == M[i][j])) {
/* If this score was determined using
* SCORE_MATCH_CONSECUTIVE, the
* previous character MUST be a match
*/
match_required =
i && j &&
M[i][j] == D[i - 1][j - 1] + SCORE_MATCH_CONSECUTIVE;
positions[i] = j--;
break;
}
}
}
}
return M[n - 1][m - 1];
}
score_t match(const char *needle, const char *haystack) {
return match_positions(needle, haystack, NULL);
}
fzy-0.8/src/match.h 0000664 0000000 0000000 00000000534 13032173445 0014231 0 ustar 00root root 0000000 0000000 #ifndef MATCH_H
#define MATCH_H MATCH_H
#include
typedef double score_t;
#define SCORE_MAX INFINITY
#define SCORE_MIN -INFINITY
int has_match(const char *needle, const char *haystack);
score_t match_positions(const char *needle, const char *haystack, size_t *positions);
score_t match(const char *needle, const char *haystack);
#endif
fzy-0.8/src/options.c 0000664 0000000 0000000 00000005507 13032173445 0014630 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
#include
#include "options.h"
static const char *usage_str =
""
"Usage: fzy [OPTION]...\n"
" -l, --lines=LINES Specify how many lines of results to show (default 10)\n"
" -p, --prompt=PROMPT Input prompt (default '> ')\n"
" -q, --query=QUERY Use QUERY as the initial search string\n"
" -e, --show-matches=QUERY Output the sorted matches of QUERY\n"
" -t, --tty=TTY Specify file to use as TTY device (default /dev/tty)\n"
" -s, --show-scores Show the scores of each match\n"
" -h, --help Display this help and exit\n"
" -v, --version Output version information and exit\n";
static void usage(const char *argv0) {
fprintf(stderr, usage_str, argv0);
}
static struct option longopts[] = {{"show-matches", required_argument, NULL, 'e'},
{"query", required_argument, NULL, 'q'},
{"lines", required_argument, NULL, 'l'},
{"tty", required_argument, NULL, 't'},
{"prompt", required_argument, NULL, 'p'},
{"show-scores", no_argument, NULL, 's'},
{"version", no_argument, NULL, 'v'},
{"benchmark", optional_argument, NULL, 'b'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}};
void options_set_defaults(options_t *options) {
/* set defaults */
options->benchmark = 0;
options->filter = NULL;
options->init_search = NULL;
options->tty_filename = "/dev/tty";
options->show_scores = 0;
options->num_lines = 10;
options->scrolloff = 1;
options->prompt = "> ";
}
void options_parse(options_t *options, int argc, char *argv[]) {
options_set_defaults(options);
int c;
while ((c = getopt_long(argc, argv, "vhse:q:l:t:p:", longopts, NULL)) != -1) {
switch (c) {
case 'v':
printf("%s " VERSION " (c) 2014 John Hawthorn\n", argv[0]);
exit(EXIT_SUCCESS);
case 's':
options->show_scores = 1;
break;
case 'q':
options->init_search = optarg;
break;
case 'e':
options->filter = optarg;
break;
case 'b':
if (optarg) {
if (sscanf(optarg, "%d", &options->benchmark) != 1) {
usage(argv[0]);
exit(EXIT_FAILURE);
}
} else {
options->benchmark = 100;
}
break;
case 't':
options->tty_filename = optarg;
break;
case 'p':
options->prompt = optarg;
break;
case 'l': {
int l;
if (!strcmp(optarg, "max")) {
l = INT_MAX;
} else if (sscanf(optarg, "%d", &l) != 1 || l < 3) {
fprintf(stderr, "Invalid format for --lines: %s\n", optarg);
fprintf(stderr, "Must be integer in range 3..\n");
usage(argv[0]);
exit(EXIT_FAILURE);
}
options->num_lines = l;
} break;
case 'h':
default:
usage(argv[0]);
exit(EXIT_SUCCESS);
}
}
if (optind != argc) {
usage(argv[0]);
exit(EXIT_FAILURE);
}
}
fzy-0.8/src/options.h 0000664 0000000 0000000 00000000511 13032173445 0014623 0 ustar 00root root 0000000 0000000 #ifndef OPTIONS_H
#define OPTIONS_H OPTIONS_H
typedef struct {
int benchmark;
const char *filter;
const char *init_search;
const char *tty_filename;
int show_scores;
unsigned int num_lines;
unsigned int scrolloff;
const char *prompt;
} options_t;
void options_parse(options_t *options, int argc, char *argv[]);
#endif
fzy-0.8/src/tty.c 0000664 0000000 0000000 00000005575 13032173445 0013762 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
#include
#include
#include
#include
#include "tty.h"
void tty_reset(tty_t *tty) {
tcsetattr(tty->fdin, TCSANOW, &tty->original_termios);
}
void tty_close(tty_t *tty) {
tty_reset(tty);
fclose(tty->fout);
close(tty->fdin);
}
void tty_init(tty_t *tty, const char *tty_filename) {
tty->fdin = open(tty_filename, O_RDONLY);
if (tty->fdin < 0) {
perror("Failed to open tty");
exit(EXIT_FAILURE);
}
tty->fout = fopen(tty_filename, "w");
if (!tty->fout) {
perror("Failed to open tty");
exit(EXIT_FAILURE);
}
if (setvbuf(tty->fout, NULL, _IOFBF, 4096)) {
perror("setvbuf");
exit(EXIT_FAILURE);
}
if (tcgetattr(tty->fdin, &tty->original_termios)) {
perror("tcgetattr");
exit(EXIT_FAILURE);
}
struct termios new_termios = tty->original_termios;
/*
* Disable all of
* ICANON Canonical input (erase and kill processing).
* ECHO Echo.
* ISIG Signals from control characters
* ICRNL Conversion of CR characters into NL
*/
new_termios.c_iflag &= ~(ICRNL);
new_termios.c_lflag &= ~(ICANON | ECHO | ISIG);
if (tcsetattr(tty->fdin, TCSANOW, &new_termios))
perror("tcsetattr");
tty_getwinsz(tty);
tty_setnormal(tty);
}
void tty_getwinsz(tty_t *tty) {
struct winsize ws;
if (ioctl(fileno(tty->fout), TIOCGWINSZ, &ws) == -1) {
tty->maxwidth = 80;
tty->maxheight = 25;
} else {
tty->maxwidth = ws.ws_col;
tty->maxheight = ws.ws_row;
}
}
char tty_getchar(tty_t *tty) {
char ch;
int size = read(tty->fdin, &ch, 1);
if (size < 0) {
perror("error reading from tty");
exit(EXIT_FAILURE);
} else if (size == 0) {
/* EOF */
exit(EXIT_FAILURE);
} else {
return ch;
}
}
int tty_input_ready(tty_t *tty) {
fd_set readfs;
struct timeval tv = {0, 0};
FD_SET(tty->fdin, &readfs);
select(tty->fdin + 1, &readfs, NULL, NULL, &tv);
return FD_ISSET(tty->fdin, &readfs);
}
static void tty_sgr(tty_t *tty, int code) {
tty_printf(tty, "%c%c%im", 0x1b, '[', code);
}
void tty_setfg(tty_t *tty, int fg) {
if (tty->fgcolor != fg) {
tty_sgr(tty, 30 + fg);
tty->fgcolor = fg;
}
}
void tty_setinvert(tty_t *tty) {
tty_sgr(tty, 7);
}
void tty_setnormal(tty_t *tty) {
tty_sgr(tty, 0);
tty->fgcolor = 9;
}
void tty_newline(tty_t *tty) {
tty_printf(tty, "%c%cK\n", 0x1b, '[');
}
void tty_clearline(tty_t *tty) {
tty_printf(tty, "%c%cK", 0x1b, '[');
}
void tty_setcol(tty_t *tty, int col) {
tty_printf(tty, "%c%c%iG", 0x1b, '[', col + 1);
}
void tty_moveup(tty_t *tty, int i) {
tty_printf(tty, "%c%c%iA", 0x1b, '[', i);
}
void tty_printf(tty_t *tty, const char *fmt, ...) {
va_list args;
va_start(args, fmt);
vfprintf(tty->fout, fmt, args);
va_end(args);
}
void tty_flush(tty_t *tty) {
fflush(tty->fout);
}
size_t tty_getwidth(tty_t *tty) {
return tty->maxwidth;
}
size_t tty_getheight(tty_t *tty) {
return tty->maxheight;
}
fzy-0.8/src/tty.h 0000664 0000000 0000000 00000002316 13032173445 0013755 0 ustar 00root root 0000000 0000000 #ifndef TTY_H
#define TTY_H TTY_H
#include
typedef struct {
int fdin;
FILE *fout;
struct termios original_termios;
int fgcolor;
size_t maxwidth;
size_t maxheight;
} tty_t;
void tty_reset(tty_t *tty);
void tty_close(tty_t *tty);
void tty_init(tty_t *tty, const char *tty_filename);
void tty_getwinsz(tty_t *tty);
char tty_getchar(tty_t *tty);
int tty_input_ready(tty_t *tty);
void tty_setfg(tty_t *tty, int fg);
void tty_setinvert(tty_t *tty);
void tty_setnormal(tty_t *tty);
#define TTY_COLOR_BLACK 0
#define TTY_COLOR_RED 1
#define TTY_COLOR_GREEN 2
#define TTY_COLOR_YELLOW 3
#define TTY_COLOR_BLUE 4
#define TTY_COLOR_MAGENTA 5
#define TTY_COLOR_CYAN 6
#define TTY_COLOR_WHITE 7
#define TTY_COLOR_NORMAL 9
/* tty_newline
* Move cursor to the beginning of the next line, clearing to the end of the
* current line
*/
void tty_newline(tty_t *tty);
/* tty_clearline
* Clear to the end of the current line without advancing the cursor.
*/
void tty_clearline(tty_t *tty);
void tty_moveup(tty_t *tty, int i);
void tty_setcol(tty_t *tty, int col);
void tty_printf(tty_t *tty, const char *fmt, ...);
void tty_flush(tty_t *tty);
size_t tty_getwidth(tty_t *tty);
size_t tty_getheight(tty_t *tty);
#endif
fzy-0.8/src/tty_interface.c 0000664 0000000 0000000 00000016253 13032173445 0015775 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
#include "match.h"
#include "tty_interface.h"
#include "../config.h"
static void clear(tty_interface_t *state) {
tty_t *tty = state->tty;
tty_setcol(tty, 0);
size_t line = 0;
while (line++ < state->options->num_lines) {
tty_newline(tty);
}
tty_clearline(tty);
if (state->options->num_lines > 0) {
tty_moveup(tty, line - 1);
}
tty_flush(tty);
}
static void draw_match(tty_interface_t *state, const char *choice, int selected) {
tty_t *tty = state->tty;
options_t *options = state->options;
char *search = state->last_search;
int n = strlen(search);
size_t positions[n + 1];
for (int i = 0; i < n + 1; i++)
positions[i] = -1;
score_t score = match_positions(search, choice, &positions[0]);
size_t maxwidth = tty_getwidth(tty);
if (options->show_scores) {
if (score == SCORE_MIN) {
tty_printf(tty, "( ) ");
} else {
tty_printf(tty, "(%5.2f) ", score);
}
}
if (selected)
tty_setinvert(tty);
for (size_t i = 0, p = 0; choice[i] != '\0'; i++) {
if (i + 1 < maxwidth) {
if (positions[p] == i) {
tty_setfg(tty, TTY_COLOR_HIGHLIGHT);
p++;
} else {
tty_setfg(tty, TTY_COLOR_NORMAL);
}
tty_printf(tty, "%c", choice[i]);
} else {
tty_printf(tty, "$");
break;
}
}
tty_setnormal(tty);
}
static void draw(tty_interface_t *state) {
tty_t *tty = state->tty;
choices_t *choices = state->choices;
options_t *options = state->options;
unsigned int num_lines = options->num_lines;
size_t start = 0;
size_t current_selection = choices->selection;
if (current_selection + options->scrolloff >= num_lines) {
start = current_selection + options->scrolloff - num_lines + 1;
size_t available = choices_available(choices);
if (start + num_lines >= available && available > 0) {
start = available - num_lines;
}
}
tty_setcol(tty, 0);
tty_printf(tty, "%s%s", options->prompt, state->search);
tty_clearline(tty);
for (size_t i = start; i < start + num_lines; i++) {
tty_printf(tty, "\n");
tty_clearline(tty);
const char *choice = choices_get(choices, i);
if (choice) {
draw_match(state, choice, i == choices->selection);
}
}
if (num_lines > 0) {
tty_moveup(tty, num_lines);
}
tty_setcol(tty, strlen(options->prompt) + strlen(state->search));
tty_flush(tty);
}
static void update_search(tty_interface_t *state) {
choices_search(state->choices, state->search);
strcpy(state->last_search, state->search);
}
static void update_state(tty_interface_t *state) {
if (strcmp(state->last_search, state->search)) {
update_search(state);
draw(state);
}
}
static void action_emit(tty_interface_t *state) {
update_state(state);
/* Reset the tty as close as possible to the previous state */
clear(state);
/* ttyout should be flushed before outputting on stdout */
tty_close(state->tty);
const char *selection = choices_get(state->choices, state->choices->selection);
if (selection) {
/* output the selected result */
printf("%s\n", selection);
} else {
/* No match, output the query instead */
printf("%s\n", state->search);
}
state->exit = EXIT_SUCCESS;
}
static void action_del_char(tty_interface_t *state) {
if (*state->search)
state->search[strlen(state->search) - 1] = '\0';
}
static void action_del_word(tty_interface_t *state) {
size_t search_size = strlen(state->search);
if (search_size)
state->search[--search_size] = '\0';
while (search_size && !isspace(state->search[--search_size]))
state->search[search_size] = '\0';
}
static void action_del_all(tty_interface_t *state) {
strcpy(state->search, "");
}
static void action_prev(tty_interface_t *state) {
update_state(state);
choices_prev(state->choices);
}
static void action_next(tty_interface_t *state) {
update_state(state);
choices_next(state->choices);
}
static void action_pageup(tty_interface_t *state) {
update_state(state);
for(size_t i = 0; i < state->options->num_lines && state->choices->selection > 0; i++)
choices_prev(state->choices);
}
static void action_pagedown(tty_interface_t *state) {
update_state(state);
for(size_t i = 0; i < state->options->num_lines && state->choices->selection < state->choices->available-1; i++)
choices_next(state->choices);
}
static void action_autocomplete(tty_interface_t *state) {
update_state(state);
const char *current_selection = choices_get(state->choices, state->choices->selection);
if (current_selection) {
strncpy(state->search, choices_get(state->choices, state->choices->selection), SEARCH_SIZE_MAX);
}
}
static void action_exit(tty_interface_t *state) {
clear(state);
tty_close(state->tty);
state->exit = EXIT_FAILURE;
}
static void append_search(tty_interface_t *state, char ch) {
char *search = state->search;
size_t search_size = strlen(search);
if (search_size < SEARCH_SIZE_MAX) {
search[search_size++] = ch;
search[search_size] = '\0';
}
}
void tty_interface_init(tty_interface_t *state, tty_t *tty, choices_t *choices, options_t *options) {
state->tty = tty;
state->choices = choices;
state->options = options;
strcpy(state->input, "");
strcpy(state->search, "");
strcpy(state->last_search, "");
state->exit = -1;
if (options->init_search)
strncpy(state->search, options->init_search, SEARCH_SIZE_MAX);
update_search(state);
}
typedef struct {
const char *key;
void (*action)(tty_interface_t *);
} keybinding_t;
#define KEY_CTRL(key) ((const char[]){((key) - ('@')), '\0'})
static const keybinding_t keybindings[] = {{"\x7f", action_del_char}, /* DEL */
{KEY_CTRL('H'), action_del_char}, /* Backspace (C-H) */
{KEY_CTRL('W'), action_del_word}, /* C-W */
{KEY_CTRL('U'), action_del_all}, /* C-U */
{KEY_CTRL('I'), action_autocomplete}, /* TAB (C-I ) */
{KEY_CTRL('C'), action_exit}, /* C-C */
{KEY_CTRL('D'), action_exit}, /* C-D */
{KEY_CTRL('M'), action_emit}, /* CR */
{KEY_CTRL('P'), action_prev}, /* C-P */
{KEY_CTRL('N'), action_next}, /* C-N */
{"\x1b[A", action_prev}, /* UP */
{"\x1bOA", action_prev}, /* UP */
{"\x1b[B", action_next}, /* DOWN */
{"\x1bOB", action_next}, /* DOWN */
{"\x1b[5~", action_pageup},
{"\x1b[6~", action_pagedown},
{NULL, NULL}};
#undef KEY_CTRL
static void handle_input(tty_interface_t *state, const char *s) {
char *input = state->input;
strcat(state->input, s);
/* See if we have matched a keybinding */
for (int i = 0; keybindings[i].key; i++) {
if (!strcmp(input, keybindings[i].key)) {
keybindings[i].action(state);
strcpy(input, "");
return;
}
}
/* Check if we are in the middle of a keybinding */
for (int i = 0; keybindings[i].key; i++)
if (!strncmp(input, keybindings[i].key, strlen(input)))
return;
/* No matching keybinding, add to search */
for (int i = 0; input[i]; i++)
if (isprint(input[i]))
append_search(state, input[i]);
/* We have processed the input, so clear it */
strcpy(input, "");
}
int tty_interface_run(tty_interface_t *state) {
draw(state);
for (;;) {
do {
char s[2] = {tty_getchar(state->tty), '\0'};
handle_input(state, s);
if (state->exit >= 0)
return state->exit;
draw(state);
} while (tty_input_ready(state->tty));
update_state(state);
}
return state->exit;
}
fzy-0.8/src/tty_interface.h 0000664 0000000 0000000 00000001030 13032173445 0015765 0 ustar 00root root 0000000 0000000 #ifndef TTY_INTERFACE_H
#define TTY_INTERFACE_H TTY_INTERFACE_H
#include "choices.h"
#include "options.h"
#include "tty.h"
#define SEARCH_SIZE_MAX 4096
typedef struct {
tty_t *tty;
choices_t *choices;
options_t *options;
char search[SEARCH_SIZE_MAX + 1];
char last_search[SEARCH_SIZE_MAX + 1];
char input[32]; /* Pending input buffer */
int exit;
} tty_interface_t;
void tty_interface_init(tty_interface_t *state, tty_t *tty, choices_t *choices, options_t *options);
int tty_interface_run(tty_interface_t *state);
#endif
fzy-0.8/test/ 0000775 0000000 0000000 00000000000 13032173445 0013152 5 ustar 00root root 0000000 0000000 fzy-0.8/test/acceptance/ 0000775 0000000 0000000 00000000000 13032173445 0015240 5 ustar 00root root 0000000 0000000 fzy-0.8/test/acceptance/Gemfile 0000664 0000000 0000000 00000000073 13032173445 0016533 0 ustar 00root root 0000000 0000000 source 'https://rubygems.org'
gem 'ttytest'
gem 'minitest'
fzy-0.8/test/acceptance/Gemfile.lock 0000664 0000000 0000000 00000000244 13032173445 0017462 0 ustar 00root root 0000000 0000000 GEM
remote: https://rubygems.org/
specs:
minitest (5.10.1)
ttytest (0.4.0)
PLATFORMS
ruby
DEPENDENCIES
minitest
ttytest
BUNDLED WITH
1.13.7
fzy-0.8/test/acceptance/acceptance_test.rb 0000664 0000000 0000000 00000007303 13032173445 0020715 0 ustar 00root root 0000000 0000000 require 'minitest'
require 'minitest/autorun'
require 'ttytest'
class FzyTest < Minitest::Test
FZY_PATH = File.expand_path('../../../fzy', __FILE__)
def setup
# fzy is fast.
# This is never hit in a (passing) test suite, but helps speed up development
TTYtest.default_max_wait_time = 0.2
end
def test_empty_list
@tty = TTYtest.new_terminal(%{echo placeholder;echo -n "" | #{FZY_PATH}})
@tty.assert_cursor_position(y: 1, x: 2)
@tty.assert_matches <<~TTY
placeholder
>
TTY
@tty.send_keys('t')
@tty.assert_cursor_position(y: 1, x: 3)
@tty.assert_matches <<~TTY
placeholder
> t
TTY
@tty.send_keys('z')
@tty.assert_cursor_position(y: 1, x: 4)
@tty.assert_matches <<~TTY
placeholder
> tz
TTY
@tty.send_keys("\r")
@tty.assert_cursor_position(y: 2, x: 0)
@tty.assert_matches <<~TTY
placeholder
tz
TTY
end
def test_one_item
@tty = TTYtest.new_terminal(%{echo placeholder;echo -n "test" | #{FZY_PATH}})
@tty.assert_matches <<~TTY
placeholder
>
test
TTY
@tty.assert_cursor_position(y: 1, x: 2)
@tty.send_keys('t')
@tty.assert_cursor_position(y: 1, x: 3)
@tty.assert_matches <<~TTY
placeholder
> t
test
TTY
@tty.send_keys('z')
@tty.assert_cursor_position(y: 1, x: 4)
@tty.assert_matches <<~TTY
placeholder
> tz
TTY
@tty.send_keys("\r")
@tty.assert_cursor_position(y: 2, x: 0)
@tty.assert_matches <<~TTY
placeholder
tz
TTY
end
def test_two_items
@tty = TTYtest.new_terminal(%{echo placeholder;echo -n "test\nfoo" | #{FZY_PATH}})
@tty.assert_cursor_position(y: 1, x: 2)
@tty.assert_matches <<~TTY
placeholder
>
test
foo
TTY
@tty.send_keys('t')
@tty.assert_cursor_position(y: 1, x: 3)
@tty.assert_matches <<~TTY
placeholder
> t
test
TTY
@tty.send_keys('z')
@tty.assert_cursor_position(y: 1, x: 4)
@tty.assert_matches <<~TTY
placeholder
> tz
TTY
@tty.send_keys("\r")
@tty.assert_matches <<~TTY
placeholder
tz
TTY
@tty.assert_cursor_position(y: 2, x: 0)
end
def ctrl(key)
((key.upcase.ord) - ('A'.ord) + 1).chr
end
def test_editing
@tty = TTYtest.new_terminal(%{echo placeholder;echo -n "test\nfoo" | #{FZY_PATH}})
@tty.assert_cursor_position(y: 1, x: 2)
@tty.assert_matches <<~TTY
placeholder
>
test
foo
TTY
@tty.send_keys("foo bar baz")
@tty.assert_cursor_position(y: 1, x: 13)
@tty.assert_matches <<~TTY
placeholder
> foo bar baz
TTY
@tty.send_keys(ctrl('H'))
@tty.assert_cursor_position(y: 1, x: 12)
@tty.assert_matches <<~TTY
placeholder
> foo bar ba
TTY
@tty.send_keys(ctrl('W'))
@tty.assert_cursor_position(y: 1, x: 10)
@tty.assert_matches <<~TTY
placeholder
> foo bar
TTY
@tty.send_keys(ctrl('U'))
@tty.assert_cursor_position(y: 1, x: 2)
@tty.assert_matches <<~TTY
placeholder
>
test
foo
TTY
end
def test_ctrl_d
@tty = TTYtest.new_terminal(%{echo -n "foo\nbar" | #{FZY_PATH}})
@tty.assert_matches ">\nfoo\nbar"
@tty.send_keys('foo')
@tty.assert_matches "> foo\nfoo"
@tty.send_keys(ctrl('D'))
@tty.assert_matches ''
@tty.assert_cursor_position(y: 0, x: 0)
end
def test_ctrl_c
@tty = TTYtest.new_terminal(%{echo -n "foo\nbar" | #{FZY_PATH}})
@tty.assert_matches ">\nfoo\nbar"
@tty.send_keys('foo')
@tty.assert_matches "> foo\nfoo"
@tty.send_keys(ctrl('C'))
@tty.assert_matches ''
@tty.assert_cursor_position(y: 0, x: 0)
end
end
fzy-0.8/test/fzytest.c 0000664 0000000 0000000 00000021344 13032173445 0015032 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include "../config.h"
#include "match.h"
#include "choices.h"
int testsrun = 0, testsfailed = 0, assertionsrun = 0;
#define assert(x) \
if (++assertionsrun && !(x)) { \
fprintf(stderr, "test \"%s\" failed\n assert(%s) was false\n at %s:%i\n\n", \
__func__, #x, __FILE__, __LINE__); \
raise(SIGTRAP); \
testsfailed++; \
return; \
}
#define assert_streq(a, b) assert(!strcmp(a, b))
void runtest(void (*test)()) {
testsrun++;
test();
}
void test_match() {
assert(has_match("a", "a"));
assert(has_match("a", "ab"));
assert(has_match("a", "ba"));
assert(has_match("abc", "a|b|c"));
/* non-match */
assert(!has_match("a", ""));
assert(!has_match("a", "b"));
assert(!has_match("ass", "tags"));
/* match when query is empty */
assert(has_match("", ""));
assert(has_match("", "a"));
}
void test_relative_scores() {
/* App/Models/Order is better than App/MOdels/zRder */
assert(match("amor", "app/models/order") > match("amor", "app/models/zrder"));
/* App/MOdels/foo is better than App/M/fOo */
assert(match("amo", "app/m/foo") < match("amo", "app/models/foo"));
/* GEMFIle.Lock < GEMFILe */
assert(match("gemfil", "Gemfile.lock") < match("gemfil", "Gemfile"));
/* GEMFIle.Lock < GEMFILe */
assert(match("gemfil", "Gemfile.lock") < match("gemfil", "Gemfile"));
/* Prefer shorter matches */
assert(match("abce", "abcdef") > match("abce", "abc de"));
/* Prefer shorter candidates */
assert(match("test", "tests") > match("test", "testing"));
/* Scores first letter highly */
assert(match("test", "testing") > match("test", "/testing"));
/* Prefer shorter matches */
assert(match("abc", " a b c ") > match("abc", " a b c "));
assert(match("abc", " a b c ") > match("abc", " a b c "));
}
void test_exact_scores() {
/* Exact match is SCORE_MAX */
assert(match("abc", "abc") == SCORE_MAX);
assert(match("aBc", "abC") == SCORE_MAX);
/* Empty query always results in SCORE_MIN */
assert(match("", "") == SCORE_MIN);
assert(match("", "a") == SCORE_MIN);
assert(match("", "bb") == SCORE_MIN);
/* Gaps */
assert(match("a", "*a") == SCORE_GAP_LEADING);
assert(match("a", "*ba") == SCORE_GAP_LEADING*2);
assert(match("a", "**a*") == SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING);
assert(match("a", "**a**") == SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING*2);
assert(match("aa", "**aa**") == SCORE_GAP_LEADING*2 + SCORE_MATCH_CONSECUTIVE + SCORE_GAP_TRAILING*2);
assert(match("aa", "**a*a**") == SCORE_GAP_LEADING + SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_GAP_TRAILING + SCORE_GAP_TRAILING);
/* Consecutive */
assert(match("aa", "*aa") == SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE);
assert(match("aaa", "*aaa") == SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE*2);
assert(match("aaa", "*a*aa") == SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_CONSECUTIVE);
/* Slash */
assert(match("a", "/a") == SCORE_GAP_LEADING + SCORE_MATCH_SLASH);
assert(match("a", "*/a") == SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH);
assert(match("aa", "a/aa") == SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH + SCORE_MATCH_CONSECUTIVE);
/* Capital */
assert(match("a", "bA") == SCORE_GAP_LEADING + SCORE_MATCH_CAPITAL);
assert(match("a", "baA") == SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL);
assert(match("aa", "baAa") == SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL + SCORE_MATCH_CONSECUTIVE);
/* Dot */
assert(match("a", ".a") == SCORE_GAP_LEADING + SCORE_MATCH_DOT);
assert(match("a", "*a.a") == SCORE_GAP_LEADING*3 + SCORE_MATCH_DOT);
assert(match("a", "*a.a") == SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_DOT);
}
void test_positions_1() {
size_t positions[3];
match_positions("amo", "app/models/foo", positions);
assert(positions[0] == 0);
assert(positions[1] == 4);
assert(positions[2] == 5);
}
void test_positions_2() {
/*
* We should prefer matching the 'o' in order, since it's the beginning
* of a word.
*/
size_t positions[4];
match_positions("amor", "app/models/order", positions);
assert(positions[0] == 0);
assert(positions[1] == 4);
assert(positions[2] == 11);
}
void test_positions_3() {
size_t positions[2];
match_positions("as", "tags", positions);
assert(positions[0] == 1);
assert(positions[1] == 3);
}
void test_positions_4() {
size_t positions[2];
match_positions("as", "examples.txt", positions);
assert(positions[0] == 2);
assert(positions[1] == 7);
}
void test_positions_5() {
size_t positions[3];
match_positions("abc", "a/a/b/c/c", positions);
assert(positions[0] == 2);
assert(positions[1] == 4);
assert(positions[2] == 6);
}
void test_positions_exact() {
size_t positions[3];
match_positions("foo", "foo", positions);
assert(positions[0] == 0);
assert(positions[1] == 1);
assert(positions[2] == 2);
}
void test_choices_empty() {
choices_t choices;
choices_init(&choices);
assert(choices.size == 0);
assert(choices.available == 0);
assert(choices.selection == 0);
choices_prev(&choices);
assert(choices.selection == 0);
choices_next(&choices);
assert(choices.selection == 0);
choices_destroy(&choices);
}
void test_choices_1() {
choices_t choices;
choices_init(&choices);
choices_add(&choices, "tags");
choices_search(&choices, "");
assert(choices.available == 1);
assert(choices.selection == 0);
choices_search(&choices, "t");
assert(choices.available == 1);
assert(choices.selection == 0);
choices_prev(&choices);
assert(choices.selection == 0);
choices_next(&choices);
assert(choices.selection == 0);
assert(!strcmp(choices_get(&choices, 0), "tags"));
assert(choices_get(&choices, 1) == NULL);
choices_destroy(&choices);
}
void test_choices_2() {
choices_t choices;
choices_init(&choices);
choices_add(&choices, "tags");
choices_add(&choices, "test");
/* Empty search */
choices_search(&choices, "");
assert(choices.selection == 0);
assert(choices.available == 2);
assert_streq(choices_get(&choices, 0), "tags");
assert_streq(choices_get(&choices, 1), "test");
choices_next(&choices);
assert(choices.selection == 1);
choices_next(&choices);
assert(choices.selection == 0);
choices_prev(&choices);
assert(choices.selection == 1);
choices_prev(&choices);
assert(choices.selection == 0);
/* Filtered search */
choices_search(&choices, "te");
assert(choices.available == 1);
assert(choices.selection == 0);
assert_streq(choices_get(&choices, 0), "test");
choices_next(&choices);
assert(choices.selection == 0);
choices_prev(&choices);
assert(choices.selection == 0);
/* No results */
choices_search(&choices, "foobar");
assert(choices.available == 0);
assert(choices.selection == 0);
/* Different order due to scoring */
choices_search(&choices, "ts");
assert(choices.available == 2);
assert(choices.selection == 0);
assert_streq(choices_get(&choices, 0), "test");
assert_streq(choices_get(&choices, 1), "tags");
choices_destroy(&choices);
}
void test_choices_without_search() {
/* Before a search is run, it should return no results */
choices_t choices;
choices_init(&choices);
assert(choices.available == 0);
assert(choices.selection == 0);
assert(choices.size == 0);
assert(choices_get(&choices, 0) == NULL);
choices_add(&choices, "test");
assert(choices.available == 0);
assert(choices.selection == 0);
assert(choices.size == 1);
assert(choices_get(&choices, 0) == NULL);
choices_destroy(&choices);
}
/* Regression test for segfault */
void test_choices_unicode() {
choices_t choices;
choices_init(&choices);
choices_add(&choices, "Edmund Husserl - Méditations cartésiennes - Introduction a la phénoménologie.pdf");
choices_search(&choices, "e");
choices_destroy(&choices);
}
void summary() {
printf("%i tests, %i assertions, %i failures\n", testsrun, assertionsrun, testsfailed);
}
static void ignore_signal(int signum) {
(void)signum;
}
int main(int argc, char *argv[]) {
(void)argc;
(void)argv;
/* We raise sigtrap on all assertion failures.
* If we have no debugger running, we should ignore it */
signal(SIGTRAP, ignore_signal);
runtest(test_match);
runtest(test_relative_scores);
runtest(test_exact_scores);
runtest(test_positions_1);
runtest(test_positions_2);
runtest(test_positions_3);
runtest(test_positions_4);
runtest(test_positions_5);
runtest(test_positions_exact);
runtest(test_choices_empty);
runtest(test_choices_1);
runtest(test_choices_2);
runtest(test_choices_without_search);
runtest(test_choices_unicode);
summary();
/* exit 0 if all tests pass */
return !!testsfailed;
}