Echo Area

I really enjoy reading the EmacsWiki. It helped me a lot when I first started using Emacs. It's a great resource with so much information.

Since it's been so important to me I figured I should look at some pages and if there was anything I could update, contribute. To help with this I wanted to show a random page on my Emacs Dashboard. Thankfully the EmacsWiki has a nice function for this: Random Page.

I've incorporated this into a widget for my dashboard:

(defun oni-dashboard-insert-random-wiki-page (_)
  "Insert a link to a random Emacs Wiki page."
  (dashboard-insert-heading "Today's Wiki page:" "w")
  (insert "\n    ")
  (dashboard-insert-shortcut 'random-wiki-page "w" "Today's Wiki page:")
  (let ((text-beginning-marker (point-marker)))
    (insert "Loading...")
    (url-retrieve "https://www.emacswiki.org/emacs?action=random"
                  (lambda (&rest _args)
                    (let ((info (prog1 (cons (url-recreate-url url-current-object)
                                             (progn
                                               (search-forward "<title>")
                                               (let ((beginning (point)))
                                                 (search-forward "</title>")
                                                 (forward-char -8)
                                                 (buffer-substring-no-properties beginning (point)))))
                                  (kill-buffer))))
                      (with-current-buffer (marker-buffer text-beginning-marker)
                        (let ((inhibit-read-only t))
                          (save-excursion
                            (goto-char (marker-position text-beginning-marker))
                            (delete-char 10)
                            (widget-create 'url-link
                                           :format (format "%%[%s%%]" (cdr info))
                                           :button-suffix ""
                                           :button-prefix ""
                                           (car info)))))))
                  nil
                  t)))

(add-to-list 'dashboard-item-generators '(random-wiki-page . oni-dashboard-insert-random-wiki-page))
(add-to-list 'dashboard-items '(random-wiki-page))

Now every time I load the dashboard (generally once per day) a wiki page url and title are asynchronously loaded and shown. It'll also show Loading... while it's doing its work so I know it's doing something, and because it's asynchronous it doesn't cause my session to block while waiting for the wiki to respond. That last part was especially nice when EmacsWiki went down for a few days due to increased levels of bots trying to crawl the site.

It's very messy, I should clean it up.

I needed to send a bit of inline code in some Markdown today and it needed to have a ? in it. I realized I hadn't done that before. I write code with ? in it somewhat frequently because Lisp uses it for quasi-quoting, but I always write everything in org syntax where you can use either = or ~. But in Markdown if you need to have a ? in your inline code you need to wrap your inline code with more ? characters.

`This is some inline code`
``This is some inline code with a ` (backtick) in it``
```This is some inline code with `` (two backticks) in it```

It looks like the sky might be the limit.

I rediscovered that I can use elfeed-search-face-alist to customize how headlines are displayed in Elfeed. I had read it before on Chris Wellons' blog, but I didn't have a use for it then.

With elfeed-search-face-alist I can define a face to be used for an article with a specific tag. I added the Blabbermouth RSS feed to my feeds.

(setq elfeed-feeds '(("https://blabbermouth.net/feed" music)))

And created 2 taggers. One tags reviews, because those always have /reviews/ in the url. The other has a list of bands that I'm especially interested in.

(defvar oni-elfeed-blabbermouth-review-tagger
  (elfeed-make-tagger :feed-url (rx "blabbermouth.net")
                      :entry-link (rx "/reviews/")
                      :add 'review)
  "Tagger that marks any reviews from Blabbermouth.")

(defvar oni-elfeed-blabbermouth-favourite-tagger
  (elfeed-make-tagger :feed-url (rx "blabbermouth.net")
                      :entry-title (rx (or "SLIPKNOT"
                                           (seq "DREAM" whitespace "THEATER")
                                           ;; And so on...
                                           ))
                      :add 'favourite)
  "Tagger that highlights specific bands from Blabbermouth.")

(add-hook 'elfeed-new-entry-hook oni-elfeed-blabbermouth-favourite-tagger)
(add-hook 'elfeed-new-entry-hook oni-elfeed-blabbermouth-review-tagger)

And then I can just set up the feeds:

(add-to-list 'elfeed-search-face-alist '(review :slant italic) t)
(add-to-list 'elfeed-search-face-alist '(favourite :foreground "#f17272") t)

As long as the face definitions don't conflict a headline's face would be the combination of all that apply. For example, by default unread headlines are bold, so unread favourite messages would be bold and somewhat reddish.

This Emacs configuration snippet for org-mode changes a task's state from whatever “head” state it's in into the next state in its sequence when you clock in to a task. I do this by setting the org-clock-in-switch-to-state variable.

#+SEQ_TODO: TODO WIP BLOCKED | DONE
#+SEQ_TODO: READ READING | FINISHED STOPPED
#+SEQ_TODO: WATCH WATCHING | WATCHED
#+SEQ_TODO: LISTEN LISTENING | DONE

(defun oni-org-maybe-change-todo-state (current-state)
  "Change the state of the current task to its next state.
Only do this outside of a capture buffer and when CURRENT-STATE
is the head state of whichever sequence of states applies to this
task."
  (if (and (not org-capture-mode)
           (member current-state org-todo-heads))
      (cadr (member current-state org-todo-keywords-1))
    current-state))

#+SEQ_TODO: TODO WIP BLOCKED | DONE

(setq org-clock-in-switch-to-state #'oni-org-maybe-change-todo-state)

For a while I've been bothered by being unable to use IELM to evaluate Emacs Lisp expressions. Then Making IELM More Comfortable pointed out that using paredit in IELM causes the RET and C-j keybindings to be bound to the wrong functions and proposes to fix them. The given fix, however, appears to change the keybindings for all buffers using paredit. I don't want that, and Emacs can do better!

A quick search yielded Buffer-locally overriding minor-mode key bindings in Emacs suggesting a fix. My adaptation of that solution:

(defun oni-elisp-ielm-remove-paredit-newline-keys ()
  "Disable ‘C-j’ and ‘RET’ keybindings from ‘paredit-mode’."
  (let ((oldmap (map-elt minor-mode-map-alist 'paredit-mode))
        (newmap (make-sparse-keymap)))
    (set-keymap-parent newmap oldmap)
    (define-key newmap (kbd "RET") nil)
    (define-key newmap (kbd "C-j") nil)
    (make-local-variable 'minor-mode-overriding-map-alist)
    (push `(paredit-mode . ,newmap) minor-mode-overriding-map-alist)))

(add-hook 'ielm-mode-hook #'oni-elisp-ielm-remove-paredit-newline-keys)

Defining RET and C-j as nil means that the keybinding defaults back to the major-mode keybinding.

I have been working on vc-p4 off-and-on for a while to make working with Perforce more enjoyable in Emacs. I have some plans for that package. One of the bigger things that I have done so far was add the option to specify the client in the .dir-locals.el.

So in my .dir-locals.el I would have something along the lines of the following:

((nil . (vc-p4-client . "SOME-CLIENT-NAME")))

This would let Emacs switch automatically between the different clients.

I wanted to use the p4 command-line rather than P4V more, but a thing that bugged me was that this didn't allow me to automatically pick the client, and I didn't like having to type in p4 -c SOME-CLIENT-NAME ... all the time. I felt like with Emacs, Eshell, and the feature I added to vc-p4 surely I should be able to do something about this.

The first problem I ran into is that Eshell doesn't load the directory-local variables when I change into a directory. So I wrote something to do that:

(defun oni-eshell-set-local-variables ()
  (dolist (elt file-local-variables-alist)
    (set (make-local-variable (car elt)) (default-value (car elt))))
  (setq file-local-variables-alist nil)
  (hack-dir-local-variables-non-file-buffer))

First it goes through all of the local variables that have been set before and resets them to their default value. This is so that any variables that are set locally don't hang around when you leave the directory. It then sets the list of currently set file local variables to nil so that it doesn't consider them cached and skips over giving them new values. Finally it calls the hack-dir-local-variables-non-file-buffer function that specifically exists to set directory-local values for variables in a buffer that isn't associated with a file.

(add-hook 'eshell-directory-change-hook #'oni-eshell-set-local-variables)

The function needs to run every single time the current directory changes, which Eshell has a hook for.

This would let me use a single variable essentially for specifying the current client to use. As long as there is a value this would work:

p4 --client $vc-p4-client ...

That's definitely easier than having to remember exactly which client I was using. It can still be better. I know that in Eshell shell-like constructs can be combined with Lisp easily by using either ${} or $(). So really I can just use a single command that checks whether there is a value for the client or not and calls p4 accordingly:

p4 $(when vc-p4-client (list "--client" vc-p4-client)) ...

This is very wordy though. Since this can be called any time it's nice to just make it an alias:

alias p4 'p4 $(when vc-p4-client (list "--client" vc-p4-client)) $*'

Now I can just call p4 and it'll specify the client for me automatically.

I haven't done a lot of stuff in Eshell, so I liked being able to write a fun little alias that combined some shell command with some simple Lisp code. Of course only after this I discovered (well, someone pointed out) that Perforce has the P4CONFIG environment variable, which names a file name to look for up the directory tree from the current directory (much like the .dir-locals.el works) and read settings from there. So I set that p4 set P4CONFIG=.p4config, and then specify the client in there.

P4CONFIG=SOME_CLIENT_NAME

And now I don't have to go through any of this, I can remove the whole feature I added to vc-p4 too.

I've been annoyed at MSYS2 for a while because Info manuals included with Emacs wouldn't show up when I opened info. The few manuals that were installed through ELPA packages showed up fine.

Some time ago I discovered this was because I installed the mingw-w64-x86_64-emacs package from MSYS2, and this package installs all the info manuals into /mingw64/share/info instead of /usr/share/info and there was no dir file in there. I couldn't quite remember how this worked so I left it alone. At least I understood what was going on.

Recently I finally took the time to look at it again. I remembered that pacman has some capabilities for hooks. I wrote a very simple one for myself to keep my Pacman mirror list updated automatically. But I couldn't remember where the default ones were located. pacman to the rescue. pacman -Ql pacman | less with a quick search for hooks and I discovered that these hooks live in /usr/share/libalpm/hooks/. A quick look in there showed that MSYS2 distributes a couple of hooks: texinfo-install.hook and texinfo-remove.hook. When a package gets installed, upgraded, or removed one of these hooks gets called.

Basically what the -install hook does is go through each file in the installed packages that is under /usr/share/info and call install-info on it. That's great, easy to reproduce on the command line:

find /mingw64/share/info -fype f -name '*.info' -exec install-info '{}' /mingw64/share/info/dir \;

This sets it up the first time, since I already have Emacs installed and didn't want to reinstall it.

[Trigger]
Type = Path
Operation = Install
Operation = Upgrade
Target = mingw64/share/info/*

[Action]
Description = Updating the mingw64 info directory file...
When = PostTransaction
Exec = /usr/bin/sh -c 'while read -r f; do install-info "$f" /mingw64/share/info/dir 2> /dev/null; done'
NeedsTargets

Put this in /etc/pacman.d/hooks/texinfo-install-mingw64.hook (or C:/msys2/etc/pacman.d/hooks/texinfo-install-mingw64.hook if you're working from Emacs), and now every time a package gets installed or upgraded and it has any files in /mingw64/share/info/ it should automatically update the dir file and give you access to all those info manuals.

The remove hook is basically the same, except it passes in the --delete option to install-info to remove the entries from the dir file.

[Trigger]
Type = Path
Operation = Remove
Target = mingw64/share/info/*

[Action]
Description = Removing old entries from the mingw64 info directory file...
When = PreTransaction
Exec = /usr/bin/sh -c 'while read -r f; do install-info --delete "$f" /mingw64/share/info/dir 2> /dev/null; done'
NeedsTargets

I've been using olivetti-mode for a little while when I write notes in org-mode and I must say that I really enjoy it. It seems like a very simple package. It doesn't have very many interactive functions or customizable options. Essentially it comes down to you enable it and you pick the default width of the text that you want. The initial 70 is a bit too small for me, but 80 or 85 is pretty comfy.

It's also possible to have it enable and disable visual-line-mode. Personally I always have this on in Org, ever since I started using org-indent-mode.

Recently I've been introduced to the idea of seeing my blog as a garden instead of a personal news site. My blog is a digital garden, not a blog and How the Blog Broke the Web have inspired me to look at my website as a garden, with a blog as just a part of it. I really don't like the idea of presenting my thoughts like a personal news site. I don't think you're that interested in me or my daily comings and goings.

What I do think you might be interested in is documents about how to do stuff that you might not know. What I'm interested in on this site is writing about things that I didn't know before.

One thing I wanted to do for this was to move away from having my latest posts as the landing page of my website. I want something hand-crafted now. It's going to be terrible, but I'm hoping it'll be fun to mess around with it, make small incremental changes over time.

coleslaw doesn't seem naturally set up for this at the moment. So after I'd set up my blog builds I wanted to extend them to include a custom front page. I looked for a way to have coleslaw do it, but it doesn't seem possible built-in, or through a plug-in. So I hackily added a step to my build step in my .gitlab-ci which just moves a named generated page into index.html.

# ...

build:
  # ...
  script:
    - cd html && coleslaw
    - cd ..
    - cp img/* public/img/
    # A temporary measure to let me define my own front page.
    - mv public/front-page.html public/index.html
  # ...

This works because in coleslaw, luckily, the usual index.html is just a symlink to the first page of recent posts.

Maybe in the not-too-distant future I'll remember to try and find the time to see if I can make a plugin for this.

My previous deployment process wasn't very will organized. Using gitolite I had set up some post-receive hooks on my server that would run some coleslaw that happened to have been installed on my server (which had become quite ancient by now).

The new process is a bit more structured.

generate-posts:
  before_script:
    - cask
  script:
    - cask emacs -batch -f package-initialize -l project.el -f org-publish-all
  artifacts:
    paths:
      - html

(setq org-publish-project-alist
      '(("posts"
         :base-directory "posts/"
         :publishing-directory "html/"
         :publishing-function org-coleslaw-publish-to-post)
        ("pages"
         :base-directory "pages/"
         :publishing-function org-coleslaw-publish-to-page
         :publishing-directory "html/")))

copy-rest:
  script:
    - mkdir html
    - cp -r .coleslawrc *.page *.post themes/ html/
  artifacts:
    paths:
      - html

build:
  image: registry.gitlab.com/ryuslash/blog
  needs:
    - job: generate-posts
      artifacts: true
    - job: copy-rest
      artifacts: true
  script:
    - cd html && coleslaw
  artifacts:
    paths:
      - public/

(;; Required information
 ;; ...
 :staging-dir "../public/"
)

RUN ros install coleslaw-org/coleslaw \
    && coleslaw --help 2>/dev/null \
    && chmod a+rx /usr/local/bin/coleslaw