# Lancer les commandes go depuis l'éditeur

Ce guide montre comment formater, vérifier, compiler, tester et exécuter votre projet sans quitter Turbo Go. Il suppose l'éditeur installé et un projet Go sous la main.

## Obtenir un fichier de départ

Lancez l'éditeur **depuis le dossier du projet**, puis choisissez **Go ▸ Create tools file** (`Alt-G`, puis `C`).

Cela écrit `.turbo-go/tools.toml` avec les cinq commandes qu'un projet Go passe avant de commiter, et l'ouvre :

```toml
[[tool]]
name = "~F~ormat"
command = "gofmt -l -w ."
output = "popup"

[[tool]]
name = "~T~est"
command = "go test ./..."
output = "popup"

[[tool]]
name = "~R~un"
command = "go run ."
# Un terminal, pas une popup : un programme qui lit le clavier doit pouvoir
# recevoir une réponse, et un programme long doit pouvoir être interrompu.
output = "terminal"
```

Chaque `[[tool]]` devient une ligne du menu **Go**, dans l'ordre du fichier — sauf s'il nomme un `menu` à lui, ce que couvre la section suivante mais une. Le fichier est relu à **chaque ouverture du menu** : une modification prend effet immédiatement.

## En lancer une

`Alt-G`, puis la lettre entre les tildes — `F` pour formater, `T` pour tester.

Une **popup** s'ouvre aussitôt et se remplit à mesure. Son titre porte la commande et, une fois terminée, son issue :

```
┌──────────── go vet ./... — exit 1 ────────────┐
│  main.go:6:2: unreachable code                │
│                                               │
│                   [ Close ]                   │
└───────────────────────────────────────────────┘
```

| Touche | Effet |
| --- | --- |
| `↑` `↓` `Page↑` `Page↓` `Début` `Fin` | Parcourir la sortie |
| `Échap` | Fermer — et **arrêter la commande** si elle tourne encore |
| `Entrée` | Fermer |

Une commande qui a réussi sans rien dire affiche `(no output)` plutôt qu'une boîte vide : on la distingue ainsi d'une commande qui n'a pas démarré.

La popup suit la sortie tant que vous n'avez pas remonté ; ensuite elle vous laisse où vous êtes.

## Choisir où va la sortie

Posez `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 terminal : couleurs, `Ctrl-C`, et le clavier atteint le programme |
| `editor` | Une fenêtre d'édition une fois terminé, à fouiller avec `Ctrl-F` |

`Run` est en `terminal` dans le fichier de départ, et c'est l'exemple même de pourquoi la clé existe : une popup ne peut pas répondre à un programme qui lit le clavier, ni être interrompue par `Ctrl-C`.

Prenez `editor` quand la sortie est quelque chose à éplucher — un long `go test -v`, ou un rapport de couverture à parcourir.

## Une commande longue immobilise l'éditeur

Une popup est modale : pendant que `go build` tourne, vous ne pouvez taper nulle part ailleurs. `Échap` la ferme et arrête la commande.

Si cela gêne pour une commande précise, donnez-lui `output = "terminal"` — la fenêtre est ordinaire et vous continuez à travailler à côté. C'est précisément l'intérêt d'avoir rendu la clé configurable.

## Ce qui arrive à vos fichiers ouverts

`Format` réécrit les fichiers sur le disque — y compris celui que vous regardez. À la fin d'une commande, l'éditeur **relit tout fichier ouvert n'ayant aucune modification non enregistrée** : la version formatée apparaît sans que vous ayez rien à faire. La barre d'état dit combien.

Un fichier ayant des modifications non enregistrées est **laissé tel quel**, 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 le formateur sont réellement en désaccord, et l'éditeur n'est pas celui qui doit trancher. Enregistrez d'abord (`F2`) puis relancez la commande, ou continuez à éditer et formatez plus tard.

## Ajouter vos propres commandes

Éditez `.turbo-go/tools.toml`. Une commande passe par `sh -c`, donc une seule entrée peut être toute une séquence :

```toml
[[tool]]
name = "~C~heck"
command = "gofmt -l -w . && go vet ./... && go test ./..."
output = "popup"

[[tool]]
name = "Tid~y~"
command = "go mod tidy"
output = "popup"

[[tool]]
name = "Cover~a~ge"
command = "go test -coverprofile=cover.out ./... && go tool cover -func=cover.out"
output = "editor"
```

Donnez à chacune une touche d'accès avec des tildes, et gardez-les distinctes — le menu répond à la première correspondance trouvée.

## Mettre un outil dans un menu à lui

Un outil qui n'a rien à voir avec Go n'a rien à faire dans le menu Go. 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"
```

Vous obtenez un menu **Tools** et un menu **Docker** sur la barre, entre Go 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 vous appartient — il n'y a pas de liste où piocher. Omettez `menu` et l'outil reste dans Go, où sont les cinq commandes de départ.

### La touche d'accès est choisie pour vous

Vous ne pouvez pas savoir, en écrivant le fichier, quelles lettres les menus de l'éditeur occupent déjà. Il s'en charge : la première lettre du nom que rien d'autre ne revendique reçoit les tildes.

`Tools` obtient `Alt-T`. `Format` obtient `Alt-M`, parce que `F` est à File, `o` à Options et `r` à Run.

É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 correspondant à une touche, donc honorer votre choix rendrait l'un des deux menus inatteignable. Elle en choisit une autre, sans rien dire.

## Variantes

- **Vous préférez `golangci-lint` à `go vet`.** Changez la commande `Lint`. `go vet` est le défaut parce qu'il fait partie de la chaîne d'outils et n'est jamais absent ; tout le reste s'installe.
- **Vous avez lancé l'éditeur depuis un sous-dossier.** Les commandes s'y exécutent, donc `./...` ne couvre que ce sous-arbre. Lancez depuis la racine du projet.
- **Le fichier contient une erreur.** Le menu affiche un `Cannot read tools` grisé à la place des commandes, et **Create tools file** reste là.
- **Une commande n'est pas installée.** La popup affiche `command not found` et `— exit 127`, ce qu'un shell aurait dit.
- **Vous voulez un menu portant le nom d'un menu existant.** `menu = "File"` vous donne un second menu File, plus loin sur la barre, avec une autre touche d'accès. Rien ne l'empêche ; rien ne le recommande non plus.
- **Votre menu n'a pas de touche d'accès.** Toutes les lettres de son nom étaient déjà prises. `F10` et les flèches y accèdent, 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 affiche `Cannot read tools`, en nommant l'outil et en listant les valeurs possibles. Un repli silencieux aurait envoyé la sortie ailleurs que là où vous l'aviez demandée.

## Demander une valeur au lancement

Certaines commandes ont besoin de quelque chose de saisi à chaque fois : un chemin de module, un nom de caisse, un test à filtrer. Mettez un `{{libellé}}` à l'endroit où la valeur va :

```toml
[[tool]]
name = "~I~nit module"
command = "go mod init {{module path}}"
output = "popup"
```

Choisir cette entrée ouvre une boîte intitulée **Init module** avec un champ, libellé `module path`. Tapez la valeur et appuyez sur Entrée ; la commande se lance avec. Échap, et rien ne se lance.

La valeur est protégée, si bien qu'un chemin contenant une espace reste un seul argument.

### Plusieurs valeurs à la fois

Un champ chacune, dans l'ordre où elles apparaissent :

```toml
[[tool]]
name = "~C~opy"
command = "cp {{from}} {{to}}"
```

**Tab** passe d'un champ à l'autre, **Entrée** lance.

### Un champ valant plusieurs arguments

La protection est le mauvais choix quand on veut dire « ajoute ces options à la fin ». Ajoutez `...` à l'intérieur des accolades et la valeur passe telle quelle :

```toml
[[tool]]
name = "Test ~o~ne"
command = "go test {{extra flags...}} ./..."
```

Tapez `-run TestParse -v` et le tout atteint la commande sous forme d'arguments séparés.

### La même valeur deux fois

Écrivez le libellé deux fois ; on ne vous le demande qu'une :

```toml
[[tool]]
name = "~N~ew directory"
command = "mkdir {{name}} && cd {{name}}"
```

### Variantes

- **La valeur est souvent la même.** Lancez-le une fois et la boîte retient ce que vous avez tapé, pour le reste de la session. Rien n'est écrit sur le disque.
- **Votre commande contient 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 que l'écran n'en contient.** 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

- Toutes les clés du fichier et toutes les règles : [Référence des outils go](../reference/go-tools.md)
- Pourquoi chaque commande a sa fenêtre terminal, et pourquoi un fichier non modifié se recharge : [Outils go](../explanation/go-tools.md)
- Les fenêtres dans lesquelles les commandes tournent : [Fenêtres terminal](../reference/terminal.md)