Introduction #
XMonad has it’s own prompt system. Some time ago, I wanted to see if it could
replace dmenu entirely. I managed it for the more common usages I had for it. My
application launcher, ssh
prompt and pass interface were easy to replace using
standard XMonad Contrib modules (XMonad.Prompt.Shell
, XMonad.Prompt.Ssh
and
XMonad.Prompt.Pass
respectively). However, things became more difficult when
it came to my universal/external Qutebrowser bookmarks menu and
yt-dlp
-and-pipe-viewer
wrapper.
This tutorial-of-sorts will assume some Haskell knowledge or not being afraid of diving straight into how Haskell works. I’m not going into great detail on how everything works here.
Bookmarks menu #
The first one I decided to tackle was the bookmarks menu, as it is by far the simplest of the two.
Let’s take a look at the original:
#!/bin/sh
bookmarks="$HOME/.config/qutebrowser/bookmarks/urls"
choice="$(awk '{print$1}' $bookmarks | sort | dmenu -p "Bookmark:" -l 30)"
[ -z $choice ] || qutebrowser "$choice"
Things get interesting at the initialisation of the choice
variable:
- It takes the contents of Qutebrowser’s bookmarks file
- It sorts the results of that
- Sends that to
dmenu
, prompting the user to make a choice
After this, it checks whether choice
is empty or not and in case it isn’t,
opens Qutebrowser with its contents.
Here is an example of how Qutebrowser saves its bookmarks:
https://www.alpinelinux.org/ index | Alpine Linux
https://www.openbsd.org/ftp.html OpenBSD: Mirrors
https://commonmark.org/ CommonMark
https://xxiivv.com/ Echorridoors
https://100r.co/site/home.html 100R — home
https://solar.lowtechmagazine.com/about.html About this website | LOW←TECH MAGAZINE
Implementation #
Its functionality does boils down to the following:
- Parse a given file according to a set of rules, returning it’s contents in the form of a list
- Allow the user to make a choice from that list
- Launch an application with that choice as parameter
Seems easy enough to implement.
Parsing the Bookmarks file #
Let’s start off by creating a function that can parse our bookmarks file. Here we need something to read a file – in this case a bookmarks file – and return its contents in the form of a list of strings.
fileContentList :: FilePath -> IO [String]
This function takes a filepath – the Filepath
datatype is an alias for
String
– and returns IO [String]
.
Now for the body of the function:
fileContentList :: FilePath -> IO [String]
fileContentList f = do
homeDir <- getEnv "HOME"
file <- readFile (homeDir ++ "/" ++ f)
return . uniqSort . lines $ file
Let’s go over what is happening here line by line.
fileContentList
is a function that takes an argument f
; then it starts a
do
block. do
blocks are used to put multiple functions in sequence in the
scope of a single function without having them interact with eachother.
Within the do
block, it first retrieves the current home directory based on
the $HOME
environment variable and binds it to homeDir
using the getEnv
function from the System.Environment
module. getEnv
returns a string with
the contents of the variable given as its argument.
Next, it retrieves the file contents from $HOME/path/to/file
using the
readFile
. This path is created by appending f
to the homeDir
.
Now for the final line.
First it takes the file
and splits it up into a list of strings based on
newlines using the lines
function.
lines $ file
Then it pipes the result from that into uniqSort
from the XMonad.Prompt
module in order to – as the name implies – sort it and get rid of any
duplicate items.
uniqSort . lines $ file
And the output of that is piped into return
:
return . uniqSort . lines $ file
This function will allow us to parse any given text file. To parse the
Qutebrowser bookmarks file, call it using .config/qutebrowser/bookmarks/url
Note: I say “pipe” because the ‘
.
’ function behaves quite similar to pipes in POSIX Shell. However, the correct way of referring to what it does is composition; it takes two functions and passes the output of the first function to the second, thereby creating – or composing a new function. As apposed to how pipes in POSIX Shell work, function composition chains are executed from right to left.
Creating a Prompt #
Let’s see if there is anything in the
XMonad.Prompt
module that looks like it could help us in creating a prompt.
mkXPrompt :: XPrompt p => p -> XPConfig -> ComplFunction -> (String -> X ()) -> X ()
Creates a prompt given:
- a prompt type, instance of the
XPrompt
class.- a prompt configuration (
def
can be used as a starting point)- a completion function (
mkComplFunFromList
can be used to create a completions function given a list of possible completions)- an action to be run: the action must take a string and return
X ()
This looks like it could serve as the basis for our prompt. The description and
type signature tell us that it is going to require an instance of the XPrompt
typeclass. So let’s create a Bookmark
datatype and implement the showXPrompt
function from XPrompt
in order to give it a default message when executed and
thereby having it derive from XPrompt
.
data Bookmark = Bookmark
instance XPrompt Bookmark where
showXPrompt Bookmark = "Bookmark: "
As its second argument, mkXPrompt
requires an instance of XPConfig
. The
XPConfig
typeclass is where you – as the name implies – specify the
configuration of XMonad’s prompts. Knowing this we can start to write function that
uses mkXPrompt
:
bookmarkPrompt c = do
mkXPrompt Bookmark c
c
is our XPConfig
argument.
This takes care of the XPrompt p => p -> XPConfig
portion of the function.
Now for the completion function, that will handle the list given to our prompt.
Let’s mostly follow the suggestion in the description of mkXPrompt
and lets
take a look at:
mkComplFunFromList' :: XPConfig -> [String] -> String -> IO [String]
This function takes a list of possible completions and returns a completions function to be used with mkXPrompt. If the string is null it will return all completions.
This is how Qutebrowser and dmenu
act by default with a given list of possible
options.
bookmarksFile = ".config/qutebrowser/bookmarks/urls" :: String
I didn’t know where to put this, but I created a string to hold the path to my bookmarks
So it takes an instance of XPConfig
– that will again be our c
argument,
and a list of strings. Here is where we feed it the contents of our file using
our fileContentList
function. We will do this by binding the output to, say
bl
for “bookmark list” with <-
. Since fileContentList
is a member of the
IO
monad and we’re working in, we have to call it using the io
function,
which is an alias for the liftIO
function.
bookmarkPrompt :: XPConfig -> (String -> X ()) -> X ()
bookmarkPrompt c f = do
bl <- io fileContentList bookmarksFile
mkXPrompt Bookmark c (mkComplFunFromList' c bl) f
You’ll see that I’ve also added argument f
, this is the function we’re going
to use to actually do something with our prompt output. Considering we’re
working with bookmarks, opening them in a browser would make sense.
openBookmark :: String -> X ()
openBookmark bookmark = do
browser <- io getBrowser
spawn $ browser ++ " '" ++ getUrl bookmark ++ "'"
where getUrl = head . words
openBookmark
is a function that takes a string and returns something in the
context of the X
monad (hence the name “XMonad”, it’s a monad that interacts
with Xorg). Let’s go through it line by line.
browser <- io getBrowser
First we get user’s browser using the getBrowser
function from the
XMonad.Prompt.Shell
module and bind that to browser
.
This function checks the $BROWSER
environment variable and if it isn’t set, it
defaults to “firefox”.
spawn $ browser ++ " '" ++ getUrl bookmark ++ "'"
Since getBrowser
returns a string, we can append things to it and feed that to
spawn
. In this case, we get the URL portion of the bookmark entry surrounded by
single quotes in case a given bookmark contains any symbols that mess up our
shell. After all, what spawn
ultimately does is feed a given string to
/bin/sh
as a command to execute.
where getUrl = head . words
For get getUrl
, we take the given string, split it into a list of strings
based on space characters, pipe that into head, thus retrieving the first item.
Keybinding #
We now have a set of functions that create a prompt populated with our Qutebrowser bookmarks file (any other list of URLs will also work) which will open our browser when choosing one.
Now all we have to do is bind it to a key. Personally I use the
XMonad.Util.EZConfig
so I have the following in my keybindings:
, ("M-M1-C-b", bookmarkPrompt (myXPConfig {autoComplete = Just 200000}) openBookmark Bookmark)
If you use the default way of defining keybindings you can use something like the following:
, ((modm .|. controlMask, xK_b), bookmarkPrompt def openBookmark)
def
is a reference to the default implementation of XPConfig
.
Everything Together #
Everything put together, your config should have something like the following added.
data Bookmark = Bookmark
instance XPrompt Bookmark where
showXPrompt Bookmark = "Bookmark: "
bookmarksFile = ".config/qutebrowser/bookmarks/urls" :: String
fileContentList :: FilePath -> IO [String]
fileContentList f = do
homeDir <- getEnv "HOME"
file <- readFile (homeDir ++ "/" ++ f)
return . uniqSort . lines $ file
bookmarkPrompt :: XPConfig -> (String -> X ()) -> X ()
bookmarkPrompt c f = do
bl <- io fileContentList bookmarksFile
mkXPrompt Bookmark c (mkComplFunFromList' c bl) f
openBookmark :: String -> X ()
openBookmark bookmark = do
browser <- io getBrowser
spawn $ browser ++ " '" ++ getUrl bookmark ++ "'"
where getUrl = head . words
-- ... keybindings
, ((modm .|. controlMask, xK_b), bookmarkPrompt def openBookmark)
-- more keybindings ...