¿Cómo puedo analizar un archivo YAML desde un script de shell de Linux?

Deseo proporcionar un archivo de configuración estructurado que sea lo más fácil posible para que lo edite un usuario no técnico (desafortunadamente tiene que ser un archivo) y por eso quería usar YAML. Sin embargo, no puedo encontrar ninguna manera de analizar esto desde un script de shell de Unix.

Mi caso de uso puede o no ser el mismo que el que estaba preguntando esta publicación original, pero definitivamente es similar.

Necesito obtener algunos YAML como variables bash. El YAML nunca tendrá más de un nivel de profundidad.

YAML se ve así:

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

Salida like-a dis:

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

Logré el resultado con esta línea:

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

• s/:[^:\/\/]/="/glo encuentra :y lo reemplaza por =", mientras lo ignora ://(para URL)
• s/$/"/gse agrega "al final de cada línea
• s/ *=/=/g elimina todos los espacios antes =

Aquí hay un analizador de solo bash que aprovecha sed y awk para analizar archivos 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);
      }
   }'
}

Entiende archivos como:

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

## output
output:
   file: "yes"

Que, cuando se analiza usando:

parse_yaml sample.yml

dará salida:

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

también comprende archivos yaml, generados por ruby ​​que pueden incluir símbolos ruby, como:

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

y generará lo mismo que en el ejemplo anterior.

El uso típico dentro de un script es:

eval $(parse_yaml sample.yml)

parse_yaml acepta un argumento de prefijo para que todas las configuraciones importadas tengan un prefijo común (lo que reducirá el riesgo de colisiones en el espacio de nombres).

parse_yaml sample.yml "CONF_"

rendimientos:

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

Tenga en cuenta que las configuraciones anteriores en un archivo pueden ser referidas por configuraciones posteriores:

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

## output
output:
   debug: $global_debug

Otro buen uso es analizar primero un archivo predeterminado y luego la configuración del usuario, que funciona ya que esta última anula la primera:

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

He escrito shyamlen Python para las necesidades de consulta de YAML desde la línea de comandos del shell.

Visión general:

$ pip install shyaml      ## installation

Archivo YAML de ejemplo (con características complejas):

$ 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

Consulta básica:

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

Consulta de bucle más compleja sobre valores complejos:

$ 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'

Algunos puntos clave:

• Todos los tipos YAML y las rarezas de sintaxis se manejan correctamente, como líneas múltiples, cadenas entre comillas, secuencias en línea ...
• \0 La salida acolchada está disponible para la manipulación sólida de entradas multilínea.
• notación punteada simple para seleccionar subvalores (es decir, subvalue.maintaineres una clave válida).
• Se proporciona acceso por índice a las secuencias (es decir, subvalue.things.-1es el último elemento de la subvalue.thingssecuencia).
• acceso a todos los elementos de secuencia / estructura de una sola vez para usar en bash loops.
• puede generar una subparte completa de un archivo YAML como ... YAML, que se combina bien para manipulaciones posteriores con shyaml.

Hay más muestras y documentación disponibles en la página de Github de shyaml o en la página de PyPI de shyaml .

yq es un procesador YAML de línea de comandos ligero y portátil

El objetivo del proyecto es ser jq o sed de archivos yaml.

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

Como ejemplo (robado directamente de la documentación ), dado un archivo sample.yaml de:

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

luego

yq r sample.yaml bob.*.cats

saldrá

- bananas
- apples

Es posible pasar un pequeño script a algunos intérpretes, como Python. Una manera fácil de hacerlo usando Ruby y su biblioteca YAML es la siguiente:

$ 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

, donde dataes un hash (o matriz) con los valores de yaml.

Como beneficio adicional, analizará muy bien el frente de Jekyll .

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

Dado que Python3 y PyYAML son dependencias bastante fáciles de cumplir hoy en día, lo siguiente puede ayudar:

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

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

aquí una versión extendida de la respuesta 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);
      }
   }'
}

Esta versión admite la -notación y la notación corta para diccionarios y listas. La siguiente entrada:

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

produce esta salida:

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"

como puede ver, los -elementos se numeran automáticamente para obtener diferentes nombres de variables para cada elemento. En bashno hay matrices multidimensionales, por lo que esta es una forma de trabajo alrededor. Múltiples niveles son compatibles. Para evitar el problema de los espacios en blanco finales mencionados por @briceburg, se deben encerrar los valores entre comillas simples o dobles. Sin embargo, todavía hay algunas limitaciones: la expansión de los diccionarios y las listas puede producir resultados incorrectos cuando los valores contienen comas. Además, las estructuras más complejas, como los valores que abarcan varias líneas (como las teclas ssh) no son compatibles (todavía).

Algunas palabras sobre el código: el primer sedcomando expande la forma abreviada de los diccionarios { key: value, ...}a regular y los convierte a un estilo yaml más simple. La segunda sedllamada hace lo mismo para la notación corta de listas y se convierte [ entry, ... ]en una lista detallada con la -notación. La tercera sedllamada es la original que maneja los diccionarios normales, ahora con la adición de manejar listas con -sangrías. La awkparte introduce un índice para cada nivel de sangría y lo aumenta cuando el nombre de la variable está vacío (es decir, al procesar una lista). Se utiliza el valor actual de los contadores en lugar del nombre de v vacío. Al subir un nivel, los contadores se ponen a cero.

Editar: he creado un repositorio github para esto.

Difícil de decir porque depende de lo que quiera que extraiga el analizador de su documento YAML. Para los casos simples, es posible que pueda utilizar grep, cut, awketc. Para el análisis más complejo que tendría que utilizar un análisis en toda regla biblioteca de Python como PyYAML o YAML :: Perl .

¡Acabo de escribir un analizador que llamé Yay! (¡ Yaml no es Yamlesque! ) Que analiza Yamlesque , un pequeño subconjunto de YAML. Entonces, si está buscando un analizador YAML 100% compatible para Bash, entonces este no lo es. Sin embargo, para citar el OP, si desea un archivo de configuración estructurado que sea lo más fácil posible para un usuario no técnico para editar que sea similar a YAML, esto puede ser de interés.

Está inspirado en la respuesta anterior, pero escribe matrices asociativas ( sí, requiere Bash 4.x ) en lugar de variables básicas. Lo hace de una manera que permite analizar los datos sin el conocimiento previo de las claves para que se pueda escribir el código controlado por datos.

Además de los elementos de la matriz de clave / valor, cada matriz tiene una keysmatriz que contiene una lista de nombres de clave, una childrenmatriz que contiene nombres de matrices secundarias y una parentclave que se refiere a su padre.

Este es un ejemplo 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

Aquí hay un ejemplo que muestra cómo usarlo:

#!/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

que salidas:

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
  }
}

Y aquí está el analizador:

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 "$@"); }

Hay algo de documentación en el archivo fuente vinculado y a continuación hay una breve explicación de lo que hace el código.

La yay_parsefunción primero localiza el inputarchivo o sale con un estado de salida de 1. Luego, determina el conjunto de datos prefix, ya sea explícitamente especificado o derivado del nombre del archivo.

Escribe bashcomandos válidos en su salida estándar que, si se ejecutan, definen matrices que representan el contenido del archivo de datos de entrada. El primero de ellos define la matriz de nivel superior:

echo "declare -g -A $prefix;"

Tenga en cuenta que las declaraciones de matriz son asociativas ( -A), que es una característica de Bash versión 4. Las declaraciones también son globales ( -g), por lo que pueden ejecutarse en una función pero estar disponibles para el alcance global como el yayayudante:

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

Los datos de entrada se procesan inicialmente con sed. Descarta líneas que no coinciden con la especificación de formato Yamlesque antes de delimitar los campos válidos de Yamlesque con un carácter de separador de archivo ASCII y eliminar las comillas dobles que rodean el campo de valor.

 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" |

Las dos expresiones son similares; difieren solo porque el primero selecciona los valores entre comillas, mientras que el segundo selecciona los que no están entre comillas.

El separador de archivos (28 / hex 12 / octal 034) se utiliza porque, como carácter no imprimible, es poco probable que esté en los datos de entrada.

El resultado se canaliza en el awkque procesa su entrada una línea a la vez. Utiliza el FS caracteres para asignar cada campo a una variable:

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

Todas las líneas tienen una sangría (posiblemente cero) y una clave, pero no todas tienen un valor. Calcula un nivel de sangría para la línea que divide la longitud del primer campo, que contiene el espacio en blanco inicial, por dos. Los elementos de nivel superior sin sangría están en el nivel de sangría cero.

A continuación, determina qué prefixusar para el elemento actual. Esto es lo que se agrega al nombre de una clave para crear un nombre de matriz. Hay una root_prefixpara la matriz de nivel superior que se define como el nombre de conjunto de datos y un carácter de subrayado:

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

La parent_keyes la clave en el nivel de sangría por encima del nivel de sangría de la línea actual y representa la colección de la que forma parte la línea actual. Los pares clave / valor de la colección se almacenarán en una matriz con su nombre definido como la concatenación de prefixy parent_key.

Para el nivel superior (nivel de sangría cero), el prefijo del conjunto de datos se utiliza como clave principal, por lo que no tiene prefijo (está establecido en ""). Todos los demás arreglos tienen el prefijo raíz.

A continuación, la clave actual se inserta en una matriz (awk-internal) que contiene las claves. Esta matriz persiste durante toda la sesión awk y, por lo tanto, contiene claves insertadas por líneas anteriores. La clave se inserta en la matriz usando su sangría como índice de la matriz.

keys[indent] = key;

Debido a que esta matriz contiene claves de líneas anteriores, se eliminan todas las claves con un nivel de sangría mayor que el nivel de sangría de la línea actual:

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

Esto deja la matriz de claves que contiene el llavero desde la raíz en el nivel de sangría 0 a la línea actual. Elimina las claves obsoletas que permanecen cuando la línea anterior se sangra más profundo que la línea actual.

La sección final genera los bashcomandos: una línea de entrada sin un valor inicia un nuevo nivel de sangría (una colección en lenguaje YAML) y una línea de entrada con un valor agrega una clave a la colección actual.

El nombre de la colección es la concatenación de la línea actual prefixy parent_key.

Cuando una clave tiene un valor, una clave con ese valor se asigna a la colección actual de esta manera:

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

La primera instrucción genera el comando para asignar el valor a un elemento de matriz asociativo nombrado después de la clave y la segunda genera el comando para agregar la clave a la keyslista delimitada por espacios de la colección :

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

Cuando una clave no tiene un valor, se inicia una nueva colección como esta:

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

La primera instrucción genera el comando para agregar la nueva colección a la childrenlista delimitada por espacios de la colección actual y la segunda genera el comando para declarar una nueva matriz asociativa para la nueva colección:

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

Toda la salida de yay_parsepuede ser analizada como comandos bash por los comandos bash evalo sourceintegrados.

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

Otra opción es convertir el YAML a JSON, luego usar jq para interactuar con la representación JSON, ya sea para extraer información o editarla.

Escribí un script de bash simple que contiene este pegamento; vea el proyecto Y2J en GitHub

Si necesita un valor único, podría utilizar una herramienta que convierta su documento YAML a JSON y lo alimente jq, por ejemplo yq.

Contenido de sample.yaml:

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

Ejemplo:

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

Sé que esto es muy específico, pero creo que mi respuesta podría ser útil para ciertos usuarios.
Si tiene nodee npminstaló en su máquina, puede usar js-yaml.
Primera instalación:

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

entonces en tu script bash

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

Además, si estás usando jqpuedes hacer algo así

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

Porque js-yamlconvierte un archivo yaml en un literal de cadena json. Luego puede usar la cadena con cualquier analizador json en su sistema unix.

Si tiene Python 2 y PyYAML, puede usar este analizador que escribí llamado parse_yaml.py . Algunas de las cosas más ingeniosas que hace es permitirle elegir un prefijo (en caso de que tenga más de un archivo con variables similares) y elegir un solo valor de un archivo yaml.

Por ejemplo, si tiene estos archivos 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

Puede cargar ambos sin conflicto.

$ 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

E incluso elige los valores que quieras.

$ 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

Podrías usar un equivalente de yq que está escrito en golang:

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

devoluciones:

62.0.3

También puede considerar usar Grunt (The JavaScript Task Runner). Se puede integrar fácilmente con la carcasa. Admite la lectura de archivos YAML ( grunt.file.readYAML) y JSON ( grunt.file.readJSON).

Esto se puede lograr creando una tarea en Gruntfile.js(o Gruntfile.coffee), por ejemplo:

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':
        });
    });

};

luego desde shell simplemente ejecute grunt foo(verifique grunt --helplas tareas disponibles)

Además, puede implementar exec:footareas ( grunt-exec) con variables de entrada pasadas desde su tarea ( foo: { cmd: 'echo bar <%= foo %>' }) para imprimir la salida en el formato que desee y luego canalizarla a otro comando.

También hay una herramienta similar a Grunt, se llama gulp con el complemento adicional gulp-yaml .

Instalar a través de: npm install --save-dev gulp-yaml

Uso de la muestra:

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/'))

Para obtener más opciones para lidiar con el formato YAML , consulte el sitio de YAML para ver los proyectos, bibliotecas y otros recursos disponibles que pueden ayudarlo a analizar ese formato.

Otras herramientas:

• Jshon

  analiza, lee y crea JSON

Sé que mi respuesta es específica, pero si uno ya tiene PHP y Symfony instalados, puede ser muy útil usar el analizador YAML de Symfony.

Por ejemplo:

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

Aquí simplemente solía var_dumpgenerar la matriz analizada pero, por supuesto, puedes hacer mucho más ... :)