@wpelevator/wp-release 0.12.0 → 0.14.0

package/dist/changeset-dependents.d.ts

@@ -2,6 +2,7 @@ import type { ChangesetConfig, DependentsConfig } from './changeset-config.ts';
 import type { ChangedPackages, ConfiguredPackage } from './changeset-packages.ts';
 import type { Changeset, ChangesetPackage, ChangesetReleasePlan, PackageRelease } from './changesets.ts';
 import type { FileJournal } from './file-journal.ts';
+import type { ReleaseRepository } from './release-repository.ts';
 /**
  * A declared dependency of a package on another configured package.
  */
@@ -67,16 +68,26 @@ export declare function assertDependentsSourcesReleased(plan: ChangesetReleasePl
  * with its sources, which the release pull request already announces when
  * the changesets of the diff release one of them. Exempting its package
  * manifest pin change keeps the check from demanding an entry for what
- * versioning rewrites anyway; documentation and code changes still need
- * their own changesets.
+ * versioning rewrites anyway. Any other change, like documentation, code or
+ * another manifest field or dependency, still needs its own changeset.
  *
- * @param changed          Changed packages and their files.
- * @param changesetsInDiff Changesets added or changed by the diff.
- * @param packages         Discovered packages.
- * @param config           Repository release configuration.
- * @return Names of the packages whose only changes are manifests of released dependents.
+ * @param input                  Changes of the diff and the repository.
+ * @param input.changed          Changed packages and their files.
+ * @param input.changesetsInDiff Changesets added or changed by the diff.
+ * @param input.packages         Discovered packages.
+ * @param input.config           Repository release configuration.
+ * @param input.repository       Repository to read the base manifests from.
+ * @param input.since            Base ref of the diff, like origin/main.
+ * @return Names of the packages whose only changes are pins of released sources.
  */
-export declare function findBundledPinChanges(changed: ChangedPackages, changesetsInDiff: Changeset[], packages: ConfiguredPackage[], config: ChangesetConfig): Promise<Set<string>>;
+export declare function findBundledPinChanges(input: {
+    changed: ChangedPackages;
+    changesetsInDiff: Changeset[];
+    packages: ConfiguredPackage[];
+    config: ChangesetConfig;
+    repository: ReleaseRepository;
+    since: string;
+}): Promise<Set<string>>;
 /**
  * Check whether a changeset names a package.
  *

package/dist/changeset-dependents.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import semverSatisfies from 'semver/functions/satisfies.js';
 import validRange from 'semver/ranges/valid.js';
 import { assertKnownPackages, globRegExp } from "./changeset-packages.js";
@@ -208,57 +209,118 @@ export async function assertDependentsSourcesReleased(plan, fullPlan, packages,
  * with its sources, which the release pull request already announces when
  * the changesets of the diff release one of them. Exempting its package
  * manifest pin change keeps the check from demanding an entry for what
- * versioning rewrites anyway; documentation and code changes still need
- * their own changesets.
+ * versioning rewrites anyway. Any other change, like documentation, code or
+ * another manifest field or dependency, still needs its own changeset.
  *
- * @param changed          Changed packages and their files.
- * @param changesetsInDiff Changesets added or changed by the diff.
- * @param packages         Discovered packages.
- * @param config           Repository release configuration.
- * @return Names of the packages whose only changes are manifests of released dependents.
+ * @param input                  Changes of the diff and the repository.
+ * @param input.changed          Changed packages and their files.
+ * @param input.changesetsInDiff Changesets added or changed by the diff.
+ * @param input.packages         Discovered packages.
+ * @param input.config           Repository release configuration.
+ * @param input.repository       Repository to read the base manifests from.
+ * @param input.since            Base ref of the diff, like origin/main.
+ * @return Names of the packages whose only changes are pins of released sources.
  */
-export async function findBundledPinChanges(changed, changesetsInDiff, packages, config) {
+export async function findBundledPinChanges(input) {
+    const { changed, changesetsInDiff, packages, config, repository, since } = input;
     const candidates = changed.packages.filter((pkg) => undefined !== config.dependents &&
         !hasChangeset(changesetsInDiff, pkg.name) &&
-        (changed.filesByPackage[pkg.name] ?? []).every((file) => 'package.json' === path.basename(file)));
+        (changed.filesByPackage[pkg.name] ?? []).every((file) => repository.relativePath(manifestFile(pkg)) === file));
     const bundled = await Promise.all(candidates.map(async (pkg) => {
-        const sources = await collectDeclarationNames(pkg, packages, config);
-        return sources.some((source) => hasChangeset(changesetsInDiff, source))
-            ? pkg.name
-            : undefined;
+        const identifiers = await collectReleasedIdentifiers(pkg, packages, config, changesetsInDiff);
+        const pinsOnly = identifiers.length > 0 &&
+            (await changesOnlyPins({
+                pkg,
+                identifiers,
+                sections: dependentsSections(config.dependents),
+                repository,
+                since,
+            }));
+        return pinsOnly ? pkg.name : undefined;
     }));
     return new Set(bundled.filter((name) => undefined !== name));
 }
 /**
- * Check whether a changeset names a package.
+ * Collect the identifiers that a package declares for the configured sources
+ * released by the changesets, by the dependency sections of the policy,
+ * without resolving the specs against the versions. The changeset check uses
+ * this to see through a pin that the versioning will rewrite after the
+ * source releases.
  *
- * @param changesets Changesets.
- * @param name       Package name.
- * @return Whether one of the changesets names the package.
+ * @param pkg        Planned package.
+ * @param packages   Discovered packages.
+ * @param config     Repository release configuration.
+ * @param changesets Changesets that release the sources.
+ * @return Declared identifiers of the released sources, like npm package names.
  */
-export function hasChangeset(changesets, name) {
-    return changesets.some((changeset) => Object.hasOwn(changeset.packages, name));
+async function collectReleasedIdentifiers(pkg, packages, config, changesets) {
+    const identifiers = [];
+    for (const source of packages) {
+        const specs = pkg.name !== source.name && hasChangeset(changesets, source.name)
+            ? await findNpmSpecs(pkg, source, dependentsSections(config.dependents))
+            : [];
+        identifiers.push(...specs.map(({ name }) => name));
+    }
+    return identifiers;
 }
 /**
- * Collect the names of the configured sources that a package declares, by the
- * dependency sections of the policy, without resolving the specs against the
- * versions. The changeset check uses this to see through a pin that the
- * versioning will rewrite after the source releases.
+ * Check whether the package manifest differs from the base only in the specs
+ * of the given identifiers. A manifest that the diff adds has no base and
+ * always counts as a change of its own.
  *
- * @param pkg      Planned package.
- * @param packages Discovered packages.
- * @param config   Repository release configuration.
- * @return Release package names the package declares.
+ * @param input             Package, identifiers and the repository.
+ * @param input.pkg         Changed package.
+ * @param input.identifiers Declared identifiers whose specs may differ.
+ * @param input.sections    Dependency sections of the policy.
+ * @param input.repository  Repository to read the base manifest from.
+ * @param input.since       Base ref of the diff, like origin/main.
+ * @return Whether only the specs of the identifiers changed.
  */
-async function collectDeclarationNames(pkg, packages, config) {
-    const names = [];
-    for (const source of packages) {
-        if (pkg.name !== source.name &&
-            (await findNpmSpecs(pkg, source, dependentsSections(config.dependents))).length > 0) {
-            names.push(source.name);
+async function changesOnlyPins(input) {
+    const { pkg, identifiers, sections, repository, since } = input;
+    const base = await repository.readFileAtMergeBase(since, manifestFile(pkg));
+    const head = await readJsonIfExists(manifestFile(pkg));
+    return (undefined !== base &&
+        undefined !== head &&
+        isDeepStrictEqual(withoutSpecs(JSON.parse(base), sections, identifiers), withoutSpecs(head, sections, identifiers)));
+}
+/**
+ * Copy a manifest without the specs of the given identifiers in the
+ * dependency sections.
+ *
+ * @param manifest    Parsed package manifest.
+ * @param sections    Dependency sections.
+ * @param identifiers Declared identifiers to drop.
+ * @return Manifest copy without those specs.
+ */
+function withoutSpecs(manifest, sections, identifiers) {
+    const stripped = { ...manifest };
+    for (const section of sections) {
+        const specs = manifest[section];
+        if ('object' === typeof specs && null !== specs) {
+            stripped[section] = Object.fromEntries(Object.entries(specs).filter(([name]) => !identifiers.includes(name)));
         }
     }
-    return names;
+    return stripped;
+}
+/**
+ * The npm manifest of a package.
+ *
+ * @param pkg Package.
+ * @return Absolute manifest path.
+ */
+function manifestFile(pkg) {
+    return path.join(pkg.directory, 'package.json');
+}
+/**
+ * Check whether a changeset names a package.
+ *
+ * @param changesets Changesets.
+ * @param name       Package name.
+ * @return Whether one of the changesets names the package.
+ */
+export function hasChangeset(changesets, name) {
+    return changesets.some((changeset) => Object.hasOwn(changeset.packages, name));
 }
 /**
  * Collect the names of the configured sources that a package builds against,

package/dist/changeset-files.d.ts

@@ -11,13 +11,14 @@ export declare function readChangesets(directory: string): Promise<Changeset[]>;
 /**
  * Pick the changesets that were added or changed since a ref.
  *
- * @param repository Repository of the changesets.
- * @param directory  Changeset directory.
- * @param changesets Pending changesets.
- * @param since      Base ref, like origin/main.
+ * @param repository  Repository of the changesets.
+ * @param directory   Changeset directory.
+ * @param changesets  Pending changesets.
+ * @param since       Base ref, like origin/main.
+ * @param uncommitted Whether to include uncommitted and untracked changesets.
  * @return Changesets of the diff.
  */
-export declare function readChangesetsSince(repository: ReleaseRepository, directory: string, changesets: Changeset[], since: string): Promise<Changeset[]>;
+export declare function readChangesetsSince(repository: ReleaseRepository, directory: string, changesets: Changeset[], since: string, uncommitted?: boolean): Promise<Changeset[]>;
 /**
  * Create a Changesets-compatible Markdown file.
  *

package/dist/changeset-files.js

@@ -28,17 +28,19 @@ export async function readChangesets(directory) {
 /**
  * Pick the changesets that were added or changed since a ref.
  *
- * @param repository Repository of the changesets.
- * @param directory  Changeset directory.
- * @param changesets Pending changesets.
- * @param since      Base ref, like origin/main.
+ * @param repository  Repository of the changesets.
+ * @param directory   Changeset directory.
+ * @param changesets  Pending changesets.
+ * @param since       Base ref, like origin/main.
+ * @param uncommitted Whether to include uncommitted and untracked changesets.
  * @return Changesets of the diff.
  */
-export async function readChangesetsSince(repository, directory, changesets, since) {
+export async function readChangesetsSince(repository, directory, changesets, since, uncommitted = false) {
     const relativeDirectory = repository.relativePath(directory);
     const changedFiles = new Set(await repository.getChangedFiles(since, {
         directory,
         diffFilter: 'ACMR',
+        uncommitted,
     }));
     return changesets.filter((changeset) => changedFiles.has(path.posix.join(relativeDirectory, changeset.fileName)));
 }

package/dist/changeset-packages.d.ts

@@ -1,4 +1,4 @@
-import type { ChangesetConfig, ChangesetPackageGroup } from './changeset-config.ts';
+import type { ChangesetConfig, ChangesetPackageGroup, DeployPackage, PackageVersionConfig } from './changeset-config.ts';
 import type { ChangesetPackage } from './changesets.ts';
 import type { ReleaseRepository } from './release-repository.ts';
 /**
@@ -6,7 +6,14 @@ import type { ReleaseRepository } from './release-repository.ts';
  */
 export interface ConfiguredPackage extends ChangesetPackage {
     group: ChangesetPackageGroup;
-    versionConfig: ChangesetPackageGroup['version'];
+    versionConfig: PackageVersionConfig;
+}
+/**
+ * A discovered package with the configuration of its group, without reading
+ * its version, which may have no version or deploy configuration.
+ */
+export interface ConfiguredDeployPackage extends DeployPackage {
+    group: ChangesetPackageGroup;
 }
 export interface ChangedPackages {
     /** Packages with changed files, in the configured order. */
@@ -16,7 +23,8 @@ export interface ChangedPackages {
 }
 /**
  * Find the packages of the configured package groups, with their current
- * versions.
+ * versions. Groups without a version configuration aren't released with
+ * changesets, so they're left out.
  *
  * @param  repository Repository the packages are in.
  * @param  config     Repository release configuration.
@@ -24,6 +32,26 @@ export interface ChangedPackages {
  * @throws {ValidationError} For a glob without matches or a duplicate package name.
  */
 export declare function discoverPackages(repository: ReleaseRepository, config: ChangesetConfig): Promise<ConfiguredPackage[]>;
+/**
+ * Find the packages of every package group, with or without a version or
+ * deploy configuration, without reading their versions.
+ *
+ * @param  repository Repository the packages are in.
+ * @param  config     Repository release configuration.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} For a glob without matches or a duplicate package name.
+ */
+export declare function discoverConfiguredPackages(repository: ReleaseRepository, config: ChangesetConfig): Promise<ConfiguredDeployPackage[]>;
+/**
+ * Find the packages of the package groups with deploy targets, including the
+ * groups without a version configuration, without reading their versions.
+ *
+ * @param  repository Repository the packages are in.
+ * @param  config     Repository release configuration.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} For a glob without matches or a duplicate package name.
+ */
+export declare function discoverDeployPackages(repository: ReleaseRepository, config: ChangesetConfig): Promise<ConfiguredDeployPackage[]>;
 /**
  * Fail for package names that aren't configured.
  *
@@ -33,15 +61,34 @@ export declare function discoverPackages(repository: ReleaseRepository, config:
  */
 export declare function assertKnownPackages(packages: ChangesetPackage[], names: string[]): void;
 /**
- * Find the packages with files changed between the merge base of a ref and
- * HEAD.
+ * Find a package by its identifier, or by its path under the configured root,
+ * so that contributors can name a package by the directory they changed.
  *
- * @param repository Repository the packages are in.
  * @param packages   Discovered packages.
- * @param since      Base ref, like origin/main.
+ * @param identifier Package identifier or path, like plugins/alpha or plugins/alpha/.
+ * @return The package, or undefined when none matches.
+ */
+export declare function findPackage<Package extends Pick<ChangesetPackage, 'name' | 'path'>>(packages: Package[], identifier: string): Package | undefined;
+/**
+ * Resolve package identifiers or paths to the package identifiers.
+ *
+ * @param  packages    Discovered packages.
+ * @param  identifiers Package identifiers or paths under the configured root.
+ * @return Package identifiers, in the given order.
+ * @throws {ValidationError} For an unknown package.
+ */
+export declare function resolvePackageNames(packages: ChangesetPackage[], identifiers: string[]): string[];
+/**
+ * Find the packages with files changed between the merge base of a ref and
+ * HEAD, or the working tree.
+ *
+ * @param repository  Repository the packages are in.
+ * @param packages    Discovered packages.
+ * @param since       Base ref, like origin/main.
+ * @param uncommitted Whether to include uncommitted and untracked files.
  * @return Changed packages and their changed files.
  */
-export declare function getChangedPackages(repository: ReleaseRepository, packages: ConfiguredPackage[], since: string): Promise<ChangedPackages>;
+export declare function getChangedPackages(repository: ReleaseRepository, packages: ConfiguredPackage[], since: string, uncommitted?: boolean): Promise<ChangedPackages>;
 /**
  * Remove the release configuration from a package passed to config callbacks.
  *

package/dist/changeset-packages.js

@@ -7,7 +7,8 @@ import { readVersion } from "./version-files.js";
 const SKIPPED_DIRECTORIES = ['.git', 'node_modules', 'vendor', 'dist'];
 /**
  * Find the packages of the configured package groups, with their current
- * versions.
+ * versions. Groups without a version configuration aren't released with
+ * changesets, so they're left out.
  *
  * @param  repository Repository the packages are in.
  * @param  config     Repository release configuration.
@@ -15,13 +16,50 @@ const SKIPPED_DIRECTORIES = ['.git', 'node_modules', 'vendor', 'dist'];
  * @throws {ValidationError} For a glob without matches or a duplicate package name.
  */
 export async function discoverPackages(repository, config) {
+    const found = await findGroupPackages(repository, config, config.packages.filter((group) => group.version));
+    const packages = [];
+    for (const pkg of found) {
+        const versionConfig = pkg.group.version;
+        packages.push({
+            ...pkg,
+            currentVersion: await readVersion(repository, pkg.directory, versionConfig.from, pkg),
+            versionConfig,
+        });
+    }
+    return packages;
+}
+/**
+ * Find the packages of every package group, with or without a version or
+ * deploy configuration, without reading their versions.
+ *
+ * @param  repository Repository the packages are in.
+ * @param  config     Repository release configuration.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} For a glob without matches or a duplicate package name.
+ */
+export async function discoverConfiguredPackages(repository, config) {
+    return findGroupPackages(repository, config, config.packages);
+}
+/**
+ * Find the packages of the package groups with deploy targets, including the
+ * groups without a version configuration, without reading their versions.
+ *
+ * @param  repository Repository the packages are in.
+ * @param  config     Repository release configuration.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} For a glob without matches or a duplicate package name.
+ */
+export async function discoverDeployPackages(repository, config) {
+    return findGroupPackages(repository, config, config.packages.filter((group) => group.deploy));
+}
+async function findGroupPackages(repository, config, groups) {
     const root = path.resolve(repository.cwd, config.root ?? '.');
     const packages = [];
-    const hasRecursiveGlob = config.packages.some((item) => item.glob.split('/').includes('**'));
+    const hasRecursiveGlob = groups.some((item) => item.glob.split('/').includes('**'));
     const directories = await findDirectories(root, '', hasRecursiveGlob
         ? Infinity
-        : Math.max(1, ...config.packages.map((item) => item.glob.split('/').length + 2)));
-    for (const group of config.packages) {
+        : Math.max(1, ...groups.map((item) => item.glob.split('/').length + 2)));
+    for (const group of groups) {
         const matcher = globRegExp(group.glob);
         const candidates = matcher.test('.')
             ? ['.', ...directories]
@@ -36,7 +74,6 @@ export async function discoverPackages(repository, config) {
         for (const relativePath of matches) {
             const directory = path.join(root, relativePath);
             const name = await packageName(directory, relativePath, group.idFrom ?? 'path');
-            const currentVersion = await readVersion(repository, directory, group.version.from, relativePath, group.tagType);
             if (packages.some((pkg) => pkg.name === name)) {
                 throw new ValidationError(`Package identifier "${name}" is configured more than once.`);
             }
@@ -45,9 +82,7 @@ export async function discoverPackages(repository, config) {
                 directory,
                 path: relativePath,
                 type: packageType(group),
-                currentVersion,
                 group,
-                versionConfig: group.version,
             });
         }
     }
@@ -68,16 +103,52 @@ export function assertKnownPackages(packages, names) {
     });
 }
 /**
- * Find the packages with files changed between the merge base of a ref and
- * HEAD.
+ * Find a package by its identifier, or by its path under the configured root,
+ * so that contributors can name a package by the directory they changed.
  *
- * @param repository Repository the packages are in.
  * @param packages   Discovered packages.
- * @param since      Base ref, like origin/main.
+ * @param identifier Package identifier or path, like plugins/alpha or plugins/alpha/.
+ * @return The package, or undefined when none matches.
+ */
+export function findPackage(packages, identifier) {
+    const packagePath = identifier
+        .replaceAll('\\', '/')
+        .replace(/^\.\//, '')
+        .replace(/\/+$/, '');
+    return (packages.find((pkg) => pkg.name === identifier) ??
+        packages.find((pkg) => pkg.path === packagePath));
+}
+/**
+ * Resolve package identifiers or paths to the package identifiers.
+ *
+ * @param  packages    Discovered packages.
+ * @param  identifiers Package identifiers or paths under the configured root.
+ * @return Package identifiers, in the given order.
+ * @throws {ValidationError} For an unknown package.
+ */
+export function resolvePackageNames(packages, identifiers) {
+    return identifiers.map((identifier) => {
+        const pkg = findPackage(packages, identifier);
+        if (!pkg) {
+            throw new ValidationError(`Unknown package "${identifier}".`);
+        }
+        return pkg.name;
+    });
+}
+/**
+ * Find the packages with files changed between the merge base of a ref and
+ * HEAD, or the working tree.
+ *
+ * @param repository  Repository the packages are in.
+ * @param packages    Discovered packages.
+ * @param since       Base ref, like origin/main.
+ * @param uncommitted Whether to include uncommitted and untracked files.
  * @return Changed packages and their changed files.
  */
-export async function getChangedPackages(repository, packages, since) {
-    const changedFiles = await repository.getChangedFiles(since);
+export async function getChangedPackages(repository, packages, since, uncommitted = false) {
+    const changedFiles = await repository.getChangedFiles(since, {
+        uncommitted,
+    });
     const filesByPackage = {};
     const changed = packages.filter((pkg) => {
         const packageFromRepo = repository.relativePath(pkg.directory);
@@ -172,7 +243,7 @@ async function packageName(directory, relativePath, idFrom) {
     return name;
 }
 function packageType(group) {
-    const kind = group.version.from.kind;
+    const kind = group.version?.from.kind;
     if ('wordpress-plugin-header' === kind) {
         return 'plugin';
     }

package/dist/changeset-prompt.d.ts

@@ -0,0 +1,119 @@
+import type { ChangesetPackage, ChangesetPackages } from './changesets.ts';
+import type { OutputStream } from './logger.ts';
+/** Terminal that the prompts read answers from and write questions to. */
+export interface PromptTerminal {
+    input: NodeJS.ReadableStream;
+    output: OutputStream;
+}
+/** Packages to choose from, and the changed ones that are preselected. */
+export interface ChangesetPromptInput {
+    /** Configured packages. */
+    packages: ChangesetPackage[];
+    /** Identifiers of the changed packages without a changeset. */
+    changed: string[];
+    /** Base ref that the changed packages were compared with. */
+    since?: string;
+    /** Release note to use instead of asking for one. */
+    summary?: string;
+}
+/** Answers of the prompts: no packages for an empty changeset. */
+export interface ChangesetPromptAnswers {
+    packages: ChangesetPackages;
+    summary: string;
+}
+/**
+ * Ask for the packages, bumps and release note of a changeset, line by line,
+ * so that it works in any terminal and with piped input.
+ */
+export declare class ChangesetPrompt {
+    readonly terminal: PromptTerminal;
+    private lines;
+    private readline;
+    /**
+     * @param terminal Input to read answers from and output for the questions.
+     */
+    constructor(terminal: PromptTerminal);
+    /**
+     * Ask for the changeset, preselecting the changed packages.
+     *
+     * @param  input Packages, changed packages and an optional release note.
+     * @return Package bumps, empty for no release, and the release note.
+     * @throws {ValidationError} If the input ends before the changeset is complete.
+     */
+    ask(input: ChangesetPromptInput): Promise<ChangesetPromptAnswers>;
+    /**
+     * Stop reading the input, so that the process can exit.
+     */
+    close(): void;
+    /**
+     * Print the numbered packages, marking the changed ones.
+     *
+     * @param input Packages and changed packages.
+     */
+    private listPackages;
+    /**
+     * Get the package question, with the changed packages as the default.
+     *
+     * @param input Packages and changed packages.
+     * @return Question text.
+     */
+    private getPackagesQuestion;
+    /**
+     * Parse the chosen packages.
+     *
+     * @param  answer Comma or space separated numbers, identifiers or paths.
+     * @param  input  Packages and changed packages.
+     * @return Package identifiers, empty for no release.
+     * @throws {ValidationError} For unknown, repeated or missing packages.
+     */
+    private parsePackages;
+    /**
+     * Parse one chosen package.
+     *
+     * @param  token    Package number, identifier or path.
+     * @param  packages Configured packages.
+     * @return Package identifier.
+     * @throws {ValidationError} For an unknown package.
+     */
+    private parsePackage;
+    /**
+     * Parse a bump, patch by default.
+     *
+     * @param  answer Bump name.
+     * @return Bump.
+     * @throws {ValidationError} For an unknown bump.
+     */
+    private parseBump;
+    /**
+     * Parse a release note.
+     *
+     * @param  answer Release note.
+     * @return Trimmed release note.
+     * @throws {ValidationError} For an empty release note.
+     */
+    private parseSummary;
+    /**
+     * Ask a question until the answer parses, printing why it didn't.
+     *
+     * @param question Question text.
+     * @param parse    Parser that throws a ValidationError for invalid answers.
+     * @return Parsed answer.
+     */
+    private askUntilValid;
+    /**
+     * Write a question and read the next line of the input.
+     *
+     * @param  question Question text.
+     * @return Answer line.
+     * @throws {ValidationError} If the input ended.
+     */
+    private readAnswer;
+    /**
+     * Get the lines of the input, reading it from the first question on. The
+     * interface stays in line mode, so the terminal echoes and edits the
+     * answers and Ctrl+C ends the process.
+     *
+     * @return Line iterator.
+     */
+    private getLines;
+}