@laurence79/wireit 0.14.13-shared-cache.0

package/lib/error.js

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as pathlib from 'path';
+export class DiagnosticPrinter {
+    #cwd;
+    /**
+     * @param workingDir Paths are printed relative to this directory.
+     */
+    constructor(workingDir) {
+        this.#cwd = workingDir;
+    }
+    print(diagnostic) {
+        if (diagnostic.location.range.length < 0) {
+            throw new Error(`Internal error: got a negative length squiggle for ${diagnostic.message}: ${diagnostic.location.range.length}`);
+        }
+        const path = this.#formatPath(diagnostic.location);
+        let result = `❌ ${path} ${diagnostic.message}
+${drawSquiggle(diagnostic.location, 4)}`;
+        if (diagnostic.supplementalLocations) {
+            for (const supplementalLocation of diagnostic.supplementalLocations) {
+                result += '\n\n' + this.#printSupplemental(supplementalLocation);
+            }
+        }
+        return result;
+    }
+    #printSupplemental(supplemental) {
+        const squiggle = drawSquiggle(supplemental.location, 8);
+        const path = this.#formatPath(supplemental.location);
+        return `    ${path} ${supplemental.message}\n${squiggle}`;
+    }
+    #formatPath(location) {
+        const relPath = pathlib.relative(this.#cwd, location.file.path);
+        const { line, character } = this.#offsetToPosition(location.file, location.range.offset);
+        return `${CYAN}${relPath}${RESET}:${YELLOW}${line}${RESET}:${YELLOW}${character}${RESET}`;
+    }
+    #offsetToPosition(file, offset) {
+        return OffsetToPositionConverter.get(file).toPosition(offset);
+    }
+}
+export class OffsetToPositionConverter {
+    static #cache = new WeakMap();
+    static get(file) {
+        let converter = OffsetToPositionConverter.#cache.get(file);
+        if (converter === undefined) {
+            converter = new OffsetToPositionConverter(file.contents);
+            OffsetToPositionConverter.#cache.set(file, converter);
+        }
+        return converter;
+    }
+    static createUncachedForTest(contents) {
+        return new OffsetToPositionConverter(contents);
+    }
+    constructor(contents) {
+        const indexes = [];
+        for (let i = 0; i < contents.length; i++) {
+            if (contents[i] === '\n') {
+                indexes.push(i);
+            }
+        }
+        this.newlineIndexes = indexes;
+    }
+    toPosition(offset) {
+        if (this.newlineIndexes.length === 0) {
+            return { line: 1, character: offset + 1 };
+        }
+        const line = this.newlineIndexes.findIndex((index) => index >= offset);
+        if (line === 0) {
+            return { line: 1, character: offset + 1 };
+        }
+        if (line === -1) {
+            return {
+                line: this.newlineIndexes.length + 1,
+                character: offset - (this.newlineIndexes[this.newlineIndexes.length - 1] ?? 0),
+            };
+        }
+        return {
+            line: line + 1,
+            character: offset - (this.newlineIndexes[line - 1] ?? 0),
+        };
+    }
+    toIdePosition(offset) {
+        const position = this.toPosition(offset);
+        return { line: position.line - 1, character: position.character - 1 };
+    }
+    toIdeRange(range) {
+        const start = this.toIdePosition(range.offset);
+        const end = this.toIdePosition(range.offset + range.length);
+        return { start, end };
+    }
+    idePositionToOffset(position) {
+        let lineOffset = this.newlineIndexes[position.line - 1];
+        lineOffset = lineOffset === undefined ? 0 : lineOffset + 1;
+        return lineOffset + position.character;
+    }
+    ideRangeToRange(range) {
+        const start = this.idePositionToOffset(range.start);
+        const end = this.idePositionToOffset(range.end);
+        return { offset: start, length: end - start };
+    }
+}
+const CYAN = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const RESET = '\x1b[0m';
+// Exported for testing
+export function drawSquiggle(location, indent) {
+    let { range: { offset, length }, } = location;
+    const fileContents = location.file.contents;
+    const startOfInitialLine = fileContents.slice(0, offset).lastIndexOf('\n') + 1;
+    const uncorrectedFirstNewlineIndexAfter = fileContents
+        .slice(offset + length)
+        .indexOf('\n');
+    const endOfLastLine = uncorrectedFirstNewlineIndexAfter === -1
+        ? undefined
+        : offset + length + uncorrectedFirstNewlineIndexAfter;
+    offset = offset - startOfInitialLine;
+    const sectionToPrint = fileContents.slice(startOfInitialLine, endOfLastLine);
+    let result = '';
+    for (const line of sectionToPrint.split('\n')) {
+        result += `${' '.repeat(indent)}${line}\n`;
+        const squiggleLength = Math.min(line.length - offset, length);
+        result +=
+            ' '.repeat(offset + indent) +
+                `${RED}${'~'.repeat(squiggleLength)}${RESET}\n`;
+        offset = 0;
+        length -= squiggleLength + 1; // +1 to account for the newline
+    }
+    // Drop the last newline.
+    return result.slice(0, -1);
+}
+export const offsetInsideRange = (offset, range) => offset >= range.offset && offset < range.offset + range.length;
+export const offsetInsideNamedNode = (offset, namedNode) => {
+    const valueEnd = namedNode.offset + namedNode.length;
+    const totalLength = valueEnd - namedNode.name.offset;
+    return offsetInsideRange(offset, {
+        offset: namedNode.name.offset,
+        length: totalLength,
+    });
+};
+/**
+ * Convert an unexpected exception to a {@link UnknownErrorThrown} failure,
+ * which includes the sript context for better debugging.
+ */
+export function convertExceptionToFailure(error, script) {
+    return {
+        ok: false,
+        error: [
+            {
+                type: 'failure',
+                reason: 'unknown-error-thrown',
+                script,
+                error,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=error.js.map

package/lib/event.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=event.js.map

package/lib/execution/base.js

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { shuffle } from '../util/shuffle.js';
+import { Deferred } from '../util/deferred.js';
+import { convertExceptionToFailure } from '../error.js';
+let executionConstructorHook;
+/**
+ * For GC testing only. A function that is called whenever an Execution is
+ * constructed.
+ */
+export function registerExecutionConstructorHook(fn) {
+    executionConstructorHook = fn;
+}
+/**
+ * A single execution of a specific script.
+ */
+export class BaseExecution {
+    #fingerprint;
+    constructor(config, executor, logger) {
+        executionConstructorHook?.(this);
+        this._config = config;
+        this._executor = executor;
+        this._logger = logger;
+    }
+    /**
+     * Execute this script and return its fingerprint. Cached, so safe to call
+     * multiple times.
+     */
+    async execute() {
+        try {
+            return await (this.#fingerprint ??= this._execute());
+        }
+        catch (error) {
+            return convertExceptionToFailure(error, this._config);
+        }
+    }
+    /**
+     * Execute all of this script's dependencies.
+     */
+    async _executeDependencies() {
+        // Randomize the order we execute dependencies to make it less likely for a
+        // user to inadvertently depend on any specific order, which could indicate
+        // a missing edge in the dependency graph.
+        shuffle(this._config.dependencies);
+        const dependencyResults = await Promise.all(this._config.dependencies.map((dependency) => {
+            return this._executor.getExecution(dependency.config).execute();
+        }));
+        const results = [];
+        const errors = new Set();
+        for (let i = 0; i < dependencyResults.length; i++) {
+            const result = dependencyResults[i];
+            if (!result.ok) {
+                for (const error of result.error) {
+                    errors.add(error);
+                }
+            }
+            else {
+                results.push([this._config.dependencies[i], result.value]);
+            }
+        }
+        if (errors.size > 0) {
+            return { ok: false, error: [...errors] };
+        }
+        return { ok: true, value: results };
+    }
+}
+/**
+ * A single execution of a specific script which has a command.
+ */
+export class BaseExecutionWithCommand extends BaseExecution {
+    constructor() {
+        super(...arguments);
+        this._servicesNotNeeded = new Deferred();
+        /**
+         * Resolves when this script no longer needs any of its service dependencies
+         * to be running. This could happen because it finished, failed, or never
+         * needed to run at all.
+         */
+        this.servicesNotNeeded = this._servicesNotNeeded.promise;
+        /**
+         * Resolves when any of the services this script depends on have terminated
+         * (see {@link ServiceScriptExecution.terminated} for exact definiton).
+         */
+        this._anyServiceTerminated = Promise.race(this._config.services.map((service) => this._executor.getExecution(service).terminated));
+    }
+    /**
+     * Ensure that all of the services this script depends on are running.
+     */
+    async _startServices() {
+        if (this._config.services.length > 0) {
+            const results = await Promise.all(this._config.services.map((service) => this._executor.getExecution(service).start()));
+            const errors = [];
+            for (const result of results) {
+                if (!result.ok) {
+                    errors.push(result.error);
+                }
+            }
+            if (errors.length > 0) {
+                return { ok: false, error: errors };
+            }
+        }
+        return { ok: true, value: undefined };
+    }
+}
+//# sourceMappingURL=base.js.map

package/lib/execution/no-command.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseExecution } from './base.js';
+import { Fingerprint } from '../fingerprint.js';
+/**
+ * Execution for a {@link NoCommandScriptConfig}.
+ */
+export class NoCommandScriptExecution extends BaseExecution {
+    async _execute() {
+        const dependencyFingerprints = await this._executeDependencies();
+        if (!dependencyFingerprints.ok) {
+            return dependencyFingerprints;
+        }
+        const fingerprint = await Fingerprint.compute(this._config, dependencyFingerprints.value);
+        if (!fingerprint.ok) {
+            return {
+                ok: false,
+                error: [fingerprint.error],
+            };
+        }
+        this._logger.log({
+            script: this._config,
+            type: 'success',
+            reason: 'no-command',
+        });
+        return { ok: true, value: fingerprint.value };
+    }
+}
+//# sourceMappingURL=no-command.js.map