Comment puis-je analyser un fichier YAML à partir d'un script shell Linux ?

Question

Je souhaite fournir un fichier de configuration structuré, aussi simple que possible à modifier pour un utilisateur non technique (malheureusement, cela doit être un fichier) et donc j'ai voulu utiliser YAML. Je ne trouve aucun moyen de le parser à partir d'un script shell Unix cependant.

Answer 1

Voici un analyseur basé sur bash qui utilise sed et awk pour analyser des fichiers yaml simples :

function parse_yaml {
   local prefix=$2
   local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
   sed -ne "s|^\($s\):|\1|" \
        -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
        -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p"  $1 |
   awk -F$fs '{
      indent = length($1)/2;
      vname[indent] = $2;
      for (i in vname) {if (i > indent) {delete vname[i]}}
      if (length($3) > 0) {
         vn=""; for (i=0; i

`Il comprend des fichiers tels que :

## définitions globales
global:
  debug: yes
  verbose: no
  debugging:
    detailed: no
    header: "debugging started"

## sortie
output:
   file: "yes"

Qui, lorsqu'il est analysé avec :

parse_yaml sample.yml

donnera en sortie :

global_debug="yes"
global_verbose="no"
global_debugging_detailed="no"
global_debugging_header="debugging started"
output_file="yes"

Il comprend également des fichiers yaml générés par ruby qui peuvent inclure des symboles ruby, comme :

---
:global:
  :debug: 'yes'
  :verbose: 'no'
  :debugging:
    :detailed: 'no'
    :header: debugging started
  :output: 'yes'

et donnera le même résultat que dans l'exemple précédent.

Une utilisation classique dans un script est la suivante :

eval $(parse_yaml sample.yml)

parse_yaml accepte un argument de préfixe afin que toutes les configurations importées aient un préfixe commun (ce qui réduira les risques de collisions de noms).

parse_yaml sample.yml "CONF_"

donne :

CONF_global_debug="yes"
CONF_global_verbose="no"
CONF_global_debugging_detailed="no"
CONF_global_debugging_header="debugging started"
CONF_output_file="yes"

Remarquez que les configurations précédentes dans un fichier peuvent être référencées par les configurations ultérieures :

## définitions globales
global:
  debug: yes
  verbose: no
  debugging:
    detailed: no
    header: "debugging started"

## sortie
output:
   debug: $global_debug

Une autre utilisation intéressante est de d'abord analyser un fichier de valeurs par défaut puis les paramètres de l'utilisateur, ce qui fonctionne puisque les paramètres ultérieurs remplacent les premiers :

eval $(parse_yaml defaults.yml)
eval $(parse_yaml project.yml)`

Answer 2

J'ai écrit shyaml en python pour les besoins de requête YAML à partir de la ligne de commande du shell.

Aperçu:

$ pip install shyaml      ## installation

Fichier YAML d'exemple (avec des fonctionnalités complexes):

$ cat < test.yaml
name: "MonNom !!"
subvalue:
    how-much: 1.1
    things:
        - first
        - second
        - third
    other-things: [a, b, c]
    maintainer: "Valentin Lab"
    description: |
        Description multiline:
        Ligne 1
        Ligne 2
EOF

Requête de base:

$ cat test.yaml | shyaml get-value subvalue.maintainer
Valentin Lab

Requête de boucle plus complexe sur des valeurs complexes:

$ cat test.yaml | shyaml values-0 | \
  while read -r -d $'\0' value; do
      echo "RECEIVED: '$value'"
  done
RECEIVED: '1.1'
RECEIVED: '- first
- second
- third'
RECEIVED: '2'
RECEIVED: 'Valentin Lab'
RECEIVED: 'Description multiline:
Ligne 1
Ligne 2'

Quelques points clés:

• tous les types YAML et les bizarreries de syntaxe sont correctement gérés, comme les chaînes multilignes, les chaînes entre guillemets, les séquences inline...
• la sortie rembourrée avec \0 est disponible pour une manipulation solide de l'entrée multiligne.
• la notation pointée simple pour sélectionner les sous-valeurs (par ex.: subvalue.maintainer est une clé valide).
• l'accès par index est fourni pour les séquences (par ex.: subvalue.things.-1 est le dernier élément de la séquence subvalue.things.)
• accès à tous les éléments de séquences/structures en une seule fois pour une utilisation dans des boucles bash.
• vous pouvez afficher une partie entière d'un fichier YAML en ... YAML, ce qui se marie bien pour des manipulations ultérieures avec shyaml.

Plus d'exemples et de documentation sont disponibles sur la page github de shyaml ou la page PyPI de shyaml.

Answer 3

Mon cas d'utilisation peut être ou non tout à fait le même que ce que demandait ce post original, mais c'est définitivement similaire.

J'ai besoin d'extraire du YAML sous forme de variables bash. Le YAML ne dépassera jamais un niveau de profondeur.

Le YAML ressemble à ceci :

KEY:                valeur
ANOTHER_KEY:        autre_valeur
OH_MY_SO_MANY_KEYS: encore_une_autre_valeur
LAST_KEY:           dernière_valeur

La sortie ressemblerait à ceci :

KEY="valeur"
ANOTHER_KEY="autre_valeur"
OH_MY_SO_MANY_KEYS="encore_une_autre_valeur"
LAST_KEY="dernière_valeur"

J'ai obtenu la sortie avec cette ligne :

sed -e 's/:[^:\/\/]/="/g;s/$/"/g;s/ *=/=/g' fichier.yaml > fichier.sh

• s/:[^:\/\/]/="/g trouve : et le remplace par =", en ignorant :// (pour les URL)
• s/$/"/g ajoute " à la fin de chaque ligne
• s/ *=/=/g supprime tous les espaces avant =

Answer 4

Il est possible de passer un petit script à certains interprètes, comme Python. Un moyen facile de le faire en utilisant Ruby et sa bibliothèque YAML est le suivant :

$ RUBY_SCRIPT="data = YAML::load(STDIN.read); puts data['a']; puts data['b']"
$ echo -e '---\na: 1234\nb: 4321' | ruby -ryaml -e "$RUBY_SCRIPT"
1234
4321

, où data est un hash (ou tableau) avec les valeurs de yaml.

En bonus, cela analysera parfaitement le front matter de Jekyll.

ruby -ryaml -e "puts YAML::load(open(ARGV.first).read)['tags']" example.md

Answer 5

Difficile à dire car cela dépend de ce que vous voulez que l'analyseur extrait de votre document YAML. Pour des cas simples, vous pourriez utiliser grep, cut, awk, etc. Pour une analyse plus complexe, vous auriez besoin d'utiliser une bibliothèque d'analyse complète telle que PyYAML de Python ou YAML::Perl.