@stacksjs/defaults 0.75.40 → 0.75.42

package/ide/vscode/tests/fake-vscode.ts

@@ -0,0 +1,228 @@
+/**
+ * Just enough of the `vscode` API for ./pickier.test.ts and ./env.test.ts:
+ * documents, diagnostics, code actions, hovers and the provider registries,
+ * recorded so tests can call the providers the way the editor would.
+ */
+
+type Listener<T> = (event: T) => unknown
+
+export function emitter<T>() {
+  const listeners = new Set<Listener<T>>()
+  return {
+    event: (listener: Listener<T>) => {
+      listeners.add(listener)
+      return { dispose: () => listeners.delete(listener) }
+    },
+    fire: (value: T) => {
+      for (const listener of [...listeners]) listener(value)
+    },
+  }
+}
+
+export class Position {
+  constructor(readonly line: number, readonly character: number) {}
+  translate(lines = 0, characters = 0) {
+    return new Position(this.line + lines, this.character + characters)
+  }
+}
+
+export class Range {
+  readonly start: Position
+  readonly end: Position
+  constructor(a: Position | number, b: Position | number, c?: number, d?: number) {
+    this.start = typeof a === 'number' ? new Position(a, b as number) : a
+    this.end = typeof a === 'number' ? new Position(c as number, d as number) : b as Position
+  }
+}
+
+export class CodeActionKind {
+  static readonly QuickFix = new CodeActionKind('quickfix')
+  static readonly SourceFixAll = new CodeActionKind('source.fixAll')
+  constructor(readonly value: string) {}
+  append(part: string) {
+    return new CodeActionKind(`${this.value}.${part}`)
+  }
+
+  contains(other: CodeActionKind) {
+    return other.value === this.value || other.value.startsWith(`${this.value}.`)
+  }
+}
+
+export class WorkspaceEdit {
+  readonly edits: Array<{ uri: unknown, range?: Range, position?: Position, text: string }> = []
+  replace(uri: unknown, range: Range, text: string) {
+    this.edits.push({ uri, range, text })
+  }
+
+  insert(uri: unknown, position: Position, text: string) {
+    this.edits.push({ uri, position, text })
+  }
+}
+
+export class MarkdownString {
+  value = ''
+  appendMarkdown(text: string) {
+    this.value += text
+    return this
+  }
+
+  appendCodeblock(code: string, language = '') {
+    this.value += `\n\`\`\`${language}\n${code}\n\`\`\`\n`
+    return this
+  }
+}
+
+export interface FakeDocument {
+  uri: { fsPath: string, scheme: string, toString: () => string }
+  languageId: string
+  version: number
+  isClosed: boolean
+  lineCount: number
+  getText: () => string
+  lineAt: (line: number) => { text: string, lineNumber: number, range: Range }
+  getWordRangeAtPosition: (position: Position) => Range | undefined
+}
+
+export function document(path: string, text: string, languageId = 'typescript'): FakeDocument {
+  const lines = text.split('\n')
+  return {
+    uri: { fsPath: path, scheme: 'file', toString: () => `file://${path}` },
+    languageId,
+    version: 1,
+    isClosed: false,
+    lineCount: lines.length,
+    getText: () => text,
+    lineAt: (line: number) => ({ text: lines[line] ?? '', lineNumber: line, range: new Range(line, 0, line, (lines[line] ?? '').length) }),
+    getWordRangeAtPosition: (position: Position) => {
+      const line = lines[position.line] ?? ''
+      const match = /\w+/.exec(line.slice(position.character))
+      return match && match.index === 0 ? new Range(position.line, position.character, position.line, position.character + match[0].length) : undefined
+    },
+  }
+}
+
+export function fakeVscode(options: { folders: string[], settings?: Record<string, unknown>, documents?: FakeDocument[] }) {
+  const settings = options.settings ?? {}
+  const diagnostics = new Map<string, any[]>()
+  const handlers = new Map<string, (...args: any[]) => any>()
+  const codeActionProviders: any[] = []
+  const formatters: any[] = []
+  const hovers: any[] = []
+  const messages: string[] = []
+  const answers: Array<string | undefined> = []
+  const inputs: any[] = []
+  const output: string[] = []
+  const applied: WorkspaceEdit[] = []
+  const clipboard: string[] = []
+  const opened = emitter<FakeDocument>()
+  const changed = emitter<{ document: FakeDocument }>()
+  const saved = emitter<FakeDocument>()
+  const closed = emitter<FakeDocument>()
+
+  const message = (text: string) => {
+    messages.push(text)
+    return Promise.resolve(answers.shift())
+  }
+
+  const api = {
+    Position,
+    Range,
+    CodeActionKind,
+    WorkspaceEdit,
+    MarkdownString,
+    DiagnosticSeverity: { Error: 0, Warning: 1, Information: 2, Hint: 3 },
+    Diagnostic: class {
+      source?: string
+      code?: string
+      constructor(readonly range: Range, readonly message: string, readonly severity: number) {}
+    },
+    CodeAction: class {
+      edit?: WorkspaceEdit
+      diagnostics?: unknown[]
+      constructor(readonly title: string, readonly kind: CodeActionKind) {}
+    },
+    Hover: class {
+      constructor(readonly contents: MarkdownString, readonly range?: Range) {}
+    },
+    TextEdit: { replace: (range: Range, newText: string) => ({ range, newText }) },
+    commands: {
+      registerCommand: (id: string, handler: (...args: any[]) => any) => {
+        handlers.set(id, handler)
+        return { dispose: () => handlers.delete(id) }
+      },
+    },
+    env: { clipboard: { writeText: async (text: string) => { clipboard.push(text) } } },
+    languages: {
+      createDiagnosticCollection: () => ({
+        set: (uri: { toString: () => string }, list: any[]) => diagnostics.set(uri.toString(), list),
+        delete: (uri: { toString: () => string }) => diagnostics.delete(uri.toString()),
+        clear: () => diagnostics.clear(),
+        dispose: () => {},
+      }),
+      registerCodeActionsProvider: (_selector: unknown, provider: unknown) => {
+        codeActionProviders.push(provider)
+        return { dispose: () => {} }
+      },
+      registerDocumentFormattingEditProvider: (_selector: unknown, provider: unknown) => {
+        formatters.push(provider)
+        return { dispose: () => {} }
+      },
+      registerHoverProvider: (_selector: unknown, provider: unknown) => {
+        hovers.push(provider)
+        return { dispose: () => {} }
+      },
+    },
+    window: {
+      activeTextEditor: undefined as undefined | { document: FakeDocument },
+      createOutputChannel: () => ({ appendLine: (line: string) => output.push(line), dispose: () => {} }),
+      showInformationMessage: message,
+      showWarningMessage: message,
+      showErrorMessage: message,
+      showInputBox: (inputOptions: unknown) => {
+        inputs.push(inputOptions)
+        return Promise.resolve(answers.shift())
+      },
+      showQuickPick: (items: string[], pickOptions: unknown) => {
+        inputs.push({ items, ...pickOptions as object })
+        return Promise.resolve(answers.shift())
+      },
+    },
+    workspace: {
+      workspaceFolders: options.folders.map((folder, index) => ({ uri: { fsPath: folder }, name: folder, index })),
+      textDocuments: options.documents ?? [],
+      getConfiguration: () => ({ get: (key: string, fallback: unknown) => key in settings ? settings[key] : fallback }),
+      getWorkspaceFolder: (uri: { fsPath: string }) => {
+        const folder = options.folders.find(candidate => uri.fsPath.startsWith(`${candidate}/`))
+        return folder ? { uri: { fsPath: folder } } : undefined
+      },
+      applyEdit: async (edit: WorkspaceEdit) => {
+        applied.push(edit)
+        return true
+      },
+      onDidOpenTextDocument: opened.event,
+      onDidChangeTextDocument: changed.event,
+      onDidSaveTextDocument: saved.event,
+      onDidCloseTextDocument: closed.event,
+      onDidChangeConfiguration: emitter<any>().event,
+    },
+  }
+
+  return {
+    api,
+    diagnostics,
+    handlers,
+    codeActionProviders,
+    formatters,
+    hovers,
+    messages,
+    answers,
+    inputs,
+    output,
+    applied,
+    clipboard,
+    events: { opened, changed, saved, closed },
+    context: { subscriptions: [] as Array<{ dispose: () => unknown }> },
+  }
+}
+
+export const flush = () => new Promise(resolve => setTimeout(resolve, 10))

package/ide/vscode/tests/manifest.test.ts

@@ -0,0 +1,88 @@
+/**
+ * The extension manifest.
+ *
+ * The Stacks extension is self-contained: stx support, pickier and env files
+ * are built in, so it installs no extension pack and depends on no other
+ * extension. stx support comes from `@stacksjs/stx-vscode`, the library build
+ * of the stx extension (Stacks.vscode-stx); with both installed, the stx
+ * extension stands down (stacksjs/stx#2020).
+ */
+import { describe, expect, it } from 'bun:test'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { libraryContributes, withStxContributes } from '../scripts/stx-contributes'
+
+const root = join(import.meta.dir, '..')
+const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+const STX_EXTENSION_ID = 'Stacks.vscode-stx'
+const projectSettings = Bun.JSONC.parse(readFileSync(join(root, '.vscode/settings.json'), 'utf8')) as Record<string, any>
+const recommendations = (Bun.JSONC.parse(readFileSync(join(root, '.vscode/extensions.json'), 'utf8')) as { recommendations: string[] }).recommendations
+
+describe('marketplace identity', () => {
+  it('is Stacks.vscode-stacks, not the stx extension', () => {
+    const id = `${manifest.publisher}.${manifest.name}`
+    expect(id).toBe('Stacks.vscode-stacks')
+    expect(id.toLowerCase()).not.toBe(STX_EXTENSION_ID.toLowerCase())
+  })
+})
+
+describe('self-contained', () => {
+  it('installs no extension pack and depends on no extension', () => {
+    expect(manifest.extensionPack).toBeUndefined()
+    expect(manifest.extensionDependencies).toBeUndefined()
+  })
+
+  it('has no runtime dependencies to ship', () => {
+    expect(manifest.dependencies).toBeUndefined()
+  })
+
+  it('recommends only itself to new projects', () => {
+    expect(recommendations.map(id => id.toLowerCase())).toEqual(['stacks.vscode-stacks'])
+  })
+
+  it('configures new projects for no other extension', () => {
+    // Settings that only mean something to an extension the project no longer
+    // asks for: ESLint, Prettier, Biome, markdownlint, shell-format, cSpell,
+    // Grammarly, vscode-icons, Todo Tree.
+    const foreign = Object.keys(projectSettings).filter(key =>
+      /^(?:eslint|prettier|biome|markdownlint|cSpell|grammarly|vsicons|todo-tree)\./.test(key))
+    expect(foreign).toEqual([])
+    expect(JSON.stringify(projectSettings)).not.toMatch(/dbaeumer|foxundermoon|DavidAnson|esbenp/i)
+  })
+
+  it('formats and fixes with pickier through this extension', () => {
+    expect(projectSettings['editor.defaultFormatter']).toBe('Stacks.vscode-stacks')
+    expect(projectSettings['editor.codeActionsOnSave']['source.fixAll.pickier']).toBe('explicit')
+  })
+})
+
+describe('stx language support', () => {
+  it('declares what @stacksjs/stx-vscode ships (run `bun run sync:stx` after updating it)', () => {
+    expect(withStxContributes(manifest, libraryContributes(root))).toEqual(manifest)
+  })
+
+  it('declares the stx language and its grammar from the bundled assets', () => {
+    expect(manifest.contributes.languages.map((language: { id: string }) => language.id)).toContain('stx')
+    expect(manifest.contributes.grammars[0].path).toStartWith('./dist/stx/')
+    expect(manifest.files).toContain('dist/stx/**')
+    expect(manifest.activationEvents).toContain('onLanguage:stx')
+  })
+
+  it('leaves snippets to runtime, so they never show twice next to the stx extension', () => {
+    expect(manifest.contributes.snippets).toBeUndefined()
+  })
+
+  it('does not map .stx files to another language', () => {
+    const extensionDefaults = manifest.contributes.configurationDefaults['files.associations'] ?? {}
+    for (const associations of [extensionDefaults, projectSettings['files.associations'] ?? {}])
+      expect(Object.keys(associations).filter(pattern => pattern.endsWith('.stx'))).toEqual([])
+  })
+})
+
+describe('packaging', () => {
+  it('ships the files the extension loads at runtime', () => {
+    for (const file of ['dist/extension.js', 'dist/pickier-worker.js', 'dist/pickier-worker.bunfig.toml'])
+      expect(manifest.files).toContain(file)
+    expect(manifest.main).toBe('./dist/extension.js')
+  })
+})

package/ide/vscode/tests/pickier.test.ts

@@ -0,0 +1,202 @@
+/**
+ * Pickier support (src/pickier.ts), driven through a fake `vscode` API and a
+ * fake worker process: no editor, no Bun, no pickier.
+ */
+import type { PickierProcess } from '../src/pickier'
+import type { PickierRequest, PickierResult } from '../src/pickier-protocol'
+import { describe, expect, it } from 'bun:test'
+import { chooseBun, createPickierSupport, disableNextLineComment, isLintedFile, isPickierConfigPath } from '../src/pickier'
+import { CodeActionKind, document, fakeVscode, flush } from './fake-vscode'
+
+const ROOT = '/work/app'
+
+interface Worker {
+  answer?: (request: PickierRequest) => PickierResult
+  ready?: false
+  fixText?: boolean
+  exitOnStart?: boolean
+}
+
+function setup(options: { worker?: Worker, files?: string[], settings?: Record<string, unknown>, documents?: ReturnType<typeof document>[] } = {}) {
+  const files = new Set(options.files ?? [`${ROOT}/buddy`])
+  const fake = fakeVscode({ folders: [ROOT], settings: options.settings, documents: options.documents })
+  const spawned: Array<{ bun: string, script: string, cwd: string, requests: PickierRequest[] }> = []
+
+  const host = {
+    exists: (path: string) => files.has(path),
+    spawnBun(bun: string, script: string, cwd: string): PickierProcess {
+      const record = { bun, script, cwd, requests: [] as PickierRequest[] }
+      spawned.push(record)
+      const lineListeners: Array<(line: string) => void> = []
+      const exitListeners: Array<() => void> = []
+      const emit = (message: unknown) => queueMicrotask(() => lineListeners.forEach(listener => listener(JSON.stringify(message))))
+      const worker = options.worker ?? {}
+
+      queueMicrotask(() => {
+        if (worker.exitOnStart)
+          return exitListeners.forEach(listener => listener())
+        if (worker.ready === false)
+          return emit({ ready: false, error: 'Cannot find package \'pickier\'', missing: true })
+        emit({ ready: true, version: '0.1.66', fixText: worker.fixText ?? true })
+      })
+
+      return {
+        write(line) {
+          const request = JSON.parse(line) as PickierRequest
+          record.requests.push(request)
+          const result = worker.answer?.(request) ?? (request.op === 'lint' ? { op: 'lint', issues: [] } : { op: request.op, text: null })
+          emit({ id: request.id, ok: true, result })
+        },
+        onLine: listener => lineListeners.push(listener),
+        onExit: listener => exitListeners.push(listener),
+        kill: () => {},
+      }
+    },
+  }
+
+  const support = createPickierSupport(fake.api as any, host, { workerPath: '/ext/dist/pickier-worker.js', lintDelayMs: 1 })
+  support.activate(fake.context)
+  return { ...fake, spawned, support }
+}
+
+describe('helpers', () => {
+  it('runs pickier on the configured Bun, else the project\'s pinned Bun, else bun on the PATH', () => {
+    expect(chooseBun(' /opt/bun ', ROOT, () => true)).toBe('/opt/bun')
+    expect(chooseBun('', ROOT, path => path === `${ROOT}/pantry/.bin/bun`)).toBe(`${ROOT}/pantry/.bin/bun`)
+    expect(chooseBun('', ROOT, () => false)).toBe('bun')
+  })
+
+  it('lints exactly the files `buddy lint` does', () => {
+    expect(isLintedFile(ROOT, `${ROOT}/app/Actions/Hello.ts`)).toBeTrue()
+    expect(isLintedFile(ROOT, `${ROOT}/README.md`)).toBeTrue()
+    expect(isLintedFile(ROOT, `${ROOT}/node_modules/x/index.ts`)).toBeFalse()
+    expect(isLintedFile(ROOT, `${ROOT}/dist/index.js`)).toBeFalse()
+    expect(isLintedFile(ROOT, `${ROOT}/resources/views/index.stx`)).toBeFalse()
+    expect(isLintedFile(ROOT, '/elsewhere/a.ts')).toBeFalse()
+  })
+
+  it('recognises the files pickier reads its config from', () => {
+    expect(isPickierConfigPath(`${ROOT}/config/code-style.ts`)).toBeTrue()
+    expect(isPickierConfigPath(`${ROOT}/pickier.config.ts`)).toBeTrue()
+    expect(isPickierConfigPath(`${ROOT}/.config/pickier.ts`)).toBeTrue()
+    expect(isPickierConfigPath(`${ROOT}/config/app.ts`)).toBeFalse()
+  })
+
+  it('disables a rule for the next line at that line\'s indentation', () => {
+    expect(disableNextLineComment('    let x = 1', 'prefer-const', '//')).toBe('    // pickier-disable-next-line prefer-const\n')
+  })
+})
+
+describe('diagnostics', () => {
+  it('reports the project pickier\'s issues on an open file, in editor coordinates', async () => {
+    const file = document(`${ROOT}/app/x.ts`, 'import { a } from \'b\'\nlet x = 1\n')
+    const { diagnostics, spawned } = setup({
+      documents: [file],
+      worker: {
+        answer: () => ({ op: 'lint', issues: [{ line: 2, column: 5, ruleId: 'prefer-const', message: '\'x\' is never reassigned', severity: 'error', help: 'Use const' }] }),
+      },
+    })
+    await flush()
+
+    expect(spawned).toHaveLength(1)
+    expect(spawned[0]).toMatchObject({ bun: 'bun', script: '/ext/dist/pickier-worker.js', cwd: ROOT })
+    expect(spawned[0]!.requests[0]).toMatchObject({ op: 'lint', file: `${ROOT}/app/x.ts` })
+
+    const [diagnostic] = diagnostics.get(`file://${ROOT}/app/x.ts`)!
+    expect(diagnostic.source).toBe('pickier')
+    expect(diagnostic.code).toBe('prefer-const')
+    expect(diagnostic.severity).toBe(0)
+    expect(diagnostic.range.start).toMatchObject({ line: 1, character: 4 })
+    expect(diagnostic.range.end).toMatchObject({ line: 1, character: 5 })
+    expect(diagnostic.message).toBe('\'x\' is never reassigned\nUse const')
+  })
+
+  it('leaves folders that are not Stacks projects alone', async () => {
+    const { spawned } = setup({ files: [], documents: [document(`${ROOT}/x.ts`, 'let x = 1\n')] })
+    await flush()
+    expect(spawned).toHaveLength(0)
+  })
+
+  it('lints nothing when turned off', async () => {
+    const { spawned } = setup({ settings: { 'pickier.enable': false }, documents: [document(`${ROOT}/x.ts`, 'let x = 1\n')] })
+    await flush()
+    expect(spawned).toHaveLength(0)
+  })
+
+  it('stops asking a project with no pickier, and says why once', async () => {
+    const { spawned, events, output, diagnostics } = setup({ worker: { ready: false }, documents: [document(`${ROOT}/a.ts`, '')] })
+    await flush()
+    events.opened.fire(document(`${ROOT}/b.ts`, '') as any)
+    await flush()
+
+    expect(spawned).toHaveLength(1)
+    expect(diagnostics.size).toBe(0)
+    expect(output.filter(line => line.includes('not available'))).toHaveLength(1)
+  })
+
+  it('gives up on a worker that keeps exiting instead of respawning it on every keystroke', async () => {
+    const { spawned, events } = setup({ worker: { exitOnStart: true } })
+    for (let i = 0; i < 5; i++) {
+      events.opened.fire(document(`${ROOT}/x${i}.ts`, '') as any)
+      await flush()
+    }
+    expect(spawned).toHaveLength(3)
+  })
+})
+
+describe('fixing and formatting', () => {
+  const FIXED = 'const x = 1\n'
+
+  it('offers source.fixAll.pickier, the code action codeActionsOnSave asks for', async () => {
+    const file = document(`${ROOT}/x.ts`, 'let x = 1\n')
+    const { codeActionProviders, spawned } = setup({ worker: { answer: request => request.op === 'fix' ? { op: 'fix', text: FIXED } : { op: 'lint', issues: [] } } })
+
+    const only = CodeActionKind.SourceFixAll.append('pickier')
+    const [action] = await codeActionProviders[0].provideCodeActions(file, undefined, { only, diagnostics: [] })
+
+    expect(action.kind.value).toBe('source.fixAll.pickier')
+    expect(action.edit.edits[0].text).toBe(FIXED)
+    expect(spawned[0]!.requests.at(-1)!.op).toBe('fix')
+
+    // The generic `source.fixAll` includes it too.
+    const generic = await codeActionProviders[0].provideCodeActions(file, undefined, { only: CodeActionKind.SourceFixAll, diagnostics: [] })
+    expect(generic).toHaveLength(1)
+  })
+
+  it('offers nothing when there is nothing to fix, or the project\'s pickier cannot fix text', async () => {
+    const file = document(`${ROOT}/x.ts`, FIXED)
+    const unchanged = setup({ worker: { answer: request => ({ op: request.op as 'fix', text: FIXED }) } })
+    expect(await unchanged.codeActionProviders[0].provideCodeActions(file, undefined, { only: CodeActionKind.SourceFixAll, diagnostics: [] })).toEqual([])
+
+    const old = setup({ worker: { fixText: false } })
+    expect(await old.codeActionProviders[0].provideCodeActions(document(`${ROOT}/x.ts`, 'let x = 1\n'), undefined, { only: CodeActionKind.SourceFixAll, diagnostics: [] })).toEqual([])
+  })
+
+  it('offers quick fixes for its own diagnostics: fix all, and disable the rule for the line', async () => {
+    const file = document(`${ROOT}/x.ts`, 'function f() {\n  let x = 1\n}\n')
+    const { codeActionProviders } = setup({ worker: { answer: request => request.op === 'fix' ? { op: 'fix', text: 'function f() {\n  const x = 1\n}\n' } : { op: 'lint', issues: [] } } })
+    const diagnostic = { source: 'pickier', code: 'prefer-const', range: { start: { line: 1, character: 6 } } }
+
+    const actions = await codeActionProviders[0].provideCodeActions(file, undefined, { diagnostics: [diagnostic, { source: 'ts', code: 1 }] })
+
+    expect(actions.map((action: any) => action.title)).toEqual(['Fix all pickier problems', 'Disable prefer-const for this line'])
+    expect(actions[1].edit.edits[0]).toMatchObject({ position: { line: 1, character: 0 }, text: '  // pickier-disable-next-line prefer-const\n' })
+  })
+
+  it('formats with the project\'s pickier', async () => {
+    const file = document(`${ROOT}/x.ts`, 'const a = "x"\n')
+    const { formatters } = setup({ worker: { answer: request => request.op === 'format' ? { op: 'format', text: 'const a = \'x\'\n' } : { op: 'lint', issues: [] } } })
+
+    const [edit] = await formatters[0].provideDocumentFormattingEdits(file)
+    expect(edit.newText).toBe('const a = \'x\'\n')
+  })
+
+  it('applies the fixes to the active file from the command palette', async () => {
+    const file = document(`${ROOT}/x.ts`, 'let x = 1\n')
+    const fake = setup({ worker: { answer: request => request.op === 'fix' ? { op: 'fix', text: FIXED } : { op: 'lint', issues: [] } } })
+    fake.api.window.activeTextEditor = { document: file }
+
+    await fake.handlers.get('stacks.pickier.fixAll')!()
+    expect(fake.applied[0]!.edits[0]!.text).toBe(FIXED)
+  })
+})