YAML: ¿Necesito citas para cadenas en YAML?

Estoy tratando de escribir un diccionario YAML para la internacionalización de un proyecto Rails. Sin embargo, estoy un poco confundido, ya que en algunos archivos veo cadenas entre comillas dobles y en otras sin comillas. Algunos puntos a considerar:

• ejemplo 1 : todas las cadenas usan comillas dobles;
• ejemplo 2 : sin cadenas (excepto las dos últimas) se utilizan comillas;
• el libro de cocina de YAML dice: El encerrar cadenas entre comillas dobles le permite usar escapes para representar caracteres ASCII y Unicode. ¿Significa esto que necesito usar comillas dobles solo cuando quiero escapar de algunos caracteres? En caso afirmativo, ¿por qué usan comillas dobles en todas partes en el primer ejemplo, solo por razones de unidad / estilísticas?
• usan las dos últimas líneas del ejemplo 2 !, la etiqueta no específica, mientras que las dos últimas líneas del primer ejemplo no lo hacen, y ambas funcionan.

Mi pregunta es: ¿cuáles son las reglas para usar los diferentes tipos de citas en YAML?

Podría decirse que:

• en general, no necesita comillas;
• si quieres escapar de los caracteres usa comillas dobles;
• usar !con comillas simples, cuando ...?!?

Después de una breve revisión del libro de cocina YAML citado en la pregunta y algunas pruebas, aquí está mi interpretación:

• En general, no necesita comillas.
• Use comillas para forzar una cadena, por ejemplo, si su clave o valor es 10pero desea que devuelva una cadena y no un Fixnum, escriba '10'o "10".
• Use comillas si su valor incluye caracteres especiales, (por ejemplo :, {, }, [, ], ,, &, *, #, ?, |, -, <, >, =, !, %, @, \).
• Las comillas simples le permiten poner casi cualquier carácter en su cadena, y no intentará analizar los códigos de escape. '\n'sería devuelto como la cadena \n.
• Las comillas dobles analizan los códigos de escape. "\n"se devolvería como un carácter de avance de línea.
• El signo de exclamación introduce un método, por ejemplo, !ruby/sympara devolver un símbolo Ruby.

Me parece que el mejor enfoque sería no usar comillas a menos que sea necesario, y luego usar comillas simples a menos que específicamente desee procesar códigos de escape.

Actualizar

"Sí" y "No" deben ir entre comillas (simples o dobles) o se interpretarán como valores TrueClass y FalseClass:

en:
  yesno:
    'yes': 'Yes'
    'no': 'No'

Tenía esta preocupación cuando trabajaba en una aplicación Rails con Docker .

Mi enfoque más preferido es generalmente no usar comillas. Esto incluye no usar comillas para:

• variables como ${RAILS_ENV}
• valores separados por dos puntos (:) como postgres-log:/var/log/postgresql
• otros valores de cadenas

Sin embargo, uso comillas dobles para los integervalores que deben convertirse en cadenas como:

• versión docker-compose como version: "3.8"
• números de puerto como "8080:8080"

Sin embargo, para casos especiales como booleans, floats, integers, y otros casos, en los que utilizan comillas para los valores de entrada podrían ser interpretadas como strings, por favor, no utilice comillas dobles.

Aquí hay un docker-compose.ymlarchivo de muestra para explicar este concepto:

version: "3"

services:
  traefik:
    image: traefik:v2.2.1
    command:
      - --api.insecure=true # Don't do that in production
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false
      - --entrypoints.web.address=:80
    ports:
      - "80:80"
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro

Eso es todo.

espero que esto ayude