Description: Lint code using eslint Author: Jonas Smedegaard Last-Update: 2020-03-25 --- This patch header follows DEP-3: http://dep.debian.net/deps/dep3/ --- a/lib/rules/amd-function-arity.js +++ b/lib/rules/amd-function-arity.js @@ -58,11 +58,11 @@ // Helpers // ----------------------------------------------------------------------------- -const isBoolean = (value) => typeof value === "boolean"; +const isBoolean = value => typeof value === "boolean"; const unassigned = (paths, params) => paths.slice(params.length); -const includes = (list) => (path) => list.indexOf(path.value) !== -1; +const includes = list => path => list.indexOf(path.value) !== -1; -const isAmdWithCallback = (node) => +const isAmdWithCallback = node => isAmdDefine(node) || isRequireCall(node) && hasCallback(node); const reportTooFew = (expected, actual) => @@ -79,7 +79,7 @@ const opts = Object.assign({}, defaults, context.options[0]); const allowed = opts.allowExtraDependencies; - const isAllowed = (paths) => + const isAllowed = paths => isBoolean(allowed) ? allowed : paths.every(includes(allowed)); return { --- a/lib/rules/enforce-define.js +++ b/lib/rules/enforce-define.js @@ -49,7 +49,7 @@ const includes = (list, item) => list.indexOf(item) !== -1; -const isDefineExpr = (child) => +const isDefineExpr = child => isExprStatement(child) && isDefineCall(child.expression); // ----------------------------------------------------------------------------- --- a/lib/rules/no-assign-exports.js +++ b/lib/rules/no-assign-exports.js @@ -31,7 +31,7 @@ // Helpers // ----------------------------------------------------------------------------- -const assignsToExports = (node) => +const assignsToExports = node => node.left.type === "Identifier" && node.left.name === "exports"; --- a/lib/rules/no-assign-require.js +++ b/lib/rules/no-assign-require.js @@ -29,13 +29,13 @@ // Helpers // ----------------------------------------------------------------------------- -const isWindow = (node) => +const isWindow = node => isIdentifier(node) && node.name === "window"; -const isRequire = (node) => +const isRequire = node => isIdentifier(node) && node.name === "require"; -const isWindowRequire = (node) => +const isWindowRequire = node => isMemberExpr(node) && isWindow(node.object) && isRequire(node.property); --- a/lib/rules/no-commonjs-exports.js +++ b/lib/rules/no-commonjs-exports.js @@ -32,7 +32,7 @@ // Helpers // ----------------------------------------------------------------------------- -const assignsToExportsProperty = (node) => +const assignsToExportsProperty = node => isMemberExpr(node.left) && node.left.object.name === "exports"; --- a/lib/rules/no-commonjs-module-exports.js +++ b/lib/rules/no-commonjs-module-exports.js @@ -32,7 +32,7 @@ // Helpers // ----------------------------------------------------------------------------- -const assignsToModuleExports = (node) => +const assignsToModuleExports = node => isMemberExpr(node.left) && node.left.object.name === "module" && node.left.property.name === "exports"; --- a/lib/rules/no-commonjs-return.js +++ b/lib/rules/no-commonjs-return.js @@ -31,11 +31,11 @@ // Helpers // ----------------------------------------------------------------------------- -const isFunction = (node) => +const isFunction = node => node.type === "FunctionDeclaration" || node.type === "FunctionExpression"; -const nearestFunction = (node) => nearest(isFunction, node); +const nearestFunction = node => nearest(isFunction, node); // ----------------------------------------------------------------------------- // Rule Definition --- a/lib/rules/no-conditional-require.js +++ b/lib/rules/no-conditional-require.js @@ -30,7 +30,7 @@ // Helpers // ----------------------------------------------------------------------------- -const isConditional = (node) => +const isConditional = node => node.type === "IfStatement" || node.type === "ConditionalExpression"; --- a/lib/rules/no-dynamic-require.js +++ b/lib/rules/no-dynamic-require.js @@ -31,7 +31,7 @@ // Helpers // ----------------------------------------------------------------------------- -const hasStaticDependencies = (node) => +const hasStaticDependencies = node => isStringLiteral(node.arguments[0]) || isStringLiteralArray(node.arguments[0]); --- a/lib/rules/no-js-extension.js +++ b/lib/rules/no-js-extension.js @@ -37,14 +37,14 @@ // Helpers // ----------------------------------------------------------------------------- -const append = (str) => (val) => val + str; -const report = (context) => (node) => context.report(node, message); +const append = str => val => val + str; +const report = context => node => context.report(node, message); -const hasJsExtension = (node) => node.value.trim().endsWith(".js"); -const startsWithOneOf = (list, str) => list.some((val) => str.startsWith(val)); -const hasNoPlugin = (str) => !str.includes("!"); +const hasJsExtension = node => node.value.trim().endsWith(".js"); +const startsWithOneOf = (list, str) => list.some(val => str.startsWith(val)); +const hasNoPlugin = str => !str.includes("!"); -const shouldBeChecked = (plugins) => (node) => +const shouldBeChecked = plugins => node => startsWithOneOf(plugins, node.value) || hasNoPlugin(node.value); --- a/lib/rules/no-multiple-define.js +++ b/lib/rules/no-multiple-define.js @@ -32,7 +32,7 @@ let defineCalls = 0; return { - CallExpression: function (node) { + CallExpression(node) { if (isDefineCall(node) && ++defineCalls > 1) { context.report(node, message); } --- a/lib/rules/no-require-tourl.js +++ b/lib/rules/no-require-tourl.js @@ -36,7 +36,7 @@ isIdentifier(node.property) && node.property.name === method; -const message = (prop) => `Use of \`require.${prop}\` is not allowed.`; +const message = prop => `Use of \`require.${prop}\` is not allowed.`; // ----------------------------------------------------------------------------- // Rule Definition --- a/lib/rules/one-dependency-per-line.js +++ b/lib/rules/one-dependency-per-line.js @@ -75,30 +75,33 @@ // Helpers // ----------------------------------------------------------------------------- -const pad = (amount) => (val) => " ".repeat(amount) + val; -const line = (node) => node.loc.start.line; -const column = (node) => node.loc.start.column; -const unique = (list) => Array.from(new Set(list)); +const pad = amount => val => " ".repeat(amount) + val; +const line = node => node.loc.start.line; +const column = node => node.loc.start.column; +const unique = list => Array.from(new Set(list)); -const hasDuplicates = (list) => unique(list).length < list.length; -const hasMultiple = (list) => unique(list).length > 1; +const hasDuplicates = list => unique(list).length < list.length; +const hasMultiple = list => unique(list).length > 1; const isLongerThan = (val, list) => Number.isInteger(val) && list.length > val; -const isAlways = (val) => val === "always"; -const isNever = (val) => val === "never"; +const isAlways = val => val === "always"; +const isNever = val => val === "never"; -const indentation = (node) => { +const indentation = node => { const statement = node.type === "ArrowFunctionExpression" ? node.body : node.body.body[0]; + return statement && line(node) !== line(statement) ? column(statement) : 0; }; -const formatPaths = (indent) => (node) => { +const formatPaths = indent => node => { const paths = node.elements.map(v => v.raw).map(pad(indent)).join(",\n"); + return `[\n${paths}\n]`; }; -const formatNames = (indent, context) => (node) => { +const formatNames = (indent, context) => node => { const names = node.params.map(v => v.name).map(pad(indent)).join(",\n"); const body = context.getSourceCode().getText(node.body); + return `function (\n${names}\n) ${body}`; }; @@ -115,12 +118,14 @@ if ((isLongerThan(val, lines) || isAlways(val)) && hasDuplicates(lines)) { const message = messages.always[setting]; - const fix = (f) => f.replaceTextRange(node.range, format(node)); + const fix = f => f.replaceTextRange(node.range, format(node)); + context.report({ node, message, fix }); } if (isNever(val) && hasMultiple(lines)) { const message = messages.never[setting]; + context.report({ node, message }); } } --- a/lib/rules/sort-amd-paths.js +++ b/lib/rules/sort-amd-paths.js @@ -52,7 +52,7 @@ // Helpers // ----------------------------------------------------------------------------- -const PLUGIN_REGEX = /^\w+\!/; +const PLUGIN_REGEX = /^\w+!/; const PATH_SEPARATOR = "/"; /** @@ -60,8 +60,8 @@ * @param {Function} fn - function to invert * @returns {Function} inverted function */ -const inverse = (fn) => function () { - return fn.apply(null, arguments) * -1; +const inverse = fn => function () { + return fn(...arguments) * -1; }; /** @@ -71,14 +71,14 @@ * @param {Function[]} fns - array of comparator functions to apply * @returns {Function} multi-criteria comparator */ -const comparator = (fns) => (a, b) => fns.reduce((n, f) => n ? n : f(a, b), 0); +const comparator = fns => (a, b) => fns.reduce((n, f) => n ? n : f(a, b), 0); /** * Compare two string values. Comparison is done based on character value, so * uppercase letters are placed before lowercase ones. - * @param {String} a - first value to compare - * @param {String} b - second value to compare - * @returns {Number} negative if `a` occurs before `b`; positive if `a` occurs + * @param {string} a - first value to compare + * @param {string} b - second value to compare + * @returns {number} negative if `a` occurs before `b`; positive if `a` occurs * after `b`; 0 if they are equivalent in sort order */ const stringCompare = (a, b) => { @@ -92,7 +92,7 @@ * before those that don't. * @param {*} a - first value to compare * @param {*} b - second value to compare - * @returns {Number} negative if `a` occurs before `b`; positive if `a` occurs + * @returns {number} negative if `a` occurs before `b`; positive if `a` occurs * after `b`; 0 if they are equivalent in sort order */ const existentialCompare = (a, b) => { @@ -105,11 +105,12 @@ * Compare two array values. * @param {Array} a - first array to compare * @param {Array} b - second array to compare - * @returns {Number} negative if `a` occurs before `b`; positive if `a` occurs + * @returns {number} negative if `a` occurs before `b`; positive if `a` occurs * after `b`; 0 if they are equivalent in sort order */ const arrayCompare = (a, b) => { const length = Math.max(a.length, b.length); + for (let i = 0; i < length; i += 1) { if (!(i in a)) return -1; if (!(i in b)) return 1; @@ -119,7 +120,7 @@ return 0; }; -const toPathDescriptor = (opts) => (node) => { +const toPathDescriptor = opts => node => { let value = opts.ignoreCase ? node.value.toLowerCase() : node.value; if (opts.sortPlugins === "ignore") { @@ -140,7 +141,7 @@ const compareBasenames = (a, b) => stringCompare(a.basename, b.basename); const compareFullPath = (a, b) => stringCompare(a.value, b.value); -const message = (expected) => +const message = expected => `Required paths are not in alphabetical order (expected '${expected}').`; // ----------------------------------------------------------------------------- --- a/lib/utils/ast.js +++ b/lib/utils/ast.js @@ -11,17 +11,18 @@ * Test if supplied `value` is an object. * @private * @param {*} value - value to test - * @returns {Boolean} true if value is an object + * @returns {boolean} true if value is an object */ function isObject(value) { const type = typeof value; + return type === "object" || type === "function"; } /** * Test if supplied `node` represents an identifier. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents an identifier + * @returns {boolean} true if node represents an identifier */ function isIdentifier(node) { return isObject(node) && node.type === "Identifier"; @@ -30,7 +31,7 @@ /** * Test if supplied `node` represents a literal of any kind. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents a literal + * @returns {boolean} true if node represents a literal */ function isLiteral(node) { return isObject(node) && node.type === "Literal"; @@ -39,7 +40,7 @@ /** * Test if supplied `node` represents a string literal. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents a string literal + * @returns {boolean} true if node represents a string literal */ function isStringLiteral(node) { return isLiteral(node) && typeof node.value === "string"; @@ -48,7 +49,7 @@ /** * Test if supplied `node` represents an array expression. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents an array expression + * @returns {boolean} true if node represents an array expression */ function isArrayExpr(node) { return isObject(node) && node.type === "ArrayExpression"; @@ -57,7 +58,7 @@ /** * Test if supplied `node` represents an object expression. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents an object expression + * @returns {boolean} true if node represents an object expression */ function isObjectExpr(node) { return isObject(node) && node.type === "ObjectExpression"; @@ -66,7 +67,7 @@ /** * Test if supplied `node` represents a function expression. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents a function expression + * @returns {boolean} true if node represents a function expression */ function isFunctionExpr(node) { return isObject(node) && @@ -77,7 +78,7 @@ /** * Test if supplied `node` represents a member expression. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents a member expression + * @returns {boolean} true if node represents a member expression */ function isMemberExpr(node) { return isObject(node) && node.type === "MemberExpression"; @@ -86,7 +87,7 @@ /** * Test if supplied `node` represents an expression of any kind. * @param {ASTNode} node - node to test - * @returns {Boolean} true if node represents an expression statement + * @returns {boolean} true if node represents an expression statement */ function isExprStatement(node) { return isObject(node) && node.type === "ExpressionStatement"; @@ -96,7 +97,7 @@ * Test if supplied `node` represents an array of string literals. Empty * arrays are also valid here. * @param {ASTNode} node - ArrayExpression node to test - * @returns {Boolean} true if node represents an array of string literals + * @returns {boolean} true if node represents an array of string literals */ function isStringLiteralArray(node) { return isArrayExpr(node) && @@ -107,7 +108,7 @@ /** * Test if supplied `node` has parameters. * @param {ASTNode} node - FunctionExpression node to test - * @returns {Boolean} true if node has at least one parameter + * @returns {boolean} true if node has at least one parameter */ function hasParams(node) { return isObject(node) && @@ -118,7 +119,7 @@ /** * Test if supplied `node` has at least one callback argument * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if node has at least one callback + * @returns {boolean} true if node has at least one callback */ function hasCallback(node) { return isObject(node) && @@ -130,7 +131,7 @@ * Determine if `node` has an ancestor satisfying `predicate`. * @param {Function} predicate - predicate to test each ancestor against * @param {ASTNode} node - child node to begin search at - * @returns {Boolean} true if an ancestor satisfies `predicate` + * @returns {boolean} true if an ancestor satisfies `predicate` */ function ancestor(predicate, node) { while ((node = node.parent)) { --- a/lib/utils/rjs.js +++ b/lib/utils/rjs.js @@ -21,9 +21,9 @@ * requirements for a Simplified CommonJS Wrapper. * @private * @param {Array} params list of function parameters to test - * @returns {Boolean} true if `params` satisfies a CommonJS Wrapper format + * @returns {boolean} true if `params` satisfies a CommonJS Wrapper format */ -const hasCommonJsParams = (params) => +const hasCommonJsParams = params => params.length && params.every((param, i) => param.name === CJS_PARAMS[i]); /** @@ -31,9 +31,9 @@ * the Simplfied CommonJS Wrapper. * @private * @param {ASTNode} node - node to test - * @returns {Boolean} true if represents a CommonJS function expression + * @returns {boolean} true if represents a CommonJS function expression */ -const isCommonJsFuncExpr = (node) => +const isCommonJsFuncExpr = node => isFunctionExpr(node) && hasCommonJsParams(node.params); /** @@ -41,17 +41,17 @@ * is, one without any parameter list. * @private * @param {ASTNode} node - node to test - * @returns {Boolean} true if represents a simple function expression + * @returns {boolean} true if represents a simple function expression */ -const isSimpleFuncExpr = (node) => +const isSimpleFuncExpr = node => isFunctionExpr(node) && !hasParams(node); /** * Determine if supplied `node` represents a call to `define`. * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents a call to `define` + * @returns {boolean} true if represents a call to `define` */ -const isDefineCall = (node) => +const isDefineCall = node => node && node.type === "CallExpression" && node.callee.type === "Identifier" && @@ -62,24 +62,24 @@ * a dependency array. This is the classic AMD style module definition. * @see http://requirejs.org/docs/api.html#defdep * @param {ASTNode} node - node to test - * @returns {Boolean} true if represents an AMD style module definition + * @returns {boolean} true if represents an AMD style module definition */ -const isAmdDefine = (node) => +const isAmdDefine = node => isDefineCall(node) && isAmdArgs(withoutModuleId(node.arguments)); /** * Determine if supplied `node` represents a require function with * a dependency array. * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents an AMD style require function + * @returns {boolean} true if represents an AMD style require function */ -const isAmdRequire = (node) => +const isAmdRequire = node => isRequireCall(node) && isAmdArgs(node.arguments); -const isAmdArgs = (args) => +const isAmdArgs = args => args.length === 2 && isArrayExpr(args[0]) && isFunctionExpr(args[1]); -const withoutModuleId = (args) => +const withoutModuleId = args => isStringLiteral(args[0]) ? args.slice(1) : args; /** @@ -88,12 +88,12 @@ * RequireJS documentation. * @see http://requirejs.org/docs/api.html#defsimple * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents an Object Module Definition + * @returns {boolean} true if represents an Object Module Definition */ -const isObjectDefine = (node) => +const isObjectDefine = node => isDefineCall(node) && isObjectArgs(withoutModuleId(node.arguments)); -const isObjectArgs = (args) => +const isObjectArgs = args => args.length === 1 && isObjectExpr(args[0]); /** @@ -101,12 +101,12 @@ * no dependency array. * @see http://requirejs.org/docs/api.html#deffunc * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents a Simple Function Definition + * @returns {boolean} true if represents a Simple Function Definition */ -const isFunctionDefine = (node) => +const isFunctionDefine = node => isDefineCall(node) && isFunctionArgs(withoutModuleId(node.arguments)); -const isFunctionArgs = (args) => +const isFunctionArgs = args => args.length === 1 && isSimpleFuncExpr(args[0]); /** @@ -114,12 +114,12 @@ * "Simplified CommonJS Wrapper" form. * @see http://requirejs.org/docs/api.html#cjsmodule * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents a Simplified CommonJS Wrapper + * @returns {boolean} true if represents a Simplified CommonJS Wrapper */ -const isCommonJsWrapper = (node) => +const isCommonJsWrapper = node => isDefineCall(node) && isCommonJsArgs(withoutModuleId(node.arguments)); -const isCommonJsArgs = (args) => +const isCommonJsArgs = args => args.length === 1 && isCommonJsFuncExpr(args[0]); /** @@ -127,21 +127,22 @@ * definition function. * @see http://requirejs.org/docs/api.html#modulename * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents a named module definition function + * @returns {boolean} true if represents a named module definition function */ -const isNamedDefine = (node) => +const isNamedDefine = node => isDefineCall(node) && isNamedArgs(node.arguments); -const isNamedArgs = (args) => +const isNamedArgs = args => (args.length === 2 || args.length === 3) && isStringLiteral(args[0]); /** * Determine if supplied `node` represents a valid `define` format. * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents a valid module definition function + * @returns {boolean} true if represents a valid module definition function */ -const isValidDefine = (node) => { +const isValidDefine = node => { const args = withoutModuleId(node.arguments); + if (args.length === 1) return isObjectExpr(args[0]) || isFunctionExpr(args[0]); if (args.length === 2) return isArrayExpr(args[0]) && isFunctionExpr(args[1]); return false; @@ -151,17 +152,17 @@ * Determine if supplied `node` represents a `require` or `requirejs` * identifier. Both are synonymous commands. * @param {ASTNode} node - Identifier node to test - * @returns {Boolean} true if represents a require identifier. + * @returns {boolean} true if represents a require identifier. */ -const isRequireIdentifier = (node) => +const isRequireIdentifier = node => node.name === "require" || node.name === "requirejs"; /** * Determine if supplied `node` represents a call to `require`. * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents a call to `require` + * @returns {boolean} true if represents a call to `require` */ -const isRequireCall = (node) => +const isRequireCall = node => node.type === "CallExpression" && node.callee.type === "Identifier" && isRequireIdentifier(node.callee); @@ -170,9 +171,9 @@ /** * Determine if supplied `node` represents a valid `require` format. * @param {ASTNode} node - CallExpression node to test - * @returns {Boolean} true if represents a valid `require` call + * @returns {boolean} true if represents a valid `require` call */ -const isValidRequire = (node) => { +const isValidRequire = node => { const args = node.arguments; // If the wrong number of arguments is present, we know it's invalid, @@ -201,7 +202,7 @@ !isFunctionExpr(args[0]); }; -const isInvalidRequireArg = (arg) => +const isInvalidRequireArg = arg => isObjectExpr(arg) || isArrayExpr(arg) || isLiteral(arg); /** @@ -210,7 +211,7 @@ * @param {ASTNode} node - CallExpression to inspect * @returns {Array} list of dependency path nodes */ -const getDependencyNodes = (node) => { +const getDependencyNodes = node => { const args = node.arguments; if (isDefineCall(node) && args.length > 1) { @@ -218,7 +219,7 @@ if (isArrayExpr(args[1])) return args[1].elements; } else if (isRequireCall(node)) { if (isArrayExpr(args[0])) return args[0].elements; - if (isStringLiteral(args[0])) return [ args[0] ]; + if (isStringLiteral(args[0])) return [args[0]]; } return []; @@ -230,7 +231,7 @@ * @param {ASTNode} node - CallExpression to inspect * @returns {Array} list of dependency path literals */ -const getDependencyStringNodes = (node) => +const getDependencyStringNodes = node => getDependencyNodes(node).filter(isStringLiteral); /** @@ -239,9 +240,9 @@ * @param {ASTNode} node - node to check * @returns {ASTNode} module definition function */ -const getModuleFunction = (node) => node.arguments.find(isFunctionExpr); +const getModuleFunction = node => node.arguments.find(isFunctionExpr); -const isAmdCall = (node) => isDefineCall(node) || isRequireCall(node); +const isAmdCall = node => isDefineCall(node) || isRequireCall(node); module.exports = { isRequireCall, --- a/tests/lib/rules/amd-function-arity.js +++ b/tests/lib/rules/amd-function-arity.js @@ -28,6 +28,7 @@ testRule("amd-function-arity", rule, { valid: [ + // Dependency count and parameter counts equal-- always valid fixtures.AMD_DEFINE, fixtures.AMD_EMPTY_DEFINE, @@ -135,6 +136,7 @@ ], invalid: [ + // Too few dependencies (invalid even with allowExtraDependencies option) { code: fixtures.AMD_DEFINE_TOO_MANY_CALLBACK_PARAMS, --- a/tests/lib/rules/enforce-define.js +++ b/tests/lib/rules/enforce-define.js @@ -69,41 +69,41 @@ { code: UNWRAPPED_FILE, filename: "main.js", - options: [ "main.js" ] + options: ["main.js"] }, { code: fixtures.NON_WRAPPED_EXPORTS, filename: "main.js", - options: [ "main.js" ] + options: ["main.js"] }, { code: fixtures.AMD_REQUIRE, filename: "main.js", - options: [ "main.js" ] + options: ["main.js"] }, { code: fixtures.AMD_REQUIREJS, filename: "main.js", - options: [ "main.js" ] + options: ["main.js"] }, // Ignore should work with full path { code: UNWRAPPED_FILE, filename: "path/to/main.js", - options: [ [ "main.js" ] ] + options: [["main.js"]] }, // Ignore should support multiple filenames { code: UNWRAPPED_FILE, filename: "main.js", - options: [ [ "main.js", "index.js" ] ] + options: [["main.js", "index.js"]] }, { code: UNWRAPPED_FILE, filename: "index.js", - options: [ [ "main.js", "index.js" ] ] + options: [["main.js", "index.js"]] } ], @@ -131,25 +131,25 @@ { code: UNWRAPPED_FILE, filename: "foo.js", - args: [ 1, "main.js" ], + options: ["main.js"], errors: [ERROR] }, { code: UNWRAPPED_FILE, filename: "foo.js", - args: [ 1, [ "main.js", "index.js" ] ], + options: [["main.js", "index.js"]], errors: [ERROR] }, { code: UNWRAPPED_FILE, filename: "path/to/foo.js", - args: [ 1, "main.js" ], + options: ["main.js"], errors: [ERROR] }, { code: UNWRAPPED_FILE, filename: "path/to/main.js/foo.js", - args: [ 1, "main.js" ], + options: ["main.js"], errors: [ERROR] } ] --- a/tests/lib/rules/no-js-extension.js +++ b/tests/lib/rules/no-js-extension.js @@ -93,22 +93,22 @@ { code: fixtures.AMD_DEFINE_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "foo" ]], + options: [["foo"]], errors: [ERROR] }, { code: fixtures.AMD_REQUIRE_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "foo" ]], + options: [["foo"]], errors: [ERROR] }, { code: fixtures.AMD_REQUIREJS_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "foo" ]], + options: [["foo"]], errors: [ERROR] }, { code: fixtures.CJS_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "foo" ]], + options: [["foo"]], errors: [ERROR] }, @@ -116,22 +116,22 @@ { code: fixtures.AMD_DEFINE_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "more", "plugins", "foo" ]], + options: [["more", "plugins", "foo"]], errors: [ERROR] }, { code: fixtures.AMD_REQUIRE_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "more", "plugins", "foo" ]], + options: [["more", "plugins", "foo"]], errors: [ERROR] }, { code: fixtures.AMD_REQUIREJS_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "more", "plugins", "foo" ]], + options: [["more", "plugins", "foo"]], errors: [ERROR] }, { code: fixtures.CJS_WITH_FOO_PLUGIN_AND_JS_EXT, - options: [[ "more", "plugins", "foo" ]], + options: [["more", "plugins", "foo"]], errors: [ERROR] } ] --- a/tests/lib/rules/one-dependency-per-line.js +++ b/tests/lib/rules/one-dependency-per-line.js @@ -182,113 +182,113 @@ { code: fixtures.AMD_DEPS_SINGLE_LINE_TWO, options: [{}], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_TWO }, { code: fixtures.AMD_DEPS_SINGLE_LINE_THREE, options: [{}], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_THREE }, { code: fixtures.AMD_DEPS_SINGLE_LINE_FOUR, options: [{}], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_FOUR }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_TWO, options: [{}], - errors: [ ALWAYS_PATHS_ERROR ], + errors: [ALWAYS_PATHS_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_TWO }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_THREE, options: [{}], - errors: [ ALWAYS_PATHS_ERROR ], + errors: [ALWAYS_PATHS_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_THREE }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_FOUR, options: [{}], - errors: [ ALWAYS_PATHS_ERROR ], + errors: [ALWAYS_PATHS_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_FOUR }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_TWO, options: [{}], - errors: [ ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_TWO }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_THREE, options: [{}], - errors: [ ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_THREE }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_FOUR, options: [{}], - errors: [ ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_FOUR }, { code: fixtures.AMD_DEPS_SINGLE_LINE_NO_INDENT_TWO, options: [{}], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_NO_INDENT_TWO }, { code: fixtures.AMD_DEPS_SINGLE_LINE_NO_INDENT_THREE, options: [{}], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_NO_INDENT_THREE }, { code: fixtures.AMD_DEPS_SINGLE_LINE_NO_INDENT_FOUR, options: [{}], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ], + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_NO_INDENT_FOUR }, // "always" for paths only { code: fixtures.AMD_DEPS_SINGLE_LINE_TWO, - options: [{"names": "never"}], - errors: [ ALWAYS_PATHS_ERROR ], + options: [{ "names": "never" }], + errors: [ALWAYS_PATHS_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_PATHS_TWO }, { code: fixtures.AMD_DEPS_SINGLE_LINE_THREE, - options: [{"names": "never"}], - errors: [ ALWAYS_PATHS_ERROR ], + options: [{ "names": "never" }], + errors: [ALWAYS_PATHS_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_PATHS_THREE }, { code: fixtures.AMD_DEPS_SINGLE_LINE_FOUR, - options: [{"names": "never"}], - errors: [ ALWAYS_PATHS_ERROR ], + options: [{ "names": "never" }], + errors: [ALWAYS_PATHS_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_PATHS_FOUR }, // "always" for names only { code: fixtures.AMD_DEPS_SINGLE_LINE_TWO, - options: [{"paths": "never"}], - errors: [ ALWAYS_NAMES_ERROR ], + options: [{ "paths": "never" }], + errors: [ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_NAMES_TWO }, { code: fixtures.AMD_DEPS_SINGLE_LINE_THREE, - options: [{"paths": "never"}], - errors: [ ALWAYS_NAMES_ERROR ], + options: [{ "paths": "never" }], + errors: [ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_NAMES_THREE }, { code: fixtures.AMD_DEPS_SINGLE_LINE_FOUR, - options: [{"paths": "never"}], - errors: [ ALWAYS_NAMES_ERROR ], + options: [{ "paths": "never" }], + errors: [ALWAYS_NAMES_ERROR], output: fixtures.AMD_DEPS_MULTI_LINE_NAMES_FOUR }, @@ -296,89 +296,89 @@ { code: fixtures.AMD_DEPS_MULTI_LINE_TWO, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_PATHS_ERROR, NEVER_NAMES_ERROR ] + errors: [NEVER_PATHS_ERROR, NEVER_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_THREE, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_PATHS_ERROR, NEVER_NAMES_ERROR ] + errors: [NEVER_PATHS_ERROR, NEVER_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_FOUR, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_PATHS_ERROR, NEVER_NAMES_ERROR ] + errors: [NEVER_PATHS_ERROR, NEVER_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_TWO, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_PATHS_ERROR ] + errors: [NEVER_PATHS_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_THREE, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_PATHS_ERROR ] + errors: [NEVER_PATHS_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_FOUR, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_PATHS_ERROR ] + errors: [NEVER_PATHS_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_TWO, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_NAMES_ERROR ] + errors: [NEVER_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_THREE, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_NAMES_ERROR ] + errors: [NEVER_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_FOUR, options: [{ "paths": "never", "names": "never" }], - errors: [ NEVER_NAMES_ERROR ] + errors: [NEVER_NAMES_ERROR] }, // Minimum values should warn when threshold exceeded { code: fixtures.AMD_DEPS_SINGLE_LINE_THREE, options: [{ "paths": 2, "names": 2 }], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ] + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_SINGLE_LINE_FOUR, options: [{ "paths": 2, "names": 2 }], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ] + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_SINGLE_LINE_THREE, options: [{ "paths": 2, "names": 2 }], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ] + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_SINGLE_LINE_FOUR, options: [{ "paths": 2, "names": 2 }], - errors: [ ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR ] + errors: [ALWAYS_PATHS_ERROR, ALWAYS_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_THREE, options: [{ "paths": "always", "names": 2 }], - errors: [ ALWAYS_NAMES_ERROR ] + errors: [ALWAYS_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_PATHS_FOUR, options: [{ "paths": "always", "names": 2 }], - errors: [ ALWAYS_NAMES_ERROR ] + errors: [ALWAYS_NAMES_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_THREE, options: [{ "paths": 2, "names": "always" }], - errors: [ ALWAYS_PATHS_ERROR ] + errors: [ALWAYS_PATHS_ERROR] }, { code: fixtures.AMD_DEPS_MULTI_LINE_NAMES_FOUR, options: [{ "paths": 2, "names": "always" }], - errors: [ ALWAYS_PATHS_ERROR ] + errors: [ALWAYS_PATHS_ERROR] } ] --- a/tests/lib/rules/sort-amd-paths.js +++ b/tests/lib/rules/sort-amd-paths.js @@ -244,7 +244,7 @@ // Tests // ----------------------------------------------------------------------------- -const errorMsg = (expected) => ({ +const errorMsg = expected => ({ message: `Required paths are not in alphabetical order (expected '${expected}').`, type: "Literal" }); --- a/tests/lib/utils/ast.js +++ b/tests/lib/utils/ast.js @@ -8,314 +8,314 @@ const assert = require("assert"); const ast = require("../../../lib/utils/ast"); -describe("ast.isIdentifier", function () { +describe("ast.isIdentifier", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isIdentifier(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isIdentifier({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `Identifier`", function () { + it("should return `false` if node contains a `type` other than `Identifier`", () => { const actual = ast.isIdentifier({ type: "Literal" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is an Identifier", function () { + it("should return `true` if supplied node is an Identifier", () => { const actual = ast.isIdentifier({ type: "Identifier" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isLiteral", function () { +describe("ast.isLiteral", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isLiteral(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isLiteral({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `Literal`", function () { + it("should return `false` if node contains a `type` other than `Literal`", () => { const actual = ast.isLiteral({ type: "Identifier" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is a `Literal`", function () { + it("should return `true` if supplied node is a `Literal`", () => { const actual = ast.isLiteral({ type: "Literal" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isStringLiteral", function () { +describe("ast.isStringLiteral", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isStringLiteral(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isStringLiteral({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `value` attribute", function () { + it("should return `false` if node does not contain a `value` attribute", () => { const actual = ast.isStringLiteral({ type: "Literal" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `Literal`", function () { + it("should return `false` if node contains a `type` other than `Literal`", () => { const actual = ast.isStringLiteral({ type: "Identifier" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `value` type other than `string`", function () { + it("should return `false` if node contains a `value` type other than `string`", () => { const actual = ast.isStringLiteral({ type: "Identifier", value: 5 }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is a `Literal` with a `string` value", function () { + it("should return `true` if supplied node is a `Literal` with a `string` value", () => { const actual = ast.isStringLiteral({ type: "Literal", value: "foobar" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isArrayExpr", function () { +describe("ast.isArrayExpr", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isArrayExpr(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isArrayExpr({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `ArrayExpression`", function () { + it("should return `false` if node contains a `type` other than `ArrayExpression`", () => { const actual = ast.isArrayExpr({ type: "foobar" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is an `ArrayExpression`", function () { + it("should return `true` if supplied node is an `ArrayExpression`", () => { const actual = ast.isArrayExpr({ type: "ArrayExpression" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isObjectExpr", function () { +describe("ast.isObjectExpr", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isObjectExpr(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isObjectExpr({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `ObjectExpression`", function () { + it("should return `false` if node contains a `type` other than `ObjectExpression`", () => { const actual = ast.isObjectExpr({ type: "foobar" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is an `ObjectExpression`", function () { + it("should return `true` if supplied node is an `ObjectExpression`", () => { const actual = ast.isObjectExpr({ type: "ObjectExpression" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isFunctionExpr", function () { +describe("ast.isFunctionExpr", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isFunctionExpr(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isFunctionExpr({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `FunctionExpression` or `ArrowFunctionExpression`", function () { + it("should return `false` if node contains a `type` other than `FunctionExpression` or `ArrowFunctionExpression`", () => { const actual = ast.isFunctionExpr({ type: "foobar" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is a `FunctionExpression`", function () { + it("should return `true` if supplied node is a `FunctionExpression`", () => { const actual = ast.isFunctionExpr({ type: "FunctionExpression" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is an `ArrowFunctionExpression`", function () { + it("should return `true` if supplied node is an `ArrowFunctionExpression`", () => { const actual = ast.isFunctionExpr({ type: "ArrowFunctionExpression" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isMemberExpr", function () { +describe("ast.isMemberExpr", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isMemberExpr(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isMemberExpr({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `MemberExpression`", function () { + it("should return `false` if node contains a `type` other than `MemberExpression`", () => { const actual = ast.isMemberExpr({ type: "foobar" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is an `MemberExpression`", function () { + it("should return `true` if supplied node is an `MemberExpression`", () => { const actual = ast.isMemberExpr({ type: "MemberExpression" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isExprStatement", function () { +describe("ast.isExprStatement", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isExprStatement(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isExprStatement({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node contains a `type` other than `ExpressionStatement`", function () { + it("should return `false` if node contains a `type` other than `ExpressionStatement`", () => { const actual = ast.isExprStatement({ type: "foobar" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node is an `ExpressionStatement`", function () { + it("should return `true` if supplied node is an `ExpressionStatement`", () => { const actual = ast.isExprStatement({ type: "ExpressionStatement" }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.isStringLiteralArray", function () { +describe("ast.isStringLiteralArray", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.isStringLiteralArray(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `type` attribute", function () { + it("should return `false` if node does not contain a `type` attribute", () => { const actual = ast.isStringLiteral({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node `type` is not an `ArrayExpression`", function () { + it("should return `false` if node `type` is not an `ArrayExpression`", () => { const actual = ast.isStringLiteralArray({ type: "FunctionExpression" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain an `elements` attribute", function () { + it("should return `false` if node does not contain an `elements` attribute", () => { const actual = ast.isStringLiteralArray({ type: "ArrayExpression" }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node `elements` contains non-string values", function () { + it("should return `false` if node `elements` contains non-string values", () => { const actual = ast.isStringLiteralArray({ type: "ArrayExpression", elements: [ @@ -326,10 +326,10 @@ }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if node `elements` contains only string values", function () { + it("should return `true` if node `elements` contains only string values", () => { const actual = ast.isStringLiteralArray({ type: "ArrayExpression", elements: [ @@ -340,138 +340,138 @@ }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if node `elements` is empty", function () { + it("should return `true` if node `elements` is empty", () => { const actual = ast.isStringLiteralArray({ type: "ArrayExpression", elements: [] }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.hasParams", function () { +describe("ast.hasParams", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.hasParams(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `params` attribute", function () { + it("should return `false` if node does not contain a `params` attribute", () => { const actual = ast.hasParams({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if `params` is empty", function () { + it("should return `false` if `params` is empty", () => { const actual = ast.hasParams({ params: [] }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node has at least one param", function () { + it("should return `true` if supplied node has at least one param", () => { const actual = ast.hasParams({ params: [{ type: "Identifier", name: "boop" }] }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.hasCallback", function () { +describe("ast.hasCallback", () => { - it("should return `false` if no argument is supplied", function () { + it("should return `false` if no argument is supplied", () => { const actual = ast.hasCallback(); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if node does not contain a `arguments` attribute", function () { + it("should return `false` if node does not contain a `arguments` attribute", () => { const actual = ast.hasCallback({}); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if `arguments` is empty", function () { + it("should return `false` if `arguments` is empty", () => { const actual = ast.hasCallback({ arguments: [] }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if `arguments` does not contain a FunctionExpression", function () { + it("should return `false` if `arguments` does not contain a FunctionExpression", () => { const actual = ast.hasCallback({ arguments: [{ type: "Identifier", name: "foobar" }] }); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `true` if supplied node has at least one FunctionExpression argument", function () { + it("should return `true` if supplied node has at least one FunctionExpression argument", () => { const actual = ast.hasCallback({ arguments: [{ type: "FunctionExpression" }] }); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.ancestor", function () { +describe("ast.ancestor", () => { const a = { type: "Program" }; const b = { type: "FunctionDeclaration", parent: a }; const c = { type: "BlockStatement", parent: b }; const d = { type: "ReturnStatement", parent: c }; - it("should return `true` if an ancestor satisfies the predicate", function () { - const actual = ast.ancestor((node) => node.type === "FunctionDeclaration", d); + it("should return `true` if an ancestor satisfies the predicate", () => { + const actual = ast.ancestor(node => node.type === "FunctionDeclaration", d); const expected = true; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `false` if no ancestor satisfies the predicate", function () { - const actual = ast.ancestor((node) => node.type === "VariableDeclaration", d); + it("should return `false` if no ancestor satisfies the predicate", () => { + const actual = ast.ancestor(node => node.type === "VariableDeclaration", d); const expected = false; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); -describe("ast.nearest", function () { +describe("ast.nearest", () => { const a = { type: "Program" }; const b = { type: "FunctionDeclaration", parent: a }; const c = { type: "BlockStatement", parent: b }; const d = { type: "ReturnStatement", parent: c }; - it("should return found node if an ancestor satisfies the predicate", function () { - const actual = ast.nearest((node) => node.type === "FunctionDeclaration", d); + it("should return found node if an ancestor satisfies the predicate", () => { + const actual = ast.nearest(node => node.type === "FunctionDeclaration", d); const expected = b; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); - it("should return `undefined` if no ancestor satisfies the predicate", function () { - const actual = ast.nearest((node) => node.type === "VariableDeclaration", d); + it("should return `undefined` if no ancestor satisfies the predicate", () => { + const actual = ast.nearest(node => node.type === "VariableDeclaration", d); const expected = undefined; - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); });