Como posso analisar um arquivo YAML a partir de um script de shell do Linux?

Desejo fornecer um arquivo de configuração estruturado que seja o mais fácil possível para um usuário não técnico editar (infelizmente deve ser um arquivo) e, portanto, desejei usar o YAML. No entanto, não consigo encontrar nenhuma maneira de analisar isso em um script de shell Unix.

Meu caso de uso pode ou não ser exatamente o que esta postagem original estava perguntando, mas é definitivamente semelhante.

Eu preciso puxar alguns YAML como variáveis ​​bash. O YAML nunca terá mais de um nível de profundidade.

YAML é assim:

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

Saída como um dis:

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

Eu consegui a saída com esta linha:

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

• s/:[^:\/\/]/="/glocaliza :e o substitui por =", enquanto ignora ://(para URLs)
• s/$/"/ganexa "ao final de cada linha
• s/ *=/=/g remove todos os espaços antes =

Aqui está um analisador bash-only que aproveita o sed e o awk para analisar arquivos 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);
      }
   }'
}

Ele entende arquivos como:

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

## output
output:
   file: "yes"

Que, quando analisado usando:

parse_yaml sample.yml

irá produzir:

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

ele também entende arquivos yaml, gerados por ruby, que podem incluir símbolos ruby, como:

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

e produzirá o mesmo que no exemplo anterior.

O uso típico em um script é:

eval $(parse_yaml sample.yml)

parse_yaml aceita um argumento de prefixo para que todas as configurações importadas tenham um prefixo comum (o que reduzirá o risco de colisões de namespace).

parse_yaml sample.yml "CONF_"

rendimentos:

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

Observe que as configurações anteriores em um arquivo podem ser referidas por configurações posteriores:

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

## output
output:
   debug: $global_debug

Outro uso interessante é primeiro analisar um arquivo padrão e, em seguida, as configurações do usuário, que funcionam, pois as últimas configurações substituem as primeiras:

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

eu escrevi shyaml em python para necessidades de consulta YAML na linha de comando do shell.

Visão geral:

$ pip install shyaml      ## installation

Arquivo YAML do exemplo (com recursos complexos):

$ 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 em loop mais complexa em valores complexos:

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

Alguns pontos-chave:

• todos os tipos de YAML e esquisitices de sintaxe são manipulados corretamente, como multilinhas, seqüências de caracteres entre aspas, sequências em linha ...
• \0 saída acolchoada está disponível para manipulação sólida de múltiplas linhas.
• notação pontilhada simples para selecionar subvalores (ou seja: subvalue.maintaineré uma chave válida).
• o acesso pelo índice é fornecido às seqüências (ou seja: subvalue.things.-1é o último elemento da subvalue.thingssequência).
• acesso a todos os elementos de sequência / estruturas de uma só vez para uso em loops de bash.
• você pode gerar uma subparte inteira de um arquivo YAML como ... YAML, que combina bem para outras manipulações com shyaml.

Mais amostras e documentação estão disponíveis na página shyaml github ou na página shyaml PyPI .

yq é um processador YAML de linha de comando leve e portátil

O objetivo do projeto é ser o jq ou sed dos arquivos yaml.

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

Como exemplo (roubado diretamente da documentação ), dado um arquivo sample.yaml de:

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

então

yq r sample.yaml bob.*.cats

irá produzir

- bananas
- apples

É possível passar um pequeno script para alguns intérpretes, como Python. Uma maneira fácil de fazer isso usando Ruby e sua biblioteca YAML é o seguinte:

$ 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

, onde dataé um hash (ou matriz) com os valores de yaml.

Como um bônus, ele analisará a matéria da frente de Jekyll muito bem.

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

Dado que Python3 e PyYAML são dependências bastante fáceis de serem encontradas hoje em dia, o seguinte pode ajudar:

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

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

aqui uma versão estendida da resposta 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 versão suporta o - notação e a notação curta de dicionários e listas. A seguinte entrada:

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

produz esta saída:

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 você pode ver o - itens são numerados automaticamente para obter nomes de variáveis ​​diferentes para cada item. Nobash não existem matrizes multidimensionais, essa é uma maneira de contornar. Vários níveis são suportados. Para contornar o problema de espaços em branco à direita mencionados por @briceburg, deve-se colocar os valores entre aspas simples ou duplas. No entanto, ainda existem algumas limitações: A expansão dos dicionários e listas pode produzir resultados incorretos quando os valores contêm vírgulas. Além disso, estruturas mais complexas, como valores que abrangem várias linhas (como ssh-keys), ainda não são suportadas.

Algumas palavras sobre o código: O primeiro sedcomando expande a forma abreviada de dicionários { key: value, ...}para regular e os converte para um estilo yaml mais simples. A segunda sedchamada faz o mesmo para a notação curta de listas e é convertida [ entry, ... ]em uma lista detalhada com a -notação. A terceira sedchamada é a original que lidava com dicionários normais, agora com a adição de lidar com listas -e recuos. A awkparte introduz um índice para cada nível de indentação e aumenta quando o nome da variável está vazio (ou seja, ao processar uma lista). O valor atual dos contadores é usado em vez do vname vazio. Ao subir um nível, os contadores são zerados.

Edit: Eu criei um repositório do github para isso.

Difícil dizer porque depende do que você deseja que o analisador extraia do seu documento YAML. Para casos simples, que você pode ser capaz de usar grep, cut, awketc. Para a análise mais complexa que você precisaria usar um full-blown analisar biblioteca, como Python PyYAML ou YAML :: Perl .

Acabei de escrever um analisador que chamei Yay! ( Yaml não é Yamlesque! ), Que analisa Yamlesque , um pequeno subconjunto de YAML. Portanto, se você está procurando um analisador YAML 100% compatível com o Bash, não é isso. No entanto, para citar o OP, se você deseja um arquivo de configuração estruturado que seja o mais fácil possível para um usuário não técnico editar semelhante ao YAML, isso pode ser interessante.

Ele é inspirado pela resposta anterior, mas grava matrizes associativas ( sim, requer o Bash 4.x ) em vez de variáveis ​​básicas. Isso é feito de uma maneira que permite que os dados sejam analisados ​​sem o conhecimento prévio das chaves, para que o código controlado por dados possa ser gravado.

Assim como os elementos da matriz chave / valor, cada matriz possui uma keysmatriz que contém uma lista de nomes de chaves, uma childrenmatriz que contém nomes de matrizes filho e uma parentchave que se refere ao seu pai.

Este é um exemplo 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

Aqui está um exemplo mostrando como usá-lo:

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

quais saídas:

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

E aqui está o analisador:

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

Há alguma documentação no arquivo de origem vinculado e abaixo está uma breve explicação do que o código faz.

A yay_parsefunção primeiro localiza o inputarquivo ou sai com um status de saída igual a 1. Em seguida, determina o conjunto de dados prefix, especificado explicitamente ou derivado do nome do arquivo.

Ele grava bashcomandos válidos em sua saída padrão que, se executados, definem matrizes que representam o conteúdo do arquivo de dados de entrada. O primeiro deles define a matriz de nível superior:

echo "declare -g -A $prefix;"

Observe que as declarações de matriz são associativas ( -A), que é um recurso da versão 4. do Bash. As declarações também são globais ( -g) para que possam ser executadas em uma função, mas estejam disponíveis para o escopo global como o yayauxiliar:

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

Os dados de entrada são processados ​​inicialmente com sed. Ele descarta linhas que não correspondem à especificação do formato Yamlesque antes de delimitar os campos válidos do Yamlesque com um caractere ASCII File Separator e remover aspas duplas ao redor do 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" |

As duas expressões são semelhantes; eles diferem apenas porque o primeiro seleciona valores entre aspas, enquanto que o segundo escolhe valores não citados.

O Separador de Arquivos (28 / hex 12 / octal 034) é usado porque, como um caractere não imprimível, é improvável que esteja nos dados de entrada.

O resultado é canalizado para o awkqual processa sua entrada uma linha por vez. Ele usa o caractere FS para atribuir cada campo a uma variável:

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

Todas as linhas têm um recuo (possivelmente zero) e uma chave, mas nem todas têm um valor. Ele calcula um nível de recuo para a linha que divide o comprimento do primeiro campo, que contém o espaço em branco à esquerda, por dois. Os itens de nível superior sem nenhum recuo estão no nível de recuo zero.

Em seguida, ele decide o que prefixusar para o item atual. É isso que é adicionado a um nome de chave para criar um nome de matriz. Existe um root_prefixpara a matriz de nível superior, definida como o nome do conjunto de dados e um sublinhado:

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

A parent_keyé a chave no nível de indentação acima do nível de indentação da linha atual e representa a coleção da qual a linha atual faz parte. Os pares chave / valor da coleção serão armazenados em uma matriz com seu nome definido como a concatenação de prefixe parent_key.

Para o nível superior (nível de recuo zero), o prefixo do conjunto de dados é usado como chave pai, portanto, ele não possui prefixo (está definido como ""). Todas as outras matrizes são prefixadas com o prefixo raiz.

Em seguida, a chave atual é inserida em um array (interno do awk) contendo as chaves. Essa matriz persiste durante toda a sessão do awk e, portanto, contém chaves inseridas por linhas anteriores. A chave é inserida na matriz usando seu recuo como índice da matriz.

keys[indent] = key;

Como essa matriz contém chaves de linhas anteriores, quaisquer chaves com um ralador de nível de recuo além do nível de recuo da linha atual são removidas:

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

Isso deixa a matriz de chaves que contém o conjunto de chaves da raiz no nível de recuo 0 até a linha atual. Ele remove chaves obsoletas que permanecem quando a linha anterior foi recuada mais profundamente que a linha atual.

A seção final gera os bashcomandos: uma linha de entrada sem valor inicia um novo nível de recuo (uma coleção na linguagem YAML) e uma linha de entrada com um valor adiciona uma chave à coleção atual.

O nome da coleção é a concatenação da linha atual prefixe parent_key.

Quando uma chave tem um valor, uma chave com esse valor é atribuída à coleção atual como esta:

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

A primeira instrução gera o comando para atribuir o valor a um elemento de matriz associativa nomeado após a chave e a segunda gera o comando para adicionar a chave à keyslista delimitada por espaço da coleção :

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

Quando uma chave não tem um valor, uma nova coleção é iniciada assim:

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

A primeira instrução gera o comando para adicionar a nova coleção à childrenlista delimitada por espaço da coleção atual e a segunda gera o comando para declarar uma nova matriz associativa para a nova coleção:

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

Toda a saída de yay_parsepode ser analisada como comandos bash pelos comandos bash evalou sourceinternos.

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

Outra opção é converter o YAML em JSON e, em seguida, use jq para interagir com a representação JSON para extrair informações ou editá-las.

Eu escrevi um script simples do bash que contém essa cola - veja o projeto Y2J no GitHub

Se você precisar de um único valor, poderá usar uma ferramenta que converta seu documento YAML em JSON e alimente jq, por exemplo yq.

Conteúdo de sample.yaml:

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

Exemplo:

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

Sei que isso é muito específico, mas acho que minha resposta pode ser útil para determinados usuários.
Se você possui nodee npminstalou em sua máquina, você pode usá-lo js-yaml.
Primeira instalação:

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

então no seu script bash

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

Além disso, se você estiver usando, jqpoderá fazer algo assim

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

Porque js-yamlconverte um arquivo yaml em um literal json string. Você pode usar a string com qualquer analisador json no seu sistema unix.

Se você tem python 2 e PyYAML, pode usar este analisador que escrevi chamado parse_yaml.py . Algumas das coisas mais simples que faz é permitir que você escolha um prefixo (caso tenha mais de um arquivo com variáveis ​​semelhantes) e escolha um único valor em um arquivo yaml.

Por exemplo, se você possui esses arquivos 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

Você pode carregar os dois sem conflito.

$ 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 até a cereja escolhe os valores que você deseja.

$ 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

Você pode usar um equivalente de yq que está escrito em golang:

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

retorna:

62.0.3

Você também pode considerar o uso do Grunt (o JavaScript Task Runner). Pode ser facilmente integrado ao shell. Ele suporta a leitura de arquivos YAML ( grunt.file.readYAML) e JSON ( grunt.file.readJSON).

Isso pode ser conseguido através da criação de uma tarefa em Gruntfile.js(ou Gruntfile.coffee), por exemplo:

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

};

depois, a partir do shell, basta executar grunt foo(verifique grunt --helpas tarefas disponíveis).

Além disso, você pode implementar exec:footask ( grunt-exec) com variáveis ​​de entrada passadas de sua task ( foo: { cmd: 'echo bar <%= foo %>' }) para imprimir a saída no formato que desejar, e canalizá-la para outro comando.

Também existe uma ferramenta semelhante ao Grunt, chamada gulp com o plug - in adicional gulp-yaml .

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

Uso da amostra:

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 obter mais opções para lidar com o formato YAML , consulte o site do YAML em busca de projetos, bibliotecas e outros recursos disponíveis, que podem ajudá-lo a analisar esse formato.

Outras ferramentas:

• Jshon

  analisa, lê e cria JSON

Sei que minha resposta é específica, mas se alguém já possui o PHP e o Symfony instalados, pode ser muito útil usar o analisador YAML do Symfony.

Por exemplo:

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

Aqui eu simplesmente utilizava var_dumpa saída do array analisado, mas é claro que você pode fazer muito mais ... :)