1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
= ANN: remembering - Add memory to dmenu, fzf and similar tools
:categories: ann
:remembering: https://euandreh.xyz/remembering/
:dmenu: https://tools.suckless.org/dmenu/
:fzf: https://github.com/junegunn/fzf
Today I pushed v0.1.0 of {remembering}[remembering], a tool to enhance the
interactive usability of menu-like tools, such as {dmenu}[dmenu] and {fzf}[fzf].
== Previous solution
:yeganesh: https://dmwit.com/yeganesh/
I previously used {yeganesh}[yeganesh] to fill this gap, but as I started to
rely less on Emacs, I added fzf as my go-to tool for doing fuzzy searching on
the terminal. But I didn't like that fzf always showed the same order of
things, when I would only need 3 or 4 commonly used files.
For those who don't know: yeganesh is a wrapper around dmenu that will remember
your most used programs and put them on the beginning of the list of
executables. This is very convenient for interactive prolonged use, as with
time the things you usually want are right at the very beginning.
But now I had this thing, yeganesh, that solved this problem for dmenu, but
didn't for fzf.
I initially considered patching yeganesh to support it, but I found it more
coupled to dmenu than I would desire. I'd rather have something that knows
nothing about dmenu, fzf or anything, but enhances tools like those in a useful
way.
== Implementation
:v-010: https://euandre.org/git/remembering/tree/remembering?id=v0.1.0
:getopts: https://www.opengroup.org/onlinepubs/9699919799/utilities/getopts.html
:sort: https://www.opengroup.org/onlinepubs/9699919799/utilities/sort.html
:awk: https://www.opengroup.org/onlinepubs/9699919799/utilities/awk.html
:spencer-quote: https://en.wikipedia.org/wiki/Henry_Spencer#cite_note-3
Other than being decoupled from dmenu, another improvement I though that could
be made on top of yeganesh is the programming language choice. Instead of
Haskell, I went with POSIX sh. Sticking to POSIX sh makes it require less
build-time dependencies. There aren't any, actually. Packaging is made much
easier due to that.
The good thing is that the program itself is small enough ({v-010}[119 lines] on
v0.1.0) that POSIX sh does the job just fine, combined with other POSIX
utilities such as {getopts}[getopts], {sort}[sort] and {awk}[awk].
The behaviour is: given a program that will read from STDIN and write a single
entry to STDOUT, `remembering` wraps that program, and rearranges STDIN so that
previous choices appear at the beginning.
Where you would do:
[source,shell]
----
$ seq 5 | fzf
5
4
3
2
> 1
5/5
>
----
And every time get the same order of numbers, now you can write:
[source,shell]
----
$ seq 5 | remembering -p seq-fzf -c fzf
5
4
3
2
> 1
5/5
>
----
On the first run, everything is the same. If you picked 4 on the previous
example, the following run would be different:
[source,shell]
----
$ seq 5 | remembering -p seq-fzf -c fzf
5
3
2
1
> 4
5/5
>
----
As time passes, the list would adjust based on the frequency of your choices.
I aimed for reusability, so that I could wrap diverse commands with
`remembering` and it would be able to work. To accomplish that, a "profile"
(the `-p something` part) stores data about different runs separately.
I took the idea of building something small with few dependencies to other
places too: - the manpages are written in troff directly; - the tests are just
more POSIX sh files; - and a POSIX Makefile to `check` and `install`.
I was aware of the value of sticking to coding to standards, but I had past
experience mostly with programming language standards, such as ECMAScript,
Common Lisp, Scheme, or with IndexedDB or DOM APIs. It felt good to rediscover
these nice POSIX tools, which makes me remember of a quote by
{spencer-quote}[Henry Spencer]:
____
Those who do not understand Unix are condemned to reinvent it, poorly.
____
== Usage examples
Here are some functions I wrote myself that you may find useful:
=== Run a command with fzf on `$PWD`
[source,shellcheck]
----
f() {
profile="$f-shell-function(pwd | sed -e 's_/_-_g')"
file="$(git ls-files | \
remembering -p "$profile" \
-c "fzf --select-1 --exit -0 --query \"$2\" --preview 'cat {}'")"
if [ -n "$file" ]; then
# shellcheck disable=2068
history -s f $@
history -s "$1" "$file"
"$1" "$file"
fi
}
----
This way I can run `f vi` or `f vi config` at the root of a repository, and the
list of files will always appear on the most used order. Adding `pwd` to the
profile allows it to not mix data for different repositories.
=== Copy password to clipboard
:pass: https://www.passwordstore.org/
[source,shell]
----
choice="$(find "$HOME/.password-store" -type f | \
grep -Ev '(.git|.gpg-id)' | \
sed -e "s|$HOME/.password-store/||" -e 's/\.gpg$//' | \
remembering -p password-store \
-c 'dmenu -l 20 -i')"
if [ -n "$choice" ]; then
pass show "$choice" -c
fi
----
Adding the above to a file and binding it to a keyboard shortcut, I can access
the contents of my {pass}[password store], with the entries ordered by usage.
=== Replacing yeganesh
Where I previously had:
[source,shell]
----
exe=$(yeganesh -x) && exec $exe
----
Now I have:
[source,shell]
----
exe=$(dmenu_path | remembering -p dmenu-exec -c dmenu) && exec $exe
----
This way, the executables appear on order of usage.
If you don't have `dmenu_path`, you can get just the underlying `stest` tool
that looks at the executables available in your `$PATH`. Here's a juicy
one-liner to do it:
[source,shell]
----
$ wget -O- https://dl.suckless.org/tools/dmenu-5.0.tar.gz | \
tar Ozxf - dmenu-5.0/arg.h dmenu-5.0/stest.c | \
sed 's|^#include "arg.h"$|// #include "arg.h"|' | \
cc -xc - -o stest
----
With the `stest` utility you'll be able to list executables in your `$PATH` and
pipe them to dmenu or something else yourself:
[source,shell]
----
$ (IFS=:; ./stest -flx $PATH;) | sort -u | remembering -p another-dmenu-exec -c dmenu | sh
----
In fact, the code for `dmenu_path` is almost just like that.
== Conclusion
:packaged: https://euandre.org/git/package-repository/
For my personal use, I've {packaged}[packaged] `remembering` for GNU Guix and
Nix. Packaging it to any other distribution should be trivial, or just
downloading the tarball and running `[sudo] make install`.
Patches welcome!
|
