💾 Archived View for tilde.team › ~m040601 › mirrorz › fzf_wiki › gmi_appended_fzf.wiki › Examples.md… captured on 2023-04-26 at 14:29:46. Gemini links have been rewritten to link to archived content
⬅️ Previous capture (2022-07-16)
-=-=-=-=-=-=-
To add a script:
- check it runs on bash and zsh
- add it under an appropriate category in the ToC
Table of Contents
=================
* [i3](#i3)
* [Copy current item to clipboard](#clipboard)
* [Processes](#processes)
* [dotfiles management](#dotfiles-management)
* [Systemctl units](#systemctl-units)
* [man pages](#man-pages)
* [apt](#apt)
* [Pacman/Yay](#pacman)
* [NPM](#npm)
* [Homebrew](#homebrew)
* [Homebrew Cask](#homebrew-cask)
* [Opening files](#opening-files)
* [Changing directory](#changing-directory)
* [Searching file contents](#searching-file-contents)
* [cd](#cd)
* [Integration with <a href="https://github.com/changyuheng/zsh-interactive-cd">zsh-interactive-cd</a>.](#integration-with-zsh-interactive-cd)
* [Interactive cd](#interactive-cd)
* [autojump](#autojump)
* [Integration with <a href="https://github.com/wting/autojump">autojump</a>](#integration-with-autojump)
* [z](#z)
* [Integration with <a href="https://github.com/rupa/z">z</a>.](#integration-with-z)
* [With <a href="https://github.com/changyuheng/fz">fz</a>.](#with-fz)
* [With <a href="https://github.com/clvv/fasd">fasd</a>.](#with-fasd-1)
* [Locate](#locate)
* [Browsing](#browsing)
* [Git](#git)
* [jrnl](#jrnl)
* [tmux](#tmux)
* [dictcc translation](#dictcc-translation)
* [fzf as rofi replacement](#fzf-as-rofi-replacement)
* [fzf as dmenu replacement](#fzf-as-dmenu-replacement)
* [Inspired by v. Opens files in ~/.viminfo](#inspired-by-v-opens-files-in-viminfo)
* [With <a href="https://github.com/clvv/fasd">fasd</a>.](#with-fasd)
* [Browsing history](#browsing-history)
* [Bookmarks](#bookmarks)
Nice collection at https://github.com/DanielFGray/fzf-scripts
# Use fd and fzf to get the args to a command.
# Works only with zsh
# Examples:
# f mv # To move files. You can write the destination after selecting the files.
# f 'echo Selected:'
# f 'echo Selected music:' --extension mp3
# fm rm # To rm files in current directory
f() {
sels=( "${(@f)$(fd "${fd_default[@]}" "${@:2}"| fzf)}" )
test -n "$sels" && print -z -- "$1 ${sels[@]:q:q}"
}
# Like f, but not recursive.
fm() f "$@" --max-depth 1
# Deps
alias fz="fzf-noempty --bind 'tab:toggle,shift-tab:toggle+beginning-of-line+kill-line,ctrl-j:toggle+beginning-of-line+kill-line,ctrl-t:top' --color=light -1 -m"
fzf-noempty () {
local in="$(</dev/stdin)"
test -z "$in" && (
exit 130
) || {
ec "$in" | fzf "$@"
}
}
ec () {
if [[ -n $ZSH_VERSION ]]
then
print -r -- "$@"
else
echo -E -- "$@"
fi
}
Inspired by the above, suggested by [Matt-A-Bennett](https://github.com/Matt-A-Bennett) (not tested in zsh):
# Run command/application and choose paths/files with fzf.
# Always return control of the terminal to user (e.g. when opening GUIs).
# The full command that was used will appear in your history just like any
# other (N.B. to achieve this I write the shell's active history to
# ~/.bash_history)
#
# Usage:
# f cd [OPTION]... (hit enter, choose path)
# f cat [OPTION]... (hit enter, choose files)
# f vim [OPTION]... (hit enter, choose files)
# f vlc [OPTION]... (hit enter, choose files)
f() {
# Store the program
program="$1"
# Remove first argument off the list
shift
# Store option flags with separating spaces, or just set as single space
options="$@"
if [ -z "${options}" ]; then
options=" "
else
options=" $options "
fi
# Store the arguments from fzf
arguments="$(fzf --multi)"
# If no arguments passed (e.g. if Esc pressed), return to terminal
if [ -z "${arguments}" ]; then
return 1
fi
# We want the command to show up in our bash history, so write the shell's
# active history to ~/.bash_history. Then we'll also add the command from
# fzf, then we'll load it all back into the shell's active history
history -w
# ADD A REPEATABLE COMMAND TO THE BASH HISTORY ############################
# Store the arguments in a temporary file for sanitising before being
# entered into bash history
: > /tmp/fzf_tmp
for file in "${arguments[@]}"; do
echo "$file" >> /tmp/fzf_tmp
done
# Put all input arguments on one line and sanitise the command by putting
# single quotes around each argument, also first put an extra single quote
# next to any pre-existing single quotes in the raw argument
sed -i "s/'/''/g; s/.*/'&'/g; s/\n//g" /tmp/fzf_tmp
# If the program is on the GUI list, add a '&' to the command history
if [[ "$program" =~ ^(nautilus|zathura|evince|vlc|eog|kolourpaint)$ ]]; then
sed -i '${s/$/ \&/}' /tmp/fzf_tmp
fi
# Grab the sanitised arguments
arguments="$(cat /tmp/fzf_tmp)"
# Add the command with the sanitised arguments to our .bash_history
echo $program$options$arguments >> ~/.bash_history
# Reload the ~/.bash_history into the shell's active history
history -r
# EXECUTE THE LAST COMMAND IN ~/.bash_history #############################
fc -s -1
# Clean up temporary variables
rm /tmp/fzf_tmp
}
# fe [FUZZY PATTERN] - Open the selected file with the default editor
# - Bypass fuzzy finder if there's only one match (--select-1)
# - Exit if there's no match (--exit-0)
fe() {
IFS=
\n' files=($(fzf-tmux --query="$1" --multi --select-1 --exit-0))
[[ -n "$files" ]] && ${EDITOR:-vim} "${files[@]}"
}
# Modified version where you can press
# - CTRL-O to open with `open` command,
# - CTRL-E or Enter key to open with the $EDITOR
fo() {
IFS=
\n' out=("$(fzf-tmux --query="$1" --exit-0 --expect=ctrl-o,ctrl-e)")
key=$(head -1 <<< "$out")
file=$(head -2 <<< "$out" | tail -1)
if [ -n "$file" ]; then
[ "$key" = ctrl-o ] && open "$file" || ${EDITOR:-vim} "$file"
fi
}
# vf - fuzzy open with vim from anywhere
# ex: vf word1 word2 ... (even part of a file name)
# zsh autoload function
vf() {
local files
files=(${(f)"$(locate -Ai -0 $@ | grep -z -vE '~
| fzf --read0 -0 -1 -m)"})
if [[ -n $files ]]
then
vim -- $files
print -l $files[1]
fi
}
# fuzzy grep open via ag
vg() {
local file
file="$(ag --nobreak --noheading $@ | fzf -0 -1 | awk -F: '{print $1}')"
if [[ -n $file ]]
then
vim $file
fi
}
# fuzzy grep open via ag with line number
vg() {
local file
local line
read -r file line <<<"$(ag --nobreak --noheading $@ | fzf -0 -1 | awk -F: '{print $1, $2}')"
if [[ -n $file ]]
then
vim $file +$line
fi
}
# fd - cd to selected directory
fd() {
local dir
dir=$(find ${1:-.} -path '*/\.*' -prune \
-o -type d -print 2> /dev/null | fzf +m) &&
cd "$dir"
}
# Another fd - cd into the selected directory
# This one differs from the above, by only showing the sub directories and not
# showing the directories within those.
fd() {
DIR=`find * -maxdepth 0 -type d -print 2> /dev/null | fzf-tmux` \
&& cd "$DIR"
}
# fda - including hidden directories
fda() {
local dir
dir=$(find ${1:-.} -type d 2> /dev/null | fzf +m) && cd "$dir"
}
# fdr - cd to selected parent directory
fdr() {
local declare dirs=()
get_parent_dirs() {
if [[ -d "${1}" ]]; then dirs+=("$1"); else return; fi
if [[ "${1}" == '/' ]]; then
for _dir in "${dirs[@]}"; do echo $_dir; done
else
get_parent_dirs $(dirname "$1")
fi
}
local DIR=$(get_parent_dirs $(realpath "${1:-$PWD}") | fzf-tmux --tac)
cd "$DIR"
}
# cf - fuzzy cd from anywhere
# ex: cf word1 word2 ... (even part of a file name)
# zsh autoload function
cf() {
local file
file="$(locate -Ai -0 $@ | grep -z -vE '~
| fzf --read0 -0 -1)"
if [[ -n $file ]]
then
if [[ -d $file ]]
then
cd -- $file
else
cd -- ${file:h}
fi
fi
}
Suggested by [@harelba](https://github.com/harelba) and [@dimonomid](https://github.com/dimonomid):
# cdf - cd into the directory of the selected file
cdf() {
local file
local dir
file=$(fzf +m -q "$1") && dir=$(dirname "$file") && cd "$dir"
}
# Another CTRL-T script to select a directory and paste it into line
__fzf_select_dir ()
{
builtin typeset READLINE_LINE_NEW="$(
command find -L . \( -path '*/\.*' -o -fstype dev -o -fstype proc \) \
-prune \
-o -type f -print \
-o -type d -print \
-o -type l -print 2>/dev/null \
| command sed 1d \
| command cut -b3- \
| env fzf -m
)"
if
[[ -n $READLINE_LINE_NEW ]]
then
builtin bind '"\er": redraw-current-line'
builtin bind '"\e^": magic-space'
READLINE_LINE=${READLINE_LINE:+${READLINE_LINE:0:READLINE_POINT}}${READLINE_LINE_NEW}${READLINE_LINE:+${READLINE_LINE:READLINE_POINT}}
READLINE_POINT=$(( READLINE_POINT + ${#READLINE_LINE_NEW} ))
else
builtin bind '"\er":'
builtin bind '"\e^":'
fi
}
builtin bind -x '"\C-x1": __fzf_select_dir'
builtin bind '"\C-t": "\C-x1\e^\er"'
Fuzzy cd for fish shell: https://gist.github.com/rumpelsepp/b1b416f52d6790de1aee
autojump(macOS) + fzf for fish shell: https://gist.github.com/l4u/06502cf680b9a3817efddfb0a9a6ede8
grep --line-buffered --color=never -r "" * | fzf
# with ag - respects .agignore and .gitignore
ag --nobreak --nonumbers --noheading . | fzf
# using ripgrep combined with preview
# find-in-file - usage: fif <searchTerm>
fif() {
if [ ! "$#" -gt 0 ]; then echo "Need a string to search for!"; return 1; fi
rg --files-with-matches --no-messages "$1" | fzf --preview "highlight -O ansi -l {} 2> /dev/null | rg --colors 'match:bg:yellow' --ignore-case --pretty --context 10 '$1' || rg --ignore-case --pretty --context 10 '$1' {}"
}
# alternative using ripgrep-all (rga) combined with fzf-tmux preview
# This requires ripgrep-all (rga) installed: https://github.com/phiresky/ripgrep-all
# This implementation below makes use of "open" on macOS, which can be replaced by other commands if needed.
# allows to search in PDFs, E-Books, Office documents, zip, tar.gz, etc. (see https://github.com/phiresky/ripgrep-all)
# find-in-file - usage: fif <searchTerm> or fif "string with spaces" or fif "regex"
fif() {
if [ ! "$#" -gt 0 ]; then echo "Need a string to search for!"; return 1; fi
local file
file="$(rga --max-count=1 --ignore-case --files-with-matches --no-messages "$*" | fzf-tmux +m --preview="rga --ignore-case --pretty --context 10 '"$*"' {}")" && echo "opening $file" && open "$file" || return 1;
}
Suggested by [@gbstan](https://github.com/gbstan)
#!/bin/bash
##
# Interactive search.
# Usage: `ff` or `ff <folder>`.
#
[[ -n $1 ]] && cd $1 # go to provided folder or noop
RG_DEFAULT_COMMAND="rg -i -l --hidden --no-ignore-vcs"
selected=$(
FZF_DEFAULT_COMMAND="rg --files" fzf \
-m \
-e \
--ansi \
--disabled \
--reverse \
--bind "ctrl-a:select-all" \
--bind "f12:execute-silent:(subl -b {})" \
--bind "change:reload:$RG_DEFAULT_COMMAND {q} || true" \
--preview "rg -i --pretty --context 2 {q} {}" | cut -d":" -f1,2
)
[[ -n $selected ]] && subl $selected # open multiple files in editor
Suggested by [@knoxknox](https://github.com/knoxknox)
#!/bin/bash
# Interactive search using ag (silver searcher)
[[ -n $1 ]] && cd $1 # go to provided folder or noop
typeset AG_DEFAULT_COMMAND="ag -i -l --hidden"
typeset IFS=
\n'
typeset selected=($(
fzf \
-m \
-e \
--ansi \
--disabled \
--reverse \
--print-query \
--bind "change:reload:$AG_DEFAULT_COMMAND {q} || true" \
--preview "ag -i --color --context=2 {q} {}"))
[ -n "$selected" ] && ${EDITOR} -c "/\\c${selected[0]}" ${selected[1]}
# fh - repeat history
fh() {
eval $( ([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s --tac | sed -E 's/ *[0-9]*\*? *//' | sed -E 's/\\/\\\\/g')
}
# fh - repeat history
fh() {
print -z $( ([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s --tac | sed -E 's/ *[0-9]*\*? *//' | sed -E 's/\\/\\\\/g')
}
Replacing `eval` with `print -z` will push the arguments onto the editing buffer stack, allowing you to edit the command before running it. It also means the command you run will appear in your history rather than just `fh`. Unfortunately this only works for zsh. See below for solutions working with Bash.
These have been tested in bash.
# fh - repeat history
runcmd (){ perl -e 'ioctl STDOUT, 0x5412, $_ for split //, <>' ; }
fh() {
([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s --tac | sed -re 's/^\s*[0-9]+\s*//' | runcmd
}
# fhe - repeat history edit
writecmd (){ perl -e 'ioctl STDOUT, 0x5412, $_ for split //, do{ chomp($_ = <>); $_ }' ; }
fhe() {
([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s --tac | sed -re 's/^\s*[0-9]+\s*//' | writecmd
}
# Another CTRL-R script to insert the selected command from history into the command line/region
__fzf_history ()
{
builtin history -a;
builtin history -c;
builtin history -r;
builtin typeset \
READLINE_LINE_NEW="$(
HISTTIMEFORMAT= builtin history |
command fzf +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r |
command sed '
/^ *[0-9]/ {
s/ *\([0-9]*\) .*/!\1/;
b end;
};
d;
: end
'
)";
if
[[ -n $READLINE_LINE_NEW ]]
then
builtin bind '"\er": redraw-current-line'
builtin bind '"\e^": magic-space'
READLINE_LINE=${READLINE_LINE:+${READLINE_LINE:0:READLINE_POINT}}${READLINE_LINE_NEW}${READLINE_LINE:+${READLINE_LINE:READLINE_POINT}}
READLINE_POINT=$(( READLINE_POINT + ${#READLINE_LINE_NEW} ))
else
builtin bind '"\er":'
builtin bind '"\e^":'
fi
}
builtin set -o histexpand;
builtin bind -x '"\C-x1": __fzf_history';
builtin bind '"\C-r": "\C-x1\e^\er"'
# re-wrote the script above
bind '"\C-r": "\C-x1\e^\er"'
bind -x '"\C-x1": __fzf_history';
__fzf_history ()
{
__ehc $(history | fzf --tac --tiebreak=index | perl -ne 'm/^\s*([0-9]+)/ and print "!$1"')
}
__ehc()
{
if
[[ -n $1 ]]
then
bind '"\er": redraw-current-line'
bind '"\e^": magic-space'
READLINE_LINE=${READLINE_LINE:+${READLINE_LINE:0:READLINE_POINT}}${1}${READLINE_LINE:+${READLINE_LINE:READLINE_POINT}}
READLINE_POINT=$(( READLINE_POINT + ${#1} ))
else
bind '"\er":'
bind '"\e^":'
fi
}
# fkill - kill process
fkill() {
local pid
pid=$(ps -ef | sed 1d | fzf -m | awk '{print $2}')
if [ "x$pid" != "x" ]
then
echo $pid | xargs kill -${1:-9}
fi
}
# fkill - kill processes - list only the ones you can kill. Modified the earlier script.
fkill() {
local pid
if [ "$UID" != "0" ]; then
pid=$(ps -f -u $UID | sed 1d | fzf -m | awk '{print $2}')
else
pid=$(ps -ef | sed 1d | fzf -m | awk '{print $2}')
fi
if [ "x$pid" != "x" ]
then
echo $pid | xargs kill -${1:-9}
fi
}
The https://github.com/NullSense/fuzzy-sys project implements frequently used systemctl unit file manipulating commands.
List all available git commands and help with [`git-commands`](https://github.com/hankchanocd/git-commands)
# fbr - checkout git branch
fbr() {
local branches branch
branches=$(git --no-pager branch -vv) &&
branch=$(echo "$branches" | fzf +m) &&
git checkout $(echo "$branch" | awk '{print $1}' | sed "s/.* //")
}
# fbr - checkout git branch (including remote branches)
fbr() {
local branches branch
branches=$(git branch --all | grep -v HEAD) &&
branch=$(echo "$branches" |
fzf-tmux -d $(( 2 + $(wc -l <<< "$branches") )) +m) &&
git checkout $(echo "$branch" | sed "s/.* //" | sed "s#remotes/[^/]*/##")
}
# fbr - checkout git branch (including remote branches), sorted by most recent commit, limit 30 last branches
fbr() {
local branches branch
branches=$(git for-each-ref --count=30 --sort=-committerdate refs/heads/ --format="%(refname:short)") &&
branch=$(echo "$branches" |
fzf-tmux -d $(( 2 + $(wc -l <<< "$branches") )) +m) &&
git checkout $(echo "$branch" | sed "s/.* //" | sed "s#remotes/[^/]*/##")
}
# fco - checkout git branch/tag
fco() {
local tags branches target
branches=$(
git --no-pager branch --all \
--format="%(if)%(HEAD)%(then)%(else)%(if:equals=HEAD)%(refname:strip=3)%(then)%(else)%1B[0;34;1mbranch%09%1B[m%(refname:short)%(end)%(end)" \
| sed '/^$/d') || return
tags=$(
git --no-pager tag | awk '{print "\x1b[35;1mtag\x1b[m\t" $1}') || return
target=$(
(echo "$branches"; echo "$tags") |
fzf --no-hscroll --no-multi -n 2 \
--ansi) || return
git checkout $(awk '{print $2}' <<<"$target" )
}
# fco_preview - checkout git branch/tag, with a preview showing the commits between the tag/branch and HEAD
fco_preview() {
local tags branches target
branches=$(
git --no-pager branch --all \
--format="%(if)%(HEAD)%(then)%(else)%(if:equals=HEAD)%(refname:strip=3)%(then)%(else)%1B[0;34;1mbranch%09%1B[m%(refname:short)%(end)%(end)" \
| sed '/^$/d') || return
tags=$(
git --no-pager tag | awk '{print "\x1b[35;1mtag\x1b[m\t" $1}') || return
target=$(
(echo "$branches"; echo "$tags") |
fzf --no-hscroll --no-multi -n 2 \
--ansi --preview="git --no-pager log -150 --pretty=format:%s '..{2}'") || return
git checkout $(awk '{print $2}' <<<"$target" )
}
# fcoc - checkout git commit
fcoc() {
local commits commit
commits=$(git log --pretty=oneline --abbrev-commit --reverse) &&
commit=$(echo "$commits" | fzf --tac +s +m -e) &&
git checkout $(echo "$commit" | sed "s/ .*//")
}
# fshow - git commit browser
fshow() {
git log --graph --color=always \
--format="%C(auto)%h%d %s %C(black)%C(bold)%cr" "$@" |
fzf --ansi --no-sort --reverse --tiebreak=index --bind=ctrl-s:toggle-sort \
--bind "ctrl-m:execute:
(grep -o '[a-f0-9]\{7\}' | head -1 |
xargs -I % sh -c 'git show --color=always % | less -R') << 'FZF-EOF'
{}
FZF-EOF"
}
alias glNoGraph='git log --color=always --format="%C(auto)%h%d %s %C(black)%C(bold)%cr% C(auto)%an" "$@"'
_gitLogLineToHash="echo {} | grep -o '[a-f0-9]\{7\}' | head -1"
_viewGitLogLine="$_gitLogLineToHash | xargs -I % sh -c 'git show --color=always % | diff-so-fancy'"
# fcoc_preview - checkout git commit with previews
fcoc_preview() {
local commit
commit=$( glNoGraph |
fzf --no-sort --reverse --tiebreak=index --no-multi \
--ansi --preview="$_viewGitLogLine" ) &&
git checkout $(echo "$commit" | sed "s/ .*//")
}
# fshow_preview - git commit browser with previews
fshow_preview() {
glNoGraph |
fzf --no-sort --reverse --tiebreak=index --no-multi \
--ansi --preview="$_viewGitLogLine" \
--header "enter to view, alt-y to copy hash" \
--bind "enter:execute:$_viewGitLogLine | less -R" \
--bind "alt-y:execute:$_gitLogLineToHash | xclip"
}
Compare against `master` branch with [`git-stack`](https://github.com/hankchanocd/git-stack)
# fcs - get git commit sha
# example usage: git rebase -i `fcs`
fcs() {
local commits commit
commits=$(git log --color=always --pretty=oneline --abbrev-commit --reverse) &&
commit=$(echo "$commits" | fzf --tac +s +m -e --ansi --reverse) &&
echo -n $(echo "$commit" | sed "s/ .*//")
}
# fstash - easier way to deal with stashes
# type fstash to get a list of your stashes
# enter shows you the contents of the stash
# ctrl-d shows a diff of the stash against your current HEAD
# ctrl-b checks the stash out as a branch, for easier merging
fstash() {
local out q k sha
while out=$(
git stash list --pretty="%C(yellow)%h %>(14)%Cgreen%cr %C(blue)%gs" |
fzf --ansi --no-sort --query="$q" --print-query \
--expect=ctrl-d,ctrl-b);
do
mapfile -t out <<< "$out"
q="${out[0]}"
k="${out[1]}"
sha="${out[-1]}"
sha="${sha%% *}"
[[ -z "$sha" ]] && continue
if [[ "$k" == 'ctrl-d' ]]; then
git diff $sha
elif [[ "$k" == 'ctrl-b' ]]; then
git stash branch "stash-$sha" $sha
break;
else
git stash show -p $sha
fi
done
}
Create a gitignore file from [gitignore.io](http://gitignore.io):
https://gist.github.com/phha/cb4f4bb07519dc494609792fb918e167
# fgst - pick files from `git status -s`
is_in_git_repo() {
git rev-parse HEAD > /dev/null 2>&1
}
fgst() {
# "Nothing to see here, move along"
is_in_git_repo || return
local cmd="${FZF_CTRL_T_COMMAND:-"command git status -s"}"
eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" fzf -m "$@" | while read -r item; do
echo "$item" | awk '{print $2}'
done
echo
}
Interactive fixup of a commit
function git-fixup () {
git ll -n 20 | fzf | cut -f 1 | xargs git commit --no-verify --fixup
}
Usage:
git fixup git rebase -i master --autosquash
[Article on fixup and autosquash](https://fle.github.io/git-tip-keep-your-branch-clean-with-fixup-and-autosquash.html).
[The shell plugin `forgit`](https://github.com/wfxr/forgit) implemented the frequently used commands with some improves(support `bash`, `zsh` and `fish`):
Suggested by [@windisch](https://github.com/windisch).
# fjrnl - Search JRNL headlines
fjrnl() {
title=$(jrnl --short | fzf --tac --no-sort) &&
jrnl -on "$(echo $title | cut -c 1-16)" $1
}
# ftags - search ctags
ftags() {
local line
[ -e tags ] &&
line=$(
awk 'BEGIN { FS="\t" } !/^!/ {print toupper($4)"\t"$1"\t"$2"\t"$3}' tags |
cut -c1-80 | fzf --nth=1,2
) && ${EDITOR:-vim} $(cut -f3 <<< "$line") -c "set nocst" \
-c "silent tag $(cut -f2 <<< "$line")"
}
# ftags - search ctags with preview
# only works if tags-file was generated with --excmd=number
ftags() {
local line
[ -e tags ] &&
line=$(
awk 'BEGIN { FS="\t" } !/^!/ {print toupper($4)"\t"$1"\t"$2"\t"$3}' tags |
fzf \
--nth=1,2 \
--with-nth=2 \
--preview-window="50%" \
--preview="bat {3} --color=always | tail -n +\$(echo {4} | tr -d \";\\\"\")"
) && ${EDITOR:-vim} $(cut -f3 <<< "$line") -c "set nocst" \
-c "silent tag $(cut -f2 <<< "$line")"
}
# zsh; needs setopt re_match_pcre. You can, of course, adapt it to your own shell easily.
tmuxkillf () {
local sessions
sessions="$(tmux ls|fzf --exit-0 --multi)" || return $?
local i
for i in "${(f@)sessions}"
do
[[ $i =~ '([^:]*):.*' ]] && {
echo "Killing $match[1]"
tmux kill-session -t "$match[1]"
}
done
}
# tm - create new tmux session, or switch to existing one. Works from within tmux too. (@bag-man)
# `tm` will allow you to select your tmux session via fzf.
# `tm irc` will attach to the irc session (if it exists), else it will create it.
tm() {
[[ -n "$TMUX" ]] && change="switch-client" || change="attach-session"
if [ $1 ]; then
tmux $change -t "$1" 2>/dev/null || (tmux new-session -d -s $1 && tmux $change -t "$1"); return
fi
session=$(tmux list-sessions -F "#{session_name}" 2>/dev/null | fzf --exit-0) && tmux $change -t "$session" || echo "No sessions found."
}
# fs [FUZZY PATTERN] - Select selected tmux session
# - Bypass fuzzy finder if there's only one match (--select-1)
# - Exit if there's no match (--exit-0)
fs() {
local session
session=$(tmux list-sessions -F "#{session_name}" | \
fzf --query="$1" --select-1 --exit-0) &&
tmux switch-client -t "$session"
}
# ftpane - switch pane (@george-b)
ftpane() {
local panes current_window current_pane target target_window target_pane
panes=$(tmux list-panes -s -F '#I:#P - #{pane_current_path} #{pane_current_command}')
current_pane=$(tmux display-message -p '#I:#P')
current_window=$(tmux display-message -p '#I')
target=$(echo "$panes" | grep -v "$current_pane" | fzf +m --reverse) || return
target_window=$(echo $target | awk 'BEGIN{FS=":|-"} {print$1}')
target_pane=$(echo $target | awk 'BEGIN{FS=":|-"} {print$2}' | cut -c 1)
if [[ $current_window -eq $target_window ]]; then
tmux select-pane -t ${target_window}.${target_pane}
else
tmux select-pane -t ${target_window}.${target_pane} &&
tmux select-window -t $target_window
fi
}
# In tmux.conf
# bind-key 0 run "tmux split-window -l 12 'bash -ci ftpane'"
To search for windows and show which is currently active, add [ftwind](https://github.com/pokey/dotfiles/blob/dade6c88af31458c323e8f0247af510bca7af0f5/bin/ftwind) somewhere in your path. Then add eg `bind-key f run -b ftwind` to your `tmux.conf`.
Allows you to select pane with `bind-key + 0`.
Requires [`ftpane()` function](https://github.com/junegunn/fzf/wiki/Examples#tmux).
# Index starts from 1 set-option -g base-index 1 # select-pane (@george-b) bind-key 0 run "tmux split-window -p 40 'bash -ci ftpane'"
ALT-` key will split the current window and start fzf for the entire list of files. The selected files will be pasted on to the original window.
# fzf-locate
bind-key -n 'M-`' run "tmux split-window -p 40 'tmux send-keys -t #{pane_id} \"$(locate / | fzf -m | paste -sd\\ -)\"'"
# Install one or more versions of specified language
# e.g. `vmi rust` # => fzf multimode, tab to mark, enter to install
# if no plugin is supplied (e.g. `vmi<CR>`), fzf will list them for you
# Mnemonic [V]ersion [M]anager [I]nstall
vmi() {
local lang=${1}
if [[ ! $lang ]]; then
lang=$(asdf plugin-list | fzf)
fi
if [[ $lang ]]; then
local versions=$(asdf list-all $lang | fzf --tac --no-sort --multi)
if [[ $versions ]]; then
for version in $(echo $versions);
do; asdf install $lang $version; done;
fi
fi
}
# Remove one or more versions of specified language
# e.g. `vmi rust` # => fzf multimode, tab to mark, enter to remove
# if no plugin is supplied (e.g. `vmi<CR>`), fzf will list them for you
# Mnemonic [V]ersion [M]anager [C]lean
vmc() {
local lang=${1}
if [[ ! $lang ]]; then
lang=$(asdf plugin-list | fzf)
fi
if [[ $lang ]]; then
local versions=$(asdf list $lang | fzf -m)
if [[ $versions ]]; then
for version in $(echo $versions);
do; asdf uninstall $lang $version; done;
fi
fi
}
[fzfimg](https://github.com/seebye/ueberzug/blob/master/examples/fzfimg.sh) allows to display images.
It's a wrapper script, so it supports the same options as fzf does.
Examples:
fzfimg.sh --preview 'draw_preview /some/path/some-image.png'
fzfimg.sh --preview-window top:80% --cycle fzfimg.sh --preview-window bottom:80% --reverse fzfimg.sh --preview-window left:50 fzfimg.sh --preview-window right:80%
[fzf-apt](https://github.com/krickelkrakel/fzf-apt): Select apt packages and build commands based on the selected packages.
# Install (one or multiple) selected application(s)
# using "brew search" as source input
# mnemonic [B]rew [I]nstall [P]ackage
bip() {
local inst=$(brew search "$@" | fzf -m)
if [[ $inst ]]; then
for prog in $(echo $inst);
do; brew install $prog; done;
fi
}
# Update (one or multiple) selected application(s)
# mnemonic [B]rew [U]pdate [P]ackage
bup() {
local upd=$(brew leaves | fzf -m)
if [[ $upd ]]; then
for prog in $(echo $upd);
do; brew upgrade $prog; done;
fi
}
# Delete (one or multiple) selected application(s)
# mnemonic [B]rew [C]lean [P]ackage (e.g. uninstall)
bcp() {
local uninst=$(brew leaves | fzf -m)
if [[ $uninst ]]; then
for prog in $(echo $uninst);
do; brew uninstall $prog; done;
fi
}
# Install or open the webpage for the selected application
# using brew cask search as input source
# and display a info quickview window for the currently marked application
install() {
local token
token=$(brew search --casks "$1" | fzf-tmux --query="$1" +m --preview 'brew info {}')
if [ "x$token" != "x" ]
then
echo "(I)nstall or open the (h)omepage of $token"
read input
if [ $input = "i" ] || [ $input = "I" ]; then
brew install --cask $token
fi
if [ $input = "h" ] || [ $input = "H" ]; then
brew home $token
fi
fi
}
# Uninstall or open the webpage for the selected application
# using brew list as input source (all brew cask installed applications)
# and display a info quickview window for the currently marked application
uninstall() {
local token
token=$(brew list --casks | fzf-tmux --query="$1" +m --preview 'brew info {}')
if [ "x$token" != "x" ]
then
echo "(U)ninstall or open the (h)omepae of $token"
read input
if [ $input = "u" ] || [ $input = "U" ]; then
brew uninstall --cask $token
fi
if [ $input = "h" ] || [ $token = "h" ]; then
brew home $token
fi
fi
}
# v - open files in ~/.viminfo
v() {
local files
files=$(grep '^>' ~/.viminfo | cut -c3- |
while read line; do
[ -f "${line/\~/$HOME}" ] && echo "$line"
done | fzf-tmux -d -m -q "$*" -1) && vim ${files//\~/$HOME}
}
Suggested by [@epiloque](https://github.com/epiloque)
v() {
local file
file="$(fasd -Rfl "$1" | fzf -1 -0 --no-sort +m)" && vi "${file}" || return 1
}
Suggested by [@mazinbokhari](https://github.com/mazinbokhari/dotfiles)
# fasd & fzf change directory - open best matched file using `fasd` if given argument, filter output of `fasd` using `fzf` else
v() {
[ $# -gt 0 ] && fasd -f -e ${EDITOR} "$*" && return
local file
file="$(fasd -Rfl "$1" | fzf -1 -0 --no-sort +m)" && vi "${file}" || return 1
}
Fish like interactive tab completion for cd in zsh.
Suggested by [@mgild](https://github.com/mgild)
Like normal cd but opens an interactive navigation window when called with no arguments. For ls, use -FG instead of --color=always on osx.
function cd() {
if [[ "$#" != 0 ]]; then
builtin cd "$@";
return
fi
while true; do
local lsd=$(echo ".." && ls -p | grep '/
| sed 's;/$;;')
local dir="$(printf '%s\n' "${lsd[@]}" |
fzf --reverse --preview '
__cd_nxt="$(echo {})";
__cd_path="$(echo $(pwd)/${__cd_nxt} | sed "s;//;/;")";
echo $__cd_path;
echo;
ls -p --color=always "${__cd_path}";
')"
[[ ${#dir} != 0 ]] || return 0
builtin cd "$dir" &> /dev/null
done
}
like normal autojump when used with arguments but displays an fzf prompt when used without
j() {
if [[ "$#" -ne 0 ]]; then
cd $(autojump $@)
return
fi
cd "$(autojump -s | sort -k1gr | awk '$1 ~ /[0-9]:/ && $2 ~ /^\// { for (i=2; i<=NF; i++) { print $(i) } }' | fzf --height 40% --reverse --inline-info)"
}
like normal z when used with arguments but displays an fzf prompt when used without.
unalias z 2> /dev/null
z() {
[ $# -gt 0 ] && _z "$*" && return
cd "$(_z -l 2>&1 | fzf --height 40% --nth 2.. --reverse --inline-info +s --tac --query "${*##-* }" | sed 's/^[0-9,.]* *//')"
}
Here is another version that also supports relaunching z with the arguments
for the previous command as the default input by using zz
unalias z
z() {
if [[ -z "$*" ]]; then
cd "$(_z -l 2>&1 | fzf +s --tac | sed 's/^[0-9,.]* *//')"
else
_last_z_args="$@"
_z "$@"
fi
}
zz() {
cd "$(_z -l 2>&1 | sed 's/^[0-9,.]* *//' | fzf -q "$_last_z_args")"
}
Since z is not very optimal located on a qwerty keyboard I have these aliased as j and jj
alias j=z alias jj=zz
It's yet another z integration. In this version, fuzzy search is enabled with tab completion.
Suggested by [@l4u](https://github.com/l4u) and [@epiloque](https://github.com/epiloque)
z() {
local dir
dir="$(fasd -Rdl "$1" | fzf -1 -0 --no-sort +m)" && cd "${dir}" || return 1
}
Suggested by [@mazinbokhari](https://github.com/mazinbokhari/dotfiles)
# fasd & fzf change directory - jump using `fasd` if given argument, filter output of `fasd` using `fzf` else
z() {
[ $# -gt 0 ] && fasd_cd -d "$*" && return
local dir
dir="$(fasd -Rdl "$1" | fzf -1 -0 --no-sort +m)" && cd "${dir}" || return 1
}
Yet another useful application for `fzf`: shell bookmarks. It looks as follows:
See complete article for details: [Fuzzy bookmarks for your shell](http://dmitryfrank.com/articles/shell_shortcuts)
OSX/Linux Version:
# c - browse chrome history
c() {
local cols sep google_history open
cols=$(( COLUMNS / 3 ))
sep='{::}'
if [ "$(uname)" = "Darwin" ]; then
google_history="$HOME/Library/Application Support/Google/Chrome/Default/History"
open=open
else
google_history="$HOME/.config/google-chrome/Default/History"
open=xdg-open
fi
cp -f "$google_history" /tmp/h
sqlite3 -separator $sep /tmp/h \
"select substr(title, 1, $cols), url
from urls order by last_visit_time desc" |
awk -F $sep '{printf "%-'$cols's \x1b[36m%s\x1b[m\n", $1, $2}' |
fzf --ansi --multi | sed 's#.*\(https*://\)#\1#' | xargs $open > /dev/null 2> /dev/null
}
Windows Version:
Function c() {
$Columns = [int]((get-host).ui.rawui.WindowSize.Width / 3)
$Separator ='{::}'
$History = "$env:USERPROFILE\AppData\Local\Google\Chrome\User Data\Default\History"
$TempFile = New-TemporaryFile
$Query = "select substr(title, 1, $Columns), url from urls order by last_visit_time desc"
Copy-Item $History -Destination $TempFile
@(sqlite3 -separator "$Separator" "$TempFile" "$Query") |
ForEach-Object {
$Title, $Url = ($_ -split $Separator)[0, 1]
"$($Title.PadRight($Columns)) `e[36m$Url`e[0m"
} | fzf --ansi --multi | ForEach-Object{start-process "chrome.exe" ($_ -replace '.*(https*://)', '$1'),'--profile-directory="Default"'}
}
Chrome Bookmarks browser with [jq](https://stedolan.github.io/jq/) for OS X
# b - browse chrome bookmarks
b() {
bookmarks_path=~/Library/Application\ Support/Google/Chrome/Default/Bookmarks
jq_script='
def ancestors: while(. | length >= 2; del(.[-1,-2]));
. as $in | paths(.url?) as $key | $in | getpath($key) | {name,url, path: [$key[0:-2] | ancestors as $a | $in | getpath($a) | .name?] | reverse | join("/") } | .path + "/" + .name + "\t" + .url'
jq -r "$jq_script" < "$bookmarks_path" \
| sed -E
s/(.*)\t(.*)/\\1\t\x1b[36m\\2\x1b[m/g' \
| fzf --ansi \
| cut -d
\t' -f2 \
| xargs open
}
Chrome Bookmarks browser with [jq](https://stedolan.github.io/jq/) for Windows
# b - browse chrome bookmarks
Function b() {
$Bookmarks = "$env:LOCALAPPDATA\Google\Chrome\User Data\Default\Bookmarks"
$JqScript=@"
def ancestors: while(. | length >= 2; del(.[-1,-2]));
. as `$in | paths(.url?) as `$key | `$in | getpath(`$key) | {name,url, path: [`$key[0:-2] | ancestors as `$a | `$in | getpath(`$a) | .name?] | reverse | join(\`"/\`") } | .path + \`"/\`" + .name + \`"|\`" + .url
"@
Get-Content "$Bookmarks" | jq -r "$JqScript" `
| ForEach-Object {
$_ -replace "(.*)\|(.*)", "`$1`t`e[36m`$2`e[0m"
} `
| fzf --ansi `
| ForEach-Object {
start-process "chrome.exe" ($_ -split "`t")[1],'--profile-directory="Default"'
}
}
Chrome Bookmarks browser with ruby
https://gist.github.com/junegunn/15859538658e449b886f (for OS X)
# Simple replacement for urlview in X # https://github.com/d630/bin/blob/master/furlview % furlview ( - | FILE ... )
[npm-fzf](https://github.com/hankchanocd/npm-fzf) - Fuzzy search npm modules with `fzf`.
# run npm script (requires jq)
fns() {
local script
script=$(cat package.json | jq -r '.scripts | keys[] ' | sort | fzf) && npm run $(echo "$script")
}
`Alt-i` to paste item from `locate /` output (zsh only):
# ALT-I - Paste the selected entry from locate output into the command line
fzf-locate-widget() {
local selected
if selected=$(locate / | fzf -q "$LBUFFER"); then
LBUFFER=$selected
fi
zle redisplay
}
zle -N fzf-locate-widget
bindkey '\ei' fzf-locate-widget
You must have [`mpc`](http://www.musicpd.org/clients/mpc/) installed on your computer in order to use this function.
fmpc() {
local song_position
song_position=$(mpc -f "%position%) %artist% - %title%" playlist | \
fzf-tmux --query="$1" --reverse --select-1 --exit-0 | \
sed -n 's/^\([0-9]\+\)).*/\1/p') || return 1
[ -n "$song_position" ] && mpc -q play $song_position
}
[fmui](https://github.com/seebye/fmui) is a configurable fzf mpd user interface using mpc.
[clerk](https://github.com/carnager/clerk) is a simple MPD client using rofi or fzf.
# CTRL-X-1 - Invoke Readline functions by name
__fzf_readline ()
{
builtin eval "
builtin bind ' \
\"\C-x3\": $(
builtin bind -l | command fzf +s +m --toggle-sort=ctrl-r
) \
'
"
}
builtin bind -x '"\C-x2": __fzf_readline';
builtin bind '"\C-x1": "\C-x2\C-x3"'
# RVM integration
frb() {
local rb
rb=$((echo system; rvm list | grep ruby | cut -c 4-) |
awk '{print $1}' |
fzf-tmux -l 30 +m --reverse) && rvm use $rb
}
You must have [`jq`](https://github.com/stedolan/jq) installed on your computer in order to use this function.
vs(){
#List all vagrant boxes available in the system including its status, and try to access the selected one via ssh
cd $(cat ~/.vagrant.d/data/machine-index/index | jq '.machines[] | {name, vagrantfile_path, state}' | jq '.name + "," + .state + "," + .vagrantfile_path'| sed 's/^"\(.*\)"$/\1/'| column -s, -t | sort -rk 2 | fzf | awk '{print $3}'); vagrant ssh
}
When you have defined an alias or wrapper for some command, you might want to inherit the completion from a parent function. Find out the completion used for your command and do:
_fzf_complete_myssh() {
_fzf_complete_ssh "$@"
}
See also `_fzf_setup_completion` in the completion source code.
Search through your LastPass vault with [LastPass CLI](https://github.com/lastpass/lastpass-cli) and copy password to clipboard.
$ lpass show -c --password $(lpass ls | fzf | awk '{print $(NF)}' | sed 's/\]//g')
The terminal command Tweak https://github.com/pindexis/marker.git
[](https://asciinema.org/a/122370?autoplay=1)
# marker templete select
_fzf_marker_main_widget() {
if echo "$BUFFER" | grep -q -P "{{"; then
_fzf_marker_placeholder
else
local selected
if selected=$(cat ${FZF_MARKER_CONF_DIR:-~/.config/marker}/*.txt |
sed -e "s/\(^[a-zA-Z0-9_-]\+\)\s/${FZF_MARKER_COMMAND_COLOR:-\x1b[38;5;255m}\1\x1b[0m /" \
-e "s/\s*\(#\+\)\(.*\)/${FZF_MARKER_COMMENT_COLOR:-\x1b[38;5;8m} \1\2\x1b[0m/" |
fzf --bind 'tab:down,btab:up' --height=80% --ansi -q "$LBUFFER"); then
LBUFFER=$(echo $selected | sed 's/\s*#.*//')
fi
zle redisplay
fi
}
_fzf_marker_placeholder() {
local strp pos placeholder
strp=$(echo $BUFFER | grep -Z -P -b -o "\{\{[\w]+\}\}")
strp=$(echo "$strp" | head -1)
pos=$(echo $strp | cut -d ":" -f1)
placeholder=$(echo $strp | cut -d ":" -f2)
if [[ -n "$1" ]]; then
BUFFER=$(echo $BUFFER | sed -e "s/{{//" -e "s/}}//")
CURSOR=$(($pos + ${#placeholder} - 4))
else
BUFFER=$(echo $BUFFER | sed "s/$placeholder//")
CURSOR=pos
fi
}
_fzf_marker_placeholder_widget() { _fzf_marker_placeholder "defval" }
zle -N _fzf_marker_main_widget
zle -N _fzf_marker_placeholder_widget
bindkey "${FZF_MARKER_MAIN_KEY:-\C-@}" _fzf_marker_main_widget
bindkey "${FZF_MARKER_PLACEHOLDER_KEY:-\C-v}" _fzf_marker_placeholder_widget
Search for all pdf files. FZF will match the query against any text found on the first page of the PDF. For instance, one can query for author names, article title, journal, institutions, keywords. It works by extracting the text on the first page of the PDF using ``pdftotext``.
The selected file is then opened by the default pdf viewer.
Requires the [pdftotext](https://en.wikipedia.org/wiki/Pdftotext) command line tool. Tested on Ubuntu 17.10 on bash and zsh.
The script is now given at https://github.com/bellecp/fast-p
Search records in BibTeX files using FZF, select records to cite, or pretty print in markdown. With vim integration.
This plugin is at https://github.com/msprev/fzf-bibtex
# Select a docker container to start and attach to
function da() {
local cid
cid=$(docker ps -a | sed 1d | fzf -1 -q "$1" | awk '{print $1}')
[ -n "$cid" ] && docker start "$cid" && docker attach "$cid"
}
# Select a running docker container to stop
function ds() {
local cid
cid=$(docker ps | sed 1d | fzf -q "$1" | awk '{print $1}')
[ -n "$cid" ] && docker stop "$cid"
}
# Select a docker container to remove
function drm() {
local cid
cid=$(docker ps -a | sed 1d | fzf -q "$1" | awk '{print $1}')
[ -n "$cid" ] && docker rm "$cid"
}
# Same as above, but allows multi selection:
function drm() {
docker ps -a | sed 1d | fzf -q "$1" --no-sort -m --tac | awk '{ print $1 }' | xargs -r docker rm
}
# Select a docker image or images to remove
function drmi() {
docker images | sed 1d | fzf -q "$1" --no-sort -m --tac | awk '{ print $3 }' | xargs -r docker rmi
}
Search and open website bookmarks stored in a [buku](https://github.com/jarun/Buku) database.
# BUKU bookmark manager
# get bookmark ids
get_buku_ids() {
buku -p -f 5 | fzf --tac --layout=reverse-list -m | \
cut -d
\t' -f 1
# awk -F= '{print $1}'
# cut -d
\t' -f 1
}
# buku open
fb() {
# save newline separated string into an array
ids=( $(get_buku_ids) )
echo buku --open ${ids[@]}
[[ -z $ids ]] && return 1 # return error if has no bookmark selected
buku --open ${ids[@]}
}
# buku update
fbu() {
# save newline separated string into an array
ids=( $(get_buku_ids) )
echo buku --update ${ids[@]} $@
[[ -z $ids ]] && return 0 # return if has no bookmark selected
buku --update ${ids[@]} $@
}
# buku write
fbw() {
# save newline separated string into an array
ids=( $(get_buku_ids) )
# print -l $ids
# update websites
for i in ${ids[@]}; do
echo buku --write $i
buku --write $i
done
}
...And a nicer looking alternative, using [fzfmenu](#fzf-as-dmenu-replacement).
#!/usr/bin/env bash
# fb - buku bookmarks fzfmenu opener
buku -p -f 4 |
awk -F
\t' '{
if ($4 == "")
printf "%s \t\x1b[38;5;208m%s\033[0m\n", $2, $3
else
printf "%s \t\x1b[38;5;124m%s \t\x1b[38;5;208m%s\033[0m\n", $2, $4, $3
}' |
fzfmenu --tabstop 1 --ansi -d
\t' --with-nth=2,3 \
--preview-window='bottom:10%' --preview 'printf "\x1b[38;5;117m%s\033[0m\n" {1}' |
awk '{print $1}' | xargs -d '\n' -I{} -n1 -r xdg-open '{}'
If you have `sqlite` installed - you can use it to query DB directly (which takes about ~2ms compared to buku's ~100ms).
To do that, replace the `buku -p -f 4` with
sqlite3 -separator
\t' "$HOME/.local/share/buku/bookmarks.db" "SELECT id,URL,metadata,tags FROM bookmarks" | awk -F
\t' '{gsub(/(^,|,$)/,"",$4); printf "%s\t%s\t%s\t%s\n", $1, $2, $3, $4}'
Now you can bind it on some key, e.g. with [sxhkd](https://github.com/baskerville/sxhkd) in sxhkdrc:
super + shift + u fb
Fuzzy search desktop entries and launch the appropriate application.
i3-dmenu-desktop --dmenu=fzf
Display in a floating window. Add this to your i3 config file (this example uses termite, but any terminal emulator that allows setting the window title can be used):
bindsym $mod+d exec --no-startup-id termite -t 'fzf-menu' -e 'i3-dmenu-desktop --dmenu=fzf' for_window [title="fzf-menu"] floating enable
Quickly display a man page using fzf and fd.
`MANPATH` has to be set to a single directory (usually `/usr/share/man`).
Accepts an optional argument for the manual section (defaults to 1).
man-find() {
f=$(fd . $MANPATH/man${1:-1} -t f -x echo {/.} | fzf) && man $f
}
fman() {
man -k . | fzf --prompt='Man> ' | awk '{print $1}' | xargs -r man
}
# Same as above, but with previews and works correctly with man pages in different sections.
function fman() {
man -k . | fzf -q "$1" --prompt='man> ' --preview
echo {} | tr -d \'()\' | awk \'{printf "%s ", $2} {print $1}\' | xargs -r man' | tr -d '()' | awk '{printf "%s ", $2} {print $1}' | xargs -r man
}
Same as above, but the preview is colored with [bat](https://github.com/sharkdp/bat)
fman() {
man -k . | fzf -q "$1" --prompt='man> ' --preview
echo {} | tr -d \'()\' | awk \'{printf "%s ", $2} {print $1}\' | xargs -r man | col -bx | bat -l man -p --color always' | tr -d '()' | awk '{printf "%s ", $2} {print $1}' | xargs -r man
}
# Get the colors in the opened man page itself
export MANPAGER="sh -c 'col -bx | bat -l man -p --paging always'"
<kbd>Tab</kbd> copy the step name.
<kbd>Enter</kbd> copy the step location
fbehave() {
behave "$@" -d -f steps 2> /dev/null | \
awk -F " *# " '/\s*(Given|When|Then|\*)/ {print $1"\t"$2}' | \
fzf -d "\t" --with-nth=1 \
--bind 'enter:execute(echo {} | cut -f2 | pbcopy )' \
--bind 'tab:execute(echo {} | cut -f1 | awk "{\$1=\$1};1" | pbcopy )'
}
https://github.com/gotbletu/shownotes/blob/master/fzf_nova/fzf-nova
download fzf-nova folder as a whole and follow the instructions in fzf-nova script
[Reference video](https://www.youtube.com/watch?v=8SqakfCSzQk)
credits @gotbletu
Why? ...Because it's faster.
So you'll need:
1. terminal that launches fast and supports custom class or window name. [St](https://st.suckless.org/) fits the bill perfectly.
2. window manager with an option to automatically put windows in center based on class or name. Most seem to have it.
#!/usr/bin/env bash
# fzfmenu - fzf as dmenu replacement
# fifos are here to not wait for end of input
# (useful for e.g. find $HOME | fzfmenu ...)
input=$(mktemp -u --suffix .fzfmenu.input)
output=$(mktemp -u --suffix .fzfmenu.output)
mkfifo $input
mkfifo $output
chmod 600 $input $output
# it's better to use st here (starts a lot faster than pretty much everything else)
# the ugly printf | sed thing is here to make args with quotes work.
# (e.g. --preview='echo {1}').
# sadly we can't use "$@" here directly because we are inside sh -c "..." call
# already.
# you can also set window dimensions via -g '=COLSxROWS', see man st.
st -c fzfmenu -n fzfmenu -e sh -c "cat $input | fzf $(printf -- " '%s'" "$@" | sed "s/^ ''$//") | tee $output" & disown
# handle ctrl+c outside child terminal window
trap "kill $! 2>/dev/null; rm -f $input $output" EXIT
cat > $input
cat $output
All arguments are passed to fzf.
Don't forget to add a float/center rule for `fzfmenu` class/name to your wm's config.
[Example usage](#buku).
[dotbare](https://github.com/kazhala/dotbare) is a command-line utility to manage your dotfiles.
It heavily utilises fzf for interactive user experience.
It is inspired by [forgit](https://github.com/wfxr/forgit), but focuses on dotfiles rather than generic git.
By default, it wraps around git bare repository but it could also be easily integrated with a symlink/GNU stow setup.
zsh keybinding to select a torrent with transmission-remote.
pick_torrent() LBUFFER="transmission-remote -t ${$({
for torrent in ${(f)"$(transmission-remote -l)"}; do
torrent_name=$torrent[73,-1]
[[ $torrent_name != (Name|) ]] && echo ${${${(s. .)torrent}[1]}%\*} $torrent_name
done
} | fzf)%% *} -"
zle -N pick_torrent
bindkey '^o' pick_torrent
# Install packages using yay (change to pacman/AUR helper of your choice)
function in() {
yay -Slq | fzf -q "$1" -m --preview 'yay -Si {1}'| xargs -ro yay -S
}
# Remove installed packages (change to pacman/AUR helper of your choice)
function re() {
yay -Qq | fzf -q "$1" -m --preview 'yay -Qi {1}' | xargs -ro yay -Rns
}
Shows version & repository, elaborate preview, bindings to show package in web, caches AUR packages list:
# Helper function to integrate yay and fzf
yzf() {
pos=$1
shift
sed "s/ /\t/g" |
fzf --nth=$pos --multi --history="${FZF_HISTDIR:-$XDG_STATE_HOME/fzf}/history-yzf$pos" \
--preview-window=60%,border-left \
--bind="double-click:execute(xdg-open 'https://archlinux.org/packages/{$pos}'),alt-enter:execute(xdg-open 'https://aur.archlinux.org/packages?K={$pos}&SB=p&SO=d&PP=100')" \
"$@" | cut -f$pos | xargs
}
# Dev note: print -s adds a shell history entry
# List installable packages into fzf and install selection
yas() {
cache_dir="/tmp/yas-$USER"
test "$1" = "-y" && rm -rf "$cache_dir" && shift
mkdir -p "$cache_dir"
preview_cache="$cache_dir/preview_{2}"
list_cache="$cache_dir/list"
{ test "$(cat "$list_cache$@" | wc -l)" -lt 50000 && rm "$list_cache$@"; } 2>/dev/null
pkg=$( (cat "$list_cache$@" 2>/dev/null || { pacman --color=always -Sl "$@"; yay --color=always -Sl aur "$@" } | sed 's/ [^ ]*unknown-version[^ ]*//' | tee "$list_cache$@") |
yzf 2 --tiebreak=index --preview="cat $preview_cache 2>/dev/null | grep -v 'Querying' | grep . || yay --color always -Si {2} | tee $preview_cache")
if test -n "$pkg"
then echo "Installing $pkg..."
cmd="yay -S $pkg"
print -s "$cmd"
eval "$cmd"
rehash
fi
}
# List installed packages into fzf and remove selection
# Tip: use -e to list only explicitly installed packages
yar() {
pkg=$(yay --color=always -Q "$@" | yzf 1 --tiebreak=length --preview="yay --color always -Qli {1}")
if test -n "$pkg"
then echo "Removing $pkg..."
cmd="yay -R --cascade --recursive $pkg"
print -s "$cmd"
eval "$cmd"
fi
}
Uses [wl-copy](https://github.com/bugaevc/wl-clipboard) to copy the current entry to the clipboard on Wayland:
export FZF_DEFAULT_OPTS='--bind "ctrl-y:execute-silent(printf {} | cut -f 2- | wl-copy --trim-newline)"'
This works with `execute-silent` but not with `execute`, presumably because `execute` waits for `wl-copy` to end. Appending a `&` did not change that.
- Todoist CLI task filitring and preview
```ps
❯ todoist --namespace --project-namespace list | fzf --preview 'todoist show {1}' | cut -d ' ' -f 1 | tr '\n' ' '
```
- The command used for preview is `todoist show {1}`
- The `show` option is used to show the task details
- The `{1}` represents the first feild in the line -> Task ID
Request database file from https://www1.dict.cc/translation_file_request.php
cat /path/to/dict.txt | tail -n +16 | fzf --tiebreak=length
[emoji.txt](https://gist.github.com/keidarcy/128141ff30a8c3f9ddc0d6c3ecb5b334)
emojis=$(curl -sSL 'https://git.io/JXXO7') selected_emoji=$(echo $emojis | fzf) echo $selected_emoji