Just Another Geek

Petite frayeur aujourd'hui après mise à jour puis redémarrage de la machine puisque je ne pouvais plus rien faire du tout depuis mon shell : ni compilé des simples programmes C, ni lancer le serveur X par exemple.

% gcc t.c
collect2: cannot find 'ld'

Pareil, plein d'erreurs inexplicables un peu partout avec des messages abscons.

Après quelques minutes de frissons, je me suis penché sur ma variable PATH que j'avais décidé de ne plus exporter il y deux mois car je voulais me contenter du PATH "par défaut" (pour diverses raisons). Visiblement, la mise à jour du paquet Debian zsh-beta [archive] a modifié l'ancien comportement.

Ca m'apprendra à faire le goret...

Voici un biff du pauvre pour voir dans quel(s) dossier(s) Maildir on a du courrier en utilisant les globbing modifiers de zsh

% alias poorbiff='print -l ~/.Maildir/.*/new/*(:h:h:t) | sort -u'
% poorbiff
.list.foo
.list.bar
.list.plop

Note: Mon ordinateur portable est mort dans d'attroces souffrances, ce qui explique mon manque de réponse aux mails depuis une semaine

extensions=''${(fR)${(M)${(f)"$(< /etc/mime.types)"}##video*}##video[[:alnum:]./-]##[\t ]#}''

1. $(< /etc/mime.types) - on extrait le contenu du fichier
2. ${(f)"..."} - on fait du line-splitting
3. ${(M)${...}##video*} - on ne sélectionne que les lignes matchant video*
4. ${(R)${...}##video[[:alnum:]./-]##[\t ]#} - on matche la partie gauche de la ligne et on garde le reste.

Maintenant, la variable $extensions contient les extensions dans un fouilli pas encore utilisable : ce qu'on veut, c'est construire une expression rationnelle qui matche un nom de fichier associé à une vidéo. On veut *(wmv|avi|mkv|mpg). Pour le moment, on a une chaine de ce genre :

wmv     avi mkv         mpg

videos="(#i)*(${(j:|:)${(z)extensions}})"

1. ${(z)extensions} - on fait un word-splitting classique (les éléments sont séparés par $IFS)
2. ${(j:|:)...} - on joint tous les mots/éléments par le caractère '|'
3. (#i)*(...) - on mets le flag "case insensitive" et le {début,fin} de l'expression rationnelle.

Comme je racontais la dernière fois, j'ai un répertoire où j'entasse tous les fichiers de la journée, cela peut être des vidéos, papiers, codes, etc.

J'aime bien visionner toutes les vidéos sans avoir me prendre la tete, donc j'aimerai bien faire :

% mplayer *

Ca marche, mais vous êtes d'accord que c'est pas terrible : mplayer tente de lire même les fichiers pdf et ca ne lui plait pas toujours... Alors on tente d'affiner :

% mplayer *(avi|mpg|mkv)

Mais comme le veut Murphy, on oublie toujours d'indiquer un format, et puis c'est long de taper (et de se souvenir) de toutes les extensions possibles.

Utilisons alors le fichier /etc/mime.types pour récupérer toutes ces extensions. Utilisons du Perl pour faire ca :

% videos="(#i)*($(perl -lane 'push @x, $F[1] if /video/ && defined $F[1];END{print join q/|/,@x}' /etc/mime.types))"
% echo $videos
(#i)*(dl|fli|gl|mpeg|mp4|qt|mxu|dif|lsf|mng|asf|wm|wmv|wmx|wvx|avi|movie)
% echo $~videos
bl.avi bl.AVI

Ce qui marche plutot bien... Mais comme c'est encore trop simple comme solution, utilisons zsh uniquement : pas besoin de gaspiller un fork() !

% extensions=''${(fR)${(M)${(f)"$(< /etc/mime.types)"}##video*}##video[[:alnum:]./-]##[\t ]#}''
% videos="(#i)*(${(j:|:)${(z)extensions}})"

(bon, j'y ai passé une heure, mais ca a plus de gueule non ? On pourrait encore factoriser une ou deux expressions mais j'ai mal à la tête...)

Pourquoi faire simple lorsqu'on peut faire compliqué ?

Miracle, parlons aujourd'hui de shell, mais pas (forcément) de zsh.

Dans son livre "The Linux Server Hacks" [archive], Rob Flickenger nous propose une astuce qu'il nomme "Turbo-mode ssh login", le principe est d'écrire un shell script qui se résume à ssh $(basename $0) $*, ensuite, on fait une montagne de liens symboliques

% ln -s ssh-to serveurA.org
% ln -s ssh-to serveurB.org

Ensuite, yapluka :

% serveurA.org
Password:

C'est bien, mais on a pas toujours le même login sur toutes les machines distantes, donc voici ma version :

#! /bin/sh

if [[ "x$1" = x-* ]]; then
    login=${1#-}
    shift
fi

ssh "${login:+$login@}$(basename "$0" )" $*

Maintenant :

% ln -s ssh-to serveurA.org
% ln -s ssh-to serveurB.org
% serveurB.org -monlogin
Password for monlogin@serveurB.org:
../..
% serveurA.org
Password:

Oui je sais, je commence à parler un peu trop de ce merveilleux shell qu'est zsh. Tant pis pour vous, c'est mon blog après tout :)

Toujours dans ma quête du moindre effort, j'aime pas retaper quelque chose que j'ai déjà tapé, surtout lorsque c'est un long path. Par exemple, lorsque vous voulez changer l'extension d'un fichier :
% mv /foo/bar/yop/yup/blabla.xt
Vous en êtes là et vous avez la flemme de retaper tout le path alors vous prenez votre souris (ou vous vous mettez en copy-mode sous screen [archive]) et vous faites un bon vieux copy/yank. Ca marche, mais c'est chia^Wfatiguant..

Voici un widget zsh qui prend le mot précédent de la ligne de commande et le copie là où est votre curseur.

copiteur () {
        zle backward-word
        zle kill-line
        zle yank
        zle yank
}
zle -N copiteur
bindkey '\el' copiteur # ESC-l

Je me fais tout le temps avoir : je tape une ligne de commande et juste avant de taper <Entrée>, je me rappelle que j'ai oublié de rajouter sudo au début. Résultat, de précieuses milisecondes perdues :)

Les widgets zsh viennent à ma rescousse :

Read next [archive]

Certains pensent que les globbing modifiers de zsh sont inutiles et ne servent qu'à troller.

Voici donc un exemple-concret-de-pourquoi-ca-rulez : il m'arrive très fréquemment de télécharger des dizaines de vidéos en même temps (avec Mozilla Firefox), mais comme je n'aime pas attendre, je veux voir celles qui sont finies de téléchargées et laisser les autres tranquille.

Je demande alors la liste des fichiers réguliers modifiés il y a moins de 15 minutes mais n'incluant pas les fichiers modifiés il y a moins de 20 secondes. (15 minutes < temps voulu < 20 secondes). Cela donne :

% mplayer *(.mm-15^ms-20)

function nba-timestamp2date() {
    if [[ "x"== "x$1"]]; then
        1=time
    fi
    perl -le "print scalar localtime $1";
}

Comment ça je suis un gros fainéant ? D'accord le nom de la fonction est aussi long que l'appel a la commande finale, mais au moins, zsh me le complète :)

Exemple :

% nba-timestamp2date
Tue Aug 10 12:27:04 2004
% nba-timestamp2date 1091940610
Sun Aug 8 06:50:10 2004

Quand on est paresseux, on l'est juqu'au bout ! (c)

zsh% print -l *(.Lm+1oL)

Comment ça c'est illisible ? C'est pourtant simple, ça affiche la liste triée sur la taille (de manière croissante) des fichiers réguliers faisant plus d'un méga-octet du répertoire courant.