berget 2.2.6 → 2.2.7

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

@@ -1,47 +1,44 @@
-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, args: readonly string[]) => boolean;
+  response: string | Error | ((command: string, args: readonly string[]) => string | Error);
+};
 
 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
-	}
+  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;
+  }
 }

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 files: Map<string, string> = new Map();
+  private dirs: Set<string> = new Set();
+  private _chmodCalls: Array<{ path: string; mode: number }> = [];
 
-	seed(path: string, content: string): void {
-		this.files.set(path, content)
-	}
+  seed(path: string, content: string): void {
+    this.files.set(path, content);
+  }
 
-	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
-	}
+  async readFile(path: string): Promise<string | null> {
+    return this.files.get(path) ?? null;
+  }
 
-	async writeFile(path: string, content: string): Promise<void> {
-		this.files.set(path, content)
-	}
+  async writeFile(path: string, content: string): Promise<void> {
+    this.files.set(path, content);
+  }
 
-	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 chmod(path: string, mode: number): Promise<void> {
+    this._chmodCalls.push({ path, mode });
+  }
+
+  getWrittenFiles(): Map<string, string> {
+    return new Map(this.files);
+  }
+
+  getChmodCalls(): Array<{ path: string; mode: number }> {
+    return this._chmodCalls;
+  }
 }

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

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