replace jest with ava

node_modules/ava/lib/serialize-error.js

@@ -0,0 +1,173 @@
+'use strict';
+const path = require('path');
+const cleanYamlObject = require('clean-yaml-object');
+const concordance = require('concordance');
+const isError = require('is-error');
+const slash = require('slash');
+const StackUtils = require('stack-utils');
+const assert = require('./assert');
+const concordanceOptions = require('./concordance-options').default;
+
+function isAvaAssertionError(source) {
+	return source instanceof assert.AssertionError;
+}
+
+function filter(propertyName, isRoot) {
+	return !isRoot || (propertyName !== 'message' && propertyName !== 'name' && propertyName !== 'stack');
+}
+
+const stackUtils = new StackUtils();
+function extractSource(stack, testFile) {
+	if (!stack || !testFile) {
+		return null;
+	}
+
+	// Normalize the test file so it matches `callSite.file`.
+	const relFile = path.relative(process.cwd(), testFile);
+	const normalizedFile = process.platform === 'win32' ? slash(relFile) : relFile;
+	for (const line of stack.split('\n')) {
+		try {
+			const callSite = stackUtils.parseLine(line);
+			if (callSite.file === normalizedFile) {
+				return {
+					isDependency: false,
+					isWithinProject: true,
+					file: path.resolve(process.cwd(), callSite.file),
+					line: callSite.line
+				};
+			}
+		} catch {}
+	}
+
+	return null;
+}
+
+function buildSource(source) {
+	if (!source) {
+		return null;
+	}
+
+	// Assume the CWD is the project directory. This holds since this function
+	// is only called in test workers, which are created with their working
+	// directory set to the project directory.
+	const projectDir = process.cwd();
+
+	const file = path.resolve(projectDir, source.file.trim());
+	const rel = path.relative(projectDir, file);
+
+	const [segment] = rel.split(path.sep);
+	const isWithinProject = segment !== '..' && (process.platform !== 'win32' || !segment.includes(':'));
+	const isDependency = isWithinProject && path.dirname(rel).split(path.sep).includes('node_modules');
+
+	return {
+		isDependency,
+		isWithinProject,
+		file,
+		line: source.line
+	};
+}
+
+function trySerializeError(err, shouldBeautifyStack, testFile) {
+	const stack = err.savedError ? err.savedError.stack : err.stack;
+
+	const retval = {
+		avaAssertionError: isAvaAssertionError(err),
+		nonErrorObject: false,
+		source: extractSource(stack, testFile),
+		stack,
+		shouldBeautifyStack
+	};
+
+	if (err.actualStack) {
+		retval.stack = err.actualStack;
+	}
+
+	if (retval.avaAssertionError) {
+		retval.improperUsage = err.improperUsage;
+		retval.message = err.message;
+		retval.name = err.name;
+		retval.statements = err.statements;
+		retval.values = err.values;
+
+		if (err.fixedSource) {
+			const source = buildSource(err.fixedSource);
+			if (source) {
+				retval.source = source;
+			}
+		}
+
+		if (err.assertion) {
+			retval.assertion = err.assertion;
+		}
+
+		if (err.operator) {
+			retval.operator = err.operator;
+		}
+	} else {
+		retval.object = cleanYamlObject(err, filter); // Cleanly copy non-standard properties
+		if (typeof err.message === 'string') {
+			retval.message = err.message;
+		}
+
+		if (typeof err.name === 'string') {
+			retval.name = err.name;
+		}
+	}
+
+	if (typeof err.stack === 'string') {
+		const lines = err.stack.split('\n');
+		if (err.name === 'SyntaxError' && !lines[0].startsWith('SyntaxError')) {
+			retval.summary = '';
+			for (const line of lines) {
+				retval.summary += line + '\n';
+				if (line.startsWith('SyntaxError')) {
+					break;
+				}
+			}
+
+			retval.summary = retval.summary.trim();
+		} else {
+			// Skip the source line header inserted by `esm`:
+			// <https://github.com/standard-things/esm/wiki/improved-errors>
+			const start = lines.findIndex(line => !/:\d+$/.test(line));
+			retval.summary = '';
+			for (let index = start; index < lines.length; index++) {
+				if (lines[index].startsWith('    at')) {
+					break;
+				}
+
+				const next = index + 1;
+				const end = next === lines.length || lines[next].startsWith('    at');
+				retval.summary += end ? lines[index] : lines[index] + '\n';
+			}
+		}
+	}
+
+	return retval;
+}
+
+function serializeError(origin, shouldBeautifyStack, err, testFile) {
+	if (!isError(err)) {
+		return {
+			avaAssertionError: false,
+			nonErrorObject: true,
+			formatted: concordance.formatDescriptor(concordance.describe(err, concordanceOptions), concordanceOptions)
+		};
+	}
+
+	try {
+		return trySerializeError(err, shouldBeautifyStack, testFile);
+	} catch {
+		const replacement = new Error(`${origin}: Could not serialize error`);
+		return {
+			avaAssertionError: false,
+			nonErrorObject: false,
+			name: replacement.name,
+			message: replacement.message,
+			stack: replacement.stack,
+			summary: replacement.message
+		};
+	}
+}
+
+module.exports = serializeError;