leah blogs: February 2015

Recently I got around to configuring less, and I collected these few tricks:

1. Sometimes I look at lists with less, and then do things step-by-step, keeping the current action at the top of the page. This works nicely until you end up at the last page of the file, and then can’t scroll down. You lose track of where you are at and get confused.

   It would be much nicer scrolling down, and filling up the buffer with ~ after the end of file, just as if you had searched in the pager.

   Actually, with ESC-SPC, you can move a full page down, filling up the buffer with ~. Toying around a bit, you’ll find out that you can override the “page length” with a prefix, i.e. 1 ESC-SPC will move down one line only!

   However, this is still inconvenient to type all the time, thus let’s define a keybinding. For this, create a file ~/.lesskey where we will put the key definitions. This file then will be compiled using lesskey(1) and generate a binary configuration file ~/.less. (I guess you can be lucky that m4 is not involved in this mess…)

   One problem is actually binding the key. You can easily bind the cursor down key (\kd) to forw-screen-force, but how do you pass 1? The canonical hack is to use the noaction action, which will behave just like you’ve typed the keys after it. Thus, we write:

   #command
   \kd noaction 1\e\40
   j noaction 1\e\40
   

   (By the way, that #command comment is important to tell lesskey you are defining key commands.)

   Finally, scrolling bliss!

   Actually, scrap that.

   The badly underdocumented key J (and K) will scroll how I want, but you only read about that in the example inside lesskey(1). Therefore, we can just do:

   #command
   \kd forw-line-force
   j forw-line-force
   

   These keybindings are there since at least 1997 and I’ve never found them before…

2. While we are redefining keys, I’ve always found it a bit clumsy to read multiple files, having to type :n and :p. Using [ and ] is much more convenient (at least on a US keyboard), and by default these keys do things of questionable utility.

   #command
   [ prev-file
   ] next-file
   

3. Did you ever wish to give feedback from less? Like have a script output some info, and you decide how to go on? Since less always exits with status 0 usually, this I thought this was tricky to do, but the quit action actually can return an arbitrary exit code, encoded as a character.

   I bound Q and :cq (like in vim) to exit with status 1:

   #command
   Q quit \1
   :cq quit \1
   

   Now you can do stuff like look at all files and have them deleted when you press Q instead of q to exit:

   for f in *; do less $f || rm $f; done
   

4. I use less a lot to look at patches, git log output, and ocassionally mailboxes. The D command as defined below will move to the next line starting with diff or commit or From␣.

   #command
   D noaction j/\^diff|commit|From \n\eu
   

   It will also “type” ESC-u to hide the highlighting. Now I can simply press D to jump to the next chunk of interest.

5. To return to where you started from after a search or going to the end of file, type ''. Typing '' again will go back, so this is also nice to toggle between two search results.

6. Back in the old days of X11R2(?) there was a tool called xless, which was exactly that: a pager like less that ran in its own X11 window. It’s quite useful. We can recreate this by combining a X11 terminal emulator and plain less with a small zsh snippet:

   xless() {
     {
       exec {stdin}<&0 {stderr}>&2
       exec urxvt -e sh -c "less ${(j: :)${(qq)@}} </dev/fd/$stdin 2>/dev/fd/$stderr"
     } &!
   }
   

   Watch the trick how we pass the stdin/stderr file descriptors and the file arguments!

   Now you can just run command-spitting-out-loads | xless and the output will be shown in a new terminal and not lock your shell.

   NP: Feine Sahne Fischfilet—Dreieinhalb Meter Lichtgestalt

Wow, almost two years have passed since the latest installment of our favorite clickbait zsh tricks series.

1. When editing long lines in the zle line editor, sometimes you want to move “by physical line”, that is, to the character in the terminal line below (like gj and gk in vim).

   We can fake that feature by finding out the terminal width and moving charwise:

   _physical_up_line()   { zle backward-char -n $COLUMNS }
   _physical_down_line() { zle forward-char  -n $COLUMNS }
   zle -N physical-up-line _physical_up_line
   zle -N physical-down-line _physical_down_line
   bindkey "\e\e[A" physical-up-line
   bindkey "\e\e[B" physical-down-line
   

   Now, ESC-up and ESC-down will move by physical line.

2. Sometimes it’s nice to do things in random order. Many tools such as image viewers, music or media players have a “shuffle” mode, but when they don’t, you can help yourself with this small trick:

   SHUF='oe|REPLY=${(l:5::0:)RANDOM}${(l:5::0:)RANDOM}${(l:5::0:)RANDOM}|'
   

   Just append ($SHUF) to any glob, and get the matches shuffled:

   % touch a b c d
   % echo *($SHUF)
   d c a b
   % echo *($SHUF)
   c a d b
   

   Note that this shuffle is slightly biased, but it should not matter in practice. In doubt, use shuf or sort -R or something else…

3. Are you getting sick of typing cd ../../.. all the time? Why not type up 3?

   up() {
     local op=print
     [[ -t 1 ]] && op=cd
     case "$1" in
       '') up 1;;
       -*|+*) $op ~$1;;
       <->) $op $(printf '../%.0s' {1..$1});;
       *) local -a seg; seg=(${(s:/:)PWD%/*})
          local n=${(j:/:)seg[1,(I)$1*]}
          if [[ -n $n ]]; then
            $op /$n
          else
            print -u2 up: could not find prefix $1 in $PWD
            return 1
          fi
     esac
   }
   

   With this helper function, you can do a lot more actually: Say you are in ~/src/zsh/Src/Builtins and want to go to ~/src/zsh. Just say up zsh. Or even just up z.

   And as a bonus, if you capture the output of up, it will print the directory you want, and not change to it. So you can do:

   mv foo.c $(up zsh)
   

4. Previous tricks (#6/#7) introduced the dirstack and how to navigate it. But why type cd -<TAB> and figure out the directory you want to go to when you simply can type cd ~[zsh] and go to the first directory in the dirstack matching zsh? For this, we define the zsh dynamic directory function:

   _mydirstack() {
     local -a lines list
     for d in $dirstack; do
       lines+="$(($#lines+1)) -- $d"
       list+="$#lines"
     done
     _wanted -V directory-stack expl 'directory stack' \
       compadd "$@" -ld lines -S']/' -Q -a list
   }
   zsh_directory_name() {
     case $1 in
       c) _mydirstack;;
       n) case $2 in
            <0-9>) reply=($dirstack[$2]);;
            *) reply=($dirstack[(r)*$2*]);;
          esac;;
       d) false;;
     esac
   }
   

   The first function is just the completion, so cd ~[<TAB> will work as well.

5. Did you ever want to move a file with spaces in the name, and mixed up argument order?

   % mv last-will.tex My\ Last\ Will.rtf
   

   Pressing ESC-t (transpose-words) between the file names will do the wrong thing by default:

   % mv My last-will.tex\ Last\ Will.rtf
   

   Luckily, we can teach transpose-words to understand shell syntax:

   autoload -Uz transpose-words-match
   zstyle ':zle:transpose-words' word-style shell
   zle -N transpose-words transpose-words-match
   

   Voila:

   % mv My\ Last\ Will.rtf last-will.tex
   

6. If you are an avid Emacs user like me, you’ll find this function useful. It enters the directory the currently active Emacs file resides in:

   cde() {
     cd ${(Q)~$(emacsclient -e '(with-current-buffer
                                  (window-buffer (selected-window))
                                  default-directory) ')}
   }
   

   You need the emacs-server functionality enabled for this to work.

7. I’m working on many different systems and try to keep a portable .zshrc between those. One problem used to be setting $PATH portably, because there is quite some difference among systems. I now let zsh figure out what belongs to $PATH:

   export PATH
   path=(
     ~/bin
     ~/.gem/ruby/*/bin(Nn[-1])
     ~/.opam/current/bin
     ~/.cabal/bin
     ~/.go/bin
     /usr/local/bin
     /usr/local/sbin
     /usr/bin
     /usr/sbin
     /sbin
     /bin
     /usr/games
     /usr/games/bin
   )
   path=( ${(u)^path:A}(N-/) )
   

   The last line will normalize all paths, and remove duplicates and nonexisting directories. Also, notice how I pick up the latest Ruby version to find the Gem bin dir by sorting them numerically.

8. One of the hardest things is to set the xterm title “correctly”, because most people do it wrong in some way, and then it will break when you have literal tabs or percent signs or tildes in your command line. Here is what I currently use:

   case "$TERM" in
     xterm*|rxvt*)
       precmd() {  print -Pn "\e]0;%m: %~\a" }
       preexec() { print -n "\e]0;$HOST: ${(q)1//(#m)[$'\000-\037\177-']/${(q)MATCH}}\a" }
   esac
   

9. For a cheap, but secure password generator, you can use this:

   zpass() {
     LC_ALL=C tr -dc '0-9A-Za-z_@#%*,.:?!~' < /dev/urandom | head -c${1:-10}
     echo
   }
   

10. Sometimes it’s interesting to find a file residing in some directory “above” (e.g. Makefile, .git and similar). We can glob these by repeating ../ using the #-operator (You have EXTENDED_GLOB enabled, right?). This will result in all matches, so let’s first sort them by directory depth:

    % pwd
    /home/chris/src/zsh/Src/Builtins
    % print -l (../)#Makefile.in(Od)
    ../Makefile.in
    ../../Makefile.in
    

    Now we can pick the first one, and also make the file name absolute:

    % print (../)#Makefile.in(Od[1]:A) 
    /home/chris/src/zsh/Makefile.in
    

    I knew the #-operator, but it never occurred to me to use it this way before.

    Until next time!

    NP: Pierced Arrows—On Our Way