turbo-editors/turbo-core · build-an-editor.md

⑂ v1.0.1

build-an-editor.md · 293 lines · 7.4 KBmarkdown    Blame HistoryRaw
   1# Tutoriel : construire un éditeur Turbo pour votre propre langage
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.
5Aucune connaissance de turbo-core n'est requise. Il vous faut Go 1.26 ou plus récent, et un terminal.
7## Prérequis
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 :
📦 Turbo Core   13git clone ssh://git@rickub.com/turbo-editors/turbo-core.git
   14
16## Étape 1 — Créer le module
18À côté de votre copie de turbo-core, tapez :
21mkdir turbo-zig && cd turbo-zig
22go mod init example.com/turbo-zig
25Vous devriez voir :
28go: creating new go.mod: module example.com/turbo-zig
31Nous avons maintenant un module vide. Nous allons le brancher sur la bibliothèque.
33## Étape 2 — Dépendre de turbo-core
📦 Turbo Core   38go mod edit -require=rickub.com/turbo-editors/turbo-core@v0.1.0
39go mod edit -replace=rickub.com/turbo-editors/turbo-core=../turbo-core
   40
42Rien ne s'affiche. Regardez `go.mod` :
45
48Vous 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.
50## Étape 3 — Dire quel éditeur c'est
52Créez `profile.go` :
55package main
📦 Turbo Core   57import "rickub.com/turbo-editors/turbo-core/profile"
   58
59// zig est l'éditeur que nous construisons.
60func 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",
71		Templates: profile.Templates{
72			Settings: settingsTemplate,
73			Snippets: snippetsTemplate,
74			Tools:    toolsTemplate,
80Voilà 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.
82## Étape 4 — Écrire les trois fichiers de départ
84Créez `templates.go` :
87package main
89const settingsTemplate = `# turbo-zig project settings.
93
94autosave = false
95autosave_delay = %q
98const snippetsTemplate = `# turbo-zig snippets.
100# Un extrait sans groupe va dans %s.
101# Les vôtres vivent dans :
104[[snippet]]
105name = "TODO"
106body = "TODO: "
109const toolsTemplate = `# turbo-zig tools.
111
112name = "~B~uild"
113command = "zig build"
114output = "popup"
116
117name = "~T~est"
118command = "zig build test"
119output = "popup"
121
122name = "~R~un"
123command = "zig build run"
124output = "terminal"
128Les 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.
130## Étape 5 — Écrire la commande
132Créez `main.go` :
135package main
137
138
142	"github.com/gdamore/tcell/v2"
📦 Turbo Core   144	"rickub.com/turbo-editors/turbo-core/app"
   145
147func main() {
148	if err := run(); err != nil {
149		fmt.Fprintln(os.Stderr, "turbo-zig:", err)
150		os.Exit(1)
154func run() error {
155	screen, err := tcell.NewScreen()
156	if err != nil {
157		return err
159	if err := screen.Init(); err != nil {
160		return err
162	defer screen.Fini()
163	screen.EnableMouse()
164	screen.EnablePaste()
166	p := zig()
167	editor := app.New(screen, "turbo-classic", p)
169	files := os.Args[1:]
170	if len(files) == 0 {
171		editor.NewFile()
173	for _, file := range files {
174		editor.Open(file)
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())
182	return editor.Run()
186## Étape 6 — Le lancer
191go mod tidy
192go run . main.go
195Votre terminal se remplit d'un bureau bleu. En haut, vous devriez lire :
198 File  Edit  Search  Run  Options  Window  Snippets  Zig  Help
201et 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.
203Nous 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.
205## Étape 7 — Colorer le langage
207Les 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` :
210package main
📦 Turbo Core   212import "rickub.com/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.
216func registerZig() {
217	syntax.Register(syntax.Definition{
218		Language:   "zig",
219		Extensions: []string{".zig"},
220		Highlight:  highlightZig,
224var 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,
230func 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)
248				class := syntax.ClassIdentifier
249				if zigKeywords[string(line[start:s.Pos()])] {
250					class = syntax.ClassKeyword
252				s.Emit(start, s.Pos(), class)
253			default:
254				s.Advance(1)
257		return s.Spans(), carry
262Ajoutez une ligne à `run`, juste au-dessus de `p := zig()` :
265	registerZig()
268## Étape 8 — Le voir coloré
270Écrivez un fichier Zig et ouvrez-le :
273cat > hello.zig <<'EOF'
274// A greeting.
275const std = @import("std");
277pub fn main() void {
278    std.debug.print("hello {d}\n", .{42});
281go run . hello.zig
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.
286## Et maintenant ?
288Vous 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.
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)

🛟 Updated. 28d5985 k33g 20h 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
📦 Turbo Core d662ceb k33g 12h ago	13	git clone ssh://git@rickub.com/turbo-editors/turbo-core.git
🛟 Updated. 28d5985 k33g 20h ago	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
📦 Turbo Core f3ade8d k33g 12h ago	38	go mod edit -require=rickub.com/turbo-editors/turbo-core@v0.1.0
📦 Turbo Core f3ade8d k33g 12h ago	39	go mod edit -replace=rickub.com/turbo-editors/turbo-core=../turbo-core
🛟 Updated. 28d5985 k33g 20h ago	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
📦 Turbo Core f3ade8d k33g 12h ago	57	import "rickub.com/turbo-editors/turbo-core/profile"
🛟 Updated. 28d5985 k33g 20h ago	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
📦 Turbo Core f3ade8d k33g 12h ago	144	"rickub.com/turbo-editors/turbo-core/app"
🛟 Updated. 28d5985 k33g 20h ago	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
📦 Turbo Core f3ade8d k33g 12h ago	212	import "rickub.com/turbo-editors/turbo-core/syntax"
🛟 Updated. 28d5985 k33g 20h ago	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)