berget 2.2.6 → 2.2.8

package/src/commands/code/__tests__/fake-command-runner.ts

@@ -1,47 +1,50 @@
-import type { CommandRunner } from '../ports/command-runner'
+import type { CommandRunner } from '../ports/command-runner';
 
 type Handler = {
-	match: (command: string, args: readonly string[]) => boolean
-	response: string | Error | ((command: string, args: readonly string[]) => string | Error)
-}
+  match: (command: string, arguments_: readonly string[]) => boolean;
+  response: ((command: string, arguments_: readonly string[]) => Error | string) | Error | string;
+};
 
 export class FakeCommandRunner implements CommandRunner {
-	private handlers: Handler[] = []
-	private _calls: Array<{ command: string; args: string[]; options?: { cwd?: string } }> = []
-
-	handle(match: string | RegExp, response: string | Error): this {
-		this.handlers.push({
-			match: (cmd, args) => {
-				const full = `${cmd} ${args.join(' ')}`
-				if (typeof match === 'string') return full.startsWith(match)
-				return match.test(full)
-			},
-			response,
-		})
-		return this
-	}
-
-	checkInstalled(binary: string): Promise<boolean> {
-		this._calls.push({ command: `check:${binary}`, args: [] })
-		return Promise.resolve(
-			this.handlers.some(h => h.match(binary, ['--version'])) || false
-		)
-	}
-
-	async run(command: string, args: readonly string[], options?: { cwd?: string }): Promise<string> {
-		this._calls.push({ command, args: [...args], options })
-		const handler = this.handlers.find(h => h.match(command, args))
-		if (!handler) throw new Error(`Unexpected command: ${command} ${args.join(' ')}`)
-
-		const result = typeof handler.response === 'function'
-			? handler.response(command, args)
-			: handler.response
-
-		if (result instanceof Error) throw result
-		return result
-	}
-
-	get calls() {
-		return this._calls
-	}
+  get calls() {
+    return this._calls;
+  }
+  private _calls: Array<{ args: string[]; command: string; options?: { cwd?: string } }> = [];
+
+  private handlers: Handler[] = [];
+
+  checkInstalled(binary: string): Promise<boolean> {
+    this._calls.push({ args: [], command: `check:${binary}` });
+    return Promise.resolve(this.handlers.some((h) => h.match(binary, ['--version'])) || false);
+  }
+
+  handle(match: RegExp | string, response: Error | string): this {
+    this.handlers.push({
+      match: (cmd, arguments_) => {
+        const full = `${cmd} ${arguments_.join(' ')}`;
+        if (typeof match === 'string') return full.startsWith(match);
+        return match.test(full);
+      },
+      response,
+    });
+    return this;
+  }
+
+  async run(
+    command: string,
+    arguments_: readonly string[],
+    options?: { cwd?: string },
+  ): Promise<string> {
+    this._calls.push({ args: [...arguments_], command, options });
+    const handler = this.handlers.find((h) => h.match(command, arguments_));
+    if (!handler) throw new Error(`Unexpected command: ${command} ${arguments_.join(' ')}`);
+
+    const result =
+      typeof handler.response === 'function'
+        ? handler.response(command, arguments_)
+        : handler.response;
+
+    if (result instanceof Error) throw result;
+    return result;
+  }
 }

package/src/commands/code/__tests__/fake-file-store.ts

@@ -1,35 +1,44 @@
-import type { FileStore } from '../ports/file-store'
+import type { FileStore } from '../ports/file-store';
 
 export interface FileEntry {
-	content: string
-	isDirectory?: boolean
+  content: string;
+  isDirectory?: boolean;
 }
 
 export class FakeFileStore implements FileStore {
-	private files: Map<string, string> = new Map()
-	private dirs: Set<string> = new Set()
+  private _chmodCalls: Array<{ mode: number; path: string }> = [];
+  private dirs: Set<string> = new Set();
+  private files: Map<string, string> = new Map();
 
-	seed(path: string, content: string): void {
-		this.files.set(path, content)
-	}
+  async chmod(path: string, mode: number): Promise<void> {
+    this._chmodCalls.push({ mode, path });
+  }
 
-	async exists(path: string): Promise<boolean> {
-		return this.files.has(path) || this.dirs.has(path)
-	}
+  async exists(path: string): Promise<boolean> {
+    return this.files.has(path) || this.dirs.has(path);
+  }
 
-	async readFile(path: string): Promise<string | null> {
-		return this.files.get(path) ?? null
-	}
+  getChmodCalls(): Array<{ mode: number; path: string }> {
+    return this._chmodCalls;
+  }
 
-	async writeFile(path: string, content: string): Promise<void> {
-		this.files.set(path, content)
-	}
+  getWrittenFiles(): Map<string, string> {
+    return new Map(this.files);
+  }
 
-	async mkdir(path: string): Promise<void> {
-		this.dirs.add(path)
-	}
+  async mkdir(path: string): Promise<void> {
+    this.dirs.add(path);
+  }
 
-	getWrittenFiles(): Map<string, string> {
-		return new Map(this.files)
-	}
+  async readFile(path: string): Promise<null | string> {
+    return this.files.get(path) ?? null;
+  }
+
+  seed(path: string, content: string): void {
+    this.files.set(path, content);
+  }
+
+  async writeFile(path: string, content: string): Promise<void> {
+    this.files.set(path, content);
+  }
 }

package/src/commands/code/__tests__/fake-prompter.ts

@@ -1,83 +1,122 @@
-import { CancelledError } from '../errors'
-import type { Prompter, Spinner } from '../ports/prompter'
+import type { Prompter, Spinner } from '../ports/prompter';
 
-export const CANCEL = Symbol('cancel')
+import { CancelledError } from '../errors';
+
+export const CANCEL = Symbol('cancel');
 
 type PromptEntry =
-	| { kind: 'select'; match?: RegExp; response: string | symbol }
-	| { kind: 'confirm'; match?: RegExp; response: boolean | symbol }
-
-export const select = <T>(
-	value: T | symbol,
-	match?: string | RegExp
-): PromptEntry => ({
-	kind: 'select',
-	match: typeof match === 'string' ? new RegExp(match) : match,
-	response: typeof value === 'symbol' ? value : String(value),
-})
-
-export const confirm = (
-	value: boolean | symbol,
-	match?: string | RegExp
-): PromptEntry => ({
-	kind: 'confirm',
-	match: typeof match === 'string' ? new RegExp(match) : match,
-	response: value,
-})
+  | { kind: 'confirm'; match?: RegExp; response: boolean | symbol }
+  | { kind: 'multiselect'; match?: RegExp; response: (string | symbol)[] }
+  | { kind: 'select'; match?: RegExp; response: string | symbol }
+  | { kind: 'text'; match?: RegExp; response: string | symbol };
+
+export const select = <T>(value: symbol | T, match?: RegExp | string): PromptEntry => ({
+  kind: 'select',
+  match: typeof match === 'string' ? new RegExp(match) : match,
+  response: typeof value === 'symbol' ? value : String(value),
+});
+
+export const text = (value: string | symbol, match?: RegExp | string): PromptEntry => ({
+  kind: 'text',
+  match: typeof match === 'string' ? new RegExp(match) : match,
+  response: value,
+});
+
+export const confirm = (value: boolean | symbol, match?: RegExp | string): PromptEntry => ({
+  kind: 'confirm',
+  match: typeof match === 'string' ? new RegExp(match) : match,
+  response: value,
+});
+
+export const multiselect = <T>(values: symbol | T[], match?: RegExp | string): PromptEntry => ({
+  kind: 'multiselect',
+  match: typeof match === 'string' ? new RegExp(match) : match,
+  response: values === CANCEL ? [CANCEL] : ((values as T[]).map(String) as (string | symbol)[]),
+});
 
 export class FakePrompter implements Prompter {
-	private _calls: Array<{ method: string; args: unknown }> = []
-	private _cursor = 0
-
-	constructor(private readonly _script: PromptEntry[]) {}
-
-	intro(message: string): void {
-		this._calls.push({ method: 'intro', args: { message } })
-	}
-	outro(message: string): void {
-		this._calls.push({ method: 'outro', args: { message } })
-	}
-	note(message: string, title?: string): void {
-		this._calls.push({ method: 'note', args: { message, title } })
-	}
-	spinner(): Spinner {
-		return {
-			start: (msg: string) => {
-				this._calls.push({ method: 'spinner.start', args: { message: msg } })
-			},
-			stop: (msg: string) => {
-				this._calls.push({ method: 'spinner.stop', args: { message: msg } })
-			},
-		}
-	}
-
-	async select<T>(opts: { message: string }): Promise<T> {
-		this._calls.push({ method: 'select', args: opts })
-		const entry = this._script[this._cursor++]
-		if (!entry) throw new Error(`No script entry for select #${this._cursor} (${opts.message})`)
-		if (entry.kind !== 'select') throw new Error(`Expected confirm, got select for ${opts.message}`)
-		if (entry.match && !entry.match.test(opts.message)) throw new Error(`Message mismatch: got "${opts.message}"`)
-		if (entry.response === CANCEL) throw new CancelledError()
-		return entry.response as T
-	}
-
-	async confirm(opts: { message: string }): Promise<boolean> {
-		this._calls.push({ method: 'confirm', args: opts })
-		const entry = this._script[this._cursor++]
-		if (!entry) throw new Error(`No script entry for confirm #${this._cursor} (${opts.message})`)
-		if (entry.kind !== 'confirm') throw new Error(`Expected select, got confirm for ${opts.message}`)
-		if (entry.match && !entry.match.test(opts.message)) throw new Error(`Message mismatch: got "${opts.message}"`)
-		if (entry.response === CANCEL) throw new CancelledError()
-		return entry.response as boolean
-	}
-
-	get calls() {
-		return this._calls
-	}
-
-	assertExhausted() {
-		if (this._cursor !== this._script.length) {
-			throw new Error(`Script not exhausted: ${this._script.length - this._cursor} entries left`)
-		}
-	}
+  get calls() {
+    return this._calls;
+  }
+  private _calls: Array<{ args: unknown; method: string }> = [];
+
+  private _cursor = 0;
+
+  constructor(private readonly _script: PromptEntry[]) {}
+  assertExhausted() {
+    if (this._cursor !== this._script.length) {
+      throw new Error(`Script not exhausted: ${this._script.length - this._cursor} entries left`);
+    }
+  }
+  async confirm(options: { message: string }): Promise<boolean> {
+    this._calls.push({ args: options, method: 'confirm' });
+    const entry = this._script[this._cursor++];
+    if (!entry)
+      throw new Error(`No script entry for confirm #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'confirm')
+      throw new Error(`Expected confirm, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
+    if (entry.response === CANCEL) throw new CancelledError();
+    return entry.response as boolean;
+  }
+  intro(message: string): void {
+    this._calls.push({ args: { message }, method: 'intro' });
+  }
+
+  async multiselect<T>(options: { message: string }): Promise<T[]> {
+    this._calls.push({ args: options, method: 'multiselect' });
+    const entry = this._script[this._cursor++];
+    if (!entry)
+      throw new Error(`No script entry for multiselect #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'multiselect')
+      throw new Error(`Expected multiselect, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
+    if (entry.response.includes(CANCEL)) throw new CancelledError();
+    return entry.response as T[];
+  }
+
+  note(message: string, title?: string): void {
+    this._calls.push({ args: { message, title }, method: 'note' });
+  }
+
+  outro(message: string): void {
+    this._calls.push({ args: { message }, method: 'outro' });
+  }
+
+  async select<T>(options: { message: string }): Promise<T> {
+    this._calls.push({ args: options, method: 'select' });
+    const entry = this._script[this._cursor++];
+    if (!entry) throw new Error(`No script entry for select #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'select')
+      throw new Error(`Expected select, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
+    if (entry.response === CANCEL) throw new CancelledError();
+    return entry.response as T;
+  }
+
+  spinner(): Spinner {
+    return {
+      start: (message: string) => {
+        this._calls.push({ args: { message: message }, method: 'spinner.start' });
+      },
+      stop: (message: string) => {
+        this._calls.push({ args: { message: message }, method: 'spinner.stop' });
+      },
+    };
+  }
+
+  async text(options: { message: string }): Promise<string> {
+    this._calls.push({ args: options, method: 'text' });
+    const entry = this._script[this._cursor++];
+    if (!entry) throw new Error(`No script entry for text #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'text')
+      throw new Error(`Expected text, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
+    if (entry.response === CANCEL) throw new CancelledError();
+    return entry.response as string;
+  }
 }