Journal Back to basics : avoir un excellent pager avec less

Posté par  . Licence CC By‑SA.
Étiquettes :
73
11
oct.
2016

Un petit article sur des trucs que j’apprécie pas mal avec less et qui explique pourquoi je n’utilise pas (et je m’énerve) quand je dois utiliser more.

D’abord pour les étourdis. Un pager est un outil en ligne de commande qui permet de naviguer dans un document texte dont la taille dépasse celle de votre terminal. C’est ce que vous utilisez sans le savoir à chaque fois que vous lisez une page de manuel avec man. Il existe trois principaux pager dans nos contrées : more (le vieux), most (le jeune) et less (mon préféré).

La base

Bon, le truc de base c’est de lui donner un fichier texte en paramètre :

less /etc/hosts

Waow !

Pour naviguer, on peut utiliser les flèches, la touche espace, mais aussi les classiques g/G.
Il est possible de rechercher du texte avec les commandes /<texte de recherche> (recherche en avant) ou ?<texte de recherche> (recherche en arrière).
Il est possible de filtrer les lignes affichées grâce à la commande &<motif> (c’est proche d’un grep <motif> fichier | less en plus souple vu qu’on peut revenir en arrière).
Une dernière option qui peut s’avérer intéressante : v. Elle ouvre le document dans votre éditeur de texte préféré (→ l’éditeur défini par la variable d’environnement VISUAL ou EDITOR, le cas échéant).

Il existe plein d’autres commandes, je vous invite à lire le manuel pour les découvrir. Je ne présente que quelques‐unes qui me sont le plus utile.

Généralement, pour l’activer il suffit de le donner dans la variable d’environnement PAGER.

Un peu de conf

Personnellement, j’aime bien avoir une configuration de less bien précise, je vais vous la décrire :

LESS_TERMCAP_mb=$'\E[01;31m'
LESS_TERMCAP_md=$'\E[01;31m'
LESS_TERMCAP_me=$'\E[0m'
LESS_TERMCAP_so=$'\E[01;44;33m'
LESS_TERMCAP_se=$'\E[0m'
LESS_TERMCAP_us=$'\E[01;32m'
LESS_TERMCAP_ue=$'\E[0m'

Ça, c’est pour avoir les man (c’est pas limité aux pages de manuel, mais c’est principalement elles qui s’en servent) en couleur.

LESS="-FSRXI"

C’est assez pratique pour ne pas avoir à redonner perpétuellement les options de less à less (et c’est pratique parce que les alias ça marche pas pour les man).
Donc ces 4 options :

  • F : quitte less si le contenu qu’il tente d’afficher fait moins d’un écran (très utile avec l’option X) ;
  • S : ne pas renvoyer à la ligne les lignes plus larges que l’écran ; je trouve que c’est plus lisible pour les journaux (les débuts de lignes sont bien alignés) ;
  • R : pour autoriser les séquences ANSI (utile pour la couleur) ;
  • X : ne nettoie pas l’écran à la fermeture ; en combinaison de -F, less devient utilisable comme un cat pour pas mal de choses. Ça me permet de continuer de voir ce qu’il y avait dans un man, même une fois quitté (et donc de ne pas avoir besoin de 2 Shells). Ça ne plaira pas à tout le monde, car ça peu polluer l’écran ;
  • I : la recherche est insensible à la casse, sauf si cette dernière contient des lettres majuscules.

C’est tout ?

Non, mon pauvre ! less peut aller plus loin. La fonctionnalité méconnue de less, c’est lesspipe. Ça permet à less de lire tout et n’importe quoi, du moment que tu sais comment le faire afficher dans un terminal.

Pour activer ça, il faut d’abord exporter deux petites variables :

eval $(lesspipe)

Ensuite, il est possible de configurer tout ça via un script à placer dans ~/.lessfilter. Par exemple, pour lire les fichiers de capture créés grâce à tcpdump ou tshark :

#!/bin/zsh
if [ -d "$1" ];then
   ls -la "$1"
   exit 0
fi
case "${(L)1}" in
   *.cap) # il n’y a pas de règles sur les
      tshark -r "$1"
      ;;
   *)
      exit 1
esac
exit 0

Puis un :

chmod 700 ~/.lessfilter~/.lessfilter

Et le tour est joué. Maintenant, il suffit de faire :

less fichier.cap

Pour voir vos traces dans votre terminal et pouvoir naviguer dedans.

Le mien, c’est l’mieux !

less est vraiment un pager très pratique et d’une extrême vélocité. L’utiliser avec des fichiers de centaines de Mio n’a jamais été un problème (il a un comportement assez rigolo, il affiche toujours instantanément le fichier, mais il met du temps à compter les lignes et on peut lui dire que ce n’est pas la peine de le faire avec un Ctrl + C).

Il existe néanmoins deux autres pagers très puissants : Vim et Emacs.
Je ne les trouve pas hyper agréables, mais je ne suis pas un spécialiste de ces deux éditeurs (j’ai un usage « normal » de vim et je suis balbutiant en emacs).
Je laisse donc les spécialistes du genre nous concocter leurs meilleures recettes qui expliquent pourquoi le leur est meilleur.
De la même manière, je ne me suis jamais plongé dans most qui a l’air plus simpliste que less, mais si parmi vous certains veulent le faire découvrir j’en serais enchanté. :)

  • # X

    Posté par  . Évalué à 10.

    Owi owi… merci tout pleins pour l’option X. less doit être l’outil que j’utilise le plus après ls et cd et n’ai jamais pensé à RTFM.

  • # Console

    Posté par  (site web personnel) . Évalué à 10.

    D'abord pour les étourdis. Un pager est un outil en ligne de commande

    Non. Enfin, oui et non. Oui, dans le sens où il se lancer avec une ligne de commande, mais ça, c'est le cas de tous les logiciels, même graphiques. Non, dans le sens où une ligne de commande ne lui suffit pas : c'est un outil en console. Comme Mutt pour le courrier électronique ou Vim pour le texte par exemple : c'est de la console, pas de la ligne de commande. La ligne de commande, c'est mail et ed.

    • [^] # Re: Console

      Posté par  . Évalué à 4.

      Effectivement mon clavier as du fourcher.

      Ceci dit, même si l'utilité est faible, il fonctionne très bien en cli : less ./etc/hosts | grep e ;)

      Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

  • # -S

    Posté par  (site web personnel) . Évalué à 10.

    Pour le fait de couper ou non les lignes, ça peut se faire avec l'option -S au lancement, mais pas seulement : en cours de lecture, on peut taper -S pour passer d'un mode à l'autre. Ça vaut pour d'autres options d'ailleurs.

    • [^] # Re: -S

      Posté par  . Évalué à 6.

      Je ne le vois pas dans le man. Merci.
      J'aimerais bien pouvoir faire l'inverse, mais j'ai rien trouvé et j'ai essayé (de répéter -S ou +S).

      Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

      • [^] # Re: -S

        Posté par  (site web personnel) . Évalué à 10. 

        COMMANDS
       -      Followed by one of the command line option letters (see OPTIONS
              below), this will change the setting of that option and print a
              message  describing  the  new  setting.  If a ^P (CONTROL-P) is
              entered immediately after the dash, the setting of  the  option
              is changed but no message is printed.  If the option letter has
              a numeric value (such as -b or -h), or a string value (such  as
              -P  or -t), a new value may be entered after the option letter.
              If no new value is entered, a message  describing  the  current
              setting is printed and nothing is changed.

       --     Like  the  - command, but takes a long option name (see OPTIONS
              below) rather than a single  option  letter.   You  must  press
              ENTER or RETURN after typing the option name.  A ^P immediately
              after the second dash suppresses printing of a message describ‐
              ing the new setting, as in the - command.

       -+     Followed  by  one  of the command line option letters this will
              reset the option to its default setting  and  print  a  message
              describing  the  new setting.  (The "-+X" command does the same
              thing as "-+X" on the command line.)  This does  not  work  for
              string-valued options.

       --+    Like the -+ command, but takes a long option name rather than a
              single option letter.

       -!     Followed by one of the command line option letters,  this  will
              reset  the  option to the "opposite" of its default setting and
              print a message describing the new setting.  This does not work
              for numeric or string-valued options.

       --!    Like the -! command, but takes a long option name rather than a
              single option letter.

       _      (Underscore.)  Followed by one of the command line option  let‐
              ters,  this will print a message describing the current setting
              of that option.  The setting of the option is not changed.

       __     (Double underscore.)  Like  the  _  (underscore)  command,  but
              takes  a  long  option name rather than a single option letter.
              You must press ENTER or RETURN after typing the option name.

OPTIONS
       Command line options are described below.  Most options may be changed
       while less is running, via the "-" command.

    • [^] # Re: -S

      Posté par  (site web personnel) . Évalué à 2.

      Yep, d'ailleurs, autant j'adhère pas mal à la plupart des options proposées par Barmic (je pense pouvoir m'habituer au X), autant le S (no wrap), c'est difficile quand on utilise pas mal d'outil basés sur less, comme git où là, sans wrapping, c'est juste horrible.
      Mais je suis bien content de connaître cette option, maintenant, c'est comme pour tout (oui emacs et tes millions d'extensions, c'est surtout toi que je regarde), si on l'utilise pas assez souvent, on l'oublie :)

  • # on peut faire beaucoup de choses avec un lesspipe

    Posté par  . Évalué à 10.

    Exemples d’extraits de lesspipe.zsh (/!\ syntaxe z-shell) :

    Tar.gzip --> liste du contenu :

    type_fichier=$(file -L -z $fichier)
    [[ $type_fichier = *:*tar*archive*gzip*compressed* ]] && {
    echo "exec tar tzvf $fichier"
    echo
    exec tar tzvf $fichier
    }

    Répertoire -> tree :

    [[ -d $fichier ]] && {
    echo "exec tree -C -A $fichier"
    echo
    exec tree -C -A $fichier
    }

    * Les PDF avec pdftotext
    * les méta-données d’images avec exiv2
    * ogginfo, metaflac
    * strings, hexdump pour les binaires
    * readlink pour les liens symboliques (attention à la récursion infinie :))
    * etc

  • # lesspipe

    Posté par  . Évalué à 10.

    Tout d'abord, je signale que ~/.lessfilter ça ne fonctionne que sous debian.

    lesspipe regarde le contenu de la variable LESSOPEN. Logiquement, on créé un script lesspipe qui renvoie ses variables lorsqu'on l'exécute sans argument :

    $ lesspipe
export LESSOPEN="| /usr/bin/lesspipe %s";
export LESSCLOSE="/usr/bin/lesspipe %s %s";

    D'où le eval $(lesspipe) pour l'activer. Il se trouve que le lesspipe fourni par debian cherche un fichier ~/.lessfilter, ce qui permet à chaque utilisateur d'avoir son script perso. Mais ce n'est pas le cas sous toutes les distribs.

    Pour ma part, j'ai refait un lesspipe à ma sauce, d'abord inspiré de ceux trouvés dans les distribs que j'ai utilisés, puis alimenté au fur et à mesure des fichiers que j'ai voulu lire avec less. Le voici aujourd'hui :

    #!/bin/sh
# input preprocessor for less

# print LESSOPEN variable, when called without args
# (use it with absolute path)
if [ $# -eq 0 ]; then
    echo "LESSOPEN=\"|$0 %s\""
    echo "LESSCHARSET=utf-8"
    if env | grep -q '^LESS=' ; then
        if ! echo $LESS | grep -q '\-R' ; then
            echo "LESS=\"-R $LESS\""
        fi
    else
        echo "LESS=-R"
    fi
    echo "export LESS LESSOPEN LESSCHARSET"
    exit
fi

# Check usage
if [ $# -gt 1 ]; then
    echo "Usage: Don't use it directly"
    echo 'Launch "eval $(/path/to/lesspipe.sh)" to use it with less'
fi

# We just determine file type of $1
# and determine which viewer is appropriate
case "$(file -Lb "$1")" in
# Folder
directory)
    ls -la "$1" 2>/dev/null ;;

# Archive
POSIX[[:space:]]tar[[:space:]]archive*)
    tar tvvf "$1" 2>/dev/null ;;
gzip[[:space:]]compressed[[:space:]]data*) # Test if tar or man 
    if gzip -dc "$1" | file - | grep -q 'tar archive' ; then
        tar tvvf "$1" 2>/dev/null
    elif gzip -dc "$1" | file - | grep -q 'roff' ; then
        gzip -dc "$1" | nroff -S -mandoc -
    else
        gzip -dc "$1" 2>/dev/null
    fi ;;
bzip2[[:space:]]compressed[[:space:]]data*)
    if bzip2 -dc "$1" | file - | grep -q 'tar archive' ; then
        tar tvvf "$1" 2>/dev/null
    elif bzip2 -dc "$1" | file - | grep -q 'roff' ; then
        bzip2 -dc "$1" | nroff -S -mandoc -
    else
        bzip2 -dc "$1" 2>/dev/null
    fi ;;
cpio[[:space:]]archive)
    which cpio >/dev/null && cpio -it < "$1" 2>/dev/null ;;
[Xx][Zz][[:space:]]compressed[[:space:]]data*)
    if xz -dc "$1" | file - | grep 'tar archive' ; then
        xz -dc "$1" | tar tvvf - 2>/dev/null
    else
        xz -dc "$1" 2>/dev/null
    fi ;;
data) # Test if lzma archive
    if xz -t "$1" ; then
        if xz -F lzma -dc "$1" | file - | grep 'tar archive' ; then
            xz -F lzma -dc "$1" | tar tvvf - 2>/dev/null
        else
            xz -F lzma -dc "$1" 2>/dev/null
        fi
    else
        echo "Unrecognized file"
    fi ;;
ISO[[:space:]]9660[[:space:]]CD-ROM[[:space:]]filesystem[[:space:]]data*)
    if which isoinfo >/dev/null ; then
        echo "$1:" ; isoinfo -d -i "$1"
        echo
        echo '***Contents:' ; isoinfo -f -i "$1"
    fi ;;
Zip[[:space:]]archive[[:space:]]data*)
    unzip -l "$1" 2>/dev/null ;;
RAR[[:space:]]archive[[:space:]]data*)
    which unrar >/dev/null && unrar l "$1" 2>/dev/null ;;

# Distributions Packages
Debian[[:space:]]binary[[:space:]]package*)
    if which dpkg >/dev/null ; then
        echo "$1:" ; dpkg --info "$1"
        echo
        echo '*** Contents:' ; dpkg-deb --contents "$1"
    else
        ar p "$1" data.tar.gz | tar tzvf -
    fi ;;
RPM*)
    if which rpm >/dev/null ; then
        echo "$1:" ; rpm -q -i -p "$1"
        echo
        echo '*** Contents:' ; rpm -q -l -p "$1"
    elif which rpm2cpio >/dev/null ; then
        rpm2cpio "$1" | cpio -it
    elif which rpm2tar >/dev/null ; then
        rpm2tar -O "$1" | tar tvf -
    fi ;;

# Printable documents
PDF[[:space:]]document*)
    which pdftotext >/dev/null && pdftotext "$1" - 2>/dev/null ;;
PostScript[[:space:]]document*)
    if which pdftotext >/dev/null && which ps2pdf >/dev/null ; then
        ps2pdf "$1" > /tmp/less-$$ 2>/dev/null
        pdftotext /tmp/less-$$ - 2>/dev/null
        rm -f /tmp/less-$$
    fi ;;
TeX[[:space:]]DVI[[:space:]]file*)
    which dvi2tty >/dev/null && dvi2tty "$1" >/dev/null ;;

# Editable documents
LaTeX*document[[:space:]]text)
    which highlight >/dev/null && highlight -S tex -O ansi "$1" 2>/dev/null ;;
HTML[[:space:]]document[[:space:]]text)
    which highlight >/dev/null && highlight -S html -O ansi "$1" 2>/dev/null ;;
OpenDocument[[:space:]]Text)
    which odt2txt >/dev/null && odt2txt "$1" 2>/dev/null ;;
CDF[[:space:]]V2[[:space:]]Document*) # MS Office document
    if echo "$1" | grep -q '\.doc$' ; then
        which catdoc >/dev/null && catdoc "$1" 2>/dev/null
    elif echo "$1" | grep -q '\.xls$' ; then
        which xls2csv >/dev/null && xls2csv "$1" 2>/dev/null
    fi ;;
troff*)
    nroff -S -mandoc "$1" 2>/dev/null ;;

# text
*[Pp]erl*script*text*)
    if which pygmentize >/dev/null ; then
        pygmentize -l pl "$1" 2>/dev/null
    elif which highlight >/dev/null ; then
        highlight -S perl -O ansi "$1" 2>/dev/null
    fi ;;
*[Pp]ython*script*text*)
    if which pygmentize >/dev/null ; then
        pygmentize -l py "$1" 2>/dev/null
    elif which highlight >/dev/null ; then
        highlight -S python -O ansi "$1" 2>/dev/null
    fi ;;
*sh*script*text*)
    if which pygmentize >/dev/null ; then
        pygmentize -l sh "$1" 2>/dev/null
    elif which highlight >/dev/null ; then
        highlight -S Bash -O ansi "$1" 2>/dev/null
    fi ;;
*[Pp]ython*script*text*)
    if which pygmentize >/dev/null ; then
        pygmentize -l py "$1" 2>/dev/null
    elif which highlight >/dev/null ; then
        highlight -S Bash -O ansi "$1" 2>/dev/null
    fi ;;
*[pP][hH][pP]*script*text*)
    if which pygmentize >/dev/null ; then
        pygmentize -l php "$1" 2>/dev/null
    elif which highlight >/dev/null ; then
        highlight -S php -O ansi "$1" 2>/dev/null
    fi ;;
*C*program*text)
    if which pygmentize >/dev/null ; then
        pygmentize -l c "$1" 2>/dev/null
    elif which highlight >/dev/null ; then
        highlight -S c -O ansi "$1" 2>/dev/null
    fi ;;
*text)
    if echo "$1" | grep -q 'Makefile' ; then
        if which pygmentize >/dev/null ; then
            pygmentize -l make "$1" 2>/dev/null
        elif which highlight >/dev/null ; then
            highlight -S make -O ansi "$1" 2>/dev/null
        fi
    else
        cat "$1" 2>/dev/null
    fi ;;

# Images
JPEG[[:space]]image[[:space:]]data*)
    which identify >/dev/null && identify "$1" 2>/dev/null
    which jp2a >/dev/null && jp2a --color "$1" 2>/dev/null ;;

*image[[:space:]]data*)
    which identify >/dev/null && identify "$1" 2>/dev/null
    which jp2a >/dev/null && convert "$1" jpg:- 2>/dev/null | jp2a --color - 2>/dev/null ;;

# Others
# *)
#   cat "$1" ;;

esac

    • [^] # Re: lesspipe

      Posté par  . Évalué à 10.

      Merci pour les précisions et l'idée de pygmentize :)

      À ta place au lieu d'avoir des 2>/dev/null, je mettrais au début du script (en changeant le shabang pour bash) :

      exec 2<&-
exec 2<>/dev/null

      Tu as la gestion des scripts python en double :)

      Dernière petite remarque à ta place je ferrais une fonction colorize qui lance pygmentize ou highlight en fonction qui prend en paramètre le lexer pygmentize et le fichier et qui a une table de correspondance entre le lexer pygmentize et l'équivalent highlight. C'est pratique à faire en bash et tu gagne quelques lignes.

      Je me suis permis de le reprendre en bash parce que je pense que je vais l'utiliser si ça ne te dérange pas :)

      #!/bin/bash
# input preprocessor for less

function cmdexist() {
  which "$1" >/dev/null
}

declare -A lexers
lexers["c"]="c"
lexers["pl"]="perl"
lexers["py"]="python"
lexers["sh"]="Bash"
lexers["php"]="php"
lexers["make"]="make"

function colorize() {
  if which pygmentize >/dev/null ; then
    pygmentize -l "$1" "$2"
  elif which highlight >/dev/null ; then
    highlight -S "${lexers[$1]}" -O ansi "$2"
  fi
}

# print LESSOPEN variable, when called without args
# (use it with absolute path)
if [ $# -eq 0 ]; then
    echo "LESSOPEN=\"|$0 %s\""
    echo "LESSCHARSET=utf-8"
    if env | grep -q '^LESS=' ; then
        if ! echo $LESS | grep -q '\-R' ; then
            echo "LESS=\"-R $LESS\""
        fi
    else
        echo "LESS=-R"
    fi
    echo "export LESS LESSOPEN LESSCHARSET"
    exit
fi

# Check usage
if [ $# -gt 1 ]; then
    echo "Usage: Don't use it directly"
    echo 'Launch "eval $(/path/to/lesspipe.sh)" to use it with less'
fi

# We just determine file type of $1
# and determine which viewer is appropriate
case "$(file -Lb "$1")" in
# Folder
directory)
    ls -la "$1" ;;

# Archive
POSIX[[:space:]]tar[[:space:]]archive*)
    tar tvvf "$1" ;;
gzip[[:space:]]compressed[[:space:]]data*) # Test if tar or man
    if gzip -dc "$1" | file - | grep -q 'tar archive' ; then
        tar tvvf "$1"
    elif gzip -dc "$1" | file - | grep -q 'roff' ; then
        gzip -dc "$1" | nroff -S -mandoc -
    else
        gzip -dc "$1"
    fi ;;
bzip2[[:space:]]compressed[[:space:]]data*)
    if bzip2 -dc "$1" | file - | grep -q 'tar archive' ; then
        tar tvvf "$1"
    elif bzip2 -dc "$1" | file - | grep -q 'roff' ; then
        bzip2 -dc "$1" | nroff -S -mandoc -
    else
        bzip2 -dc "$1"
    fi ;;
cpio[[:space:]]archive)
    cmdexist cpio && cpio -it < "$1" ;;
[Xx][Zz][[:space:]]compressed[[:space:]]data*)
    if xz -dc "$1" | file - | grep 'tar archive' ; then
        xz -dc "$1" | tar tvvf -
    else
        xz -dc "$1"
    fi ;;
data) # Test if lzma archive
    if xz -t "$1" ; then
        if xz -F lzma -dc "$1" | file - | grep 'tar archive' ; then
            xz -F lzma -dc "$1" | tar tvvf -
        else
            xz -F lzma -dc "$1"
        fi
    else
        echo "Unrecognized file"
    fi ;;
ISO[[:space:]]9660[[:space:]]CD-ROM[[:space:]]filesystem[[:space:]]data*)
    if cmdexist isoinfo ; then
        echo "$1:" ; isoinfo -d -i "$1"
        echo
        echo '***Contents:' ; isoinfo -f -i "$1"
    fi ;;
Zip[[:space:]]archive[[:space:]]data*)
    unzip -l "$1" ;;
RAR[[:space:]]archive[[:space:]]data*)
    cmdexist unrar && unrar l "$1" ;;

# Distributions Packages
Debian[[:space:]]binary[[:space:]]package*)
    if cmdexist dpkg ; then
        echo "$1:" ; dpkg --info "$1"
        echo
        echo '*** Contents:' ; dpkg-deb --contents "$1"
    else
        ar p "$1" data.tar.gz | tar tzvf -
    fi ;;
RPM*)
    if cmdexist rpm ; then
        echo "$1:" ; rpm -q -i -p "$1"
        echo
        echo '*** Contents:' ; rpm -q -l -p "$1"
    elif cmdexist rpm2cpio ; then
        rpm2cpio "$1" | cpio -it
    elif cmdexist rpm2tar ; then
        rpm2tar -O "$1" | tar tvf -
    fi ;;

# Printable documents
PDF[[:space:]]document*)
    cmdexist pdftotext && pdftotext "$1" - ;;
PostScript[[:space:]]document*)
    if cmdexist pdftotext && cmdexist ps2pdf ; then
        ps2pdf "$1" > /tmp/less-$$
        pdftotext /tmp/less-$$ -
        rm -f /tmp/less-$$
    fi ;;
TeX[[:space:]]DVI[[:space:]]file*)
    cmdexist dvi2tty && dvi2tty "$1" >/dev/null ;;

# Editable documents
LaTeX*document[[:space:]]text)
    cmdexist highlight && highlight -S tex -O ansi "$1" ;;
HTML[[:space:]]document[[:space:]]text)
    cmdexist highlight && highlight -S html -O ansi "$1" ;;
OpenDocument[[:space:]]Text)
    cmdexist odt2txt && odt2txt "$1" ;;
CDF[[:space:]]V2[[:space:]]Document*) # MS Office document
    if [[ "$1" =~ .doc$ ]] ; then
        cmdexist catdoc && catdoc "$1"
    elif [[ "$1" =~ .xls$ ]] ; then
        cmdexist xls2csv && xls2csv "$1"
    fi ;;
troff*)
    nroff -S -mandoc "$1" ;;

# text
*[Pp]erl*script*text*)      colorize pl "$1" ;;
*[Pp]ython*script*text*)    colorize py "$1" ;;
*sh*script*text*)           colorize sh "$1" ;;
*[pP][hH][pP]*script*text*) colorize php "$1" ;;
*C*program*text)            colorize php "$1" ;;
*text)
    if [[ "$1" =~ ^[mM]akefile$ ]] ; then
        colorize make "$1"
    else
        cat "$1"
    fi ;;

# Images
JPEG[[:space]]image[[:space:]]data*)
    cmdexist identify && identify "$1"
    cmdexist jp2a && jp2a --color "$1" ;;

*image[[:space:]]data*)
    cmdexist identify && identify "$1"
    cmdexist jp2a && convert "$1" jpg:- | jp2a --color - ;;

# Others
# *)
#   cat "$1" ;;

esac

      J'ai remarqué la commande : dvi2tty "$1" >/dev/null il écris sur sa sortie standard ? (je ne connais pas du tout l'outil)

      Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

      • [^] # Re: lesspipe

        Posté par  . Évalué à 4.

        J'ai remarqué la commande : dvi2tty "$1" >/dev/null il écris sur sa sortie standard ? (je ne connais pas du tout l'outil)

        Ça date, et je n'ai pas souvenir d'avoir lu un DVI depuis longtemps (les rares fois où je fais du LaTeX, je produis en pdf directement). Du coup, je pense que c'est une erreur, le >/dev/null est en trop.

        Ta reprise est sympa, je vais la récupérer du coup. C'est vrai que j'ai rajouté des lignes au fur et à mesure mais n'ai jamais revu ce script globalement.

        • [^] # Re: lesspipe

          Posté par  . Évalué à 4.

          Ta reprise est sympa, je vais la récupérer du coup. C'est vrai que j'ai rajouté des lignes au fur et à mesure mais n'ai jamais revu ce script globalement.

          Je continue à la faire évoluer et je l'ai ajouter à mes configurations : https://bitbucket.org/barmic/config/src/f0240b4d142f0f2994f13f125e55bd85fd02aa7c/lessfilter?at=default&fileviewer=file-view-default (bouh c'est pas libre tout ça tout ça…)

          Il y avait encore quelques coquilles par exemple la coloration qui n'était faite qu'avec highlight pour certains fichiers.
          Et j'ai ajouté une liste de fichiers particulier que je veux coloriser mais que ça ne se déduit pas avec file (.bashrc/.zshrc/…).

          Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

          • [^] # Re: lesspipe

            Posté par  (Mastodon) . Évalué à 2.

            Vous pouvez mettre cette ligne là pour détecter les ISOs, ça lira de la même façon les DVD en UDF !

            ISO[[:space:]]9660[[:space:]]CD-ROM[[:space:]]filesystem[[:space:]]data | UDF[[:space:]]filesystem[[:space:]]data*)

            Pour les fichiers LaTeX file me sort ça :
            base.tex: LaTeX 2e document, UTF-8 Unicode text
            Donc LaTeX*document[[:space:]]text) ne fonctionne pas.
            J'ai remplacé par LaTeX*document*[[:space:]]text)

            Et dernier point :
            *text) colorize "${particular_files[$(basename $1)]}" "$1" ;;
            Avec le basename, ça fonctionne aussi avec less ~/.bashrc par exemple.

            Yth, premier test que je fais avec le script, ça marche pô ^

            • [^] # Re: lesspipe

              Posté par  . Évalué à 3.

              J'ai mis à jour. Je te crois sur parole pour les DVD je n'ai pas de lecteur CD/DVD sur ma machine :)

              Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

              • [^] # Re: lesspipe

                Posté par  (Mastodon) . Évalué à 2. Dernière modification le 13 octobre 2016 à 13:09.

                Erf, j'ai fait locate *.iso, pris un fichier au pif, et testé, c'était tout moche, alors j'ai cherché, et c'était un DVD en UDF ^^

                Yth.

  • # tail -f fichier_de_log ? non ! less +F fichier_de_log

    Posté par  . Évalué à 10.

    J'étais tombé sur un post d'un blog qui présentait less +F, et c'est de la grosse balle. Ça permet de se mettre en attente sur un fichier (comme tail -f), mais on peut aussi interrompre l'attente pour se balader dans le fichier, puis se remettre en attente sur le fichier. Ça remplace très avantageusement tail -f /var/log/messages par exemple.

    $ while [ 1 ]; do date >> log_file; sleep 1 ; done &
[1] 12294
# je coupe des lignes, la commande suivante affiche en fait less sur tout le terminal
$ less +F ./log_file
Tue Oct 11 13:31:37 CEST 2016
Tue Oct 11 13:31:38 CEST 2016
Waiting for data... (interrupt to abort)
# sur pression de Ctrl-C
Tue Oct 11 13:32:15 CEST 2016
Tue Oct 11 13:32:16 CEST 2016
Tue Oct 11 13:32:17 CEST 2016
Tue Oct 11 13:32:18 CEST 2016
Tue Oct 11 13:32:19 CEST 2016
./log_file (END)
# on peut naviguer dans le fichier de log comme on fait habituellement dans less.
# pour reprendre la mise à jour du fichier, il suffit de se déplacer en fin de fichier (touche F)
Tue Oct 11 13:33:34 CEST 2016
Tue Oct 11 13:33:35 CEST 2016
Tue Oct 11 13:33:36 CEST 2016
Tue Oct 11 13:33:37 CEST 2016
Waiting for data... (interrupt to abort)
# et hop, de retour sur le lecture des nouvelles entrées dans le fichier

  • # most

    Posté par  . Évalué à 3.

    Perso j'utilise most: http://unix.stackexchange.com/questions/81129/what-are-the-differences-between-most-more-and-less

    Mais je me souvient plus pouquoi. Je pense que c'etait parceque il y avait de la coloration automatique

    • [^] # Re: most

      Posté par  . Évalué à 1. Dernière modification le 11 octobre 2016 à 16:35.

      Je faisais ça aussi, pour la même raison, jusqu'à ce que je réalise que "less is more que most". Je ne sais plus pourquoi celà dit…

      (édit: ça devait être probablement les raccourcis de type vi)

  • # options de LESS

    Posté par  . Évalué à 7.

    adepte de less également depuis longtemps, c'est amusant de voir que j'utilise de toutes autres options par défaut (dans la variable LESS) :

    export LESS="-e -i -m -R"

    avec :
    - -e : pour quitter Less la seconde fois qu'on atteint la fin de fichier (évite de sortir obligatoirement par un q)
    - -i : pour ignorer la casse dans les recherches sauf s'il y a [au moins] une lettre majuscule dans le motif recherché
    - -m : affiche le pourcentage où se situe la partie affichée du fichier
    - -R : permet d'afficher un fichier contenant des codes couleurs ANSI

    Quant à l'option X, bien que je l'ai notée, je n'ai jamais pu m'y habituer :-P

  • # jump target

    Posté par  . Évalué à 10.

    Quand on cherche un motif, il peut-être ennuyant que la ligne qui le contienne soit tout en haut de l'écran. Ça ne permet pas forcément de voir le contexte.

    L'option --jump-target=n ou -jn permet de mettre n lignes au dessus (n positif), voire de mettre la ligne trouvée tout en bas (n négatif). Il est également possible de fixer la valeur en pourcentage de l'écran : .2 pour 20%. La mise en couleur décrite dans le journal permet que le motif trouvé apparaisse en surbrillance.

    On peut ajouter dans son .bashrc :

    export LESS="-FSRXIj.2"

  • # case insensitive

    Posté par  . Évalué à 4.

    I : la recherche est insensible à la casse sauf si cette dernière contient des lettres majuscules

    Tu es sûr de ton coup ? Le man dit le contraire.

    -i or --ignore-case
    Causes searches to ignore case; that is, uppercase and lowercase are considered identical. This option is ignored if any uppercase letters appear in the search pattern; in other words, if a pattern contains uppercase letters, then that search does not ignore case.
    -I or --IGNORE-CASE
    Like -i, but searches ignore case even if the pattern contains uppercase letters.

  • # Configuration des touches

    Posté par  . Évalué à 4.

    Il est possible d'utiliser un fichier de configuration avec la commande lesskey pour les raccourcis clavier.

    man lesskey

    Je m'en sers également pour y mettre les variables d'environnement standards (LESS, LESSHISTFILE, …) pour éviter de plomber mon environnement à l'affichage.

    Mais je bute par contre pour y mettre les variables LESS_TERMCAP_*. Est-ce que quelqu'un a réussi déjà ? Je me dis que c'est peut-être une séquence d'échappement précise pour que ça marche…

    Un exemple de fichier:

            #command
        # format: string <whitespace> action [extra-string] <newline>
        s    noaction
        S    toggle-option o
        \    next-file 
        \e\  prev-file 
        #line-edit
        ^H      backspace
        #env
        LESS = --no-init --status-column --force --LONG-PROMPT --RAW-CONTROL-CHARS --shift 10 --squeeze-blank-lines --quit-if-one-screen
        LESSHISTSIZE = 5000
        LESSHISTFILE = /tmp/less/history
        LESSCHARSET = utf-8

    • [^] # Re: Configuration des touches

      Posté par  . Évalué à 5.

      Effectivement, les variables LESS_TERMCAP_* c'est moche dans l'affichage de 'env', et en fonction de l'ordre ca peut même pourrir les couleurs du terminal…

      Je n'ai pas essaye le fichier de config de lesskey, c'est intéressant.

      Un contournement, qui va marcher pour man seulement, avec un script ~/.bin/manpager.sh :

      #!/bin/bash
export LESS_TERMCAP_mb=$'\E[01;31m'
export LESS_TERMCAP_md=$'\E[01;31m'
export LESS_TERMCAP_me=$'\E[0m'
export LESS_TERMCAP_so=$'\E[01;44;33m'
export LESS_TERMCAP_se=$'\E[0m'
export LESS_TERMCAP_us=$'\E[01;32m'
export LESS_TERMCAP_ue=$'\E[0m'
exec less "$@"

      et ensuite, dans .bashrc :

      export MANPAGER=~/.bin/manpager.sh

  • # pointeur vers une ligne du man

    Posté par  (site web personnel, Mastodon) . Évalué à 0.

    Un truc que j'aime bien laisser sur les forums et autres stackoverflow, c'est une commande qui permet de trouver une ligne particulière d'un man avec par exemple pour le paramètre -r de less :

    man less | less +/'^ *-r'

    On ne peut pas mettre d'array dans le string...

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.