| 📦 Turbo Golo d710c1b k33g 20h ago | 1 | # Lancer des commandes Golo depuis l'éditeur |
| 2 | |
| 3 | 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`. |
| 4 | |
| 5 | ## Obtenir un fichier de départ |
| 6 | |
| 7 | Lancez l'éditeur **depuis le répertoire où vivent vos scripts**, puis choisissez **Golo ▸ Create tools file** (`Alt-G`, puis `C`). |
| 8 | |
| 9 | Cela écrit `.turbo-golo/tools.toml` avec les commandes qu'un programmeur Golo lance le plus, et l'ouvre. Les trois premières : |
| 10 | |
| 11 | ```toml |
| 12 | [[tool]] |
| 13 | name = "~R~un" |
| 14 | # The interpreter, on the file you name. A terminal, not a popup: a script that |
| 15 | # reads the keyboard has to be able to be answered, and one that runs long has |
| 16 | # to be able to be interrupted. |
| 17 | command = "golo {{script, e.g. main.golo}}" |
| 18 | output = "terminal" |
| 19 | |
| 20 | [[tool]] |
| 21 | name = "~T~est" |
| 22 | # Every *_test.golo under the current directory, with gololang.Testing. |
| 23 | command = "golo --test" |
| 24 | output = "popup" |
| 25 | |
| 26 | [[tool]] |
| 27 | name = "Test ~o~ne" |
| 28 | command = "golo --test {{test file or directory}}" |
| 29 | output = "popup" |
| 30 | ``` |
| 31 | |
| 32 | 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. |
| 33 | |
| 34 | ## En lancer une |
| 35 | |
| 36 | `Alt-G`, puis la lettre entre les tildes — `R` pour exécuter, `T` pour tester. |
| 37 | |
| 38 | **Run** demande d'abord, parce que Golo n'a pas de manifeste qui dise quel fichier est le programme : |
| 39 | |
| 40 | ``` |
| 41 | ┌──────────────── Run ────────────────┐ |
| 42 | │ script, e.g. main.golo │ |
| 43 | │ [ ] │ |
| 44 | └─────────────────────────────────────┘ |
| 45 | ``` |
| 46 | |
| 47 | 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. |
| 48 | |
| 49 | **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é : |
| 50 | |
| 51 | ``` |
| 52 | ┌──────────────── golo --test — ok ─────────────────┐ |
| 53 | │ 🧪 Running Golo tests... │ |
| 54 | │ │ |
| 55 | │ 📝 shapes_test.golo │ |
| 56 | │ ✓ a point describes itself │ |
| 57 | │ ✅ 1 test(s) passed │ |
| 58 | │ │ |
| 59 | │ [ Close ] │ |
| 60 | └────────────────────────────────────────────────────┘ |
| 61 | ``` |
| 62 | |
| 63 | | Touche | Effet | |
| 64 | | --- | --- | |
| 65 | | `↑` `↓` `PgUp` `PgDn` `Home` `End` | Parcourir la sortie | |
| 66 | | `Échap` | Le fermer — et **arrêter la commande** si elle tourne encore | |
| 67 | | `Entrée` | Le fermer | |
| 68 | |
| 69 | 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é. |
| 70 | |
| 71 | ## Le reste du menu |
| 72 | |
| 73 | | Entrée | Ce qu'elle lance | Où | |
| 74 | | --- | --- | --- | |
| 75 | | **Debug** | `golo --debug <script>` — l'interpréteur avec son débogueur pas à pas | un terminal, parce que le débogueur lit le clavier | |
| 76 | | **REPL** | `golo` — la boucle lire-évaluer-imprimer | un terminal | |
| 77 | | **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 | |
| 78 | | **Build native** | `gogolo build -o <sortie> <script>` — Golo → Go → un exécutable natif | un popup ; il faut l'outillage Go | |
| 79 | | **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` | |
| 80 | |
| 81 | `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. |
| 82 | |
| 83 | ## Choisir où va la sortie |
| 84 | |
| 85 | Réglez `output` sur un outil : |
| 86 | |
| 87 | | `output` | Ce que vous obtenez | |
| 88 | | --- | --- | |
| 89 | | `popup` | Un dialogue qui se remplit pendant l'exécution. Le défaut. | |
| 90 | | `terminal` | Une fenêtre de terminal : les couleurs, `Ctrl-C`, et le clavier atteint le programme | |
| 91 | | `editor` | Une fenêtre d'édition une fois fini, pour fouiller avec `Ctrl-F` | |
| 92 | |
| 93 | `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. |
| 94 | |
| 95 | 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. |
| 96 | |
| 97 | ## Une commande longue retient l'éditeur |
| 98 | |
| 99 | Un popup est modal : pendant que `gogolo build` tourne, vous ne pouvez taper nulle part ailleurs. `Échap` le ferme et arrête la commande. |
| 100 | |
| 101 | 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. |
| 102 | |
| 103 | ## Ce qui arrive à vos fichiers ouverts |
| 104 | |
| 105 | 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. |
| 106 | |
| 107 | Un fichier avec des modifications non enregistrées est **laissé tranquille**, et la barre d'état le dit aussi : |
| 108 | |
| 109 | ``` |
| 110 | Reloaded 2 files; 1 file with unsaved changes left alone |
| 111 | ``` |
| 112 | |
| 113 | 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. |
| 114 | |
| 115 | ## Ajouter vos propres commandes |
| 116 | |
| 117 | Éditez `.turbo-golo/tools.toml`. Une commande va à `sh -c`, une entrée peut donc être une séquence entière : |
| 118 | |
| 119 | ```toml |
| 120 | [[tool]] |
| 121 | name = "Test and ~b~uild" |
| 122 | command = "golo --test && gogolo build -o bin/app main.golo" |
| 123 | output = "popup" |
| 124 | |
| 125 | [[tool]] |
| 126 | name = "~T~ranspile" |
| 127 | command = "gogolo transpile {{script, e.g. main.golo}}" |
| 128 | output = "editor" |
| 129 | |
| 130 | [[tool]] |
| 131 | name = "Run in ~D~ocker" |
| 132 | command = "docker run --rm -v \"$PWD:/app\" -w /app k33g/gololang:latest /golo ./{{script}}" |
| 133 | output = "terminal" |
| 134 | ``` |
| 135 | |
| 136 | Donnez à chacune une touche chaude entre tildes, et gardez-les distinctes — le menu répond à la première correspondance qu'il trouve. |
| 137 | |
| 138 | ## Mettre un outil dans un menu à lui |
| 139 | |
| 140 | Un outil qui n'a rien à voir avec Golo n'a pas sa place dans le menu Golo. Donnez-lui un `menu` : |
| 141 | |
| 142 | ```toml |
| 143 | [[tool]] |
| 144 | name = "~E~cho" |
| 145 | command = "echo TADA" |
| 146 | output = "terminal" |
| 147 | menu = "Tools" |
| 148 | |
| 149 | [[tool]] |
| 150 | name = "~U~p" |
| 151 | command = "docker compose up -d" |
| 152 | menu = "Docker" |
| 153 | |
| 154 | [[tool]] |
| 155 | name = "~D~own" |
| 156 | command = "docker compose down" |
| 157 | menu = "Docker" |
| 158 | ``` |
| 159 | |
| 160 | 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. |
| 161 | |
| 162 | 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. |
| 163 | |
| 164 | ### La touche chaude est choisie pour vous |
| 165 | |
| 166 | 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. |
| 167 | |
| 168 | `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. |
| 169 | |
| 170 | É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. |
| 171 | |
| 172 | ## Variantes |
| 173 | |
| 174 | - **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. |
| 175 | - **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. |
| 176 | - **Le fichier contient une erreur.** Le menu affiche un `Cannot read tools` grisé à la place des commandes, et **Create tools file** est toujours là. |
| 177 | - **`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. |
| 178 | - **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. |
| 179 | - **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. |
| 180 | - **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. |
| 181 | |
| 182 | ## Demander une valeur à l'exécution |
| 183 | |
| 184 | Six des commandes de départ le font déjà. Le motif est un `{{libellé}}` là où va la valeur : |
| 185 | |
| 186 | ```toml |
| 187 | [[tool]] |
| 188 | name = "~N~ew script" |
| 189 | command = "golo new main --module {{module name, e.g. hello.World}} --name {{file name without .golo}}" |
| 190 | output = "popup" |
| 191 | ``` |
| 192 | |
| 193 | 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. |
| 194 | |
| 195 | La valeur est citée, un chemin avec un espace reste donc un seul argument. |
| 196 | |
| 197 | ### Un champ pour plusieurs arguments |
| 198 | |
| 199 | Citer est faux quand on veut dire « mets ceci à la fin ». Ajoutez `...` dans les accolades et la valeur passe telle quelle : |
| 200 | |
| 201 | ```toml |
| 202 | [[tool]] |
| 203 | name = "Run with ~a~rguments" |
| 204 | command = "golo main.golo {{arguments...}}" |
| 205 | output = "terminal" |
| 206 | ``` |
| 207 | |
| 208 | Tapez `--verbose input.txt` et les deux atteignent le script comme des arguments séparés — `args` dans `function main = |args|` les contient. |
| 209 | |
| 210 | ### La même valeur deux fois |
| 211 | |
| 212 | Écrivez le libellé deux fois ; on vous la demande une fois : |
| 213 | |
| 214 | ```toml |
| 215 | [[tool]] |
| 216 | name = "~C~ompile and run" |
| 217 | command = "gogolo build -o /tmp/app {{script}} && /tmp/app" |
| 218 | ``` |
| 219 | |
| 220 | ### Variantes |
| 221 | |
| 222 | - **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. |
| 223 | - **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. |
| 224 | - **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. |
| 225 | |
| 226 | ## Voir aussi |
| 227 | |
| 228 | - Chaque clé du fichier et chaque règle : [Référence des outils Golo](../reference/golo-tools.md) |
| 229 | - Pourquoi Run vient en premier, et pourquoi un fichier non modifié se recharge : [Outils Golo](../explanation/golo-tools.md) |
| 230 | - Les fenêtres dans lesquelles les commandes tournent : [Fenêtres de terminal](../reference/terminal.md) |