| 🛟 Updated. 28d5985 k33g 6h ago | 1 | # Tutoriel : construire un éditeur Turbo pour votre propre langage |
| 2 | |
| 3 | À la fin de ce tutoriel, vous disposerez d'un IDE de terminal en plein écran — barre de menus, fenêtres déplaçables, souris, thèmes, arborescence de projet, fenêtres de terminal et coloration syntaxique — pour le langage de votre choix. Nous en construirons un pour **Zig**, et il fera environ quatre-vingts lignes de Go. |
| 4 | |
| 5 | Aucune connaissance de turbo-core n'est requise. Il vous faut Go 1.26 ou plus récent, et un terminal. |
| 6 | |
| 7 | ## Prérequis |
| 8 | |
| 9 | - Go 1.26 ou plus récent dans votre PATH. |
| 10 | - Une copie de turbo-core à côté de l'endroit où vous allez travailler. Si vous n'en avez pas : |
| 11 | |
| 12 | ```bash |
| 13 | git clone https://codeberg.org/turbo-editors/turbo-core.git |
| 14 | ``` |
| 15 | |
| 16 | ## Étape 1 — Créer le module |
| 17 | |
| 18 | À côté de votre copie de turbo-core, tapez : |
| 19 | |
| 20 | ```bash |
| 21 | mkdir turbo-zig && cd turbo-zig |
| 22 | go mod init example.com/turbo-zig |
| 23 | ``` |
| 24 | |
| 25 | Vous devriez voir : |
| 26 | |
| 27 | ``` |
| 28 | go: creating new go.mod: module example.com/turbo-zig |
| 29 | ``` |
| 30 | |
| 31 | Nous avons maintenant un module vide. Nous allons le brancher sur la bibliothèque. |
| 32 | |
| 33 | ## Étape 2 — Dépendre de turbo-core |
| 34 | |
| 35 | Tapez : |
| 36 | |
| 37 | ```bash |
| 38 | go mod edit -require=codeberg.org/turbo-editors/turbo-core@v0.1.0 |
| 39 | go mod edit -replace=codeberg.org/turbo-editors/turbo-core=../turbo-core |
| 40 | ``` |
| 41 | |
| 42 | Rien ne s'affiche. Regardez `go.mod` : |
| 43 | |
| 44 | ```bash |
| 45 | cat go.mod |
| 46 | ``` |
| 47 | |
| 48 | Vous devriez voir une ligne `require` et une ligne `replace` nommant turbo-core. C'est le `replace` qui fait que la copie posée à côté de vous est celle qui sera utilisée. |
| 49 | |
| 50 | ## Étape 3 — Dire quel éditeur c'est |
| 51 | |
| 52 | Créez `profile.go` : |
| 53 | |
| 54 | ```go |
| 55 | package main |
| 56 | |
| 57 | import "codeberg.org/turbo-editors/turbo-core/profile" |
| 58 | |
| 59 | // zig est l'éditeur que nous construisons. |
| 60 | func zig() profile.Profile { |
| 61 | return profile.Profile{ |
| 62 | Name: "Turbo Zig", |
| 63 | Slug: "turbo-zig", |
| 64 | Language: "Zig", |
| 65 | ToolsMenu: "~Z~ig", |
| 66 | RootMarkers: []string{"build.zig"}, |
| 67 | Server: profile.Server{ |
| 68 | Command: "zls", |
| 69 | InstallHint: "voir https://github.com/zigtools/zls", |
| 70 | }, |
| 71 | Templates: profile.Templates{ |
| 72 | Settings: settingsTemplate, |
| 73 | Snippets: snippetsTemplate, |
| 74 | Tools: toolsTemplate, |
| 75 | }, |
| 76 | } |
| 77 | } |
| 78 | ``` |
| 79 | |
| 80 | Voilà la totalité de ce qui distingue cet éditeur de Turbo Go. Nous n'avons pas encore écrit les modèles — c'est l'étape suivante. |
| 81 | |
| 82 | ## Étape 4 — Écrire les trois fichiers de départ |
| 83 | |
| 84 | Créez `templates.go` : |
| 85 | |
| 86 | ```go |
| 87 | package main |
| 88 | |
| 89 | const settingsTemplate = `# turbo-zig project settings. |
| 90 | |
| 91 | [editor] |
| 92 | |
| 93 | theme = %q |
| 94 | autosave = false |
| 95 | autosave_delay = %q |
| 96 | ` |
| 97 | |
| 98 | const snippetsTemplate = `# turbo-zig snippets. |
| 99 | # |
| 100 | # Un extrait sans groupe va dans %s. |
| 101 | # Les vôtres vivent dans : |
| 102 | # %s |
| 103 | |
| 104 | [[snippet]] |
| 105 | name = "TODO" |
| 106 | body = "TODO: " |
| 107 | ` |
| 108 | |
| 109 | const toolsTemplate = `# turbo-zig tools. |
| 110 | |
| 111 | [[tool]] |
| 112 | name = "~B~uild" |
| 113 | command = "zig build" |
| 114 | output = "popup" |
| 115 | |
| 116 | [[tool]] |
| 117 | name = "~T~est" |
| 118 | command = "zig build test" |
| 119 | output = "popup" |
| 120 | |
| 121 | [[tool]] |
| 122 | name = "~R~un" |
| 123 | command = "zig build run" |
| 124 | output = "terminal" |
| 125 | ` |
| 126 | ``` |
| 127 | |
| 128 | Les trous comptent : `settingsTemplate` prend le nom du thème puis le délai de sauvegarde automatique, `snippetsTemplate` prend le nom du groupe sans nom puis le chemin des extraits de l'utilisateur. La [référence Profile](../reference/profile.md) les donne exactement. |
| 129 | |
| 130 | ## Étape 5 — Écrire la commande |
| 131 | |
| 132 | Créez `main.go` : |
| 133 | |
| 134 | ```go |
| 135 | package main |
| 136 | |
| 137 | import ( |
| 138 | "context" |
| 139 | "fmt" |
| 140 | "os" |
| 141 | |
| 142 | "github.com/gdamore/tcell/v2" |
| 143 | |
| 144 | "codeberg.org/turbo-editors/turbo-core/app" |
| 145 | ) |
| 146 | |
| 147 | func main() { |
| 148 | if err := run(); err != nil { |
| 149 | fmt.Fprintln(os.Stderr, "turbo-zig:", err) |
| 150 | os.Exit(1) |
| 151 | } |
| 152 | } |
| 153 | |
| 154 | func run() error { |
| 155 | screen, err := tcell.NewScreen() |
| 156 | if err != nil { |
| 157 | return err |
| 158 | } |
| 159 | if err := screen.Init(); err != nil { |
| 160 | return err |
| 161 | } |
| 162 | defer screen.Fini() |
| 163 | screen.EnableMouse() |
| 164 | screen.EnablePaste() |
| 165 | |
| 166 | p := zig() |
| 167 | editor := app.New(screen, "turbo-classic", p) |
| 168 | |
| 169 | files := os.Args[1:] |
| 170 | if len(files) == 0 { |
| 171 | editor.NewFile() |
| 172 | } |
| 173 | for _, file := range files { |
| 174 | editor.Open(file) |
| 175 | } |
| 176 | |
| 177 | ctx, cancel := context.WithCancel(context.Background()) |
| 178 | defer cancel() |
| 179 | editor.StartLanguageServer(ctx, app.ProjectRoot(p, files)) |
| 180 | defer editor.Language().Stop(context.Background()) |
| 181 | |
| 182 | return editor.Run() |
| 183 | } |
| 184 | ``` |
| 185 | |
| 186 | ## Étape 6 — Le lancer |
| 187 | |
| 188 | Tapez : |
| 189 | |
| 190 | ```bash |
| 191 | go mod tidy |
| 192 | go run . main.go |
| 193 | ``` |
| 194 | |
| 195 | Votre terminal se remplit d'un bureau bleu. En haut, vous devriez lire : |
| 196 | |
| 197 | ``` |
| 198 | File Edit Search Run Options Window Snippets Zig Help |
| 199 | ``` |
| 200 | |
| 201 | et une fenêtre au milieu montrant `main.go`. Appuyez sur **F10** pour ouvrir la barre de menus, les flèches pour vous y déplacer, et **Alt-X** pour sortir. |
| 202 | |
| 203 | Nous avons un éditeur qui marche. Tout ce qui est sur cette barre fonctionne : **F3** ouvre un fichier, **F8** ouvre une fenêtre de terminal avec un vrai shell dedans, **F9** ouvre l'arborescence du projet, **Options ▸ Theme** propose onze thèmes de couleurs. |
| 204 | |
| 205 | ## Étape 7 — Colorer le langage |
| 206 | |
| 207 | Les fichiers Zig ne sont pas encore colorés, parce que rien n'a dit à la bibliothèque ce qu'est Zig. Créez `syntax.go` : |
| 208 | |
| 209 | ```go |
| 210 | package main |
| 211 | |
| 212 | import "codeberg.org/turbo-editors/turbo-core/syntax" |
| 213 | |
| 214 | // registerZig enseigne à la bibliothèque un tout petit peu de Zig : ses |
| 215 | // mots-clés, ses commentaires et ses chaînes. |
| 216 | func registerZig() { |
| 217 | syntax.Register(syntax.Definition{ |
| 218 | Language: "zig", |
| 219 | Extensions: []string{".zig"}, |
| 220 | Highlight: highlightZig, |
| 221 | }) |
| 222 | } |
| 223 | |
| 224 | var zigKeywords = map[string]bool{ |
| 225 | "const": true, "var": true, "fn": true, "pub": true, "return": true, |
| 226 | "if": true, "else": true, "while": true, "for": true, "struct": true, |
| 227 | "try": true, "defer": true, "test": true, "comptime": true, |
| 228 | } |
| 229 | |
| 230 | func highlightZig(src string) [][]syntax.Span { |
| 231 | return syntax.ScanLines(src, func(line []rune, carry struct{}) ([]syntax.Span, struct{}) { |
| 232 | s := syntax.NewLineScanner(line) |
| 233 | for !s.AtEnd() { |
| 234 | switch r := s.Peek(0); { |
| 235 | case r == ' ' || r == '\t': |
| 236 | s.SkipSpaces() |
| 237 | case s.HasPrefix(0, "//"): |
| 238 | s.TakeRest(syntax.ClassComment) |
| 239 | case r == '"': |
| 240 | syntax.TakeQuoted(s, '"', syntax.ClassString) |
| 241 | case syntax.IsDigit(r): |
| 242 | s.TakeWhile(syntax.ClassNumber, syntax.IsWordRune) |
| 243 | case syntax.IsLetter(r) || r == '_': |
| 244 | start := s.Pos() |
| 245 | for !s.AtEnd() && syntax.IsWordRune(s.Peek(0)) { |
| 246 | s.Advance(1) |
| 247 | } |
| 248 | class := syntax.ClassIdentifier |
| 249 | if zigKeywords[string(line[start:s.Pos()])] { |
| 250 | class = syntax.ClassKeyword |
| 251 | } |
| 252 | s.Emit(start, s.Pos(), class) |
| 253 | default: |
| 254 | s.Advance(1) |
| 255 | } |
| 256 | } |
| 257 | return s.Spans(), carry |
| 258 | }) |
| 259 | } |
| 260 | ``` |
| 261 | |
| 262 | Ajoutez une ligne à `run`, juste au-dessus de `p := zig()` : |
| 263 | |
| 264 | ```go |
| 265 | registerZig() |
| 266 | ``` |
| 267 | |
| 268 | ## Étape 8 — Le voir coloré |
| 269 | |
| 270 | Écrivez un fichier Zig et ouvrez-le : |
| 271 | |
| 272 | ```bash |
| 273 | cat > hello.zig <<'EOF' |
| 274 | // A greeting. |
| 275 | const std = @import("std"); |
| 276 | |
| 277 | pub fn main() void { |
| 278 | std.debug.print("hello {d}\n", .{42}); |
| 279 | } |
| 280 | EOF |
| 281 | go run . hello.zig |
| 282 | ``` |
| 283 | |
| 284 | `const`, `pub`, `fn` sont dessinés dans la couleur des mots-clés, `// A greeting.` dans celle des commentaires, `"hello {d}\n"` dans celle des chaînes et `42` dans celle des nombres. Appuyez sur **Alt-X** pour sortir. |
| 285 | |
| 286 | ## Et maintenant ? |
| 287 | |
| 288 | Vous avez un éditeur. Ce qui lui manque encore, c'est un vrai analyseur — celui ci-dessus connaît quatorze mots-clés et ignore tout des chaînes multilignes `\\` et des littéraux de caractère. |
| 289 | |
| 290 | - Pour en écrire un correct → [Ajouter un langage](../how-to/add-a-language.md) |
| 291 | - Pour faire marcher la complétion → [Dialoguer avec un serveur de langage](../how-to/talk-to-a-language-server.md) |
| 292 | - Pour voir tous les champs que vous avez sautés → [Référence Profile](../reference/profile.md) |
| 293 | - Pour comprendre pourquoi la bibliothèque a cette forme → [Architecture](../explanation/architecture.md) |