Publicado em 11/11/2014 – Versão de texto

TOML v0.3.1

Tom's Obvious, Minimal Language.

Por Tom Preston-Werner.

Fique ciente de que esta especificação ainda está mudando muito. Até que seja marcado como 1.0, você deve presumir que é instável e agir de acordo.

Objetivos

TOML visa ser um formato de arquivo de configuração mínimo que seja fácil de ler devido à semântica óbvia. O TOML foi projetado para mapear inequivocamente para uma tabela de hash. O TOML deve ser fácil de analisar em estruturas de dados em uma ampla variedade de idiomas.

Especificação

TOML é case-sensitive, ou seja, diferencia maiúsculo de minúsculo.
Espaço em branco significa tabulação (0x09) ou espaço (0x20).

Comentário

Fale o que pensa com o símbolo de cerquilha. Eles vão do símbolo até o final da linha.

# Sou um comentário. Ouça-me rugir. Grrrrr.
chave = "valor" # É, você pode fazer isso.

String

Há quatro maneiras de expressar strings: básica, básica multilinha, literal e literal multilinha. Todas as strings devem conter apenas caracteres UTF-8 válidos.

Strings básicas são delimitadas por aspas. Qualquer caractere Unicode pode ser usado, exceto aqueles que devem ter escape: aspas, barra invertida e os caracteres de controle (U+0000 a U+001F).

"Sou uma string. \"Você me colocar entre aspas\". Nome\tJos\u00E9\nLocal\tSF."

Por conveniência, alguns caracteres populares têm uma sequência de escape compacta.

\b         - backspace        (U+0008)
\t         - tabulação        (U+0009)
\n         - linefeed         (U+000A)
\f         - form feed        (U+000C)
\r         - carriage return  (U+000D)
\"         - aspas            (U+0022)
\/         - barra            (U+002F)
\\         - barra invertida  (U+005C)
\uXXXX     - unicode          (U+XXXX)
\UXXXXXXXX - unicode          (U+XXXXXXXX)

Qualquer caractere Unicode pode ter escape com as formas \uXXXX ou \UXXXXXXXX. Note que os códigos de escape devem ser pontos de código em Unicode válido.

Outros caracteres especiais são reservados e, se usados, TOML deve produzir um erro.

Dica Pro™: Você pode notar que esta especificação de string é a mesma que a definição de string do JSON, exceto que TOML requer codificação UTF-8. Isso é de propósito.

Às vezes, você precisa expressar passagens de texto (por exemplo, arquivos de tradução) ou deseja dividir uma string muito longa em várias linhas. O TOML torna isso fácil. Strings básicas multilinha são delimitadas por três aspas em cada lado e permitem novas linhas. Se o primeiro caractere após o delimitador de abertura for uma nova linha (0x0A), então ele será cortado. Todos os outros espaços em branco permanecem intactos.

# As strings a seguir são equivalentes byte a byte:
chave1 = "Um\nDois"
chave2 = """Um\nDois"""
chave3 = """
Um
Dois"""

Para escrever strings longas sem introduzir espaços em branco estranhos, termine a linha com \ ("barra invertida"). O caractere \ será cortado junto com todos os espaços em branco (incluindo novas linhas) até o próximo caractere diferente de espaço em branco ou delimitador de fechamento. Se os dois primeiros caracteres após o delimitador de abertura forem uma barra invertida e uma nova linha (0x5C0A), ambos serão cortados junto com todos os espaços em branco (incluindo novas linhas) até o próximo caractere diferente de espaço em branco ou delimitador de fechamento. Todas as sequências de escape que são válidas para strings básicas também são válidas para strings básicas multilinha.

# As strings a seguir são equivalentes byte a byte:
chave1 = "A rápida raposa marrom pula sobre o cachorro preguiçoso."

chave2 = """
A rápida raposa \


  marrom pula sobre \
    o cachorro preguiçoso."""

chave3 = """\
       A rápida raposa \
       marrom pula sobre \
       o cachorro preguiçoso.\
       """

Qualquer caractere Unicode pode ser usado, exceto aqueles que devem ter escape: barra invertida e os caracteres de controle (U+0000 a U+001F). As aspas não precisam ter escape, a menos que sua presença crie um delimitador de fechamento prematuro.

Se você com frequência especifica caminhos do Windows ou expressões regulares, ter que fazer escape de barras invertidas rapidamente se torda tedioso e sujeito a erros. Para ajudar, o TOML oferece suporte a strings literais que não permitem escape. Strings literais são delimitadas por aspas simples. Como strings básicas, mas devem aparecer um uma única linha:

# O que você vê é o que você obtém.
winpath  = 'C:\Users\nodejs\templates'
winpath2 = '\\ServerX\admin$\system32\'
com_aspas = 'Tom "Dubs" Preston-Werner'
regex    = '<\i\c*\s*>'

Como não há escape, não há como escrever uma aspa simples dentro de uma string literal entre aspas simples. Felizmente, o TOML oferece suporte a uma versão multilinha de strings literais que resolve esse problema. Strings literais multilinha são delimitadas por três aspas simples de cada lado e permitem novas linhas. Como strings literais, não há como fazer escape. Se o primeiro caractere após o delimitador de abertura for uma nova linha (0x0A), ele será cortado. Todos os outros conteúdos entre os delimitadores são interpretados como estão, sem modificação.

regex2 = '''Eu( não)? preciso de \d{2} maçãs'''
linhas = '''
A primeira nova linha é
cortada em strings brutas.
   Todos os outros espaços
   em branco são preservados.
'''

Para dados binários, é recomendável usar Base64 ou outra codificação ASCII ou UTF-8 adequada. A manipulação dessa codificação será específica do aplicativo.

Inteiro

Inteiros são números inteiros. Números positivos podem ser prefixados com um sinal de mais. Números negativos são prefixados com um sinal de menos.

Zeros à esquerda não são permitidos. Formas hexadecimais, octais e binárias não são permitidas. Valores como "infinito" e "não é um número" que não podem ser expressos como uma série de dígitos não são permitidos.

Intervalos de 64 bits (longo com sinal) são esperados (−9,223,372,036,854,775,808 to 9,223,372,036,854,775,807).

Ponto flutuante

Um ponto flutuante consiste em uma parte inteira (que segue as mesmas regras dos valores inteiros decimais) seguida por uma parte fracionária e/ou uma parte expoente. Se uma parte fracionária e uma parte expoente estiverem presentes, a parte fracionária deve preceder a parte expoente.

# fracionário
+1.0
3.1415
-0.01

# expoente
5e+22
1e6
-2E-2

# ambos
6.626e-34

Uma parte fracionária é um ponto decimal seguido por um ou mais dígitos.

Uma parte expoente é um E (maiúsculo ou minúsculo) seguido por uma parte inteira (que pode ser prefixada com um sinal de mais ou menos).

Precisão (dupla) de 64 bits esperada.

Booleano

Booleanos são apenas os tokens com os quais você está acostumado. Sempre minúsculos.

true
false

Data e hora

Datas/horas têm o formato da RFC 3339.

1979-05-27T07:32:00Z
1979-05-27T00:32:00-07:00
1979-05-27T00:32:00.999999-07:00

Array

Arrays são colchetes com outros primitivos dentro. O espaço em branco é ignorado. Os elementos são separados por vírgulas. Os tipos de dados podem ser misturados.

[ 1, 2, 3 ]
[ "vermelho", "amarelo", "verde" ]
[ [ 1, 2 ], [3, 4, 5] ]
[ [ 1, 2 ], ["a", "b", "c"] ] # tudo bem
[ 1, 2.0 ] # nota: isso NÃO está correto

Arrays também podem ser multilinhas. Portanto, além de ignorar os espaços em branco, os arrays também ignoram as novas linhas entre os colchetes. As vírgulas de terminação são aceitas antes do colchete de fechamento.

chave = [
  1, 2, 3
]

chave = [
  1,
  2, # tudo bem
]

Tabela

Tabelas (também conhecidas como tabelas hash ou dicionários) são coleções de pares chave/valor. Elas aparecem entre colchetes em uma linha própria. Você pode diferenciá-las de arrays porque os arrays são apenas valores.

[tabela]

Abaixo disso, e até a próxima tabela ou EOF, estão as chaves/valores dessa tabela. As chaves estão à esquerda do sinal de igual e os valores à direita. As chaves começam com o primeiro caractere diferente de espaço em branco ou [ e terminam com o último caractere diferente de espaço em branco antes do sinal de igual. As chaves não podem conter um caractere #. Não há garantia de que os pares chave/valor nas tabelas estejam em uma ordem específica.

[tabela]
chave = "valor"

Você pode recuar as chaves e seus valores o quanto quiser. Tabulações ou espaços. Fique à vontade. Por que, você pergunta? Porque você pode ter tabelas aninhadas. Massa demais.

As tabelas aninhadas são indicadas por nomes de tabela com pontos nelas. Nomeie suas tabelas como quiser, só não use #, ., [ ou ].

[cachorro.batatinha]
tipo = "pug"

Na terra do JSON, isso resultaria na seguinte estrutura:

{ "cachorro": { "batatinha": { "tipo": "pug" } } }

Você não precisa especificar todas as supertabelas se não quiser. TOML sabe como fazer isso para você.

# [x] você
# [x.y] não
# [x.y.z] precisa disso
[x.y.z.w] # para que isso funcione

Tabelas vazias são permitidas e simplesmente não possuem pares chave/valor dentro delas.

Desde que uma supertabela não tenha sido definida diretamente e não tenha definido uma chave específica, você ainda pode escrever nela.

[a.b]
c = 1

[a]
d = 2

Você não pode definir nenhuma chave ou tabela mais de uma vez. Fazer isso é inválido.

# NÃO FAÇA ISSO

[a]
b = 1

[a]
c = 2

# TAMBÉM NÃO FAÇA ISSO

[a]
b = 1

[a.b]
c = 2

Todos os nomes e chaves de tabelas devem estar vazios.

# NÃO É UM TOML VÁLIDO
[]
[a.]
[a..b]
[.b]
[.]
 = "sem nome de chave" # não permitido

Array de tabelas

A última sintaxe que ainda não foi expressa é um array de tabelas. Este pode ser expresso usando um nome de tabela entre colchetes duplos. Cada tabela com o mesmo nome entre colchetes duplos será um elemento no array. As tabelas são inseridas no array na ordem encontrada. Uma tabela com colchetes duplos sem nenhum par chave/valor será considerada uma tabela vazia.

[[produtos]]
nome = "Martelo"
sku = 738594937

[[produtos]]

[[produtos]]
nome = "Prego"
sku = 284758393
cor = "cinza"

Na terra do JSON, isso resultaria na seguinte estrutura.

{
  "produtos": [
    { "nome": "Martelo", "sku": 738594937 },
    { },
    { "nome": "Prego", "sku": 284758393, "color": "cinza" }
  ]
}

Você também pode criar arrays aninhados de tabelas. Basta usar a mesma sintaxe de colchetes duplos nas subtabelas. Cada subtabela entre colchetes pertencerá ao elemento de tabela definido mais recentemente acima dela.

[[fruta]]
  nome = "uva"

  [fruta.fisico]
    cor = "roxa"
    forma = "redonda"

  [[fruta.variedade]]
    nome = "roxa deliciosa"

  [[fruta.variedade]]
    nome = "cabernet sauvignon"


[[fruta]]
  nome = "banana"

  [[fruta.variedade]]
    nome = "banana-da-terra"

O TOML acima é mapeado para o seguinte JSON.

{
  "fruta": [
    {
      "nome": "uva",
      "fisico": {
        "cor": "roxa",
        "forma": "redonda"
      },
      "variedade": [
        { "nome": "roxa deliciosa" },
        { "nome": "cabernet sauvignon" }
      ]
    },
    {
      "nome": "banana",
      "variedade": [
        { "nome": "banana-da-terra" }
      ]
    }
  ]
}

A tentativa de definir uma tabela normal com o mesmo nome de um array já estabelecido deve produzir um erro no momento da análise.

# DOCUMENTO TOML INVÁLIDO
[[fruta]]
  nome = "uva"

  [[fruta.variedade]]
    nome = "roxa deliciosa"

  # Esta tabela conflita com a tabela anterior
  [fruta.variedade]
    nome = "cabernet sauvignon"