1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
|
package jslang
import (
"fmt"
"os"
"strings"
"testing"
"rickub.com/turbo-editors/turbo-core/settings"
"rickub.com/turbo-editors/turbo-core/snippets"
"rickub.com/turbo-editors/turbo-core/syntax"
"rickub.com/turbo-editors/turbo-core/tools"
)
// The starter files Turbo JS writes are the one part of a project's .turbo-js
// directory that is about JavaScript and Node, so this is where what is *in*
// them is checked. That the file written is the profile's template at all is
// turbo-core's test.
// noUserSnippets points the user's own snippets at an empty directory, so a
// test never reads whoever is running it.
func noUserSnippets(t *testing.T) {
t.Helper()
t.Setenv(Profile().SnippetDirEnvVar(), t.TempDir())
}
// loadTools reads a project's tools, failing the test if it cannot.
func loadTools(t *testing.T, dir string) tools.List {
t.Helper()
list, err := tools.Load(Profile(), dir)
if err != nil {
t.Fatalf("tools.Load(%q) error = %v", dir, err)
}
return list
}
// loadSnippets reads a project's snippets, failing the test if it cannot.
func loadSnippets(t *testing.T, dir string) snippets.List {
t.Helper()
list, err := snippets.Load(Profile(), dir)
if err != nil {
t.Fatalf("snippets.Load(%q) error = %v", dir, err)
}
return list
}
// createTools writes the starter tools file into a fresh project.
func createTools(t *testing.T) string {
t.Helper()
dir := t.TempDir()
if _, err := tools.Create(Profile(), dir); err != nil {
t.Fatalf("tools.Create() error = %v", err)
}
return dir
}
// createSnippets writes the starter snippets file into a fresh project.
func createSnippets(t *testing.T) string {
t.Helper()
noUserSnippets(t)
dir := t.TempDir()
if _, err := snippets.Create(Profile(), dir); err != nil {
t.Fatalf("snippets.Create() error = %v", err)
}
return dir
}
// readFile returns a file's contents.
func readFile(t *testing.T, path string) string {
t.Helper()
data, err := os.ReadFile(path)
if err != nil {
t.Fatalf("reading %s: %v", path, err)
}
return string(data)
}
// plain strips the tilde hot-key markers from a label.
func plain(label string) string { return strings.ReplaceAll(label, "~", "") }
// hotKey returns the character between the tildes, or 0 when there is none.
func hotKey(label string) rune {
first := strings.IndexByte(label, '~')
if first < 0 || first+1 >= len(label) {
return 0
}
return rune(label[first+1])
}
// starterTools are the commands the starter file offers, by the plain name of
// each. Every one of them was run against Node 24 and npm 11 before it was
// written here.
var starterTools = map[string]string{
"Install": "npm install",
"Format": "npx prettier --write .",
"Lint": "npx eslint .",
"Test": "node --test",
"Run": "node {{script, e.g. main.js}}",
"Start": "npm start",
"Echo": "echo 🎉 tada!",
}
func TestTheCreatedToolsFileHoldsTheNodeCommandsAndTheExampleBesideThem(t *testing.T) {
// These are what a Node project runs before it commits, and they are the
// reason the file exists at all.
dir := createTools(t)
byName := map[string]string{}
for _, tool := range loadTools(t, dir).Tools() {
byName[plain(tool.Name)] = tool.Command
}
for name, command := range starterTools {
if got := byName[name]; got != command {
t.Errorf("%s runs %q, want %q", name, got, command)
}
}
for name := range byName {
if _, ok := starterTools[name]; !ok {
t.Errorf("the created file holds a tool this test does not know about: %q", name)
}
}
}
func TestTheCreatedToolsCarryDistinctHotKeys(t *testing.T) {
// Seven items in two menus are worth reaching with one keystroke each.
dir := createTools(t)
seen := map[rune]string{}
for _, tool := range loadTools(t, dir).Tools() {
key := hotKey(tool.Name)
if key == 0 {
t.Errorf("%q has no hot key", tool.Name)
continue
}
if other, clash := seen[key]; clash {
t.Errorf("%q and %q both answer to %c", other, tool.Name, key)
}
seen[key] = tool.Name
}
}
func TestEachToolGoesWhereItsOwnOutputBelongs(t *testing.T) {
// `node` runs a program that may read the keyboard, and `npm start`
// usually runs a server that has to be interruptible; a popup can do
// neither. Echo is a terminal too, as the worked example of a tool in a
// menu of its own. The rest say something short and are read once.
dir := createTools(t)
want := map[string]tools.Output{
"Install": tools.OutputPopup,
"Format": tools.OutputPopup,
"Lint": tools.OutputPopup,
"Test": tools.OutputPopup,
"Run": tools.OutputTerminal,
"Start": tools.OutputTerminal,
"Echo": tools.OutputTerminal,
}
for _, tool := range loadTools(t, dir).Tools() {
name := plain(tool.Name)
if tool.Output == "" {
t.Errorf("%q leaves its output to the default rather than saying it", tool.Name)
}
if got := tool.Where(); got != want[name] {
t.Errorf("%s goes to %q, want %q", name, got, want[name])
}
}
}
func TestTheCreatedToolsFileExplainsItself(t *testing.T) {
contents := readFile(t, tools.Path(Profile(), createTools(t)))
for _, want := range []string{"[[tool]]", "sh -c", "hot key", "popup", "terminal", "editor", "package.json"} {
if !strings.Contains(contents, want) {
t.Errorf("the created file never mentions %q:\n%s", want, contents)
}
}
}
func TestTheCreatedToolsFileNamesTheJavaScriptMenuAndNoOtherEditors(t *testing.T) {
// The comments explain which menu a tool lands in by naming it, and naming
// the wrong editor's menu is the copy-and-paste mistake this catches.
contents := readFile(t, tools.Path(Profile(), createTools(t)))
if !strings.Contains(contents, "JavaScript menu") {
t.Errorf("the created file never names the JavaScript menu:\n%s", contents)
}
for _, other := range []string{"Rust menu", "Go menu", "Python menu", "Golo menu", "MoonBit menu", "cargo", "uv "} {
if strings.Contains(contents, other) {
t.Errorf("the created file still says %q:\n%s", other, contents)
}
}
}
func TestTheCreatedToolsFileShowsHowToUseAnotherMenu(t *testing.T) {
contents := readFile(t, tools.Path(Profile(), createTools(t)))
for _, want := range []string{"menu says which menu", `menu = "Tools"`} {
if !strings.Contains(contents, want) {
t.Errorf("the created file never shows %q:\n%s", want, contents)
}
}
}
func TestTheCreatedToolsFileExplainsHowToAskForAValue(t *testing.T) {
// A parameterised tool is only discoverable if the file people get says the
// syntax exists. The double-brace warning is here too, because somebody
// reading this file may well have an awk one-liner in mind.
contents := readFile(t, tools.Path(Profile(), createTools(t)))
for _, want := range []string{
"{{label}}",
"npm install {{package name}}",
"{{extra flags...}}",
"Double braces, not single",
} {
if !strings.Contains(contents, want) {
t.Errorf("the created file never mentions %q:\n%s", want, contents)
}
}
}
func TestOnlyRunAsksForAValueAndItAsksForTheScript(t *testing.T) {
// The examples live in comments, so none of them may become a real tool.
// Run is the one real placeholder: a Node project has no single entry
// point the editor could know, so it has to ask which script to run.
for _, tool := range loadTools(t, createTools(t)).Tools() {
got := tool.Placeholders()
if plain(tool.Name) != "Run" {
if got != nil {
t.Errorf("%q asks for %v; only Run takes a value", tool.Name, got)
}
continue
}
if len(got) != 1 || !strings.HasPrefix(got[0].Label, "script") {
t.Errorf("Run asks for %v, want exactly one value, the script", got)
}
}
}
func TestTheCreatedSnippetsFileHoldsUsableJavaScriptAndJSONSnippets(t *testing.T) {
dir := createSnippets(t)
for _, language := range []syntax.Language{Language, LanguageJSON} {
groups := loadSnippets(t, dir).Groups(string(language))
if len(groups) == 0 {
t.Errorf("the created file offers nothing at all in a %s file", language)
}
for _, group := range groups {
for _, snippet := range group.Snippets {
if snippet.Name == "" || snippet.Body == "" {
t.Errorf("the created file holds an unusable snippet %+v", snippet)
}
}
}
}
}
func TestTheCreatedSnippetsIndentWithTwoSpacesTheWayPrettierDoes(t *testing.T) {
// Prettier writes two spaces, and it is what `npx prettier --write` — the
// Format tool — enforces. A tab, or four spaces, that crept in would land
// in somebody's file and be reformatted out on the next run, which is a
// diff nobody asked for.
for _, group := range loadSnippets(t, createSnippets(t)).Groups(string(Language)) {
for _, snippet := range group.Snippets {
if strings.Contains(snippet.Body, "\t") {
t.Errorf("%q indents with a tab:\n%q", snippet.Name, snippet.Body)
}
for _, line := range strings.Split(snippet.Body, "\n") {
indent := len(line) - len(strings.TrimLeft(line, " "))
if indent%2 != 0 {
t.Errorf("%q has a line indented by %d spaces, want a multiple of two:\n%q", snippet.Name, indent, line)
}
}
}
}
}
func TestTheCreatedSnippetsFileExplainsItself(t *testing.T) {
contents := readFile(t, snippets.ProjectPath(Profile(), createSnippets(t)))
for _, want := range []string{"[[snippet]]", "languages", "group", "General", "Prettier", snippets.UserPath(Profile())} {
if !strings.Contains(contents, want) {
t.Errorf("the created file never mentions %q:\n%s", want, contents)
}
}
}
func TestTheCreatedSnippetsFileListsEveryLanguageTheEditorKnows(t *testing.T) {
// The comment is where a user finds out what they may write in a languages
// key. One that omits a language the editor colours sends them looking for
// a feature that is already there.
Register()
contents := readFile(t, snippets.ProjectPath(Profile(), createSnippets(t)))
// The header comment, before the first snippet: a name that only appears
// in a snippet's own languages key is not a list anyone reads.
// The comment itself mentions "[[snippet]]", so the cut is at the first
// one that begins a line.
header, _, _ := strings.Cut(contents, "\n[[snippet]]")
for _, language := range syntax.Registered() {
if !strings.Contains(header, string(language)) {
t.Errorf("the created file's header never mentions the %q language:\n%s", language, header)
}
}
}
func TestTheCreatedSettingsFileExplainsItself(t *testing.T) {
project := t.TempDir()
if _, err := settings.Create(Profile(), project, "turbo-classic"); err != nil {
t.Fatalf("settings.Create() error = %v", err)
}
contents := readFile(t, settings.Path(Profile(), project))
for _, want := range []string{"theme", "autosave", "autosave_delay", "-list-themes"} {
if !strings.Contains(contents, want) {
t.Errorf("the created file never mentions %q:\n%s", want, contents)
}
}
}
func TestTheCreatedSettingsFileTurnsAutosaveOn(t *testing.T) {
// A project that has gone to the trouble of creating a settings file has
// said what it wants. The file is the visible, editable place to say
// otherwise, which is why the default lives here and not in the library.
project := t.TempDir()
if _, err := settings.Create(Profile(), project, "turbo-classic"); err != nil {
t.Fatalf("settings.Create() error = %v", err)
}
loaded, err := settings.Load(Profile(), project)
if err != nil {
t.Fatalf("settings.Load() error = %v", err)
}
if !loaded.Autosave {
t.Errorf("the created settings file leaves autosave off:\n%s", readFile(t, settings.Path(Profile(), project)))
}
if loaded.AutosaveDelay != settings.DefaultAutosaveDelay {
t.Errorf("AutosaveDelay = %v, want the library default %v", loaded.AutosaveDelay, settings.DefaultAutosaveDelay)
}
}
func TestAProjectWithNoSettingsFileStillDoesNotAutosave(t *testing.T) {
// The other half of the decision. Turning autosave on for a project that
// never opted in would mean the editor writing to disk in any directory it
// is started in, which is a different and much larger claim.
if settings.Default().Autosave {
t.Error("settings.Default() autosaves; a project with no settings file never opted in")
}
}
// The four embedded templates and the blanks profile.Templates says each one
// takes. Kept together so that adding a verb to a .tmpl file without saying so
// here fails, which is the guard the constants used to get for free by sitting
// next to the contract.
var embeddedTemplates = []struct {
name string
body string
verb string
blanks int
filledBy []any
}{
{"settings.toml.tmpl", settingsTemplate, "%q", 2, []any{"turbo-classic", "2s"}},
{"snippets.toml.tmpl", snippetsTemplate, "%s", 2, []any{"General", "/tmp/snippets.toml"}},
{"tools.toml.tmpl", toolsTemplate, "%", 0, nil},
{"acp.toml.tmpl", agentsTemplate, "%[", 2, []any{".turbo-js", "/tmp/acp.toml"}},
}
func TestEveryTemplateIsEmbeddedAndNotEmpty(t *testing.T) {
// go:embed fails to compile when a file is missing, but an empty file
// compiles happily and writes an empty starter file into somebody's
// project.
for _, template := range embeddedTemplates {
if len(template.body) == 0 {
t.Errorf("%s embedded as nothing", template.name)
}
}
}
func TestEveryTemplateTakesTheBlanksItsContractPromises(t *testing.T) {
// profile.Templates documents the count and the verb of each. The
// templates live in files of their own, so nothing but this notices a
// verb added, removed, or changed.
for _, template := range embeddedTemplates {
if got := strings.Count(template.body, template.verb); got != template.blanks {
t.Errorf("%s holds %d %q, want %d", template.name, got, template.verb, template.blanks)
}
}
}
func TestFillingATemplateLeavesNoFormattingMarker(t *testing.T) {
// Go writes %!q(MISSING) or %!(EXTRA …) into the output rather than
// failing, so a template with the wrong number of blanks produces a file
// that is written, opened, and wrong.
for _, template := range embeddedTemplates {
filled := template.body
if template.filledBy != nil {
filled = fmt.Sprintf(template.body, template.filledBy...)
}
if strings.Contains(filled, "%!") {
t.Errorf("%s filled to:\n%s", template.name, filled)
}
}
}
func TestEveryTemplateNamesThisEditorAndNoOther(t *testing.T) {
// The four templates started as Turbo Rust's. A leftover "turbo-rust" —
// or a leftover Rust word — in a file written into somebody's Node
// project is the whole class of mistake this catches, and it is invisible
// to every other test here.
others := []string{
"turbo-go", "turbo-rust", "turbo-python", "turbo-moonbit", "turbo-golo",
"cargo", "rustup", ".rs files", "gopls", "pylsp", "moon ", "golo",
}
for _, template := range embeddedTemplates {
t.Run(template.name, func(t *testing.T) {
for _, other := range others {
if strings.Contains(template.body, other) {
t.Errorf("the %s template still says %q:\n%s", template.name, other, template.body)
}
}
if !strings.Contains(template.body, Slug) {
t.Errorf("the %s template never names %s:\n%s", template.name, Slug, template.body)
}
})
}
}
|