turbo-editors/turbo-golo · languages.md

⑂ b2b07ec0fe8e8d54362f3a1a6f1b089e9198ebd8

languages.md · 294 lines · 19.3 KBmarkdown    Blame HistoryRaw
📦 Turbo Golo   1# Référence : langages colorés
3> Description neutre des fichiers que Turbo Golo colore, de la façon dont il décide, et de ce que chaque scanner reconnaît.
5## Reconnaissance
7L'**extension** d'un fichier décide dès qu'elle est l'une de celles-ci :
Extension | Langage |
--- | --- |
`.golo` | Golo |
`.toml` | TOML |
`.yaml`, `.yml` | YAML |
`.md`, `.markdown` | Markdown |
`.js`, `.mjs`, `.cjs` | JavaScript |
`.html`, `.htm` | HTML |
`.xml`, `.xsd`, `.xsl`, `.xslt`, `.svg`, `.plist`, `.csproj`, `.pom` | XML |
`.sh`, `.bash`, `.zsh` | Shell |
`.dockerfile`, `.containerfile` | Dockerfile |
21Les extensions sont comparées sans tenir compte de la casse, et seule la dernière compte : `notes.golo.md` est du Markdown, et `main.golo.backup` n'est pas du Golo.
23Un fichier dont l'extension ne décide rien est ensuite cherché par son **nom**. Seuls les fichiers sans extension utile en ont besoin :
Nom | Langage |
--- | --- |
`Dockerfile`, `Containerfile` | Dockerfile |
29Un nom correspond sur sa totalité ou sur la partie avant le premier point, sans tenir compte de la casse — `Dockerfile`, `dockerfile` et `Dockerfile.dev` sont donc tous reconnus, tandis que `Dockerfile.md` est du Markdown, parce que l'extension est consultée d'abord.
31Un fichier que ni l'une ni l'autre table ne réclame est lu par sa **première ligne**. Un shebang nommant `golo` en fait du Golo : `#` ouvre un commentaire en Golo, l'interpréteur lit donc la ligne comme tel, et un script installé sans son extension et lancé comme une commande est du Golo et rien d'autre. Un shebang nommant un shell — `sh`, `bash`, `zsh`, `dash` ou `ksh` — en fait un script shell. L'interpréteur est reconnu comme élément de chemin ou comme argument d'`env`.
Première ligne | Résultat |
--- | --- |
`#!/usr/bin/env golo` | Golo |
`#!/usr/local/bin/golo` | Golo |
`#!/bin/sh` | Shell |
`#!/usr/bin/env bash` | Shell |
`#!/usr/bin/env -S bash -e` | Shell |
`#!/usr/bin/env node` | Non coloré |
Tout ce qui ne commence pas par `#!` | Non coloré |
43L'ordre est fixe — extension, puis nom, puis première ligne — et le premier qui décide l'emporte.
45Tout le reste est affiché en texte brut. Ce n'est pas une erreur — ouvrir un PNG dans l'éditeur n'est pas une faute, c'est juste non coloré.
47
49Chaque scanner produit le même vocabulaire de classes, et chacune correspond à une clé de thème.
Classe | Clé de thème | Produite par |
--- | --- | --- |
`identifier` | `syntax.identifier` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
`keyword` | `syntax.keyword` | Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile |
`type` | `syntax.type` | Golo (noms capitalisés et chemins de module), TOML (en-têtes de table), YAML (tags) |
`builtin` | `syntax.builtin` | Golo (les fonctions de l'interpréteur), JavaScript, shell (builtins et expansions), YAML (ancres et alias), Dockerfile (variables) |
`constant` | `syntax.constant` | Golo, TOML, JavaScript, shell, YAML, HTML et XML (entités) |
`function` | `syntax.function` | Golo, JavaScript, shell (la commande) |
`string` | `syntax.string` | tous |
`char` | `syntax.char` | Golo (`'c'`) |
`number` | `syntax.number` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
`comment` | `syntax.comment` | Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile |
`operator` | `syntax.operator` | Golo, TOML, JavaScript, shell, HTML, YAML (en-têtes de scalaires bloc), XML, Dockerfile |
`punctuation` | `syntax.punctuation` | Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile |
`heading` | `syntax.heading` | Markdown |
`tag` | `syntax.tag` | HTML, XML |
`attribute` | `syntax.attribute` | HTML, XML, Dockerfile (options) |
`emphasis` | `syntax.emphasis` | Markdown |
`link` | `syntax.link` | Markdown |
71Golo ne produit aucune portée `heading`, `tag`, `attribute`, `emphasis` ou `link`. Dans `turbo-classic`, `syntax.number` et `syntax.constant` sont tous deux magenta et `syntax.char` a le vert de `syntax.string`, si bien que `42` et `true` partagent une couleur là, et `'x'` et `"x"` aussi ; d'autres thèmes les séparent. Voir [écrire son propre thème](../how-to/write-a-theme.md) pour changer cela.
75Écrit à la main, dans `internal/gololang`, contre `lexer/lexer.go` et `token/token.go` de GoloScript. Ce que le lexer lit comme un token, le scanner le colore comme une portée.
77**Quatre constructions franchissent une ligne**, et sont portées à la ligne suivante exactement comme le lexer les lit : un commentaire bloc `----` jusqu'à son `----` fermant ; une chaîne `"…"` jusqu'à son guillemet fermant ; une chaîne multiligne `"""…"""` jusqu'à ses trois guillemets fermants ; un littéral de caractère `'…'` jusqu'à son apostrophe fermante. Aucune des quatre ne s'imbrique. Une chaîne non terminée colore donc le reste du fichier, jusqu'à un guillemet — ce que l'interpréteur lit comme telle.
Reconnu | Comme |
--- | --- |
`and`, `augment`, `augmentation`, `await`, `break`, `case`, `catch`, `continue`, `else`, `finally`, `for`, `foreach`, `function`, `if`, `import`, `in`, `is`, `isnt`, `let`, `local`, `match`, `module`, `not`, `oftype`, `or`, `orIfNull`, `otherwise`, `return`, `spawn`, `struct`, `then`, `throw`, `try`, `union`, `var`, `when`, `while`, `with` | mot-clé |
`true`, `false`, `null` | constante |
les 157 builtins de l'interpréteur — `println`, `print`, `str`, `len`, `list`, `map`, `set`, `array`, `vector`, `range`, `readFile`, `toJSON`, `fromJSON`, `httpGet`, `DynamicObject`, … | builtin |
tout autre nom commençant par une majuscule ASCII — `Point`, `Shape`, `Circle`, `Result_Failure`, `Some` | type |
le chemin pointé après `module` ou `import` — `hello.World`, `gololang.Errors`, `java.util.List` — en une seule portée | type |
le nom après `function` — `main` dans `function main = \|args\|` | fonction |
tout autre nom en minuscules immédiatement avant `(` | fonction |
tout autre nom : toute lettre ou marque Unicode, `_`, ou un emoji, puis des lettres, des chiffres et les mêmes — `x`, `été`, `名前`, `😀`, `🚀launch` | identifiant |
`"…"` avec les échappements `\n \t \r \\ \" \' \0 \xHH`, sur plusieurs lignes | chaîne |
`"""…"""`, sur plusieurs lignes, sans échappement | chaîne |
`'…'` avec les mêmes échappements, sur plusieurs lignes | caractère |
`42`, `3.14`, `1.5e-3`, `2E10`, `42L`, `3.14F`, `2.0f` | nombre |
`#` jusqu'à la fin de la ligne, shebang compris | commentaire |
`----` … `----`, sur plusieurs lignes | commentaire |
`..`, `...` | opérateur |
les suites de `+-*/%=<>!&\|^~?:` — dont `->`, `?:`, `==`, `!=`, `<=`, `>=` | opérateur |
`()[]{},;` et un `.` seul | ponctuation |
`$` dans `augment Shape$Circle` | ponctuation |
100**Un point rejoint un nombre seulement quand un chiffre le suit.** C'est le test du lexer lui-même, et c'est ce qui garde `1..3` comme un nombre et un intervalle plutôt que le double `1.` et un `.3` égaré.
102**Un exposant peut n'avoir aucun chiffre.** Le lexer lit `1e` comme un flottant et laisse le parseur se plaindre, `1e` est donc une seule portée de nombre.
104**Un nom capitalisé est un type par convention, pas par règle.** Golo vous laisse écrire `let Count = 1`, et il est coloré comme un type quand même. Les structs, les unions, les variantes et les cibles d'augmentation sont ce que les gens capitalisent, et la couleur suit les gens.
106**`Some`, `None`, `Ok` et `Err` sont des types, pas des constantes.** Ce sont les variantes d'unions ordinaires déclarées dans `gololang.Errors`, disponibles après un `import`, pas des builtins.
108**`DynamicObject` est un builtin, majuscule comprise.** Il est dans la table de l'interpréteur, et la table l'emporte sur la règle de casse.
110**Les noms peuvent contenir toute lettre Unicode, et des emoji.** Le `isLetter` du lexer admet les lettres, les marques, `_` et quatre blocs d'emoji (émoticônes, symboles et pictogrammes divers, symboles de transport et de cartes, symboles et pictogrammes supplémentaires) ; le scanner applique la même règle.
112**La coloration suit le lexer, pas le parseur.** Le parseur de GoloScript, en v0.1.1, refuse plusieurs tokens que son lexer lit : les suffixes `L`, `F` et `f`, un littéral de caractère `'c'`, l'intervalle `..`, `orIfNull`, `oftype` et `local function`. Ils sont colorés comme le lexer les lit, et le serveur de langage marque la ligne quand le parseur les refuse. `demos/syntax-tour/lexer-only.golo` en contient un de chaque.
114**Non reconnu**, chacun pour une raison énoncée :
Non reconnu | Parce que |
--- | --- |
`1_000` comme un seul nombre | Le lexer n'a pas de séparateur de chiffres : `_` commence un nom, c'est donc `1` puis `_000` |
`0xFF`, `0b1010`, `0o17` comme nombres | Le lexer n'a pas de préfixe de base : `0xFF` est `0` puis le nom `xFF` |
`.5` comme nombre | Le lexer exige un chiffre avant le point, c'est donc un point puis `5` |
`42l` comme long | Le lexer n'accepte que le `L` majuscule, c'est donc `42` et le nom `l` |
`---` comme commentaire | Quatre tirets ouvrent un commentaire bloc ; trois sont une suite d'opérateurs |
Un mot-clé après `:` comme nom de méthode | `obj: match()` garde `match` en mot-clé — le scanner ne suit pas ce qu'un deux-points introduit |
Un échappement dans `"""…"""` | Le lexer ajoute chaque rune jusqu'aux trois guillemets, `"""a\"""` se termine donc à son premier `"""` |
Un constructeur autrement que comme un type | Rien dans la syntaxe ne sépare `Circle(1.0)` d'un type appliqué à des arguments |
Une chaîne non terminée qui s'arrête à sa ligne | L'interpréteur lit jusqu'au guillemet fermant où qu'il soit, la couleur le suit donc — l'inverse de la décision de Turbo MoonBit, pour la raison inverse |
Si un nom est lié dans cette portée | Rien ici ne lit plus d'une ligne à la fois ; c'est la question du serveur de langage, et [F1 y répond](../how-to/ask-about-code.md) |
Reconnu | Comme |
--- | --- |
`# commentaire` | commentaire |
`[table]`, `[[tableau]]` | le nom comme type, les crochets comme ponctuation |
`clé =` | identifiant, puis opérateur |
`"basique"`, `'littérale'`, `"""multiligne"""`, `'''multiligne'''` | chaîne |
`true`, `false` | constante |
nombres, dates, heures, `inf`, `nan` | nombre |
142Un fichier compose, un manifeste Kubernetes et un workflow de CI sont tous cela : il n'y a pas de dialecte séparé, parce qu'un dialecte serait le schéma de quelqu'un d'autre à maintenir en phase.
Reconnu | Comme |
--- | --- |
`# commentaire` | commentaire |
`clé:` avant un espace ou la fin de ligne | la clé comme identifiant, le deux-points comme ponctuation |
`"citée": 1`, `'citée': 1` | la clé citée comme identifiant |
`- ` ouvrant un élément de séquence | ponctuation |
`"…"`, `'…'` | chaîne |
`true`, `false`, `yes`, `no`, `on`, `off`, `null` | constante, quelle que soit la casse |
nombres, dates et heures écrits sans guillemets | nombre |
`&ancre`, `*alias` | builtin |
`!!str`, `!Custom` | type |
`---`, `...` | toute la ligne comme ponctuation |
`{`, `}`, `[`, `]`, `,` | ponctuation |
`\|`, `>`, avec leurs indicateurs de troncature et d'indentation | l'en-tête comme opérateur, le corps comme chaîne |
159**Un deux-points n'est un séparateur que si un espace ou la fin de ligne le suit.** `image: nginx:1.27` est une clé et une valeur, et `url: http://example.com/x` est une clé et une URL — colorer les deux-points intérieurs comme séparateurs mettrait chaque tag d'image et chaque URL en trois couleurs.
161**L'étendue d'un scalaire bloc est décidée par l'indentation**, pas par un délimiteur. La première ligne de contenu après `|` ou `>` fixe l'indentation du bloc ; chaque ligne indentée au moins autant lui appartient, et la première qui ne l'est pas le termine. **Une ligne vide dans un bloc reste dans le bloc** : un scalaire littéral garde ses lignes vides, et terminer le bloc au premier saut de paragraphe couperait en deux un script shell dans un fichier de CI.
163**Un `#` a besoin d'un espace devant pour ouvrir un commentaire**, `colour: ff#00aa` est donc un seul scalaire.
Non reconnu | Parce que |
--- | --- |
Le schéma d'un fichier compose, d'un manifeste ou d'un workflow | Colorer `services:` autrement que n'importe quelle clé signifie porter le schéma de quelqu'un d'autre, et il vieillit le jour où ils ajoutent une clé |
Les flux multi-documents comme documents séparés | `---` est coloré, mais rien n'est réinitialisé ; rien dans la coloration ne dépend des frontières de documents |
Si un mot nu est une chaîne ou un nombre pour un parseur | `1.2.3` est une version pour un lecteur et une chaîne pour YAML ; le scanner colore ce à quoi cela ressemble |
171## Markdown
Reconnu | Comme |
--- | --- |
`# Titre` … `###### Titre` | toute la ligne comme titre |
`**gras**`, `__gras__`, `*italique*`, `_italique_` | emphase |
`` `code` `` | chaîne |
`[texte](cible)`, `![alt](src)` | le tout comme lien |
`- `, `* `, `+ `, `1. `, `1) ` | le marqueur comme ponctuation |
`>` | ponctuation |
`---`, `***`, `___` | ponctuation |
les clôtures ` ``` ` et `~~~` | tout le bloc, lignes d'ouverture et de fermeture comprises, comme chaîne |
184Un bloc clôturé est **d'une seule couleur quel que soit le langage annoncé** : ```` ```golo ```` ne colore pas son contenu comme du Golo. La suite de marqueurs qui ouvre un bloc doit être fermée par le même caractère, une clôture en accents graves n'est donc pas fermée par une en tildes. Une clôture non fermée colore jusqu'à la fin du fichier.
186La suite de marqueurs ouvrant une emphase doit être fermée par une suite de même longueur, `**gras**` est donc une portée plutôt que deux italiques.
188## JavaScript
Reconnu | Comme |
--- | --- |
`const`, `let`, `function`, `class`, `async`, `await`, `import`, `export`, … | mot-clé |
`true`, `false`, `null`, `undefined`, `NaN`, `Infinity`, `this` | constante |
`console`, `document`, `window`, `Array`, `Object`, `Promise`, `Math`, `JSON`, … | builtin |
un nom immédiatement avant `(` | fonction |
`"…"`, `'…'` | chaîne |
`` `…` ``, interpolations comprises, sur plusieurs lignes | chaîne |
`//` jusqu'à la fin de ligne, `/* … */` sur plusieurs lignes | commentaire |
`42`, `3.14`, `0x1f`, `0b1010`, `0o777`, `1_000_000`, `1e6`, `10n` | nombre |
les suites de `+-*/%=<>!&|^~?:` | opérateur |
`()[]{},;.` | ponctuation |
203**Les littéraux d'expressions régulières ne sont pas reconnus.** Distinguer `/x/g` d'une division demande de savoir si le token précédent pouvait terminer une expression ; une mauvaise supposition colore le reste d'une ligne comme une chaîne, ce qui est pire que de laisser une regex de la couleur d'un opérateur.
205Les globales sont reconnues par leur nom, un fichier qui masque `Math` le voit donc toujours coloré comme builtin — la même règle que suivent ici les builtins de Golo.
Reconnu | Comme |
--- | --- |
`<tag`, `</tag`, `>`, `/>` | balise |
les noms d'attributs, dont `data-*`, `xlink:href`, `@click`, `v-bind.prop` | attribut |
`=` | opérateur |
`"…"`, `'…'` | chaîne |
`<!-- … -->`, sur plusieurs lignes | commentaire |
`&amp;`, `&#169;` | constante |
`<!DOCTYPE …>` et les autres déclarations | mot-clé |
219Le texte entre les balises n'est pas coloré. Un `&` nu sans `;` dans les 32 caractères est laissé tranquille, parce que c'est du texte légal.
221**Le contenu de `<script>` et `<style>` n'est pas coloré** comme du JavaScript et du CSS.
225Son propre scanner plutôt que celui de HTML, pour une raison qui compte : CDATA. Tout l'intérêt de `<![CDATA[ … ]]>` est que son contenu n'est *pas* du balisage, et colorer les balises qu'il contient comme des balises est exactement à l'envers.
Reconnu | Comme |
--- | --- |
`<?xml version="1.0"?>` et les autres instructions de traitement | la cible et `?>` comme mot-clé, les paires entre elles comme attributs et chaînes |
`<!DOCTYPE …>` et les autres formes `<!` | mot-clé |
`<!-- … -->`, sur plusieurs lignes | commentaire |
`<![CDATA[ … ]]>`, sur plusieurs lignes | chaîne |
`<tag`, `</tag`, `>`, `/>` | balise |
`<ns:tag>`, `xsi:type` | le préfixe et le nom local en **une** portée |
les noms d'attributs | attribut |
`=` | opérateur |
`"…"`, `'…'` | chaîne |
`&amp;`, `&#169;` | constante |
240**Un commentaire et une section CDATA se ferment sur des délimiteurs différents**, et sont portés séparément : un `-->` dans une section CDATA ne la termine pas.
242**Un `&` nu sans point-virgule dans les 32 caractères est laissé tranquille**, parce que c'est du texte légal dans bien des documents et qu'avaler le reste de la ligne serait la plus grosse erreur.
244Le texte entre les balises n'est pas coloré.
246
248Vaut pour `sh`, `bash` et `zsh` : les mots-clés reconnus sont ceux qu'ils partagent.
Reconnu | Comme |
--- | --- |
`if`, `then`, `fi`, `for`, `while`, `case`, `esac`, `function`, `return`, … | mot-clé |
`true`, `false` | constante |
`echo`, `printf`, `export`, `local`, `read`, `cd`, `set`, `source`, … | builtin |
`$NAME`, `${…}`, `$(…)`, `$1`, `$?`, `$@` | builtin |
le **premier mot nu d'une ligne** | fonction |
chaque mot nu suivant, et `NAME` dans `NAME=valeur` | identifiant |
`'…'`, sans rien d'échappé ni de développé dedans | chaîne |
`"…"`, avec les expansions dedans colorées comme des expansions | chaîne |
`#` jusqu'à la fin de ligne | commentaire |
262`$(a $(b) c)` est une seule portée : l'imbrication est comptée. Une option comme `-euo` est un seul mot, pas un moins et un mot.
264**Les heredocs ne sont pas reconnus.** `<<EOF` et le texte qui suit sont colorés comme du shell ordinaire.
266## Dockerfile
Reconnu | Comme |
--- | --- |
`FROM`, `RUN`, `COPY`, `ADD`, `ARG`, `ENV`, `CMD`, `ENTRYPOINT`, `EXPOSE`, `LABEL`, `USER`, `VOLUME`, `WORKDIR`, `HEALTHCHECK`, `ONBUILD`, `SHELL`, `STOPSIGNAL`, `MAINTAINER` | mot-clé, quelle que soit la casse |
`AS`, `NONE` | mot-clé |
`# commentaire`, y compris les directives `# syntax=` et `# escape=` | commentaire |
`--from=builder`, `--chown=me:me` | le nom de l'option comme attribut |
`$NAME`, `${NAME}`, `${NAME:-default}` | builtin, en une portée jusqu'à l'accolade fermante |
`"…"`, `'…'` | chaîne |
un `\` final | opérateur |
les nombres | nombre |
les chemins et références d'images — `/usr/local/bin`, `golang:1.26-alpine` | identifiant, en **une** portée |
280**Seul le premier mot d'une ligne peut être une instruction**, et un mot qui n'en est pas une est un argument — ce qui garde le premier mot d'une ligne de continuation hors de la couleur des mots-clés.
282**Rien ne franchit une ligne.** Un `\` joint deux lignes pour Docker, mais chaque moitié se lit toujours comme une commande et est colorée seule.
Non reconnu | Parce que |
--- | --- |
Le shell dans un `RUN` | Il faudrait lancer le scanner shell sur une partie de ligne et reporter ses colonnes, et `RUN` peut contenir n'importe quel langage |
Les heredocs dans un `RUN` | La même raison que pour le scanner shell |
Quelle étape un `--from` nomme | Rien ici ne lit le reste du fichier |
290## Voir aussi
292- [Format des fichiers de thème](themes.md) — chaque clé vers laquelle ces classes résolvent
293- [Coloration et complétion](../explanation/colouring-and-completion.md) — pourquoi les scanners sont écrits ainsi
294- [Écrire son propre thème](../how-to/write-a-theme.md)