Journal Back to basics : avoir un excellent pager avec less

Posté par . Licence CC by-sa
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 AINSI (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 (page perso) . É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 (page perso) . É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 (page perso) . É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 (page perso) . É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 . É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 . Évalué à 2. Dernière modification le 13/10/16 à 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/10/16 à 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 . É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'

Suivre le flux des commentaires

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