Socket
Socket
Sign inDemoInstall

eslint-plugin-node

Package Overview
Dependencies
Maintainers
1
Versions
60
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

eslint-plugin-node - npm Package Compare versions

Comparing version 0.4.1 to 0.5.0

lib/util/get-value-if-string.js

166

lib/rules/no-unsupported-features.js

@@ -14,2 +14,3 @@ /**

var features = require("../util/features");
var getValueIfString = require("../util/get-value-if-string");

@@ -23,2 +24,3 @@ //------------------------------------------------------------------------------

var FUNC_TYPE = /^(?:Arrow)?Function(?:Declaration|Expression)$/;
var CLASS_TYPE = /^Class(?:Declaration|Expression)$/;
var DESTRUCTURING_PARENT_TYPE = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression|AssignmentExpression|VariableDeclarator)$/;

@@ -28,2 +30,29 @@ var BINARY_NUMBER = /^0[bB]/;

var UNICODE_ESC = /\\u\{.+?\}/;
var NEW_BUILTIN_TYPES = [
"Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array",
"Int32Array", "Uint32Array", "Float32Array", "Float64Array", "DataView",
"Map", "Set", "WeakMap", "WeakSet", "Proxy", "Reflect", "Promise", "Symbol"
];
var SUBCLASSING_TEST_TARGETS = [
"Array", "RegExp", "Function", "Promise", "Boolean", "Number", "String",
"Map", "Set"
];
var PROPERTY_TEST_TARGETS = {
Object: ["assign", "is", "getOwnPropertySymbols", "setPrototypeOf"],
String: ["raw", "fromCodePoint"],
Array: ["from", "of"],
Number: [
"isFinite", "isInteger", "isSafeInteger", "isNaN", "EPSILON",
"MIN_SAFE_INTEGER", "MAX_SAFE_INTEGER"
],
Math: [
"clz32", "imul", "sign", "log10", "log2", "log1p", "expm1", "cosh",
"sinh", "tanh", "acosh", "asinh", "atanh", "trunc", "fround", "cbrt",
"hypot"
],
Symbol: [
"hasInstance", "isConcatSpreadablec", "iterator", "species", "replace",
"search", "split", "match", "toPrimitive", "toStringTag", "unscopables"
]
};

@@ -42,3 +71,4 @@ /**

ignores = [];
} else {
}
else {
version = options.version;

@@ -61,3 +91,4 @@ ignores = options.ignores || [];

});
} else if (typeof feature.node === "number") {
}
else if (typeof feature.node === "number") {
retv[key] = Object.freeze({

@@ -69,3 +100,4 @@ name: feature.name,

});
} else {
}
else {
retv[key] = Object.freeze({

@@ -113,2 +145,6 @@ name: feature.name,

function getIdentifierName(node) {
return node.name;
}
//------------------------------------------------------------------------------

@@ -191,3 +227,4 @@ // Rule Definition

});
} else if (!isStrict()) {
}
else if (!isStrict()) {
context.report({

@@ -210,31 +247,44 @@ node: node,

Program: function() {
"Program:exit": function() {
// Check new global variables.
NEW_BUILTIN_TYPES.forEach(function(name) {
eachReferences([name], function(reference) {
report(reference.identifier, name);
});
});
// Check static methods.
eachReferences(
[
"Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array",
"Uint16Array", "Int32Array", "Uint32Array", "Float32Array",
"Float64Array", "DataView"
],
Object.keys(PROPERTY_TEST_TARGETS),
function(reference) {
report(reference.identifier, "typedArrays");
var node = reference.identifier;
var parentNode = node.parent;
if (parentNode.type !== "MemberExpression" ||
parentNode.object !== node
) {
return;
}
var objectName = node.name;
var properties = PROPERTY_TEST_TARGETS[objectName];
var propertyName = (parentNode.computed ? getValueIfString : getIdentifierName)(parentNode.property);
if (propertyName && properties.indexOf(propertyName) !== -1) {
report(parentNode, objectName + "." + propertyName);
}
}
);
eachReferences(["Map", "Set"], function(reference) {
report(reference.identifier, "mapSet");
});
eachReferences(["WeakMap", "WeakSet"], function(reference) {
report(reference.identifier, "weakMapSet");
});
eachReferences(["Proxy"], function(reference) {
report(reference.identifier, "proxy");
});
eachReferences(["Reflect"], function(reference) {
report(reference.identifier, "reflect");
});
eachReferences(["Promise"], function(reference) {
report(reference.identifier, "promise");
});
eachReferences(["Symbol"], function(reference) {
report(reference.identifier, "symbol");
});
// Check subclassing
eachReferences(
SUBCLASSING_TEST_TARGETS,
function(reference) {
var node = reference.identifier;
var parentNode = node.parent;
if (CLASS_TYPE.test(parentNode.type) &&
parentNode.superClass === node
) {
report(node, "extends" + node.name);
}
}
);
},

@@ -246,7 +296,7 @@

ArrowFunctionExpression: function(node) {
"ArrowFunctionExpression": function(node) {
report(node, "arrowFunctions");
},
AssignmentPattern: function(node) {
"AssignmentPattern": function(node) {
if (FUNC_TYPE.test(node.parent.type)) {

@@ -257,3 +307,3 @@ report(node, "defaultParameters");

FunctionDeclaration: function(node) {
"FunctionDeclaration": function(node) {
var scope = context.getScope().upper;

@@ -268,3 +318,3 @@ if (scope.type !== "global" && scope.type !== "function") {

FunctionExpression: function(node) {
"FunctionExpression": function(node) {
if (node.generator) {

@@ -275,11 +325,11 @@ report(node, "generatorFunctions");

MetaProperty: function(node) {
"MetaProperty": function(node) {
var meta = node.meta.name || node.meta;
var property = node.property.name || node.property;
if (meta === "new" && property === "target") {
report(node, "newTarget");
report(node, "new.target");
}
},
RestElement: function(node) {
"RestElement": function(node) {
if (FUNC_TYPE.test(node.parent.type)) {

@@ -294,7 +344,7 @@ report(node, "restParameters");

ClassDeclaration: function(node) {
"ClassDeclaration": function(node) {
report(node, "classes");
},
ClassExpression: function(node) {
"ClassExpression": function(node) {
report(node, "classes");

@@ -307,10 +357,11 @@ },

ForOfStatement: function(node) {
"ForOfStatement": function(node) {
report(node, "forOf");
},
VariableDeclaration: function(node) {
"VariableDeclaration": function(node) {
if (node.kind === "const") {
report(node, "const");
} else if (node.kind === "let") {
}
else if (node.kind === "let") {
report(node, "let");

@@ -324,3 +375,3 @@ }

ArrayPattern: function(node) {
"ArrayPattern": function(node) {
if (DESTRUCTURING_PARENT_TYPE.test(node.parent.type)) {

@@ -331,3 +382,3 @@ report(node, "destructuring");

Identifier: function(node) {
"Identifier": function(node) {
var raw = sourceCode.getText(node);

@@ -339,14 +390,17 @@ if (UNICODE_ESC.test(raw)) {

Literal: function(node) {
"Literal": function(node) {
if (typeof node.value === "number") {
if (BINARY_NUMBER.test(node.raw)) {
report(node, "binaryNumberLiterals");
} else if (OCTAL_NUMBER.test(node.raw)) {
}
else if (OCTAL_NUMBER.test(node.raw)) {
report(node, "octalNumberLiterals");
}
} else if (typeof node.value === "string") {
}
else if (typeof node.value === "string") {
if (UNICODE_ESC.test(node.raw)) {
report(node, "unicodeCodePointEscapes");
}
} else if (node.regex) {
}
else if (node.regex) {
if (node.regex.flags.indexOf("y") !== -1) {

@@ -361,3 +415,3 @@ report(node, "regexpY");

NewExpression: function(node) {
"NewExpression": function(node) {
if (node.callee.type === "Identifier" &&

@@ -378,3 +432,3 @@ node.callee.name === "RegExp" &&

ObjectPattern: function(node) {
"ObjectPattern": function(node) {
if (DESTRUCTURING_PARENT_TYPE.test(node.parent.type)) {

@@ -385,3 +439,3 @@ report(node, "destructuring");

Property: function(node) {
"Property": function(node) {
if (node.parent.type === "ObjectExpression" &&

@@ -394,7 +448,7 @@ (node.computed || node.shorthand || node.method)

SpreadElement: function(node) {
"SpreadElement": function(node) {
report(node, "spreadOperators", 5);
},
TemplateLiteral: function(node) {
"TemplateLiteral": function(node) {
report(node, "templateStrings");

@@ -407,15 +461,15 @@ },

ExportAllDeclaration: function(node) {
"ExportAllDeclaration": function(node) {
report(node, "modules");
},
ExportDefaultDeclaration: function(node) {
"ExportDefaultDeclaration": function(node) {
report(node, "modules");
},
ExportNamedDeclaration: function(node) {
"ExportNamedDeclaration": function(node) {
report(node, "modules");
},
ImportDeclaration: function(node) {
"ImportDeclaration": function(node) {
report(node, "modules");

@@ -422,0 +476,0 @@ }

28

lib/rules/shebang.js

@@ -85,3 +85,3 @@ /**

return {
"Program": function(node) {
Program: function(node) {
context.report({

@@ -93,5 +93,4 @@ node: node,

return fixer.replaceTextRange([0, shebang.length], NODE_SHEBANG);
} else {
return fixer.insertTextBeforeRange([0, 0], NODE_SHEBANG);
}
return fixer.insertTextBeforeRange([0, 0], NODE_SHEBANG);
}

@@ -101,15 +100,14 @@ });

};
} else {
return {
"Program": function(node) {
context.report({
node: node,
message: "This file needs no shebang.",
fix: function(fixer) {
return fixer.removeRange([0, shebang.length]);
}
});
}
};
}
return {
Program: function(node) {
context.report({
node: node,
message: "This file needs no shebang.",
fix: function(fixer) {
return fixer.removeRange([0, shebang.length]);
}
});
}
};
};

@@ -116,0 +114,0 @@

3

lib/util/cache.js

@@ -54,3 +54,4 @@ /**

entry.expire = now + SKIP_TIME;
} else {
}
else {
this.map[key] = {

@@ -57,0 +58,0 @@ value: value,

6

lib/util/check-existence.js

@@ -44,7 +44,9 @@ /**

}
} else {
}
else {
try {
resolve.sync(target.name, opts);
continue;
} catch (err) {
}
catch (err) {
// ignore.

@@ -51,0 +53,0 @@ }

3

lib/util/check-publish.js

@@ -75,3 +75,4 @@ /**

}
} else {
}
else {
// This file is published, so this cannot import private files.

@@ -78,0 +79,0 @@ for (i = 0; i < targets.length; ++i) {

3

lib/util/exists.js

@@ -28,5 +28,6 @@ /**

return fs.statSync(filePath).isFile();
} catch (err) {
}
catch (err) {
return false;
}
};

416

lib/util/features.js

@@ -14,56 +14,60 @@ /**

module.exports = {
defaultParameters: {
//--------------------------------------------------------------------------
// Syntax
//--------------------------------------------------------------------------
"defaultParameters": {
name: "Default Parameters",
node: NaN
},
restParameters: {
"restParameters": {
name: "Rest Parameters",
node: NaN
},
spreadOperators: {
"spreadOperators": {
name: "Spread Operators",
node: 5
},
objectLiteralExtensions: {
"objectLiteralExtensions": {
name: "Object Literal Extensions",
node: 4
},
forOf: {
name: "For..of Loops",
"forOf": {
name: "'for..of' Loops",
node: 0.12
},
binaryNumberLiterals: {
"binaryNumberLiterals": {
name: "Binary Number Literals",
node: 4
},
octalNumberLiterals: {
"octalNumberLiterals": {
name: "Octal Number Literals",
node: 4
},
templateStrings: {
"templateStrings": {
name: "Template Strings",
node: 4
},
regexpY: {
name: "RegExp \"y\" Flags",
"regexpY": {
name: "RegExp 'y' Flags",
node: NaN
},
regexpU: {
name: "RegExp \"u\" Flags",
"regexpU": {
name: "RegExp 'u' Flags",
node: NaN
},
destructuring: {
"destructuring": {
name: "Destructuring",
node: NaN
},
unicodeCodePointEscapes: {
"unicodeCodePointEscapes": {
name: "Unicode Code Point Escapes",
node: 4
},
newTarget: {
name: "\"new.target\"",
"new.target": {
name: "'new.target'",
node: 5
},
const: {
name: "\"const\" Declarations",
"const": {
name: "'const' Declarations",
node: {

@@ -74,4 +78,4 @@ sloppy: NaN,

},
let: {
name: "\"let\" Declarations",
"let": {
name: "'let' Declarations",
node: {

@@ -82,3 +86,3 @@ sloppy: NaN,

},
blockScopedFunctions: {
"blockScopedFunctions": {
name: "Block-Scoped Functions",

@@ -90,11 +94,11 @@ node: {

},
arrowFunctions: {
"arrowFunctions": {
name: "Arrow Functions",
node: 4
},
generatorFunctions: {
"generatorFunctions": {
name: "Generator Functions",
node: 4
},
classes: {
"classes": {
name: "Classes",

@@ -106,38 +110,368 @@ node: {

},
typedArrays: {
name: "Typed Arrays",
"modules": {
name: "Import and Export Declarations",
node: NaN
},
//--------------------------------------------------------------------------
// Runtime
//--------------------------------------------------------------------------
"Object.assign": {
name: "'Object.assign'",
singular: true,
node: 4
},
"Object.is": {
name: "'Object.is'",
singular: true,
node: 0.12
},
mapSet: {
name: "Map and Set",
"Object.getOwnPropertySymbols": {
name: "'Object.getOwnPropertySymbols'",
singular: true,
node: 0.12
},
weakMapSet: {
name: "WeakMap and WeakSet",
"Object.setPrototypeOf": {
name: "'Object.setPrototypeOf'",
singular: true,
node: 0.12
},
proxy: {
name: "Proxy",
"String.raw": {
name: "'String.raw'",
singular: true,
node: 4
},
"String.fromCodePoint": {
name: "'String.fromCodePoint'",
singular: true,
node: 4
},
"Array.from": {
name: "'Array.from'",
singular: true,
node: 4
},
"Array.of": {
name: "'Array.of'",
singular: true,
node: 4
},
"Number.isFinite": {
name: "'Number.isFinite'",
singular: true,
node: 0.10
},
"Number.isInteger": {
name: "'Number.isInteger'",
singular: true,
node: 0.12
},
"Number.isSafeInteger": {
name: "'Number.isSafeInteger'",
singular: true,
node: 0.12
},
"Number.isNaN": {
name: "'Number.isNaN'",
singular: true,
node: 0.10
},
"Number.EPSILON": {
name: "'Number.EPSILON'",
singular: true,
node: 0.12
},
"Number.MIN_SAFE_INTEGER": {
name: "'Number.MIN_SAFE_INTEGER'",
singular: true,
node: 0.12
},
"Number.MAX_SAFE_INTEGER": {
name: "'Number.MAX_SAFE_INTEGER'",
singular: true,
node: 0.12
},
"Math.clz32": {
name: "'Math.clz32'",
singular: true,
node: 0.12
},
"Math.imul": {
name: "'Math.imul'",
singular: true,
node: 0.12
},
"Math.sign": {
name: "'Math.sign'",
singular: true,
node: 0.12
},
"Math.log10": {
name: "'Math.log10'",
singular: true,
node: 0.12
},
"Math.log2": {
name: "'Math.log2'",
singular: true,
node: 0.12
},
"Math.log1p": {
name: "'Math.log1p'",
singular: true,
node: 0.12
},
"Math.expm1": {
name: "'Math.expm1'",
singular: true,
node: 0.12
},
"Math.cosh": {
name: "'Math.cosh'",
singular: true,
node: 0.12
},
"Math.sinh": {
name: "'Math.sinh'",
singular: true,
node: 0.12
},
"Math.tanh": {
name: "'Math.tanh'",
singular: true,
node: 0.12
},
"Math.acosh": {
name: "'Math.acosh'",
singular: true,
node: 0.12
},
"Math.asinh": {
name: "'Math.asinh'",
singular: true,
node: 0.12
},
"Math.atanh": {
name: "'Math.atanh'",
singular: true,
node: 0.12
},
"Math.trunc": {
name: "'Math.trunc'",
singular: true,
node: 0.12
},
"Math.fround": {
name: "'Math.fround'",
singular: true,
node: 0.12
},
"Math.cbrt": {
name: "'Math.cbrt'",
singular: true,
node: 0.12
},
"Math.hypot": {
name: "'Math.hypot'",
singular: true,
node: 0.12
},
"Int8Array": {
name: "'Int8Array'",
singular: true,
node: 0.12
},
"Uint8Array": {
name: "'Uint8Array'",
singular: true,
node: 0.12
},
"Uint8ClampedArray": {
name: "'Uint8ClampedArray'",
singular: true,
node: 0.12
},
"Int16Array": {
name: "'Int16Array'",
singular: true,
node: 0.12
},
"Uint16Array": {
name: "'Uint16Array'",
singular: true,
node: 0.12
},
"Int32Array": {
name: "'Int32Array'",
singular: true,
node: 0.12
},
"Uint32Array": {
name: "'Uint32Array'",
singular: true,
node: 0.12
},
"Float32Array": {
name: "'Float32Array'",
singular: true,
node: 0.12
},
"Float64Array": {
name: "'Float64Array'",
singular: true,
node: 0.12
},
"DataView": {
name: "'DataView'",
singular: true,
node: 0.12
},
"Map": {
name: "'Map'",
singular: true,
node: 0.12
},
"Set": {
name: "'Set'",
singular: true,
node: 0.12
},
"WeakMap": {
name: "'WeakMap'",
singular: true,
node: 0.12
},
"WeakSet": {
name: "'WeakSet'",
singular: true,
node: 0.12
},
"Proxy": {
name: "'Proxy'",
singular: true,
node: NaN
},
reflect: {
name: "Reflect",
"Reflect": {
name: "'Reflect'",
singular: true,
node: NaN
},
promise: {
name: "Promise",
"Promise": {
name: "'Promise'",
singular: true,
node: 0.12
},
symbol: {
name: "Symbol",
"Symbol": {
name: "'Symbol'",
singular: true,
node: 0.12
},
modules: {
name: "Import and Export Declarations",
"Symbol.hasInstance": {
name: "'Symbol.hasInstance'",
singular: true,
node: NaN
},
"Symbol.isConcatSpreadablec": {
name: "'Symbol.isConcatSpreadablec'",
singular: true,
node: NaN
},
"Symbol.iterator": {
name: "'Symbol.iterator'",
singular: true,
node: 0.12
},
"Symbol.species": {
name: "'Symbol.species'",
singular: true,
node: NaN
},
"Symbol.replace": {
name: "'Symbol.replace'",
singular: true,
node: NaN
},
"Symbol.search": {
name: "'Symbol.search'",
singular: true,
node: NaN
},
"Symbol.split": {
name: "'Symbol.split'",
singular: true,
node: NaN
},
"Symbol.match": {
name: "'Symbol.match'",
singular: true,
node: NaN
},
"Symbol.toPrimitive": {
name: "'Symbol.toPrimitive'",
singular: true,
node: NaN
},
"Symbol.toStringTag": {
name: "'Symbol.toStringTag'",
singular: true,
node: NaN
},
"Symbol.unscopables": {
name: "'Symbol.unscopables'",
singular: true,
node: 4
},
"extendsArray": {
name: "Subclassing of 'Array'",
singular: true,
node: NaN
},
"extendsRegExp": {
name: "Subclassing of 'RegExp'",
singular: true,
node: 5
},
"extendsFunction": {
name: "Subclassing of 'Function'",
singular: true,
node: NaN
},
"extendsPromise": {
name: "Subclassing of 'Promise'",
singular: true,
node: 5
},
"extendsBoolean": {
name: "Subclassing of 'Boolean'",
singular: true,
node: 4
},
"extendsNumber": {
name: "Subclassing of 'Number'",
singular: true,
node: 4
},
"extendsString": {
name: "Subclassing of 'String'",
singular: true,
node: 4
},
"extendsMap": {
name: "Subclassing of 'Map'",
singular: true,
node: 4
},
"extendsSet": {
name: "Subclassing of 'Set'",
singular: true,
node: 4
}
};

6

lib/util/get-npmignore.js

@@ -168,5 +168,7 @@ /**

retv.match = and(filterNeverIgnoredFiles(p), or(filesIgnore, npmignoreIgnore));
} else if (filesIgnore) {
}
else if (filesIgnore) {
retv.match = and(filterNeverIgnoredFiles(p), filesIgnore);
} else if (npmignoreIgnore) {
}
else if (npmignoreIgnore) {
retv.match = and(filterNeverIgnoredFiles(p), npmignoreIgnore);

@@ -173,0 +175,0 @@ }

6

lib/util/get-package-json.js

@@ -41,3 +41,4 @@ /**

}
} catch (err) {
}
catch (err) {
// do nothing.

@@ -64,4 +65,3 @@ }

var dir = startDir;
var prevDir;
var data;
var prevDir, data;

@@ -68,0 +68,0 @@ do {

31

lib/util/get-require-targets.js

@@ -16,2 +16,3 @@ /**

var getTryExtensions = require("./get-try-extensions");
var getValueIfString = require("./get-value-if-string");
var ImportTarget = require("./import-target");

@@ -44,32 +45,2 @@

/**
* Gets the value of a given node if it's a literal or a template literal.
*
* @param {ASTNode} node - A node to get.
* @returns {string|null} The value of the node, or `null`.
*/
function getValueIfString(node) {
if (!node) {
return null;
}
switch (node.type) {
case "Literal":
if (typeof node.value === "string") {
return node.value;
}
break;
case "TemplateLiteral":
if (node.expressions.length === 0) {
return node.quasis[0].value.cooked;
}
break;
// no default
}
return null;
}
/**
* Gets references of "require".

@@ -76,0 +47,0 @@ *

9

package.json
{
"name": "eslint-plugin-node",
"version": "0.4.1",
"version": "0.5.0",
"description": "Additional ESLint's rules for Node.js",

@@ -13,3 +13,3 @@ "files": [

"clean": "rimraf coverage",
"lint": "eslint lib tests --rulesdir lib/rules --rule \"{no-missing-require:2, no-unpublished-require:2, shebang:2}\"",
"lint": "eslint lib tests/lib --rulesdir lib/rules --rule \"{no-missing-require:2, no-unpublished-require:2, shebang:2}\"",
"build": "node scripts/generate-index.js",

@@ -31,4 +31,5 @@ "test": "npm-run-all clean lint test:mocha",

"coveralls": "^2.11.4",
"eslint": "^1.10.3",
"eslint-config-eslint": "^1.0.1",
"eslint": "1.10.3",
"eslint-config-mysticatea": "^1.9.0",
"eslint-plugin-mysticatea": "^1.0.3",
"istanbul": "^0.4.0",

@@ -35,0 +36,0 @@ "mocha": "^2.3.4",

6

README.md

@@ -46,1 +46,7 @@ # eslint-plugin-node

- [shebang](docs/rules/shebang.md) - Suggest correct usage of shebang. (fixable)
## FAQ
Q: The `no-missing-import` / `no-missing-require` rules don't work with nested folders in SublimeLinter-eslint
A: See [context.getFilename() in rule returns relative path](https://github.com/roadhump/SublimeLinter-eslint#contextgetfilename-in-rule-returns-relative-path) in the SublimeLinter-eslint FAQ.
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc