[RÉSOLU] Passer une sortie échapée comme paramètre à une commande BASH

Bonjour à toutes et tous,

j’ai besoin d’effectuer des traitements sur une liste de fichier filtrés à partir d’une commande git.

Rien de compliqué mais voilà: je connais mes utilisateurs et je souhaite prévoir le cas ou le nom de fichier contient des espaces, guillemets.

ex:

$ git diff --name-only --cached -- '*.rs'
fichier1.rs
"nom \"a la noix\" pour 'moi.rs"

Ultra simplifié pour l’exemple voici ce que je cherche à faire:

$ git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*' | xargs cat # Le grep est juste la pour exemple: commande git -> filtrage -> passage des noms de fichier en param d'une commande.

Et là c’est le drame:

xargs: guillemets simple non appairés ; par défaut les guillemets sont particuliers à xargs à moins d'utiliser l'option -0
cat: 'nom \a': Aucun fichier ou dossier de ce type
cat: la: Aucun fichier ou dossier de ce type
cat: 'noix"': Aucun fichier ou dossier de ce type
cat: pour: Aucun fichier ou dossier de ce type

Quelques recherches, je reviens à la charge:

$ git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*' | xargs -rd '\n' printf '%s'
fichier1.rs"nom \"a la noix\" pour 'moi.rs"

Cela semble mieux non ? J’essaie ?

$ git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*' | xargs -rd '\n ' cat
cat: '"nom \"a la noix\" pour '\''moi.rs"': Aucun fichier ou dossier de ce type

Peut être devrais-je le passer tel quel à xargs avec l’option -0 ?

$ git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*' | xargs -0 cat
cat: '''fichier1.rs'$'\n''"nom \"a la noix\" pour '\''moi.rs"'$'\n': Aucun fichier ou dossier de ce type

Non…

Quelques chose m’échappe savez vous quoi ?

(«m’échappe» vous l’avez ? )

git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*' | xargs -I {} cat {}

C’est mieux comme ça ? xargs est une plaie à utiliser.

Es-tu sûr de faire la commande dans le dossier racine de ton dépôt git ? Car git diff donne des chemins relatif à la racine. Il existe bien une option relative, mais elle n’affiche que les différences internes au dossier courant.

Pour pouvoir utiliser xargs avec -0, qui signifie que les noms de fichiers sont transmis comme des chaînes C, il faut utiliser grep avec --null ou l’équivalent de ton implémentation.
Ceci dit, je ne vois pas l’utilité du -E à grep dans tes exemples, mais c’est une autre histoire.

Autre possibilité à envisager : tu es obligé d’utiliser Bash ? De mon point de vue ça ressemble au genre de tâches qui se fait très bien avec n’importe quel langage de script capable d’accéder à des API Git et de lancer des programmes arbitraires.

Les intérêts dans ton cas, ce serait un script plus lisible, plus maintenable, plus souple dans les possibilités de filtrage, sans être obligé de jongler avec des chaines de caractères pour essayer de retrouver les noms de fichiers concernés.

Évidemment c’est surtout intéressant si tu as besoin d’un script pérenne et pas juste d’un truc lancé une seule fois.

Là ici, s’il utiliserait un script bash ça serait plus simple. Le problème ici c’est que c’est one-liner.

bash n’est pas idéal mais fonctionne bien tout de même.

Malheureusement, cela ne marche pas mieux:

git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*' | xargs -I {} cat {}
xargs: guillemets simple non appairés ; par défaut les guillemets sont particuliers à xargs à moins d'utiliser l'option -0

Avec l’option -0:

$ git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*' | xargs -0 -I {} cat "{}"
cat: '''fichier1.rs'$'\n''"nom \"a la noix\" pour '\''moi.rs"'$'\n': Aucun fichier ou dossier de ce type

Cela ne pose pas de pb: la finalité est l’utilisation dans un hook (j’ajoute pour les curieux que j’ai des contraintes qui m’empêchent d’utiliser une lib genre pre-commit avec laquelle je travaille pourtant d’habitude…)

À moins que je n’ai mal compris ta solution, le résultat est similaire:

$ git diff --name-only --cached -- '*.rs' | grep --null --color=no -E '.*' | xargs -0 cat 
cat: '''fichier1.rs'$'\n''"nom \"a la noix\" pour '\''moi.rs"'$'\n': Aucun fichier ou dossier de ce type

En effet, le grep ici ne sert qu’a montrer un contexte simplifé, je l’ai ajouté pour préciser qu’un ensemble de traitement était réalisé dont un grep

J’en conviens, et il me semble envisageable d’utiliser Python pour ce script ce que je ferais en l’absence de solution. L’avantage que je vois à BASH c’est que, lançant un grand nombre de commande aux retours parfois mmh… exotique, je m’évite de fastidieux traitement de sortie. Et puis je suis à l’aise avec BASH pour cet usage d’habitude .

Cependant ma curiosité restera entière: comment passer à xargs une entrée telle que celle ci ? Cette question risque de hanter mes nuits c’est pourquoi je persiste

Je ne suis pas contre cette option cependant en quoi plusieurs lignes permettraient de régler le problème ?

Je ne suis pas contre cette option cependant en quoi plusieurs lignes permettraient de régler le problème ?

Déjà, tu ne t’embêtes plus avec xargs et sa gestion particulière des chaînes.

Ensuite, ça permet de bien structurer ce que tu fais, des structures de contrôles et l’utilisation de variable pour nommer les étapes intermédiaires. Ici, on pourrait séparer l’étape où on liste les fichiers de celle où on filtre les fichiers. Je ne l’ai pas fait mais ça ressemblerais à ça.

#!/bin/bash

FILE_TO_BATCH=$(git diff --name-only --cached -- '*.rs' | grep --color=no -E '.*')
BATCH_COMMAND=cat

for file in $FILE_TO_BATCH
do
  $BATCH_COMMAND $file
done

Bref, le problème à l’ai plus complexe que juste ça. Est-ce que tu pourrais nous transmettre tes versions de xargs, grep et git ? Histoire que l’on comprennent pourquoi une commande qui marche chez nous ne marche pas chez toi.

En effet

Voici les versions de mes outils:

$ xargs --version
xargs (GNU findutils) 4.7.0

$ grep --version
grep (GNU grep) 3.4

$ git --version
git version 2.25.1

Je suis d’accord avec toi, cela semble un peu plus complexe que je ne l’imaginais.

FILE_TO_BATCH=$(git diff --name-only --cached -- '*.rs' | grep --null --color=no -E '.*')
echo $FILE_TO_BATCH
BATCH_COMMAND=cat

for file in $FILE_TO_BATCH
do
    echo "On cat $file"
  $BATCH_COMMAND "$file"
done

En sortie: 

fichier1.rs "nom \"a la noix\" pour 'moi.rs"

On cat fichier1.rs
Fichier 1 est impriméFichier 1 est imprimé
On cat "nom
cat: '"nom': Aucun fichier ou dossier de ce type
On cat \"a
cat: '\"a': Aucun fichier ou dossier de ce type
On cat la
cat: la: Aucun fichier ou dossier de ce type
On cat noix\"
cat: 'noix\"': Aucun fichier ou dossier de ce type
On cat pour
cat: pour: Aucun fichier ou dossier de ce type
On cat 'moi.rs"
cat: ''\''moi.rs"': Aucun fichier ou dossier de ce type

Une manière simple de reproduire sans installer git peut être d’utiliser ls -1

$ ls --version
ls (GNU coreutils) 8.30

# Conditions initiales
touch 'nom "a la noix" pour '\''moi.rs'
echo "Victoire de \"cat\" pour nom à la noix !" >> 'nom "a la noix" pour '\''moi.rs'

touch fichier1.rs
echo "Fichier 1 est imprimé" >> fichier1.rs

FILE_TO_BATCH="$(ls -1 *.rs | grep --null --color=no -E '.*')"

echo "$FILE_TO_BATCH"

for file in ${FILE_TO_BATCH}
do
  echo "On cat $file"
  cat "$file"
done

Donne en sortie:

fichier1.rs nom "a la noix" pour 'moi.rs

On cat fichier1.rs
Fichier 1 est impriméFichier 1 est imprimé
On cat nom
cat: nom: Aucun fichier ou dossier de ce type
On cat "a
cat: '"a': Aucun fichier ou dossier de ce type
On cat la
cat: la: Aucun fichier ou dossier de ce type
On cat noix"
cat: 'noix"': Aucun fichier ou dossier de ce type
On cat pour
cat: pour: Aucun fichier ou dossier de ce type
On cat 'moi.rs
cat: "'moi.rs": Aucun fichier ou dossier de ce type

J’en profite pour vois remmercier de vos réponses et pour votre temps

Merci Gil Cot pour ces réponses qui me font reconsidérer l’usage d’un while avec read dans ces cas mais aussi l’existence du séparateur NUL qui m’était totalement passé sous les radars.

Je constate qu’il est aussi possible de faire:

git diff --name-only -z --cached -- '*.rs' | 
    while IFS=$'\0' read -r -d $'\0' line; do 
    echo $line
done

afin de traiter les fichiers un à un en évitant les problèmes de quoting de git-diff.

Du coup, je propose la résolution du tout premier problème que je décrivais avec des pipes:

# git diff -z : utilise le caractère NULL dans la sortie et revoie les chaînes brutes (sans quotes comme dit dans le réponse de Gil Cot)
# grep --null-data : permet d'accepter les chaînes brutes en entrée de grep
git diff --name-only --cached -z -- '*.rs' | grep --null-data --color=no -E '.*'  | xargs -0 cat 

Attention que ton grep envoie les lignes qui matchent (ou ces lignes préfixé du nom du fichiers) alors que tu xargs est supposé donner des noms de fichiers à cat

$ grep '.*' fichier1.rs 
Fichier 1 est imprimé
$ # toute la ligne en couleur

Je te suggère de remplacer --color=no par --files-with-matches et éventuellement de rajouter (une fois que tu as fini de tester) --no-messages

J’ai l’impression qu’il y a confusion, ici l’input (la sortie de git diff) est déjà une liste de noms de fichiers, qui est juste filtrée par grep avant d’être filée comme arguments à cat. L’option --files-with-matches est utile avec rgrep, mais pas ici (ça va juste répondre «(standard input)»).

Ou j’ai rien compris ?

Je pensais qu’il s’agissait de rechercher un motif dans les fichiers modifiés, et m’étais demandé initialement pourquoi n’avoir pas passé le grep à xargs …ou sinon, t’as raison lxnv, il aurait fallu effectivement écrire grep --null --color=no -l -s '.*' $(git diff --name-only --cached -z -- '*.rs') | xargs -0 cat

Je n’avais pas du tout pensé qu’il s’agissait de refiltrer les noms des fichiers (parce-que ayant vu la restriction *.rs avant et le motif '.*' ensuite.) En plus j’avais oublié que le pipe impliquait qu’on avait le contenu dans lequel chercher (soit stdin, et donc plus de fichier à lui passer) Du coup, c’est plutôt git diff --name-only --cached -z -- '*.rs' | grep -z --line-buffered -s '.*' | xargs -0 cat que j’aurais du recommander.

Désolé pour la confusion du coup.