| 📦 Turbo Go 3d7798b k33g 13h ago | 1 | # Lancer les commandes go depuis l'éditeur |
| 2 | |
| 3 | 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. |
| 4 | |
| 5 | ## Obtenir un fichier de départ |
| 6 | |
| 7 | Lancez l'éditeur **depuis le dossier du projet**, puis choisissez **Go ▸ Create tools file** (`Alt-G`, puis `C`). |
| 8 | |
| 9 | Cela écrit `.turbo-go/tools.toml` avec les cinq commandes qu'un projet Go passe avant de commiter, et l'ouvre : |
| 10 | |
| 11 | ```toml |
| 12 | [[tool]] |
| 13 | name = "~F~ormat" |
| 14 | command = "gofmt -l -w ." |
| 15 | output = "popup" |
| 16 | |
| 17 | [[tool]] |
| 18 | name = "~T~est" |
| 19 | command = "go test ./..." |
| 20 | output = "popup" |
| 21 | |
| 22 | [[tool]] |
| 23 | name = "~R~un" |
| 24 | command = "go run ." |
| 25 | # Un terminal, pas une popup : un programme qui lit le clavier doit pouvoir |
| 26 | # recevoir une réponse, et un programme long doit pouvoir être interrompu. |
| 27 | output = "terminal" |
| 28 | ``` |
| 29 | |
| 30 | 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. |
| 31 | |
| 32 | ## En lancer une |
| 33 | |
| 34 | `Alt-G`, puis la lettre entre les tildes — `F` pour formater, `T` pour tester. |
| 35 | |
| 36 | Une **popup** s'ouvre aussitôt et se remplit à mesure. Son titre porte la commande et, une fois terminée, son issue : |
| 37 | |
| 38 | ``` |
| 39 | ┌──────────── go vet ./... — exit 1 ────────────┐ |
| 40 | │ main.go:6:2: unreachable code │ |
| 41 | │ │ |
| 42 | │ [ Close ] │ |
| 43 | └───────────────────────────────────────────────┘ |
| 44 | ``` |
| 45 | |
| 46 | | Touche | Effet | |
| 47 | | --- | --- | |
| 48 | | `↑` `↓` `Page↑` `Page↓` `Début` `Fin` | Parcourir la sortie | |
| 49 | | `Échap` | Fermer — et **arrêter la commande** si elle tourne encore | |
| 50 | | `Entrée` | Fermer | |
| 51 | |
| 52 | 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é. |
| 53 | |
| 54 | La popup suit la sortie tant que vous n'avez pas remonté ; ensuite elle vous laisse où vous êtes. |
| 55 | |
| 56 | ## Choisir où va la sortie |
| 57 | |
| 58 | Posez `output` sur un outil : |
| 59 | |
| 60 | | `output` | Ce que vous obtenez | |
| 61 | | --- | --- | |
| 62 | | `popup` | Un dialogue qui se remplit pendant l'exécution. Le défaut. | |
| 63 | | `terminal` | Une fenêtre terminal : couleurs, `Ctrl-C`, et le clavier atteint le programme | |
| 64 | | `editor` | Une fenêtre d'édition une fois terminé, à fouiller avec `Ctrl-F` | |
| 65 | |
| 66 | `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`. |
| 67 | |
| 68 | Prenez `editor` quand la sortie est quelque chose à éplucher — un long `go test -v`, ou un rapport de couverture à parcourir. |
| 69 | |
| 70 | ## Une commande longue immobilise l'éditeur |
| 71 | |
| 72 | Une popup est modale : pendant que `go build` tourne, vous ne pouvez taper nulle part ailleurs. `Échap` la ferme et arrête la commande. |
| 73 | |
| 74 | 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. |
| 75 | |
| 76 | ## Ce qui arrive à vos fichiers ouverts |
| 77 | |
| 78 | `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. |
| 79 | |
| 80 | Un fichier ayant des modifications non enregistrées est **laissé tel quel**, et la barre d'état le dit aussi : |
| 81 | |
| 82 | ``` |
| 83 | Reloaded 2 files; 1 file with unsaved changes left alone |
| 84 | ``` |
| 85 | |
| 86 | 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. |
| 87 | |
| 88 | ## Ajouter vos propres commandes |
| 89 | |
| 90 | Éditez `.turbo-go/tools.toml`. Une commande passe par `sh -c`, donc une seule entrée peut être toute une séquence : |
| 91 | |
| 92 | ```toml |
| 93 | [[tool]] |
| 94 | name = "~C~heck" |
| 95 | command = "gofmt -l -w . && go vet ./... && go test ./..." |
| 96 | output = "popup" |
| 97 | |
| 98 | [[tool]] |
| 99 | name = "Tid~y~" |
| 100 | command = "go mod tidy" |
| 101 | output = "popup" |
| 102 | |
| 103 | [[tool]] |
| 104 | name = "Cover~a~ge" |
| 105 | command = "go test -coverprofile=cover.out ./... && go tool cover -func=cover.out" |
| 106 | output = "editor" |
| 107 | ``` |
| 108 | |
| 109 | Donnez à chacune une touche d'accès avec des tildes, et gardez-les distinctes — le menu répond à la première correspondance trouvée. |
| 110 | |
| 111 | ## Mettre un outil dans un menu à lui |
| 112 | |
| 113 | Un outil qui n'a rien à voir avec Go n'a rien à faire dans le menu Go. Donnez-lui un `menu` : |
| 114 | |
| 115 | ```toml |
| 116 | [[tool]] |
| 117 | name = "~E~cho" |
| 118 | command = "echo TADA" |
| 119 | output = "terminal" |
| 120 | menu = "Tools" |
| 121 | |
| 122 | [[tool]] |
| 123 | name = "~U~p" |
| 124 | command = "docker compose up -d" |
| 125 | menu = "Docker" |
| 126 | |
| 127 | [[tool]] |
| 128 | name = "~D~own" |
| 129 | command = "docker compose down" |
| 130 | menu = "Docker" |
| 131 | ``` |
| 132 | |
| 133 | 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. |
| 134 | |
| 135 | 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. |
| 136 | |
| 137 | ### La touche d'accès est choisie pour vous |
| 138 | |
| 139 | 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. |
| 140 | |
| 141 | `Tools` obtient `Alt-T`. `Format` obtient `Alt-M`, parce que `F` est à File, `o` à Options et `r` à Run. |
| 142 | |
| 143 | É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. |
| 144 | |
| 145 | ## Variantes |
| 146 | |
| 147 | - **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. |
| 148 | - **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. |
| 149 | - **Le fichier contient une erreur.** Le menu affiche un `Cannot read tools` grisé à la place des commandes, et **Create tools file** reste là. |
| 150 | - **Une commande n'est pas installée.** La popup affiche `command not found` et `— exit 127`, ce qu'un shell aurait dit. |
| 151 | - **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. |
| 152 | - **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. |
| 153 | - **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. |
| 154 | |
| 155 | ## Demander une valeur au lancement |
| 156 | |
| 157 | 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 : |
| 158 | |
| 159 | ```toml |
| 160 | [[tool]] |
| 161 | name = "~I~nit module" |
| 162 | command = "go mod init {{module path}}" |
| 163 | output = "popup" |
| 164 | ``` |
| 165 | |
| 166 | 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. |
| 167 | |
| 168 | La valeur est protégée, si bien qu'un chemin contenant une espace reste un seul argument. |
| 169 | |
| 170 | ### Plusieurs valeurs à la fois |
| 171 | |
| 172 | Un champ chacune, dans l'ordre où elles apparaissent : |
| 173 | |
| 174 | ```toml |
| 175 | [[tool]] |
| 176 | name = "~C~opy" |
| 177 | command = "cp {{from}} {{to}}" |
| 178 | ``` |
| 179 | |
| 180 | **Tab** passe d'un champ à l'autre, **Entrée** lance. |
| 181 | |
| 182 | ### Un champ valant plusieurs arguments |
| 183 | |
| 184 | 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 : |
| 185 | |
| 186 | ```toml |
| 187 | [[tool]] |
| 188 | name = "Test ~o~ne" |
| 189 | command = "go test {{extra flags...}} ./..." |
| 190 | ``` |
| 191 | |
| 192 | Tapez `-run TestParse -v` et le tout atteint la commande sous forme d'arguments séparés. |
| 193 | |
| 194 | ### La même valeur deux fois |
| 195 | |
| 196 | Écrivez le libellé deux fois ; on ne vous le demande qu'une : |
| 197 | |
| 198 | ```toml |
| 199 | [[tool]] |
| 200 | name = "~N~ew directory" |
| 201 | command = "mkdir {{name}} && cd {{name}}" |
| 202 | ``` |
| 203 | |
| 204 | ### Variantes |
| 205 | |
| 206 | - **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. |
| 207 | - **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. |
| 208 | - **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. |
| 209 | |
| 210 | ## Voir aussi |
| 211 | |
| 212 | - Toutes les clés du fichier et toutes les règles : [Référence des outils go](../reference/go-tools.md) |
| 213 | - Pourquoi chaque commande a sa fenêtre terminal, et pourquoi un fichier non modifié se recharge : [Outils go](../explanation/go-tools.md) |
| 214 | - Les fenêtres dans lesquelles les commandes tournent : [Fenêtres terminal](../reference/terminal.md) |