\input{../_preamble}
\input{../_preamble_bbl}
\usepackage{menukeys}
\title{grep et bash}
\usepackage{units}
\usepackage{cleveref}
\usepackage{booktabs}
\usepackage{xltabular}
\usepackage{dingbat}
\usepackage{mdframed}
\mdfsetup{
  backgroundcolor=Lavender,
  hidealllines=true}
\usepackage{minted}
\surroundwithmdframed{minted}
\setminted{
  breaklines,
  breaksymbolright=\small\carriagereturn}
\setmintedinline{bgcolor=Lavender}
\usepackage{soul}

\begin{document}
\maketitle
\renewcommand{\contentsname}{Sommaire}
\tableofcontents

\chapter{grep, les expressions régulières}
\label{cha:grep-les-expressions}
Les expressions régulières se rapprochent des \emph{wildcards} ou
\enquote{métacaractères} qui ont été présentés dans
\href{https://notabug.org/ralessi/courses/src/master/fichiers/01-ligne-de-commande.tex#L709}{le
  cours sur la ligne de commande}. C'est une technique commune à pour
ainsi dire tous les langages de programmation qui permet de construire
des \enquote{modèles}, en anglais \emph{patterns}, susceptibles de
capturer des chaînes de caractères.

Par exemple, soit le fichier suivant:
\begin{minted}{text}
/usr/share/dict/cracklib-small
\end{minted}
Ce fichier fait partie d'un programme dont le rôle est de vérifier la
robustesse des mots de passe. Il contient un grand nombre d'entrées, à
raison d'un mot par ligne. Vérifions cela:
\begin{minted}{text}
[robert@kiddo courses]$ wc -l /usr/share/dict/cracklib-small 
54763 /usr/share/dict/cracklib-small
\end{minted}
L'expression régulière suivante retourne tous les mots de cinq lettres
de ce fichier qui commencent par la lettre \verb|c| et se terminent
par la lettre \verb|h|:
\begin{minted}{text}
[robert@kiddo courses]$ grep '\<c...h\>' /usr/share/dict/cracklib-small
catch
cinch
clash
cloth
coach
conch
couch
cough
crash
crush
czech
\end{minted}

\begin{quoting}
  \textsc{Rem.} \verb|grep| recherche les modèles ligne par
  ligne et retourne donc un résultat positif dès lors qu'un modèle
  donné a été trouvé au moins une fois dans une ligne.
\end{quoting}

\paragraph{Modèles}
Pour construire les modèles (\emph{patterns}), on peut utiliser les
symboles suivants\footnote{Cette liste n'est pas exhaustive.}:
\begin{xltabular}{\linewidth}{lX}
  \toprule
  Symbole & Signification \\ \midrule\endhead
  \verb|.| & tout caractère unique\\
  \verb|?| & le caractère précédent est répété 0 ou une fois\\
  \verb|*| & le caractère précédent est répété 0 fois ou autant
             de fois que possible\\
  \verb|+| & le caractère précédent est répété une fois \emph{au
             moins}\\
  \verb|{n}| & le caractère précédent est répété exactement \emph{n}
               fois\\
  \verb|{n,m}| & le caractère précédent est répété au moins \emph{n}
                 fois et au plus \emph{m} fois\\
  \verb|[abc]| & le caractère précédent est l'un de ceux qui se
                 trouvent entre les crochets droits\\
  \verb|[^abc]| & le caractère précédent n'est pas l'un de ceux qui se
                  trouvent entre les crochets droits\\
  \verb|[a-z]| & le caractère précédent est compris entre \emph{a} et
                 \emph{z}, dans l'ordre de la table des
                 caractères. C'est le sens du trait d'union entre les
                 lettres \verb|a| et \verb|z|. On peut bien sûr
                 combiner des chaînes avec et sans trait d'union. Par
                 exemple, \verb|[A-Ea-e]| correspond aux cinq
                 premières lettres de l'alphabet, en majuscule et en
                 minuscule. \\
  \verb|()| & ce qui est inclus entre les parenthèses est traité comme
              un groupe \\
  
  \verb+|+ & opérateur logique signifiant \emph{ou} \\
  \verb|^| & représente le début de la ligne\\
  \verb|$| & représente la fin de la ligne\\ \\
  \verb|\<| et \verb|\>| & représentent respectivement un début et une
                           fin de mot\\
  \bottomrule
\end{xltabular}

\paragraph{grep, egrep}
À la place de \verb|grep|, on peut saisir à la ligne de commande
\verb|egrep| ou \verb|grep -E| pour \emph{extended regular
  expressions}. Quelle est la différence? Retenez ici simplement que
sous \verb|grep| les metacaractères
\begin{minted}{text}
? + { } | ( )
\end{minted}
doivent être précédés de la \emph{séquence d'échappement} \verb|\|
comme ceci:
\begin{minted}{text}
\? \+ \{ \} \| \( \)
\end{minted}
tandis que cela ne se fait pas avec \verb|egrep|.

\paragraph{options}
La commande \verb|(e)grep| peut recevoir un grand nombre
d'options. Parmi ces options, retenons celles-ci:
\begin{description}
\item[-n] retourne les numéros des lignes dans lesquelles le modèle de
  recherche a été trouvé.
\item[-c] retourne le nombre d'occurrences trouvées.
\item[-i] demande à \verb|grep| de ne pas faire de différence entre
  les minuscules et les majuscules.
\item[-H] retourne le nom du fichier dans lequel le modèle recherché
  est trouvé.
\item[-v] \emph{nie} le modèle recherché: \verb|grep| retournera donc
  les lignes dans lesquelles le modèle \emph{n'a pas été trouvé}. 
\end{description}

\paragraph{Exemples}
Les exemples ci-dessous utilisent \href{https://notabug.org/ralessi/courses/src/master/fichiers/01-ligne-de-commande.tex#L732}{la
    technique de la redirection}.
\begin{minted}{text}
[robert@kiddo courses]$ cat /usr/share/dict/cracklib-small | grep '\<s.*m\>' | grep 'ea'
scream
seagram
sealteam
seam
sidearm
steam
stream
sunbeam
sunbeam's
\end{minted}
  \begin{quoting}
    \textbf{Commentaire:} La ligne de commande fait ici successivement
  les opérations suivantes:
    \begin{enumerate}
    \item Concaténation de toutes les lignes du fichier
      \verb|cracklib-small|
    \item Sélection de tous les mots qui commencent par la lettre
      \verb|s| et se terminent par la lettre \verb|m|.
    \item Parmi ces mots, sélection de ceux qui contiennent la chaîne
      \verb|ea|.
    \end{enumerate}
  \end{quoting}
\begin{minted}{text}
[robert@kiddo courses]$ cat /usr/share/dict/cracklib-small | grep '\<.....\>' | grep -E 'o{2}|e{2}' | grep 't' | column -c 70
afoot   fleet   needn't skeet   steep   taboo   three   tweed
beets   foote   roost   sleet   steer   taboo's three's
boost   greet   roots   sooth   stood   teems   tools
booth   hoots   scoot   steed   stool   teens   tooth
boots   loots   sheet   steel   stoop   teeth   trees
booty   meets   shoot   steen   sweet   tepee   troop
\end{minted}
\begin{quoting}
  \textbf{Commentaire:} La ligne de commande fait ici successivement
  les opérations suivantes:
  \begin{enumerate}
  \item Concaténation de toutes les lignes du fichier
    \verb|cracklib-small|
  \item Sélection des mots de cinq caractères.
  \item Parmi ces mots, sélection de ceux qui contiennent \emph{soit}
    la chaîne \verb|oo| \emph{soit} la chaîne \verb|ee|.
  \item Enfin, sélection, parmi ces derniers mots, de ceux qui
    contiennent la lettre \verb|t|
  \item La dernière ligne, dont on n'a pas étudié la syntaxe, demande
    l'affichage du résultat sous la forme de colonnes tabulées.
  \end{enumerate}
\end{quoting}

\chapter{bash}
\label{cha:bash}
Comme on l'a vu, \verb|bash| est le \emph{shell} le plus répandu sur
les systèmes Linux aujourd'hui. On peut écrire en \verb|bash| des
\emph{scripts}, autrement dit de petits programmes informatiques, pour
réaliser des suites d'opérations plus ou moins complexes.

Voici un exemple très simple. Prenons les lignes suivantes:
\begin{minted}[linenos]{text}
mkdir sauvegarde
cp *.tex sauvegarde
zip -r sauvegarde.zip sauvegarde
\end{minted}
Ces trois lignes exécutent successivement les opérations suivantes:
\begin{enumerate}
\item Création d'un répertoire intitulé \verb|sauvegarde|
\item Copie de tous les fichiers \TeX{} dans le répertoire
  \verb|sauvegarde|
\item Création d'une archive \verb|.zip| de tout le répertoire.
\end{enumerate}

Pour éviter de répéter ces trois lignes de commande et d'encourir le
risque de se tromper dans la saisie, on peut décider de les écrire
dans un fichier texte que l'on appellera par exemple \verb|backup.sh|
de la façon suivante:
\begin{minted}[linenos]{bash}
#!/bin/bash
mkdir sauvegarde
cp *.tex sauvegarde
zip -r sauvegarde.zip sauvegarde
\end{minted}

Il suffit alors de demander à \verb|bash| d'exécuter ce fichier pour
que les trois opérations soient réalisées d'un coup. Comme les scripts
écrits en \verb|bash| sont interprétés par le \textsl{shell}
\verb|bash|, \emph{toute ligne de commande peut être exécutée dans un
  script}. Réciproquement, \emph{tout ce qui peut entrer dans un
  script peut aussi être exécuté à la ligne de commande}.

\section{L'éditeur de texte}
\label{sec:lediteur-de-texte}
C'est dans un \emph{éditeur de texte} que l'on saisit tout code
informatique. Certains éditeurs de texte sont très simples à
utiliser. Nous allons prendre ici l'exemple de l'un des plus simples,
\verb|nano|. Pour le lancer, il suffit de saisir à la ligne de
commande: \mintinline{text}|nano|. Après avoir lancé \verb|nano| et
saisi le script donné ci-dessus, voici ce que l'on obtient:
\begin{minted}[linenos,fontsize=\footnotesize]{text}
  GNU nano 2.8.2                     Nouvel espace                           

#!/bin/bash
mkdir sauvegarde
cp *.tex sauvegarde
zip -r sauvegarde.zip sauvegarde

















^G Aide      ^O Écrire    ^W Chercher  ^K Couper    ^J Justifier ^C Pos. cur.
^X Quitter   ^R Lire fich.^\ Remplacer ^U Coller    ^T Orthograp.^_ Aller lig.
\end{minted}

Les lignes 24 et 25 correspondent au menu de \verb|nano|. On n'y
accède pas par la souris, mais à l'aide des \emph{raccourcis clavier}
qui sont tous préfixés par le \emph{caret} (\verb|^|) qui représente
la touche \keys{Ctrl} du clavier. Donc pour quitter le programme, on
appuiera sur \keys{Ctrl-X}: voici ce que montre \verb|nano| au bas du
terminal après avoir saisi \keys{Ctrl-X}:
\begin{minted}[linenos,fontsize=\footnotesize]{text}
Écrire l'espace modifié ? (Répondre « Non » ABANDONNE les modifications.)       
 O Oui
 N Non          ^C Annuler
\end{minted}
Les opérations suivantes sont donc possibles:
\begin{enumerate}
\item \keys{O}: sauvegarde le fichier.
\item \keys{N}: quitte \verb|nano| sans sauvegarder.
\item \keys{Ctrl-C}: annule l'opération et retourne à l'éditeur de texte.
\end{enumerate}
Appuyons sur la touche \keys{O}. \verb|nano| nous invite alors à
entrer le nom du script:
\begin{minted}[linenos,fontsize=\footnotesize]{text}
Nom du fichier à écrire: backup.sh                                              
^G Aide             M-D Format DOS      M-A Ajout (à la fin)M-B Copie de sécu.
^C Annuler          M-M Format Mac      M-P Ajout (au début)^T Parcourir
\end{minted}
Après avoir entré le nom du fichier et appuyé sur la touche
\keys{Enter} pour confirmer le choix, on retourne au terminal et à la
ligne de commande.

\section{Le \emph{shebang}}
\label{sec:le-shebang}
La première ligne du script \verb|backup.sh| donné en exemple
ci-dessus appelle un commentaire particulier:
\begin{minted}[linenos]{bash}
#!/bin/bash
\end{minted}

Dans cette ligne, la séquence \mintinline{bash}|#!| s'appelle le
\emph{shebang}. Par convention, le \emph{shebang} est un préfixe que
l'on fait suivre du nom du programme qui doit interpréter le script,
précédé de son chemin d'accès absolu.

Le \emph{shebang} est important car il permet d'accéder aux
interpréteurs auxquels on souhaite accéder depuis la ligne de
commande. Par exemple, pour un script écrit en Python2, la première
ligne sera:
\begin{minted}[linenos]{python}
#!/usr/bin/env python2
"""
 Mon premier script en Python
"""
print("bonjour le monde!")
\end{minted}

\section{Les commentaires}
\label{sec:les-commentaires}
En \verb|bash|, tout ce qui, sur une même ligne, suit le signe
\mintinline{bash}|#| \emph{n'est ni interprété, ni exécuté}. On
utilise donc ce signe pour introduire des \emph{commentaires} dans le
code informatique.

Les commentaires ne servent pas uniquement à introduire des remarques
pour son usage personnel. Ils servent aussi, et surtout, à donner des
indications sur le code lui-même pour permettre aux autres de mieux
comprendre la programmation. Si le code est bien commenté, alors on
doit pouvoir le lire comme on lit un livre. Cela est très important
car les programmes longs et complexes dépassent souvent et parfois
même survivent à leur auteur.

Si le code est bien compris, il sera facilement mis à jour, corrigé et
augmenté par d'autres programmeurs.

L'art de commenter le code informatique tout en l'écrivant porte le
nom de \emph{literate programming}. Il a été inventé par Donald
E.~Knuth, le créateur de \TeX, qui a posé tous les principes de cet
art dans le cadre de la programmation en
\textsf{WEB}\footnote{\cite{Knuth1983}. Voir également en ligne
  \url{http://www.literateprogramming.com/}}.

\section{Exécution}
\label{sec:execution}
Il faut ici approfondir la notion de \emph{permissions} sur les
fichiers qui a été présentée dans le cours sur la
\href{https://notabug.org/ralessi/courses/src/master/fichiers/01-ligne-de-commande.tex#L451}{ligne
  de commande}. Nous avons en effet étudié trois types de permissions
sur les fichiers: en lecture, en écriture et en exécution. Revenons
sur les permissions données par défaut au script \verb|backup.sh|:
\begin{minted}{text}
[robert@kiddo courses]$ ls -l backup.sh 
-rw-r--r-- 1 robert robert 82 17 sept. 22:06 backup.sh
\end{minted}
Soit:
\begin{itemize}
\item lecture et écriture pour l'utilisateur \verb|robert| (\verb|rw|);
\item lecture seule pour le groupe \verb|robert| (\verb|r|);
\item lecture seule pour le reste du monde (\verb|r|)
\end{itemize}

\paragraph{chmod}
La commande qui permet de changer les droits s'appelle
\verb|chmod|. Pour comprendre comment l'utiliser, il faut savoir que
les permissions sont traduites par des valeurs numériques, à savoir:
\begin{itemize}
\item 4 pour le droit \emph{lecture};
\item 2 pour le droit \emph{écriture};
\item 1 pour le droit \emph{exécution}.
\end{itemize}
Ces valeurs peuvent être additionnées. On analyse donc ainsi les
permissions sur le fichier \verb|backup.sh|:
\begin{itemize}
\item utilisateur \verb|robert|, lecture + écriture: $4+2=6$;
\item groupe \verb|robert|, lecture: $4$;
\item reste du monde, lecture: $4$.
\end{itemize}
Soit $644$. Pour ajouter à l'utilisateur \verb|robert| seulement la
permission en exécution, il faudrait donc porter cette valeur à
$744$. Nous allons ici donner ce droit à la fois à \verb|robert|, au
groupe \verb|robert| et au reste du monde, soit une valeur de
$755$. La syntaxe est la suivante:
\begin{minted}{text}
chmod xyz <fichier>
\end{minted}
où \verb|xyz| sont les trois chiffres qui représentent les permissions.
\begin{minted}[escapeinside=||, linenos]{text}
[robert@kiddo courses]$ chmod 755 backup.sh 
[robert@kiddo courses]$ ls -l --color backup.sh 
-rwxr-xr-x 1 robert robert 82 17 sept. 22:06 |\textcolor{green}{backup.sh}|
\end{minted}
\begin{quoting}
  \textbf{Commentaire}:
  \begin{enumerate}
  \item La commande \verb|chmod| a été entrée à la ligne 1.
  \item À la ligne 2, nous avons lancé la commande
    \mintinline{text}|ls -l --color| sur le fichier \verb|backup.sh|:
    les droits listés à la ligne 3 montrent bien que la valeur
    \verb|x| a été ajoutée aux trois endroits possibles. On voit enfin
    que l'option \verb|--color| affiche en vert les fichiers qui sont
    exécutables.
  \end{enumerate}
\end{quoting}

Nous pouvons désormais exécuter notre script:
\begin{minted}[linenos,escapeinside=||]{text}
[robert@kiddo courses]$ ls -l --color
total 36
-rwxr-xr-x 1 robert robert   82 17 sept. 22:06 |\textcolor{green}{backup.sh}|
-rw-r--r-- 1 robert robert  165 16 sept. 19:40 bibliography.bib
drwxr-xr-x 5 robert robert 4096 17 sept. 22:30 |\textcolor{blue}{fichiers}|
-rw-r--r-- 1 robert robert  680 16 sept. 18:34 makefile
-rw-r--r-- 1 robert robert  898 16 sept. 19:39 _preamble_bbl.tex
-rw-r--r-- 1 robert robert  699 14 sept. 15:02 _preamble-ed.tex
-rw-r--r-- 1 robert robert  719 16 sept. 19:39 _preamble.tex
-rw-r--r-- 1 robert robert 1407 17 sept. 00:15 README.md
-rw-r--r-- 1 robert robert 1804 17 sept. 00:15 README.tex
[robert@kiddo courses]$ ./backup.sh 
  adding: sauvegarde/ (stored 0%)
  adding: sauvegarde/README.tex (deflated 57%)
  adding: sauvegarde/_preamble.tex (deflated 45%)
  adding: sauvegarde/_preamble_bbl.tex (deflated 57%)
  adding: sauvegarde/_preamble-ed.tex (deflated 44%)
[robert@kiddo courses]$ ls -l --color
total 44
-rwxr-xr-x 1 robert robert   82 17 sept. 22:06 |\textcolor{green}{backup.sh}|
-rw-r--r-- 1 robert robert  165 16 sept. 19:40 bibliography.bib
drwxr-xr-x 5 robert robert 4096 17 sept. 22:31 |\textcolor{blue}{fichiers}|
-rw-r--r-- 1 robert robert  680 16 sept. 18:34 makefile
-rw-r--r-- 1 robert robert  898 16 sept. 19:39 _preamble_bbl.tex
-rw-r--r-- 1 robert robert  699 14 sept. 15:02 _preamble-ed.tex
-rw-r--r-- 1 robert robert  719 16 sept. 19:39 _preamble.tex
-rw-r--r-- 1 robert robert 1407 17 sept. 00:15 README.md
-rw-r--r-- 1 robert robert 1804 17 sept. 00:15 README.tex
drwxr-xr-x 2 robert robert 4096 17 sept. 22:31 |\textcolor{blue}{sauvegarde}|
-rw-r--r-- 1 robert robert 2828 17 sept. 22:31 sauvegarde.zip
[robert@kiddo courses]$ ls sauvegarde
_preamble_bbl.tex  _preamble-ed.tex  _preamble.tex  README.tex
\end{minted}
\begin{quoting}
  \textbf{Commentaire:}
  \begin{itemize}
  \item lignes 1--11: la commande \verb|ls -l --color| donne l'état du
    dossier \emph{avant} l'exécution du script \verb|backup.sh|;
  \item lignes 12--17: exécution du script et messages du terminal;
  \item lignes 18--30: la commande \verb|ls -l --color| donne l'état du
    dossier \emph{après} l'exécution du script \verb|backup.sh|. On
    voit qu'un nouveau répertoire \verb|sauvegarde| a été créé, de
    même qu'un fichier archive \verb|sauvegarde.zip|;
  \item lignes 31--32: la commande \verb|ls sauvegarde| liste le
    contenu de ce répertoire. On y trouve tous les fichiers
    \verb|.tex| qui y ont été copiés par le script.
  \end{itemize}
\end{quoting}

\paragraph{PATH} Un dernier point reste à éclaircir: à la ligne 12,
pourquoi a-t-on écrit \mintinline{bash}|./backup.sh| et non pas
simplement \mintinline{bash}|backup.sh|? Tout simplement pour des
raisons de sécurité. En effet, le principe est que les fichiers
exécutables se trouvent dans certains répertoires-système spécialement
conçus pour les accueillir. C'est pour cette raison que l'on peut
lancer les commandes \verb|bash| sans avoir à les préfixer. Or notre
répertoire de travail ne fait partie de ces répertoires spéciaux. Il
faut donc préfixer tout script exécutable qui s'y trouve par son
\emph{chemin d'accès}, soit relatif, soit absolu. On a choisi ici la
première méthode: dans la séquence \mintinline{text}|./|, le point
représente le répertoire courant tandis que le \emph{slash} précise
qu'il s'agit d'un chemin d'accès. Sans le \emph{slash}, le
\emph{shell} aurait compris le point comme un préfixe de fichier
caché.

\hfill\verb|../..| à suivre

\end{document}