@d-es-ign/stryker-js-core 9.6.0

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './file-utils.js';
+export * from './object-utils.js';
+export * from './string-builder.js';
+export * from './string-utils.js';
+export * from './temporary-directory.js';
+export * from './timer.js';

package/src/utils/json-rpc-event-deserializer.ts

@@ -0,0 +1,48 @@
+const CONTENT_LENGTH_HEADER = 'Content-Length:';
+const CARRIAGE_RETURN_CODE = '\r'.charCodeAt(0);
+const LINE_FEED_CODE = '\n'.charCodeAt(0);
+
+export class JsonRpcEventDeserializer {
+  #chunk = Buffer.alloc(0);
+
+  deserialize(data: Buffer): unknown[] {
+    this.#chunk = Buffer.concat([this.#chunk, data]);
+    const events: unknown[] = [];
+    do {
+      const headerInfo = parseHeader(this.#chunk);
+      if (!headerInfo) {
+        break;
+      }
+      const { header, contentStart } = headerInfo;
+      const contentLengthIndex = header.indexOf(CONTENT_LENGTH_HEADER);
+      const contentLength = parseInt(
+        header
+          .substring(contentLengthIndex + CONTENT_LENGTH_HEADER.length)
+          .trim(),
+        10,
+      );
+      const contentEnd = contentStart + contentLength;
+      if (this.#chunk.length < contentEnd) {
+        // Not enough data yet, wait for next events
+        break;
+      }
+      const content = this.#chunk.subarray(contentStart, contentEnd).toString();
+      this.#chunk = this.#chunk.subarray(contentEnd);
+      events.push(JSON.parse(content));
+    } while (this.#chunk.length > 0);
+    return events;
+  }
+}
+function parseHeader(chunk: Buffer) {
+  for (let i = 0; i < chunk.length; i++) {
+    if (
+      chunk[i] === CARRIAGE_RETURN_CODE &&
+      chunk[i + 1] === LINE_FEED_CODE &&
+      chunk[i + 2] === CARRIAGE_RETURN_CODE &&
+      chunk[i + 3] === LINE_FEED_CODE
+    ) {
+      return { header: chunk.subarray(0, i).toString(), contentStart: i + 4 };
+    }
+  }
+  return undefined;
+}

package/src/utils/object-utils.ts

@@ -0,0 +1,106 @@
+import treeKill from 'tree-kill';
+import { StrykerError, KnownKeys } from '@stryker-mutator/util';
+import {
+  Location,
+  Position,
+  schema,
+  WarningOptions,
+} from '@stryker-mutator/api/core';
+
+export const objectUtils = {
+  /**
+   * Calls a defined callback function on each element of a map, and returns an array that contains the results.
+   *
+   * @param subject The map to act on
+   * @param callbackFn The callback fn
+   * @returns
+   */
+  map<K, V, R>(subject: Map<K, V>, callbackFn: (value: V, key: K) => R): R[] {
+    const results: R[] = [];
+    subject.forEach((value, key) => results.push(callbackFn(value, key)));
+    return results;
+  },
+
+  /**
+   * A wrapper around `process.env` (for testability)
+   */
+  getEnvironmentVariable(nameEnvironmentVariable: string): string | undefined {
+    return process.env[nameEnvironmentVariable];
+  },
+
+  undefinedEmptyString(str: string | undefined): string | undefined {
+    if (str) {
+      return str;
+    }
+    return undefined;
+  },
+
+  getEnvironmentVariableOrThrow(name: string): string {
+    const value = this.getEnvironmentVariable(name);
+    if (value === undefined) {
+      throw new StrykerError(`Missing environment variable "${name}"`);
+    } else {
+      return value;
+    }
+  },
+
+  isWarningEnabled(
+    warningType: KnownKeys<WarningOptions>,
+    warningOptions: WarningOptions | boolean,
+  ): boolean {
+    if (typeof warningOptions === 'boolean') {
+      return warningOptions;
+    } else {
+      return !!warningOptions[warningType];
+    }
+  },
+
+  /**
+   * A wrapper around `process.exitCode = n` (for testability)
+   */
+  setExitCode(n: number): void {
+    process.exitCode = n;
+  },
+
+  kill(pid: number | undefined): Promise<void> {
+    return new Promise((res, rej) => {
+      treeKill(pid!, 'SIGKILL', (err?: Error & { code?: number }) => {
+        if (err && !canIgnore(err.code)) {
+          rej(err);
+        } else {
+          res();
+        }
+      });
+
+      function canIgnore(code: number | undefined) {
+        // https://docs.microsoft.com/en-us/windows/desktop/Debug/system-error-codes--0-499-
+        // these error codes mean the program is _already_ closed.
+        return code === 255 || code === 128;
+      }
+    });
+  },
+
+  /**
+   * Converts an internal StrykerJS 0-based location to a schema.Location (1-based).
+   * @param location the StrykerJS 0-based location
+   * @returns the schema.Location (1-based)
+   */
+  toSchemaLocation(location: Location): schema.Location {
+    return {
+      end: this.toSchemaPosition(location.end),
+      start: this.toSchemaPosition(location.start),
+    };
+  },
+
+  /**
+   * Converts an internal StrykerJS 0-based position to a schema.Position (1-based).
+   * @param pos the StrykerJS 0-based position
+   * @returns the schema.Position (1-based)
+   */
+  toSchemaPosition(pos: Position): schema.Position {
+    return {
+      column: pos.column + 1,
+      line: pos.line + 1,
+    };
+  },
+};

package/src/utils/string-builder.ts

@@ -0,0 +1,30 @@
+import { EOL } from 'os';
+
+// 8kB
+const DEFAULT_MAX_SIZE = 8192;
+
+export class StringBuilder {
+  private currentLength = 0;
+  private readonly strings: string[] = [];
+  private readonly maxSize = DEFAULT_MAX_SIZE;
+
+  public append(str: string): void {
+    this.strings.push(str);
+    this.currentLength += str.length;
+    while (this.currentLength > this.maxSize && this.strings.length > 1) {
+      const shifted = this.strings.shift()!;
+      this.currentLength -= shifted.length;
+    }
+  }
+
+  public toString(): string {
+    return this.strings.join('');
+  }
+
+  public static concat(...builders: StringBuilder[]): string {
+    return builders
+      .map((b) => b.toString())
+      .filter(Boolean)
+      .join(EOL);
+  }
+}

package/src/utils/string-utils.ts

@@ -0,0 +1,61 @@
+import { propertyPath } from '@stryker-mutator/util';
+import { StrykerOptions, schema } from '@stryker-mutator/api/core';
+import emojiRegex from 'emoji-regex';
+
+const emojiRe = emojiRegex();
+
+export function padLeft(input: string): string {
+  return input
+    .split('\n')
+    .map((str) => '\t' + str)
+    .join('\n');
+}
+
+export function plural(items: number): string {
+  if (items > 1) {
+    return 's';
+  } else {
+    return '';
+  }
+}
+
+export function serialize(thing: unknown): string {
+  return JSON.stringify(thing);
+}
+
+export function deserialize<T>(stringified: string): T {
+  return JSON.parse(stringified);
+}
+
+export function getEmojiForStatus(status: schema.MutantStatus): string {
+  switch (status) {
+    case 'Killed':
+      return '✅';
+    case 'NoCoverage':
+      return '🙈';
+    case 'Ignored':
+      return '🤥';
+    case 'Survived':
+      return '👽';
+    case 'Timeout':
+      return '⏰';
+    case 'Pending':
+      return '⌛';
+    case 'RuntimeError':
+    case 'CompileError':
+      return '💥';
+  }
+}
+
+export function stringWidth(input: string): number {
+  let { length } = input;
+  for (const match of input.matchAll(emojiRe)) {
+    length = length - match[0].length + 2;
+  }
+  return length;
+}
+
+/**
+ * Print the name of (or path to) a stryker option
+ */
+export const optionsPath = propertyPath<StrykerOptions>();

package/src/utils/temporary-directory.ts

@@ -0,0 +1,83 @@
+import path from 'path';
+import fs from 'fs';
+
+import { StrykerOptions } from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { Disposable } from 'typed-inject';
+
+export class TemporaryDirectory implements Disposable {
+  #temporaryDirectory?: string;
+  public removeDuringDisposal: boolean;
+
+  public static readonly inject = tokens(
+    commonTokens.logger,
+    commonTokens.options,
+  );
+  constructor(
+    private readonly log: Logger,
+    private readonly options: StrykerOptions,
+  ) {
+    this.removeDuringDisposal = Boolean(options.cleanTempDir);
+  }
+
+  public async initialize(): Promise<void> {
+    const parent = path.resolve(this.options.tempDirName);
+    await fs.promises.mkdir(parent, { recursive: true });
+    this.#temporaryDirectory = await fs.promises.mkdtemp(
+      path.join(parent, this.options.inPlace ? 'backup-' : 'sandbox-'),
+    );
+    this.log.debug('Using temp directory "%s"', this.#temporaryDirectory);
+  }
+
+  get path() {
+    if (!this.#temporaryDirectory) {
+      this.#throwNotInitialized();
+    }
+    return this.#temporaryDirectory;
+  }
+
+  #throwNotInitialized(): never {
+    throw new Error('initialize() was not called!');
+  }
+
+  /**
+   * Deletes the Stryker-temp directory
+   */
+  public async dispose(): Promise<void> {
+    if (this.removeDuringDisposal && this.#temporaryDirectory) {
+      this.log.debug(
+        'Deleting stryker temp directory %s',
+        this.#temporaryDirectory,
+      );
+      try {
+        await fs.promises.rm(this.#temporaryDirectory, {
+          recursive: true,
+          force: true,
+        });
+      } catch {
+        this.log.info(
+          `Failed to delete stryker temp directory ${this.#temporaryDirectory}`,
+        );
+      }
+      try {
+        const lingeringDirectories = await fs.promises.readdir(
+          this.options.tempDirName,
+        );
+        if (!lingeringDirectories.length) {
+          try {
+            await fs.promises.rmdir(this.options.tempDirName);
+          } catch (e) {
+            // It's not THAT important, maybe another StrykerJS process started in the meantime.
+            this.log.debug(
+              `Failed to clean temp ${path.basename(this.options.tempDirName)}`,
+              e,
+            );
+          }
+        }
+      } catch {
+        // Can safely be ignored, the parent directory doesn't exist
+      }
+    }
+  }
+}

package/src/utils/timer.ts

@@ -0,0 +1,58 @@
+export class Timer {
+  private readonly start: Date;
+  private readonly markers: Record<string, Date | undefined> =
+    Object.create(null);
+
+  constructor(private readonly now = () => new Date()) {
+    this.start = this.now();
+  }
+  public humanReadableElapsed(sinceMarker?: string): string {
+    const elapsedSeconds = this.elapsedSeconds(sinceMarker);
+    return new Intl.ListFormat('en').format(
+      [
+        Timer.humanReadableElapsedMinutes(elapsedSeconds),
+        Timer.humanReadableElapsedSeconds(elapsedSeconds),
+      ].filter(Boolean),
+    );
+  }
+
+  public elapsedSeconds(sinceMarker?: string): number {
+    const elapsedMs = this.elapsedMs(sinceMarker);
+    return Math.floor(elapsedMs / 1000);
+  }
+
+  public elapsedMs(sinceMarker?: string): number {
+    const marker = sinceMarker && this.markers[sinceMarker];
+    if (marker) {
+      return this.now().getTime() - marker.getTime();
+    } else {
+      return this.now().getTime() - this.start.getTime();
+    }
+  }
+
+  public mark(name: string): void {
+    this.markers[name] = this.now();
+  }
+
+  private static humanReadableElapsedSeconds(elapsedSeconds: number) {
+    const restSeconds = elapsedSeconds % 60;
+    return this.formatTime('second', restSeconds);
+  }
+
+  private static humanReadableElapsedMinutes(elapsedSeconds: number) {
+    const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+    if (elapsedMinutes === 0) {
+      return '';
+    } else {
+      return this.formatTime('minute', elapsedMinutes);
+    }
+  }
+
+  private static formatTime(word: 'minute' | 'second', elapsed: number) {
+    return elapsed.toLocaleString('en', {
+      unit: word,
+      style: 'unit',
+      unitDisplay: 'long',
+    });
+  }
+}