# Lancer des commandes Golo depuis l'éditeur

Ce guide montre comment exécuter, tester, déboguer et compiler vos scripts sans quitter Turbo Golo. Il suppose que l'éditeur est installé et que vous avez un répertoire contenant un fichier `.golo`.

## Obtenir un fichier de départ

Lancez l'éditeur **depuis le répertoire où vivent vos scripts**, puis choisissez **Golo ▸ Create tools file** (`Alt-G`, puis `C`).

Cela écrit `.turbo-golo/tools.toml` avec les commandes qu'un programmeur Golo lance le plus, et l'ouvre. Les trois premières :

```toml
[[tool]]
name = "~R~un"
# The interpreter, on the file you name. A terminal, not a popup: a script that
# reads the keyboard has to be able to be answered, and one that runs long has
# to be able to be interrupted.
command = "golo {{script, e.g. main.golo}}"
output = "terminal"

[[tool]]
name = "~T~est"
# Every *_test.golo under the current directory, with gololang.Testing.
command = "golo --test"
output = "popup"

[[tool]]
name = "Test ~o~ne"
command = "golo --test {{test file or directory}}"
output = "popup"
```

Chaque `[[tool]]` devient une ligne du menu **Golo**, dans l'ordre d'apparition — sauf s'il nomme un `menu` à lui, ce qu'une section plus bas couvre. Le fichier est lu à chaque ouverture du menu, une modification prend donc effet immédiatement.

## En lancer une

`Alt-G`, puis la lettre entre les tildes — `R` pour exécuter, `T` pour tester.

**Run** demande d'abord, parce que Golo n'a pas de manifeste qui dise quel fichier est le programme :

```
┌──────────────── Run ────────────────┐
│  script, e.g. main.golo             │
│  [                               ]  │
└─────────────────────────────────────┘
```

Tapez `main.golo` et appuyez sur `Entrée`. Une fenêtre de terminal s'ouvre et le script s'y exécute ; quand il finit la fenêtre reste, montrant ce qu'il a imprimé. Appuyez sur `Ctrl-W` pour la fermer. Relancez-le et la boîte se souvient du nom pour le reste de la session.

**Test** ouvre aussitôt un **popup**, qui se remplit pendant que la commande tourne. Son titre porte la commande et, une fois finie, comment cela s'est passé :

```
┌──────────────── golo --test — ok ─────────────────┐
│  🧪 Running Golo tests...                          │
│                                                    │
│  📝 shapes_test.golo                               │
│    ✓ a point describes itself                      │
│    ✅ 1 test(s) passed                             │
│                                                    │
│                     [ Close ]                      │
└────────────────────────────────────────────────────┘
```

| Touche | Effet |
| --- | --- |
| `↑` `↓` `PgUp` `PgDn` `Home` `End` | Parcourir la sortie |
| `Échap` | Le fermer — et **arrêter la commande** si elle tourne encore |
| `Entrée` | Le fermer |

Une commande qui a réussi en silence affiche `(no output)` plutôt qu'une boîte vide, pour qu'on la distingue d'une commande qui n'a pas démarré.

## Le reste du menu

| Entrée | Ce qu'elle lance | Où |
| --- | --- | --- |
| **Debug** | `golo --debug <script>` — l'interpréteur avec son débogueur pas à pas | un terminal, parce que le débogueur lit le clavier |
| **REPL** | `golo` — la boucle lire-évaluer-imprimer | un terminal |
| **New script** | `golo new main --module <nom> --name <fichier>` — un programme de départ tiré du modèle de GoloScript | un popup ; le nouveau fichier apparaît dans l'arbre du projet |
| **Build native** | `gogolo build -o <sortie> <script>` — Golo → Go → un exécutable natif | un popup ; il faut l'outillage Go |
| **Build wasm** | `wagolo build -target=<wasi\|js\|wasip2> -o <sortie.wasm> <script>` — Golo → Go → TinyGo → WebAssembly | un popup ; il faut TinyGo, et `wasm-tools` pour `wasip2` |

`Build native` peut prendre du temps : il lance le compilateur Go. Le popup est modal, pendant qu'il tourne vous ne pouvez taper nulle part ailleurs ; `Échap` le ferme et arrête la compilation.

## Choisir où va la sortie

Réglez `output` sur un outil :

| `output` | Ce que vous obtenez |
| --- | --- |
| `popup` | Un dialogue qui se remplit pendant l'exécution. Le défaut. |
| `terminal` | Une fenêtre de terminal : les couleurs, `Ctrl-C`, et le clavier atteint le programme |
| `editor` | Une fenêtre d'édition une fois fini, pour fouiller avec `Ctrl-F` |

`Run`, `Debug` et `REPL` sont en `terminal` dans le fichier de départ, et ils sont l'exemple de la raison d'être de la clé : un popup ne peut pas répondre à un script qui appelle `readln`, ne peut pas être interrompu par `Ctrl-C` pendant qu'`httpServe` écoute, et ne peut pas du tout être un REPL.

Prenez `editor` quand la sortie est quelque chose à parcourir — le source Go que `gogolo transpile main.golo` imprime, ou un long rapport de tests que vous voulez fouiller.

## Une commande longue retient l'éditeur

Un popup est modal : pendant que `gogolo build` tourne, vous ne pouvez taper nulle part ailleurs. `Échap` le ferme et arrête la commande.

Si cela gêne pour une commande donnée, donnez-lui `output = "terminal"` — la fenêtre est une fenêtre ordinaire et vous pouvez continuer à travailler à côté. C'est à cela que sert la clé configurable.

## Ce qui arrive à vos fichiers ouverts

Golo n'a pas de formateur, rien dans le fichier de départ ne réécrit donc le fichier que vous regardez. Mais `New script` écrit un nouveau fichier dans le répertoire, `gogolo build -keep-go` laisse un `.go` à côté de votre script, et un outil à vous peut faire n'importe quoi. Quand une commande se termine, l'éditeur **relit tous les fichiers ouverts qui n'ont pas de modifications non enregistrées**, un fichier qu'une autre commande a changé apparaît donc tel qu'il est désormais, et l'arbre du projet est rafraîchi pour qu'un nouveau fichier s'y montre. La barre d'état dit combien.

Un fichier avec des modifications non enregistrées est **laissé tranquille**, et la barre d'état le dit aussi :

```
Reloaded 2 files; 1 file with unsaved changes left alone
```

C'est délibéré : votre modification et la commande sont réellement en désaccord, et ce n'est pas à l'éditeur de décider qui l'emporte. Enregistrez d'abord (`F2`) et relancez la commande, ou continuez à éditer.

## Ajouter vos propres commandes

Éditez `.turbo-golo/tools.toml`. Une commande va à `sh -c`, une entrée peut donc être une séquence entière :

```toml
[[tool]]
name = "Test and ~b~uild"
command = "golo --test && gogolo build -o bin/app main.golo"
output = "popup"

[[tool]]
name = "~T~ranspile"
command = "gogolo transpile {{script, e.g. main.golo}}"
output = "editor"

[[tool]]
name = "Run in ~D~ocker"
command = "docker run --rm -v \"$PWD:/app\" -w /app k33g/gololang:latest /golo ./{{script}}"
output = "terminal"
```

Donnez à chacune une touche chaude entre tildes, et gardez-les distinctes — le menu répond à la première correspondance qu'il trouve.

## Mettre un outil dans un menu à lui

Un outil qui n'a rien à voir avec Golo n'a pas sa place dans le menu Golo. Donnez-lui un `menu` :

```toml
[[tool]]
name = "~E~cho"
command = "echo TADA"
output = "terminal"
menu = "Tools"

[[tool]]
name = "~U~p"
command = "docker compose up -d"
menu = "Docker"

[[tool]]
name = "~D~own"
command = "docker compose down"
menu = "Docker"
```

Cela vous donne un menu **Tools** et un menu **Docker** sur la barre, entre Golo et Help, dans l'ordre où les noms apparaissent pour la première fois dans le fichier. Docker contient ses deux outils. Rien à redémarrer : enregistrez le fichier et la barre suit.

Le nom est à vous — il n'y a pas de liste où choisir. Omettez `menu` et l'outil reste dans Golo, où sont huit des neuf commandes de départ.

### La touche chaude est choisie pour vous

Vous ne pouvez pas savoir, en écrivant le fichier, quelles lettres les menus propres de l'éditeur ont prises. Il le calcule donc : la première lettre du nom que rien d'autre ne revendique reçoit les tildes.

`Tools` obtient `Alt-T`, parce que `T` est libre. Un menu appelé `Format` obtiendrait `Alt-A`, parce que `F` est à File, `o` à Options et `r` à Run. Un menu appelé `Go` n'obtiendrait aucune touche du tout — `G` est à Golo et `O` à Options — et `F10` serait le chemin vers lui.

Écrivez les tildes vous-même — `menu = "Doc~k~er"` — et une lettre libre est conservée. Une lettre prise ne l'est pas : la barre répond au *premier* menu qui correspond à une touche, honorer votre choix rendrait donc l'un des deux menus inatteignable. Il choisit une autre lettre et ne dit rien.

## Variantes

- **Vous avez un seul script et jamais un autre.** Remplacez `golo {{script, e.g. main.golo}}` par `golo main.golo`, et la boîte cesse d'apparaître. Le champ est là parce qu'un fichier de départ ne peut pas savoir quel fichier est le programme.
- **Vous avez lancé l'éditeur depuis un sous-répertoire.** Les commandes s'y exécutent, et les chemins relatifs dans la boîte sont relatifs à lui. Partez du répertoire où sont les scripts.
- **Le fichier contient une erreur.** Le menu affiche un `Cannot read tools` grisé à la place des commandes, et **Create tools file** est toujours là.
- **`gogolo` ou `wagolo` n'est pas installé.** Le popup affiche `command not found` et `— exit 127`, ce qu'un shell aurait dit. L'`install.sh` de GoloScript installe les trois binaires ensemble ; un téléchargement de release en donne un à la fois.
- **Vous voulez un menu du nom d'un qui existe.** `menu = "File"` vous donne un second menu File, plus loin sur la barre, avec une autre touche chaude. Rien ne l'empêche ; rien ne le recommande non plus.
- **Votre menu n'a pas de touche chaude.** Toutes les lettres de son nom étaient déjà prises. `F10` et les flèches l'atteignent, et la souris aussi. Renommez-le avec une lettre libre.
- **Vous avez mal orthographié la valeur d'`output`.** Tout le fichier est refusé et le menu dit `Cannot read tools`, en nommant l'outil et en listant ce que la valeur aurait pu être. Un repli silencieux aurait envoyé la sortie quelque part où vous ne l'aviez pas demandée.

## Demander une valeur à l'exécution

Six des commandes de départ le font déjà. Le motif est un `{{libellé}}` là où va la valeur :

```toml
[[tool]]
name = "~N~ew script"
command = "golo new main --module {{module name, e.g. hello.World}} --name {{file name without .golo}}"
output = "popup"
```

La choisir ouvre une boîte titrée **New script** avec deux champs, un par `{{…}}`, dans leur ordre d'apparition. **Tab** passe de l'un à l'autre, **Entrée** lance la commande. Échap, et rien ne se lance.

La valeur est citée, un chemin avec un espace reste donc un seul argument.

### Un champ pour plusieurs arguments

Citer est faux quand on veut dire « mets ceci à la fin ». Ajoutez `...` dans les accolades et la valeur passe telle quelle :

```toml
[[tool]]
name = "Run with ~a~rguments"
command = "golo main.golo {{arguments...}}"
output = "terminal"
```

Tapez `--verbose input.txt` et les deux atteignent le script comme des arguments séparés — `args` dans `function main = |args|` les contient.

### La même valeur deux fois

Écrivez le libellé deux fois ; on vous la demande une fois :

```toml
[[tool]]
name = "~C~ompile and run"
command = "gogolo build -o /tmp/app {{script}} && /tmp/app"
```

### Variantes

- **La valeur est la même la plupart du temps.** Lancez une fois et la boîte se souvient de ce que vous avez tapé, pour le reste de la session. Ce n'est pas écrit sur le disque.
- **Votre commande a déjà des accolades.** `awk '{print $1}'` et `find . -exec rm {} +` sont laissés tranquilles : seules les doubles accolades demandent quelque chose.
- **La commande demande plus de valeurs qu'il n'en tient à l'écran.** L'éditeur le dit plutôt que d'ouvrir une boîte dont le bouton OK est sous le bas du terminal. Agrandissez le terminal, ou coupez la commande en deux outils.

## Voir aussi

- Chaque clé du fichier et chaque règle : [Référence des outils Golo](../reference/golo-tools.md)
- Pourquoi Run vient en premier, et pourquoi un fichier non modifié se recharge : [Outils Golo](../explanation/golo-tools.md)
- Les fenêtres dans lesquelles les commandes tournent : [Fenêtres de terminal](../reference/terminal.md)