supertape 9.4.0 → 10.0.0

package/ChangeLog

@@ -1,3 +1,17 @@
+2024.01.26, v10.0.0
+
+feature:
+- 174a856 supertape: help
+- 0e55c2f supertape: isStop
+- 64c7acb supertape: add support of worker_threads
+- 1e4429d supertape: putout v35.0.0
+
+2024.01.05, v9.5.0
+
+feature:
+- 3abf553 supertape: operator: improve fail message when operator returns function
+- 74893c0 supertape: c8 v9.0.0
+
 2023.12.28, v9.4.0
 
 feature:

package/README.md

@@ -56,6 +56,7 @@ Options
    --no-check-scopes           do not check that messages contains scope: 'scope: message'
    --no-check-assertions-count do not check that assertion count is no more then 1
    --no-check-duplicates       do not check messages for duplicates
+   --no-worker                 disable worker thread
 ```
 
 ## Environment variables

package/bin/communication.mjs

@@ -0,0 +1,45 @@
+import {
+    parentPort,
+    workerData,
+} from 'node:worker_threads';
+import {EventEmitter} from 'node:events';
+
+const {assign} = Object;
+
+export const createCommunication = (argv) => {
+    if (parentPort)
+        return {
+            parentPort,
+            workerData,
+        };
+    
+    const {newWorker, newParentPort} = fakeWorkers();
+    
+    return {
+        worker: newWorker,
+        parentPort: newParentPort,
+        workerData: argv,
+    };
+};
+
+export function fakeWorkers() {
+    const newWorker = new EventEmitter();
+    const newParentPort = new EventEmitter();
+    
+    assign(newWorker, {
+        postMessage: (a) => {
+            newParentPort.emit('message', a);
+        },
+    });
+    
+    assign(newParentPort, {
+        postMessage: (a) => {
+            newWorker.emit('message', a);
+        },
+    });
+    
+    return {
+        newParentPort,
+        newWorker,
+    };
+}

package/bin/formatter.mjs

@@ -0,0 +1,63 @@
+import {EventEmitter} from 'node:events';
+
+export const createFormatter = (parentPort) => {
+    const formatter = new EventEmitter();
+    
+    formatter.on('start', ({total}) => {
+        parentPort.postMessage(['start', {
+            total,
+        }]);
+    });
+    
+    formatter.on('test', ({test}) => {
+        parentPort.postMessage(['test', {
+            test,
+        }]);
+    });
+    
+    formatter.on('test:end', ({count, total, failed, test}) => {
+        parentPort.postMessage(['test:end', {
+            total,
+            count,
+            failed,
+            test,
+        }]);
+    });
+    
+    formatter.on('comment', (message) => {
+        parentPort.postMessage(['test:end', {
+            message,
+        }]);
+    });
+    
+    formatter.on('test:success', ({count, message}) => {
+        parentPort.postMessage(['test:success', {
+            count,
+            message,
+        }]);
+    });
+    
+    formatter.on('test:fail', ({at, count, message, operator, result, expected, output, errorStack}) => {
+        parentPort.postMessage(['fail', {
+            at,
+            count,
+            message,
+            operator,
+            result: JSON.stringify(result),
+            expected: JSON.stringify(expected),
+            output,
+            errorStack,
+        }]);
+    });
+    
+    formatter.on('end', ({count, passed, failed, skiped}) => {
+        parentPort.postMessage(['end', {
+            count,
+            passed,
+            failed,
+            skiped,
+        }]);
+    });
+    
+    return formatter;
+};

package/bin/is-stop.mjs

@@ -0,0 +1,17 @@
+import fullstore from 'fullstore';
+
+const noop = () => {};
+
+export const createIsStop = (parentPort) => {
+    if (!parentPort)
+        return noop;
+    
+    const isStop = fullstore(false);
+    
+    parentPort?.on('message', ([event]) => {
+        if (event === 'stop')
+            isStop(true);
+    });
+    
+    return isStop;
+};

package/bin/subscribe.mjs

@@ -0,0 +1,28 @@
+import keyPress from '@putout/cli-keypress';
+import harnessCreator from '../lib/formatter/harness.js';
+
+const {createHarness} = harnessCreator;
+
+const resolveFormatter = async (name) => await import(`@supertape/formatter-${name}`);
+
+export async function subscribe({name, quiet, exit, worker, stdout}) {
+    const {isStop} = keyPress();
+    const harness = createHarness(await resolveFormatter(name));
+    
+    if (!quiet)
+        harness.pipe(stdout);
+    
+    worker.on('exit', (code) => {
+        exit(code);
+    });
+    
+    worker.on('message', ([type, a]) => {
+        harness.write({
+            type,
+            ...a,
+        });
+        
+        if (isStop())
+            worker.postMessage(['stop']);
+    });
+}

package/bin/supertape.mjs

@@ -1,18 +1,43 @@
-#!/usr/bin/env node
-
 import process from 'node:process';
+import {createCommunication} from './communication.mjs';
+import {subscribe} from './subscribe.mjs';
+import {createIsStop} from './is-stop.mjs';
+import {createFormatter} from './formatter.mjs';
+import {parseArgs} from '../lib/cli/parse-args.js';
 import cli from '../lib/cli.js';
 
+const {
+    worker,
+    parentPort,
+    workerData,
+} = createCommunication(process.argv);
+
+const args = parseArgs(process.argv.slice(2));
+
 const {
     stdout,
     stderr,
     exit,
 } = process;
 
-export default cli({
+const workerFormatter = createFormatter(parentPort);
+const isStop = createIsStop(parentPort);
+
+if (worker)
+    subscribe({
+        name: args.format,
+        quiet: args.quiet,
+        exit,
+        worker,
+        stdout,
+    });
+
+export default await cli({
     stdout,
     stderr,
     exit,
     cwd: process.cwd(),
-    argv: process.argv.slice(2),
+    argv: workerData.slice(2),
+    workerFormatter,
+    isStop,
 });

package/bin/trace.mjs

@@ -0,0 +1,3 @@
+export const createTrace = (parentPort) => (event, data) => {
+    parentPort?.postMessage([event, data]);
+};

package/bin/tracer.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import {Worker} from 'node:worker_threads';
+import {parseArgs} from '../lib/cli/parse-args.js';
+import {subscribe} from './subscribe.mjs';
+
+const {
+    cwd,
+    exit,
+    stdout,
+} = process;
+
+const args = parseArgs(process.argv.slice(2));
+const write = stdout.write.bind(stdout);
+
+if (!args.worker) {
+    await import('./supertape.mjs');
+    exit();
+}
+
+const slave = new URL('./supertape.mjs', import.meta.url);
+
+const worker = new Worker(slave, {
+    workerData: process.argv,
+    stdin: true,
+});
+
+await subscribe({
+    name: args.format,
+    args,
+    worker,
+    exit,
+    cwd,
+    write,
+    stdout,
+});

package/help.json

@@ -5,5 +5,6 @@
     "-r, --require              ": "require module",
     "--no-check-scopes          ": "do not check that messages contains scope: 'scope: message'",
     "--no-check-assertions-count": "do not check that assertion count is no more then 1",
-    "--no-check-duplicates      ": "do not check messages for duplicates"
+    "--no-check-duplicates      ": "do not check messages for duplicates",
+    "--no-worker                ": "disable worker thread"
 }

package/lib/cli/parse-args.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const process = require('node:process');
+const yargsParser = require('yargs-parser');
+const {isArray} = Array;
+const maybeFirst = (a) => isArray(a) ? a.pop() : a;
+const maybeArray = (a) => isArray(a) ? a : [a];
+
+const {
+    SUPERTAPE_CHECK_DUPLICATES = '1',
+    SUPERTAPE_CHECK_SCOPES = '1',
+    SUPERTAPE_CHECK_ASSERTIONS_COUNT = '1',
+} = process.env;
+
+const yargsOptions = {
+    configuration: {
+        'strip-aliased': true,
+        'strip-dashed': true,
+    },
+    coerce: {
+        require: maybeArray,
+        format: maybeFirst,
+    },
+    string: [
+        'format',
+        'require',
+    ],
+    boolean: [
+        'version',
+        'help',
+        'check-duplicates',
+        'check-scopes',
+        'check-assertions-count',
+        'worker',
+    ],
+    alias: {
+        version: 'v',
+        format: 'f',
+        help: 'h',
+        require: 'r',
+        checkDuplicates: 'd',
+        checkScopes: 's',
+        checkAssertionsCount: 'a',
+    },
+    default: {
+        format: 'progress-bar',
+        require: [],
+        checkDuplicates: SUPERTAPE_CHECK_DUPLICATES !== '0',
+        checkScopes: SUPERTAPE_CHECK_SCOPES !== '0',
+        checkAssertionsCount: SUPERTAPE_CHECK_ASSERTIONS_COUNT !== '0',
+        worker: true,
+    },
+};
+
+module.exports.yargsOptions = yargsOptions;
+module.exports.parseArgs = (argv) => yargsParser(argv, yargsOptions);

package/lib/cli.js

@@ -5,12 +5,13 @@ const {resolve: resolvePath} = require('path');
 const {once} = require('events');
 const {pathToFileURL} = require('url');
 
-const yargsParser = require('yargs-parser');
 const glob = require('glob');
 const fullstore = require('fullstore');
 const tryToCatch = require('try-to-catch');
 const keypress = require('@putout/cli-keypress');
+
 const {simpleImport} = require('./simple-import');
+const {parseArgs, yargsOptions} = require('./cli/parse-args');
 
 const supertape = require('..');
 const {
@@ -22,30 +23,23 @@ const {
     SKIPED,
 } = require('./exit-codes');
 
-const {isArray} = Array;
-
-const maybeFirst = (a) => isArray(a) ? a.pop() : a;
-const maybeArray = (a) => isArray(a) ? a : [a];
 const isExclude = (a) => !a.includes('node_modules');
-
 const removeDuplicates = (a) => Array.from(new Set(a));
+
 const filesCount = fullstore(0);
 
-const {
-    SUPERTAPE_CHECK_DUPLICATES = '1',
-    SUPERTAPE_CHECK_SCOPES = '1',
-    SUPERTAPE_CHECK_ASSERTIONS_COUNT = '1',
-    SUPERTAPE_CHECK_SKIPED = '0',
-} = process.env;
+const {SUPERTAPE_CHECK_SKIPED = '0'} = process.env;
 
-module.exports = async ({argv, cwd, stdout, stderr, exit}) => {
-    const {isStop} = keypress();
+module.exports = async ({argv, cwd, stdout, stderr, exit, isStop, workerFormatter}) => {
+    isStop = isStop || keypress().isStop;
+    
     const [error, result] = await tryToCatch(cli, {
         argv,
         cwd,
         stdout,
         exit,
         isStop,
+        workerFormatter,
     });
     
     if (error) {
@@ -77,46 +71,8 @@ module.exports = async ({argv, cwd, stdout, stderr, exit}) => {
     return exit(OK);
 };
 
-const yargsOptions = {
-    configuration: {
-        'strip-aliased': true,
-        'strip-dashed': true,
-    },
-    coerce: {
-        require: maybeArray,
-        format: maybeFirst,
-    },
-    string: [
-        'format',
-        'require',
-    ],
-    boolean: [
-        'version',
-        'help',
-        'check-duplicates',
-        'check-scopes',
-        'check-assertions-count',
-    ],
-    alias: {
-        version: 'v',
-        format: 'f',
-        help: 'h',
-        require: 'r',
-        checkDuplicates: 'd',
-        checkScopes: 's',
-        checkAssertionsCount: 'a',
-    },
-    default: {
-        format: 'progress-bar',
-        require: [],
-        checkDuplicates: SUPERTAPE_CHECK_DUPLICATES !== '0',
-        checkScopes: SUPERTAPE_CHECK_SCOPES !== '0',
-        checkAssertionsCount: SUPERTAPE_CHECK_ASSERTIONS_COUNT !== '0',
-    },
-};
-
-async function cli({argv, cwd, stdout, isStop}) {
-    const args = yargsParser(argv, yargsOptions);
+async function cli({argv, cwd, stdout, isStop, workerFormatter}) {
+    const args = parseArgs(argv);
     
     if (args.version) {
         stdout.write(`v${require('../package').version}\n`);
@@ -171,6 +127,7 @@ async function cli({argv, cwd, stdout, isStop}) {
         checkDuplicates,
         checkScopes,
         checkAssertionsCount,
+        workerFormatter,
     });
     
     const stream = await supertape.createStream();

package/lib/formatter/communication.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const {parentPort, workerData} = require('node:worker_threads');
+
+const {EventEmitter} = require('node:events');
+const process = require('node:process');
+
+const {assign} = Object;
+
+module.exports.createCommunication = () => {
+    if (parentPort)
+        return {
+            parentPort,
+            workerData,
+        };
+    
+    const newWorker = new EventEmitter();
+    const newParentPort = new EventEmitter();
+    
+    assign(newWorker, {
+        postMessage: (a) => {
+            newParentPort.emit('message', a);
+        },
+    });
+    
+    assign(newParentPort, {
+        postMessage: (a) => {
+            newWorker.emit('message', a);
+        },
+    });
+    
+    return {
+        worker: newWorker,
+        parentPort: newParentPort,
+        workerData: process.argv,
+    };
+};

package/lib/formatter/harness.js

@@ -69,5 +69,6 @@ function run(reporter, type, data) {
     if (type === 'fail')
         return reporter.fail(data);
     
-    return reporter.end(data);
+    if (type === 'end')
+        return reporter.end(data);
 }

package/lib/operators.mjs

@@ -240,12 +240,12 @@ function validateEnd({name, operators, runnerState}) {
 
 const validate = (a) => {
     if (isFn(a))
-        return fail('looks like operator returns function, it will always fail');
+        return fail(`☝️ Looks like operator returns function, it will always fail: '${a}'`);
     
     return a;
 };
 
-const returnMissing = () => fail('looks like operator returns nothing, it will always fail');
+const returnMissing = () => fail('☝️ Looks like operator returns nothing, it will always fail');
 
 function run(name, {formatter, count, incCount, incPassed, incFailed}, testState = returnMissing()) {
     const {

package/lib/run-tests.js

@@ -16,7 +16,6 @@ const notSkip = ({skip}) => !skip;
 const getInitOperators = async () => await import('./operators.mjs');
 
 const {SUPERTAPE_TIMEOUT = 3000} = process.env;
-
 const DEBUG_TIME = 3000 * 1000;
 
 const timeout = (time, value) => {

package/lib/supertape.js

@@ -45,7 +45,7 @@ const defaultOptions = {
     checkScopes: true,
 };
 
-function _createEmitter({quiet, stream = stdout, format, getOperators, isStop, readyFormatter}) {
+function _createEmitter({quiet, stream = stdout, format, getOperators, isStop, readyFormatter, workerFormatter}) {
     const tests = [];
     const emitter = new EventEmitter();
     
@@ -77,7 +77,7 @@ function _createEmitter({quiet, stream = stdout, format, getOperators, isStop, r
         const operators = await getOperators();
         
         const result = await runTests(tests, {
-            formatter,
+            formatter: workerFormatter || formatter,
             operators,
             isStop,
         });
@@ -152,6 +152,7 @@ function test(message, fn, options = {}) {
         checkScopes,
         checkAssertionsCount,
         checkIfEnded,
+        workerFormatter,
     } = {
         ...defaultOptions,
         ...initedOptions,
@@ -168,12 +169,12 @@ function test(message, fn, options = {}) {
     setValidations(validations);
     
     const at = getAt();
-    
     const emitter = options.emitter || createEmitter({
         format,
         quiet,
         getOperators,
         isStop,
+        workerFormatter,
     });
     
     mainEmitter = emitter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supertape",
-  "version": "9.4.0",
+  "version": "10.0.0",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "📼 Supertape simplest high speed test runner with superpowers",
   "homepage": "http://github.com/coderaiser/supertape",
@@ -19,8 +19,8 @@
   },
   "type": "commonjs",
   "bin": {
-    "tape": "bin/supertape.mjs",
-    "supertape": "bin/supertape.mjs"
+    "tape": "bin/tracer.mjs",
+    "supertape": "bin/tracer.mjs"
   },
   "repository": {
     "type": "git",
@@ -74,9 +74,9 @@
     "testing"
   ],
   "devDependencies": {
-    "@babel/core": "^7.12.9",
+    "@babel/core": "^8.0.0-alpha.5",
     "@iocmd/wait": "^2.1.0",
-    "c8": "^8.0.0",
+    "c8": "^9.0.0",
     "check-dts": "^0.7.0",
     "currify": "^4.0.0",
     "eslint": "^8.0.0",
@@ -88,7 +88,7 @@
     "montag": "^1.0.0",
     "nodemon": "^3.0.1",
     "pullout": "^4.0.0",
-    "putout": "^34.0.0",
+    "putout": "^35.0.0",
     "runsome": "^1.0.0",
     "try-catch": "^3.0.0",
     "typescript": "^5.1.6"