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

Je souhaite fournir un fichier de configuration structuré qui soit aussi facile que possible à modifier pour un utilisateur non technique (malheureusement, il doit s'agir d'un fichier) et j'ai donc voulu utiliser YAML. Cependant, je ne trouve aucun moyen d'analyser cela à partir d'un script shell Unix.

Mon cas d'utilisation peut ou non être tout à fait le même que ce que ce message original demandait, mais il est certainement similaire.

J'ai besoin de tirer quelques YAML en tant que variables bash. Le YAML n'aura jamais plus d'un niveau de profondeur.

YAML ressemble à ceci:

KEY:                value
ANOTHER_KEY:        another_value
OH_MY_SO_MANY_KEYS: yet_another_value
LAST_KEY:           last_value

Sortie comme un dis:

KEY="value"
ANOTHER_KEY="another_value"
OH_MY_SO_MANY_KEYS="yet_another_value"
LAST_KEY="last_value"

J'ai réalisé le résultat avec cette ligne:

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

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

Voici un analyseur bash uniquement qui exploite 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<indent; i++) {vn=(vn)(vname[i])("_")}
         printf("%s%s%s=\"%s\"\n", "'$prefix'",vn, $2, $3);
      }
   }'
}

Il comprend des fichiers tels que:

## global definitions
global:
  debug: yes
  verbose: no
  debugging:
    detailed: no
    header: "debugging started"

## output
output:
   file: "yes"

Qui, une fois analysé en utilisant:

parse_yaml sample.yml

affichera:

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

il comprend également les 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 affichera le même que dans l'exemple précédent.

l'utilisation typique dans un script est:

eval $(parse_yaml sample.yml)

parse_yaml accepte un argument de préfixe afin que les paramètres importés aient tous un préfixe commun (ce qui réduira le risque de collisions d'espace 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"

Notez que les paramètres précédents d'un fichier peuvent être référencés par des paramètres ultérieurs:

## global definitions
global:
  debug: yes
  verbose: no
  debugging:
    detailed: no
    header: "debugging started"

## output
output:
   debug: $global_debug

Une autre utilisation intéressante consiste à analyser d'abord un fichier par défaut, puis les paramètres utilisateur, ce qui fonctionne car ces derniers remplacent les premiers:

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

J'ai écrit shyamlen python pour les besoins des requêtes YAML à partir de la ligne de commande du shell.

Aperçu:

$ pip install shyaml      ## installation

Exemple de fichier YAML (avec des fonctionnalités complexes):

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

Requête de base:

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

Requête en 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: 'Multiline description:
Line 1
Line 2'

Quelques points clés:

• tous les types YAML et les bizarreries de syntaxe sont correctement gérés, sous forme de chaînes multilignes, entre guillemets, séquences en ligne ...
• \0 la sortie rembourrée est disponible pour la manipulation d'entrée multiligne solide.
• notation simple en pointillé pour sélectionner les sous-valeurs (c'est-à-dire: subvalue.maintainerest une clé valide).
• l'accès par index est fourni aux séquences (c'est-à-dire: subvalue.things.-1est le dernier élément de la subvalue.thingsséquence.)
• accès à tous les éléments de séquence / structs en une seule fois pour une utilisation dans les boucles bash.
• vous pouvez générer une sous-partie entière d'un fichier YAML sous la forme ... YAML, qui se marient bien pour d'autres manipulations avec shyaml.

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

yq est un processeur YAML de ligne de commande léger et portable

Le but du projet est d'être le jq ou sed des fichiers yaml.

( https://github.com/mikefarah/yq#readme )

A titre d'exemple (volé directement dans la documentation ), étant donné un fichier sample.yaml de:

---
bob:
  item1:
    cats: bananas
  item2:
    cats: apples

puis

yq r sample.yaml bob.*.cats

sortira

- bananas
- apples

Il est possible de passer un petit script à certains interprètes, comme Python. Un moyen simple 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ù dataest un hachage (ou un tableau) avec les valeurs de yaml.

En prime, il analysera très bien les avant- propos de Jekyll .

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

Étant donné que Python3 et PyYAML sont des dépendances assez faciles à rencontrer de nos jours, les éléments suivants peuvent aider:

yaml() {
    python3 -c "import yaml;print(yaml.safe_load(open('$1'))$2)"
}

VALUE=$(yaml ~/my_yaml_file.yaml "['a_key']")

voici une version étendue de la réponse de Stefan Farestam:

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

Cette version prend en charge la -notation et la notation courte pour les dictionnaires et les listes. L'entrée suivante:

global:
  input:
    - "main.c"
    - "main.h"
  flags: [ "-O3", "-fpic" ]
  sample_input:
    -  { property1: value, property2: "value2" }
    -  { property1: "value3", property2: 'value 4' }

produit cette sortie:

global_input_1="main.c"
global_input_2="main.h"
global_flags_1="-O3"
global_flags_2="-fpic"
global_sample_input_1_property1="value"
global_sample_input_1_property2="value2"
global_sample_input_2_property1="value3"
global_sample_input_2_property2="value 4"

comme vous pouvez le voir, les -éléments sont automatiquement numérotés afin d'obtenir des noms de variables différents pour chaque élément. Il bashn'y a pas de tableaux multidimensionnels, c'est donc une façon de contourner. Plusieurs niveaux sont pris en charge. Pour contourner le problème avec les espaces blancs de fin mentionnés par @briceburg, vous devez placer les valeurs entre guillemets simples ou doubles. Cependant, il existe encore certaines limitations: l'expansion des dictionnaires et des listes peut produire des résultats erronés lorsque les valeurs contiennent des virgules. De plus, les structures plus complexes comme les valeurs couvrant plusieurs lignes (comme les clés ssh) ne sont pas (encore) prises en charge.

Quelques mots sur le code: La première sedcommande étend la forme abrégée des dictionnaires { key: value, ...}en standard et les convertit en un style yaml plus simple. Le deuxième sedappel fait de même pour la notation courte des listes et se convertit [ entry, ... ]en une liste détaillée avec la -notation. Le troisième sedappel est celui d'origine qui traitait les dictionnaires normaux, maintenant avec l'ajout pour gérer les listes avec -et indentations. La awkpartie introduit un index pour chaque niveau d'indentation et l'augmente lorsque le nom de la variable est vide (c'est-à-dire lors du traitement d'une liste). La valeur actuelle des compteurs est utilisée à la place du vname vide. En remontant d'un niveau, les compteurs sont remis à zéro.

Edit: j'ai créé un référentiel github pour cela.

Difficile à dire car cela dépend de ce que vous voulez que l'analyseur extrait de votre document YAML. Pour les cas simples, vous pourriez être en mesure d'utiliser grep, cut, awketc. Pour l' analyse plus complexe , vous devez utiliser une bibliothèque entière analyse tels que Python PyYAML ou YAML :: Perl .

Je viens d'écrire un analyseur que j'ai appelé Yay! ( Yaml n'est pas Yamlesque! ) Qui analyse Yamlesque , un petit sous-ensemble de YAML. Donc, si vous recherchez un analyseur YAML 100% conforme pour Bash, ce n'est pas ça. Cependant, pour citer l'OP, si vous voulez un fichier de configuration structuré qui soit aussi facile que possible pour un utilisateur non technique à éditer qui soit de type YAML, cela peut être intéressant.

Il est inséré par la réponse précédente mais écrit des tableaux associatifs ( oui, il nécessite Bash 4.x ) au lieu de variables de base. Il le fait d'une manière qui permet aux données d'être analysées sans connaissance préalable des clés afin que le code basé sur les données puisse être écrit.

En plus des éléments du tableau clé / valeur, chaque tableau a un keystableau contenant une liste de noms de clés, un childrentableau contenant les noms des tableaux enfants et une parentclé qui fait référence à son parent.

Voici un exemple de Yamlesque:

root_key1: this is value one
root_key2: "this is value two"

drink:
  state: liquid
  coffee:
    best_served: hot
    colour: brown
  orange_juice:
    best_served: cold
    colour: orange

food:
  state: solid
  apple_pie:
    best_served: warm

root_key_3: this is value three

Voici un exemple montrant comment l'utiliser:

#!/bin/bash
# An example showing how to use Yay

. /usr/lib/yay

# helper to get array value at key
value() { eval echo \${$1[$2]}; }

# print a data collection
print_collection() {
  for k in $(value $1 keys)
  do
    echo "$2$k = $(value $1 $k)"
  done

  for c in $(value $1 children)
  do
    echo -e "$2$c\n$2{"
    print_collection $c "  $2"
    echo "$2}"
  done
}

yay example
print_collection example

qui sort:

root_key1 = this is value one
root_key2 = this is value two
root_key_3 = this is value three
example_drink
{
  state = liquid
  example_coffee
  {
    best_served = hot
    colour = brown
  }
  example_orange_juice
  {
    best_served = cold
    colour = orange
  }
}
example_food
{
  state = solid
  example_apple_pie
  {
    best_served = warm
  }
}

Et voici l'analyseur:

yay_parse() {

   # find input file
   for f in "$1" "$1.yay" "$1.yml"
   do
     [[ -f "$f" ]] && input="$f" && break
   done
   [[ -z "$input" ]] && exit 1

   # use given dataset prefix or imply from file name
   [[ -n "$2" ]] && local prefix="$2" || {
     local prefix=$(basename "$input"); prefix=${prefix%.*}
   }

   echo "declare -g -A $prefix;"

   local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
   sed -n -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" "$input" |
   awk -F$fs '{
      indent       = length($1)/2;
      key          = $2;
      value        = $3;

      # No prefix or parent for the top level (indent zero)
      root_prefix  = "'$prefix'_";
      if (indent ==0 ) {
        prefix = "";          parent_key = "'$prefix'";
      } else {
        prefix = root_prefix; parent_key = keys[indent-1];
      }

      keys[indent] = key;

      # remove keys left behind if prior row was indented more than this row
      for (i in keys) {if (i > indent) {delete keys[i]}}

      if (length(value) > 0) {
         # value
         printf("%s%s[%s]=\"%s\";\n", prefix, parent_key , key, value);
         printf("%s%s[keys]+=\" %s\";\n", prefix, parent_key , key);
      } else {
         # collection
         printf("%s%s[children]+=\" %s%s\";\n", prefix, parent_key , root_prefix, key);
         printf("declare -g -A %s%s;\n", root_prefix, key);
         printf("%s%s[parent]=\"%s%s\";\n", root_prefix, key, prefix, parent_key);
      }
   }'
}

# helper to load yay data file
yay() { eval $(yay_parse "$@"); }

Il y a une documentation dans le fichier source lié et ci-dessous est une brève explication de ce que fait le code.

La yay_parsefonction localise d'abord le inputfichier ou se termine avec un statut de sortie de 1. Ensuite, elle détermine l'ensemble de données prefix, soit explicitement spécifié soit dérivé du nom de fichier.

Il écrit des bashcommandes valides dans sa sortie standard qui, si elles sont exécutées, définissent des tableaux représentant le contenu du fichier de données d'entrée. Le premier de ceux-ci définit le tableau de niveau supérieur:

echo "declare -g -A $prefix;"

Notez que les déclarations de tableau sont associatives ( -A), ce qui est une fonctionnalité de Bash version 4. Les déclarations sont également globales ( -g) afin qu'elles puissent être exécutées dans une fonction mais être disponibles pour la portée globale comme l' yayaide:

yay() { eval $(yay_parse "$@"); }

Les données d'entrée sont initialement traitées avec sed. Il supprime les lignes qui ne correspondent pas à la spécification de format Yamlesque avant de délimiter les champs Yamlesque valides avec un caractère séparateur de fichier ASCII et de supprimer les guillemets doubles entourant le champ de valeur.

 local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
 sed -n -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" "$input" |

Les deux expressions sont similaires; ils diffèrent uniquement parce que le premier choisit les valeurs cotées alors que le second choisit les valeurs non cotées.

Le séparateur de fichiers (28 / hex 12 / octal 034) est utilisé car, en tant que caractère non imprimable, il est peu probable qu'il se trouve dans les données d'entrée.

Le résultat est acheminé dans awklequel traite son entrée une ligne à la fois. Il utilise le caractère FS pour affecter chaque champ à une variable:

indent       = length($1)/2;
key          = $2;
value        = $3;

Toutes les lignes ont un retrait (éventuellement zéro) et une clé mais elles n'ont pas toutes une valeur. Il calcule un niveau d'indentation pour la ligne divisant la longueur du premier champ, qui contient l'espace blanc de début, par deux. Les éléments de niveau supérieur sans aucun retrait sont au niveau de retrait zéro.

Ensuite, il détermine ce qu'il prefixfaut utiliser pour l'élément actuel. C'est ce qui est ajouté à un nom de clé pour créer un nom de tableau. Il y a un root_prefixpour le tableau de niveau supérieur qui est défini comme le nom de l'ensemble de données et un trait de soulignement:

root_prefix  = "'$prefix'_";
if (indent ==0 ) {
  prefix = "";          parent_key = "'$prefix'";
} else {
  prefix = root_prefix; parent_key = keys[indent-1];
}

Le parent_keyest la clé au niveau de retrait au-dessus du niveau de retrait de la ligne actuelle et représente la collection dont la ligne actuelle fait partie. Les paires clé / valeur de la collection seront stockées dans un tableau avec son nom défini comme la concaténation de prefixet parent_key.

Pour le niveau supérieur (retrait de niveau zéro), le préfixe de l'ensemble de données est utilisé comme clé parente, il n'a donc pas de préfixe (il est défini sur ""). Tous les autres tableaux sont précédés du préfixe racine.

Ensuite, la clé actuelle est insérée dans un tableau (awk-internal) contenant les clés. Ce tableau persiste pendant toute la session awk et contient donc des clés insérées par les lignes précédentes. La clé est insérée dans le tableau en utilisant son retrait comme index du tableau.

keys[indent] = key;

Étant donné que ce tableau contient des clés des lignes précédentes, toutes les clés avec un niveau d'indentation supérieur au niveau d'indentation de la ligne actuelle sont supprimées:

 for (i in keys) {if (i > indent) {delete keys[i]}}

Cela laisse le tableau de clés contenant le porte-clés de la racine au niveau d'indentation 0 à la ligne courante. Il supprime les clés obsolètes qui restent lorsque la ligne précédente était plus profonde que la ligne actuelle.

La dernière section produit les bashcommandes: une ligne d'entrée sans valeur démarre un nouveau niveau d'indentation (une collection en langage YAML) et une ligne d'entrée avec une valeur ajoute une clé à la collection actuelle.

Le nom de la collection est la concaténation des lignes actuelles prefixet parent_key.

Lorsqu'une clé a une valeur, une clé avec cette valeur est affectée à la collection actuelle comme ceci:

printf("%s%s[%s]=\"%s\";\n", prefix, parent_key , key, value);
printf("%s%s[keys]+=\" %s\";\n", prefix, parent_key , key);

La première instruction génère la commande pour affecter la valeur à un élément de tableau associatif nommé d'après la clé et la seconde renvoie la commande pour ajouter la clé à la keysliste délimitée par des espaces de la collection :

<current_collection>[<key>]="<value>";
<current_collection>[keys]+=" <key>";

Lorsqu'une clé n'a pas de valeur, une nouvelle collection est démarrée comme ceci:

printf("%s%s[children]+=\" %s%s\";\n", prefix, parent_key , root_prefix, key);
printf("declare -g -A %s%s;\n", root_prefix, key);

La première instruction renvoie la commande pour ajouter la nouvelle collection à la childrenliste délimitée par des espaces de la collection actuelle et la seconde renvoie la commande pour déclarer un nouveau tableau associatif pour la nouvelle collection:

<current_collection>[children]+=" <new_collection>"
declare -g -A <new_collection>;

Toute la sortie de yay_parsepeut être analysée en tant que commandes bash par les commandes bash evalou sourceintégrées.

perl -ne 'chomp; printf qq/%s="%s"\n/, split(/\s*:\s*/,$_,2)' file.yml > file.sh

Une autre option consiste à convertir le YAML en JSON, puis à utiliser jq pour interagir avec la représentation JSON, soit pour en extraire des informations, soit pour la modifier.

J'ai écrit un script bash simple qui contient cette colle - voir le projet Y2J sur GitHub

Si vous avez besoin d'une valeur unique, vous pouvez utiliser un outil qui convertit votre document YAML en JSON et alimente jq, par exemple yq.

Contenu de sample.yaml:

---
bob:
  item1:
    cats: bananas
  item2:
    cats: apples
  thing:
    cats: oranges

Exemple:

$ yq -r '.bob["thing"]["cats"]' sample.yaml 
oranges

Je sais que c'est très précis, mais je pense que ma réponse pourrait être utile pour certains utilisateurs.
Si vous avez nodeet npminstallé sur votre machine, vous pouvez utiliser js-yaml.
Première installation:

npm i -g js-yaml
# or locally
npm i js-yaml

puis dans votre script bash

#!/bin/bash
js-yaml your-yaml-file.yml

Aussi, si vous utilisez, jqvous pouvez faire quelque chose comme ça

#!/bin/bash
json="$(js-yaml your-yaml-file.yml)"
aproperty="$(jq '.apropery' <<< "$json")"
echo "$aproperty"

Parce que js-yamlconvertit un fichier yaml en un littéral de chaîne json. Vous pouvez ensuite utiliser la chaîne avec n'importe quel analyseur json de votre système unix.

Si vous avez python 2 et PyYAML, vous pouvez utiliser cet analyseur que j'ai écrit appelé parse_yaml.py . Certaines des choses les plus intéressantes qu'il fait est de vous permettre de choisir un préfixe (au cas où vous auriez plus d'un fichier avec des variables similaires) et de choisir une seule valeur dans un fichier yaml.

Par exemple, si vous avez ces fichiers yaml:

staging.yaml:

db:
    type: sqllite
    host: 127.0.0.1
    user: dev
    password: password123

prod.yaml:

db:
    type: postgres
    host: 10.0.50.100
    user: postgres
    password: password123

Vous pouvez charger les deux sans conflit.

$ eval $(python parse_yaml.py prod.yaml --prefix prod --cap)
$ eval $(python parse_yaml.py staging.yaml --prefix stg --cap)
$ echo $PROD_DB_HOST
10.0.50.100
$ echo $STG_DB_HOST
127.0.0.1

Et même cerise sur le gâteau, choisissez les valeurs que vous souhaitez.

$ prod_user=$(python parse_yaml.py prod.yaml --get db_user)
$ prod_port=$(python parse_yaml.py prod.yaml --get db_port --default 5432)
$ echo prod_user
postgres
$ echo prod_port
5432

Vous pouvez utiliser un équivalent de yq écrit en golang:

./go-yg -yamlFile /home/user/dev/ansible-firefox/defaults/main.yml -key
firefox_version

Retour:

62.0.3

Vous pouvez également envisager d'utiliser Grunt (The JavaScript Task Runner). Peut être facilement intégré à la coque. Il prend en charge la lecture des fichiers YAML ( grunt.file.readYAML) et JSON ( grunt.file.readJSON).

Ceci peut être réalisé en créant une tâche dans Gruntfile.js(ou Gruntfile.coffee), par exemple:

module.exports = function (grunt) {

    grunt.registerTask('foo', ['load_yml']);

    grunt.registerTask('load_yml', function () {
        var data = grunt.file.readYAML('foo.yml');
        Object.keys(data).forEach(function (g) {
          // ... switch (g) { case 'my_key':
        });
    });

};

puis à partir du shell, exécutez simplement grunt foo(vérifiez grunt --helples tâches disponibles).

De plus, vous pouvez implémenter des exec:footâches ( grunt-exec) avec des variables d'entrée passées de votre tâche ( foo: { cmd: 'echo bar <%= foo %>' }) afin d'imprimer la sortie dans le format de votre choix, puis la diriger vers une autre commande.

Il existe également un outil similaire à Grunt, il s'appelle gulp avec le plugin supplémentaire gulp-yaml .

Installer via: npm install --save-dev gulp-yaml

Exemple d'utilisation:

var yaml = require('gulp-yaml');

gulp.src('./src/*.yml')
  .pipe(yaml())
  .pipe(gulp.dest('./dist/'))

gulp.src('./src/*.yml')
  .pipe(yaml({ space: 2 }))
  .pipe(gulp.dest('./dist/'))

gulp.src('./src/*.yml')
  .pipe(yaml({ safe: true }))
  .pipe(gulp.dest('./dist/'))

Pour plus d'options pour gérer le format YAML , consultez le site YAML pour les projets, bibliothèques et autres ressources disponibles qui peuvent vous aider à analyser ce format.

Autres outils:

• Jshon

  analyse, lit et crée JSON

Je sais que ma réponse est spécifique, mais si PHP et Symfony sont déjà installés, il peut être très pratique d'utiliser l'analyseur YAML de Symfony.

Par exemple:

php -r "require '$SYMFONY_ROOT_PATH/vendor/autoload.php'; \
    var_dump(\Symfony\Component\Yaml\Yaml::parse(file_get_contents('$YAML_FILE_PATH')));"

Ici, j'ai simplement utilisé var_dumppour sortir le tableau analysé mais bien sûr, vous pouvez faire beaucoup plus ... :)