Commit ⋅ sindresorhus/eslint-plugin-unicorn

Showing 2 of 2 files from the diff.

rules/utils/global-reference-tracker.js changed.

@@ -1,8 +1,8 @@

'use strict';
const {ReferenceTracker} = require('eslint-utils');

const createTraceMap = object => {
	let map = {[ReferenceTracker.READ]: true};
const createTraceMap = (object, type) => {
	let map = {[type]: true};

	const path = object.split('.').reverse();
	for (const name of path) {

@@ -22,9 +22,10 @@

		objects = [object],
		filter,
		handle,
		type = ReferenceTracker.READ,
	}) {
		for (const object of objects) {
			Object.assign(this.#traceMap, createTraceMap(object));
			Object.assign(this.#traceMap, createTraceMap(object, type));
		}

		this.#filter = filter;

@@ -60,6 +61,12 @@

	}
}

Object.assign(GlobalReferenceTracker, {
	READ: ReferenceTracker.READ,
	CALL: ReferenceTracker.CALL,
	CONSTRUCT: ReferenceTracker.CONSTRUCT,
});

module.exports = {
	GlobalReferenceTracker,
};

@@ -1,5 +1,5 @@

'use strict';
const {ReferenceTracker} = require('eslint-utils');
const {GlobalReferenceTracker} = require('./utils/global-reference-tracker.js');
const builtins = require('./utils/builtins.js');
const {
	switchCallExpressionToNewExpression,

@@ -11,64 +11,65 @@

	disallow: 'Use `{{name}}()` instead of `new {{name}}()`.',
};

function * enforceNewExpression({sourceCode, tracker}) {
	const traceMap = Object.fromEntries(
		builtins.enforceNew.map(name => [name, {[ReferenceTracker.CALL]: true}]),
	);

	for (const {node, path: [name]} of tracker.iterateGlobalReferences(traceMap)) {
		if (name === 'Object') {
			const {parent} = node;
			if (
				parent.type === 'BinaryExpression'
				&& (parent.operator === '===' || parent.operator === '!==')
				&& (parent.left === node || parent.right === node)
			) {
				continue;
			}
function enforceNewExpression({node, path: [name]}, sourceCode) {
	if (name === 'Object') {
		const {parent} = node;
		if (
			parent.type === 'BinaryExpression'
			&& (parent.operator === '===' || parent.operator === '!==')
			&& (parent.left === node || parent.right === node)
		) {
			return;
		}

		yield {
			node,
			messageId: 'enforce',
			data: {name},
			fix: fixer => switchCallExpressionToNewExpression(node, sourceCode, fixer),
		};
	}

	return {
		node,
		messageId: 'enforce',
		data: {name},
		fix: fixer => switchCallExpressionToNewExpression(node, sourceCode, fixer),
	};
}

function * enforceCallExpression({sourceCode, tracker}) {
	const traceMap = Object.fromEntries(
		builtins.disallowNew.map(name => [name, {[ReferenceTracker.CONSTRUCT]: true}]),
	);
function enforceCallExpression({node, path: [name]}, sourceCode) {
	const problem = {
		node,
		messageId: 'disallow',
		data: {name},
	};

	for (const {node, path: [name]} of tracker.iterateGlobalReferences(traceMap)) {
		const problem = {
			node,
			messageId: 'disallow',
			data: {name},
	if (name !== 'String' && name !== 'Boolean' && name !== 'Number') {
		problem.fix = function * (fixer) {
			yield * switchNewExpressionToCallExpression(node, sourceCode, fixer);
		};

		if (name !== 'String' && name !== 'Boolean' && name !== 'Number') {
			problem.fix = function * (fixer) {
				yield * switchNewExpressionToCallExpression(node, sourceCode, fixer);
			};
		}

		yield problem;
	}

	return problem;
}

/** @param {import('eslint').Rule.RuleContext} context */
const create = context => ({
	* 'Program:exit'() {
		const sourceCode = context.getSourceCode();
		const tracker = new ReferenceTracker(context.getScope());
const create = context => {
	const sourceCode = context.getSourceCode();
	const newExpressionTracker = new GlobalReferenceTracker({
		objects: builtins.disallowNew,
		type: GlobalReferenceTracker.CONSTRUCT,
		handle: reference => enforceCallExpression(reference, sourceCode),
	});
	const callExpressionTracker = new GlobalReferenceTracker({
		objects: builtins.enforceNew,
		type: GlobalReferenceTracker.CALL,
		handle: reference => enforceNewExpression(reference, sourceCode),
	});

		yield * enforceNewExpression({sourceCode, tracker});
		yield * enforceCallExpression({sourceCode, tracker});
	},
});
	return {
		* 'Program:exit'() {
			const scope = context.getScope();

			yield * newExpressionTracker.track(scope);
			yield * callExpressionTracker.track(scope);
		},
	};
};

/** @type {import('eslint').Rule.RuleModule} */
module.exports = {

Files		•	•	Coverage
configs	136	136	0	100.00%
rules	20,145	20,119	26	99.87%
scripts	135	99	36	73.33%
index.js	36	36	0	100.00%
Project Totals (203 files)	20,452	20,390	62	99.70%

View CI Build Download

coverage:
  status:
    project:
      default:
        target: 99%
        threshold: 1%

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

22	22		objects = [object],
23	23		filter,
24	24		handle,
	25	+	type = ReferenceTracker.READ,
25	26		}) {
26	27		for (const object of objects) {
27		-	Object.assign(this.#traceMap, createTraceMap(object));
	28	+	Object.assign(this.#traceMap, createTraceMap(object, type));
28	29		}
29	30
30	31		this.#filter = filter;

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

1	1		'use strict';
2	2		const {ReferenceTracker} = require('eslint-utils');
3	3
4		-	const createTraceMap = object => {
5		-	let map = {[ReferenceTracker.READ]: true};
	4	+	const createTraceMap = (object, type) => {
	5	+	let map = {[type]: true};
6	6
7	7		const path = object.split('.').reverse();
8	8		for (const name of path) {

60	61		}
61	62		}
62	63
	64	+	Object.assign(GlobalReferenceTracker, {
	65	+	READ: ReferenceTracker.READ,
	66	+	CALL: ReferenceTracker.CALL,
	67	+	CONSTRUCT: ReferenceTracker.CONSTRUCT,
	68	+	});
	69	+
63	70		module.exports = {
64	71		GlobalReferenceTracker,
65	72		};

1	1		'use strict';
2		-	const {ReferenceTracker} = require('eslint-utils');
	2	+	const {GlobalReferenceTracker} = require('./utils/global-reference-tracker.js');
3	3		const builtins = require('./utils/builtins.js');
4	4		const {
5	5		switchCallExpressionToNewExpression,

11	11		disallow: 'Use `{{name}}()` instead of `new {{name}}()`.',
12	12		};
13	13
14		-	function * enforceNewExpression({sourceCode, tracker}) {
15		-	const traceMap = Object.fromEntries(
16		-	builtins.enforceNew.map(name => [name, {[ReferenceTracker.CALL]: true}]),
17		-	);
18		-
19		-	for (const {node, path: [name]} of tracker.iterateGlobalReferences(traceMap)) {
20		-	if (name === 'Object') {
21		-	const {parent} = node;
22		-	if (
23		-	parent.type === 'BinaryExpression'
24		-	&& (parent.operator === '===' \|\| parent.operator === '!==')
25		-	&& (parent.left === node \|\| parent.right === node)
26		-	) {
27		-	continue;
28		-	}
	14	+	function enforceNewExpression({node, path: [name]}, sourceCode) {
	15	+	if (name === 'Object') {
	16	+	const {parent} = node;
	17	+	if (
	18	+	parent.type === 'BinaryExpression'
	19	+	&& (parent.operator === '===' \|\| parent.operator === '!==')
	20	+	&& (parent.left === node \|\| parent.right === node)
	21	+	) {
	22	+	return;
29	23		}
30		-
31		-	yield {
32		-	node,
33		-	messageId: 'enforce',
34		-	data: {name},
35		-	fix: fixer => switchCallExpressionToNewExpression(node, sourceCode, fixer),
36		-	};
37	24		}
	25	+
	26	+	return {
	27	+	node,
	28	+	messageId: 'enforce',
	29	+	data: {name},
	30	+	fix: fixer => switchCallExpressionToNewExpression(node, sourceCode, fixer),
	31	+	};
38	32		}
39	33
40		-	function * enforceCallExpression({sourceCode, tracker}) {
41		-	const traceMap = Object.fromEntries(
42		-	builtins.disallowNew.map(name => [name, {[ReferenceTracker.CONSTRUCT]: true}]),
43		-	);
	34	+	function enforceCallExpression({node, path: [name]}, sourceCode) {
	35	+	const problem = {
	36	+	node,
	37	+	messageId: 'disallow',
	38	+	data: {name},
	39	+	};
44	40
45		-	for (const {node, path: [name]} of tracker.iterateGlobalReferences(traceMap)) {
46		-	const problem = {
47		-	node,
48		-	messageId: 'disallow',
49		-	data: {name},
	41	+	if (name !== 'String' && name !== 'Boolean' && name !== 'Number') {
	42	+	problem.fix = function * (fixer) {
	43	+	yield * switchNewExpressionToCallExpression(node, sourceCode, fixer);
50	44		};
51		-
52		-	if (name !== 'String' && name !== 'Boolean' && name !== 'Number') {
53		-	problem.fix = function * (fixer) {
54		-	yield * switchNewExpressionToCallExpression(node, sourceCode, fixer);
55		-	};
56		-	}
57		-
58		-	yield problem;
59	45		}
	46	+
	47	+	return problem;
60	48		}
61	49
62	50		/** @param {import('eslint').Rule.RuleContext} context */
63		-	const create = context => ({
64		-	* 'Program:exit'() {
65		-	const sourceCode = context.getSourceCode();
66		-	const tracker = new ReferenceTracker(context.getScope());
	51	+	const create = context => {
	52	+	const sourceCode = context.getSourceCode();
	53	+	const newExpressionTracker = new GlobalReferenceTracker({
	54	+	objects: builtins.disallowNew,
	55	+	type: GlobalReferenceTracker.CONSTRUCT,
	56	+	handle: reference => enforceCallExpression(reference, sourceCode),
	57	+	});
	58	+	const callExpressionTracker = new GlobalReferenceTracker({
	59	+	objects: builtins.enforceNew,
	60	+	type: GlobalReferenceTracker.CALL,
	61	+	handle: reference => enforceNewExpression(reference, sourceCode),
	62	+	});
67	63
68		-	yield * enforceNewExpression({sourceCode, tracker});
69		-	yield * enforceCallExpression({sourceCode, tracker});
70		-	},
71		-	});
	64	+	return {
	65	+	* 'Program:exit'() {
	66	+	const scope = context.getScope();
	67	+
	68	+	yield * newExpressionTracker.track(scope);
	69	+	yield * callExpressionTracker.track(scope);
	70	+	},
	71	+	};
	72	+	};
72	73
73	74		/** @type {import('eslint').Rule.RuleModule} */
74	75		module.exports = {

1	coverage:
2	status:
3	project:
4	default:
5	target: 99%
6	threshold: 1%

Updating our web app