ava 0.16.0 → 0.18.2

package/types/make.js

@@ -14,9 +14,10 @@
 
 const path = require('path');
 const fs = require('fs');
+const isArraySorted = require('is-array-sorted');
 const runner = require('../lib/runner');
 
-const arrayHas = parts => part => parts.includes(part);
+const arrayHas = parts => part => parts.indexOf(part) !== -1;
 
 const base = fs.readFileSync(path.join(__dirname, 'base.d.ts'), 'utf8');
 
@@ -35,24 +36,34 @@ function generatePrefixed(prefix) {
 	for (const part of allParts) {
 		const parts = prefix.concat([part]);
 
-		if (prefix.includes(part) || !verify(parts, true)) {
+		if (prefix.indexOf(part) !== -1 || !verify(parts, true)) {
 			// Function already in prefix or not allowed here
 			continue;
 		}
 
+		// If `parts` is not sorted, we alias it to the sorted chain
+		if (!isArraySorted(parts)) {
+			const chain = parts.sort().join('.');
+
+			if (exists(parts)) {
+				output += `\texport const ${part}: typeof test.${chain};\n`;
+			}
+
+			continue;
+		}
+
 		// Check that `part` is a valid function name.
 		// `always` is a valid prefix, for instance of `always.after`,
 		// but not a valid function name.
 		if (verify(parts, false)) {
-			if (!isSorted(parts)) {
-				output += '\texport const ' + part + ': typeof test.' + parts.sort().join('.') + ';\n';
-				continue;
-			} else if (prefix.includes(parts, 'todo')) {
+			if (parts.indexOf('todo') !== -1) { // eslint-disable-line no-negated-condition
 				output += '\t' + writeFunction(part, 'name: string', 'void');
 			} else {
 				const type = testType(parts);
-				output += '\t' + writeFunction(part, 'name: string, implementation: ' + type);
-				output += '\t' + writeFunction(part, 'implementation: ' + type);
+				output += '\t' + writeFunction(part, `name: string, implementation: ${type}`);
+				output += '\t' + writeFunction(part, `implementation: ${type}`);
+				output += '\t' + writeFunction(part, `name: string, implementation: Macros<${type}Context>, ...args: any[]`);
+				output += '\t' + writeFunction(part, `implementation: Macros<${type}Context>, ...args: any[]`);
 			}
 		}
 
@@ -63,13 +74,19 @@ function generatePrefixed(prefix) {
 		return children;
 	}
 
-	return 'export namespace ' + ['test'].concat(prefix).join('.') + ' {\n' + output + '}\n' + children;
+	const namespace = ['test'].concat(prefix).join('.');
+
+	return `export namespace ${namespace} {\n${output}}\n${children}`;
 }
 
 function writeFunction(name, args) {
-	return 'export function ' + name + '(' + args + '): void;\n';
+	return `export function ${name}(${args}): void;\n`;
 }
 
+// Checks whether a chain is a valid function name (when `asPrefix === false`)
+// or a valid prefix that could contain members.
+// For instance, `test.always` is not a valid function name, but it is a valid
+// prefix of `test.always.after`.
 function verify(parts, asPrefix) {
 	const has = arrayHas(parts);
 
@@ -93,28 +110,42 @@ function verify(parts, asPrefix) {
 		// `always` can only be used with `after` or `afterEach`.
 		// Without it can still be a valid prefix
 		if (has('after') || has('afterEach')) {
-			if (!asPrefix) {
-				return false;
-			}
-		} else if (!verify(parts.concat(['after'])) && !verify(parts.concat(['afterEach']))) {
+			return true;
+		}
+
+		if (!verify(parts.concat(['after']), false) && !verify(parts.concat(['afterEach']), false)) {
 			// If `after` nor `afterEach` cannot be added to this prefix,
 			// `always` is not allowed here.
 			return false;
 		}
+
+		// Only allowed as a prefix
+		return asPrefix;
 	}
 
 	return true;
 }
 
-// Checks that an array is sorted
-function isSorted(a) {
-	for (let i = 1; i < a.length; i++) {
-		if (a[i - 1] >= a[i]) {
-			return false;
+// Checks whether a chain is a valid function name or a valid prefix with some member
+function exists(parts) {
+	if (verify(parts, false)) {
+		// Valid function name
+		return true;
+	}
+
+	if (!verify(parts, true)) {
+		// Not valid prefix
+		return false;
+	}
+
+	// Valid prefix, check whether it has members
+	for (const prefix of allParts) {
+		if (parts.indexOf(prefix) === -1 && exists(parts.concat([prefix]))) {
+			return true;
 		}
 	}
 
-	return true;
+	return false;
 }
 
 // Returns the type name of for the test implementation
@@ -123,11 +154,11 @@ function testType(parts) {
 	let type = 'Test';
 
 	if (has('cb')) {
-		type = 'Callback' + type;
+		type = `Callback${type}`;
 	}
 
-	if (!has('beforeEach') && !has('afterEach')) {
-		type = 'Contextual' + type;
+	if (!has('before') && !has('after')) {
+		type = `Contextual${type}`;
 	}
 
 	return type;

package/lib/send.js

@@ -1,16 +0,0 @@
-'use strict';
-
-// utility to send messages to processes
-module.exports = function (ps, name, data) {
-	if (typeof ps === 'string') {
-		data = name || {};
-		name = ps;
-		ps = process;
-	}
-
-	ps.send({
-		name: 'ava-' + name,
-		data: data,
-		ava: true
-	});
-};