#28398880

Build Type

push

Committed by

Commit Message

<a href="https://github.com/benmosher/eslint-plugin-import/commit/<a class=hub.com/benmosher/eslint-plugin-import/commit/<a class="double-link" href="https://git"><a class=hub.com/benmosher/eslint-plugin-import/commit/<a class="double-link" href="https://git"><a class=hub.com/benmosher/eslint-plugin-import/commit/957f821fafaafa51bccf25b4b1e4736fd9dea833">957f821fa<a href="https://github.com/benmosher/eslint-plugin-import/commit/957f821fafaafa51bccf25b4b1e4736fd9dea833">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/benmosher/eslint-plugin-import/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/benmosher/eslint-plugin-import/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/benmosher/eslint-plugin-import/commit/957f821fafaafa51bccf25b4b1e4736fd9dea833&quot;&gt;957f821fa&lt;/a&gt;&lt;a href=&quot;https://github.com/benmosher/eslint-plugin-import/commit/957f821fafaafa51bccf25b4b1e4736fd9dea833&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/benmosher/eslint-plugin-import/commit/957f821fafaafa51bccf25b4b1e4736f&lt;/a&gt;d9dea833&quot;&gt;&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/benmosher/eslint-plugin-import/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/benmosher/eslint-plugin-import/commit/<a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/d8fc508f627c5d71559c725959bc6110af8b586a">d8fc508f6</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/957f821fafaafa51bccf25b4b1e4736fd9dea833">&amp;quot;&amp;gt;d8fc508f6&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;d8fc508f6&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/benmosher/eslint-plugin-import/commit/957f821fafaafa51bccf25b4b1e4736fd9dea&lt;/a&gt;833&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/benmosher/eslint-plugin-import/commit/<a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/1359e247b">1359e247b">1359e247b</a>

Run Details

1364 of 1850 branches covered (73.73%)

1677 of 2594 relevant lines covered (64.65%)

39.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.79

/src/rules/newline-after-import.js

/**
 * @fileoverview Rule to enforce new line after import not followed by another import.
 * @author Radek Benkel
 */

import isStaticRequire from '../core/staticRequire';
import docsUrl from '../docsUrl';

import debug from 'debug';
const log = debug('eslint-plugin-import:rules:newline-after-import');

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

function containsNodeOrEqual(outerNode, innerNode) {
  return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1];
}

function getScopeBody(scope) {
  if (scope.block.type === 'SwitchStatement') {
    log('SwitchStatement scopes not supported');
    return null;
  }

  const { body } = scope.block;
  if (body && body.type === 'BlockStatement') {
    return body.body;
  }

  return body;
}

function findNodeIndexInScopeBody(body, nodeToFind) {
  return body.findIndex((node) => containsNodeOrEqual(node, nodeToFind));
}

function getLineDifference(node, nextNode) {
  return nextNode.loc.start.line - node.loc.end.line;
}

function isClassWithDecorator(node) {
  return node.type === 'ClassDeclaration' && node.decorators && node.decorators.length;
}

function isExportDefaultClass(node) {
  return node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'ClassDeclaration';
}

function isExportNameClass(node) {

  return node.type === 'ExportNamedDeclaration' && node.declaration && node.declaration.type === 'ClassDeclaration';
}

module.exports = {
  meta: {
    type: 'layout',
    docs: {
      url: docsUrl('newline-after-import'),
    },
    fixable: 'whitespace',
    schema: [
      {
        'type': 'object',
        'properties': {
          'count': {
            'type': 'integer',
            'minimum': 1,
          },
        },
        'additionalProperties': false,
      },
    ],
  },
  create(context) {
    let level = 0;
    const requireCalls = [];

    function checkForNewLine(node, nextNode, type) {
      if (isExportDefaultClass(nextNode) || isExportNameClass(nextNode)) {
        const classNode = nextNode.declaration;

        if (isClassWithDecorator(classNode)) {
          nextNode = classNode.decorators[0];
        }
      } else if (isClassWithDecorator(nextNode)) {
        nextNode = nextNode.decorators[0];
      }

      const options = context.options[0] || { count: 1 };
      const lineDifference = getLineDifference(node, nextNode);
      const EXPECTED_LINE_DIFFERENCE = options.count + 1;

      if (lineDifference < EXPECTED_LINE_DIFFERENCE) {
        let column = node.loc.start.column;

        if (node.loc.start.line !== node.loc.end.line) {
          column = 0;
        }

        context.report({
          loc: {
            line: node.loc.end.line,
            column,
          },
          message: `Expected ${options.count} empty line${options.count > 1 ? 's' : ''} \
after ${type} statement not followed by another ${type}.`,
          fix: fixer => fixer.insertTextAfter(
            node,
            '\n'.repeat(EXPECTED_LINE_DIFFERENCE - lineDifference)
          ),
        });
      }
    }

    function incrementLevel() {
      level++;
    }
    function decrementLevel() {
      level--;
    }

    function checkImport(node) {
      const { parent } = node;
      const nodePosition = parent.body.indexOf(node);
      const nextNode = parent.body[nodePosition + 1];

      // skip "export import"s
      if (node.type === 'TSImportEqualsDeclaration' && node.isExport) {
        return;
      }

      if (nextNode && nextNode.type !== 'ImportDeclaration' && (nextNode.type !== 'TSImportEqualsDeclaration' || nextNode.isExport)) {
        checkForNewLine(node, nextNode, 'import');
      }
    }

    return {
      ImportDeclaration: checkImport,
      TSImportEqualsDeclaration: checkImport,
      CallExpression(node) {
        if (isStaticRequire(node) && level === 0) {
          requireCalls.push(node);
        }
      },
      'Program:exit': function () {
        log('exit processing for', context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename());
        const scopeBody = getScopeBody(context.getScope());
        log('got scope:', scopeBody);

        requireCalls.forEach(function (node, index) {
          const nodePosition = findNodeIndexInScopeBody(scopeBody, node);
          log('node position in scope:', nodePosition);

          const statementWithRequireCall = scopeBody[nodePosition];
          const nextStatement = scopeBody[nodePosition + 1];
          const nextRequireCall = requireCalls[index + 1];

          if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) {
            return;
          }

          if (nextStatement &&
             (!nextRequireCall || !containsNodeOrEqual(nextStatement, nextRequireCall))) {

            checkForNewLine(statementWithRequireCall, nextStatement, 'require');
          }
        });
      },
      FunctionDeclaration: incrementLevel,
      FunctionExpression: incrementLevel,
      ArrowFunctionExpression: incrementLevel,
      BlockStatement: incrementLevel,
      ObjectExpression: incrementLevel,
      Decorator: incrementLevel,
      'FunctionDeclaration:exit': decrementLevel,
      'FunctionExpression:exit': decrementLevel,
      'ArrowFunctionExpression:exit': decrementLevel,
      'BlockStatement:exit': decrementLevel,
      'ObjectExpression:exit': decrementLevel,
      'Decorator:exit': decrementLevel,
    };
  },
};

1	/**
2	* @fileoverview Rule to enforce new line after import not followed by another import.
3	* @author Radek Benkel
4	*/
5
6	import isStaticRequire from '../core/staticRequire';
7	import docsUrl from '../docsUrl';
8
9	import debug from 'debug';
10	const log = debug('eslint-plugin-import:rules:newline-after-import');	1✔
11
12	//------------------------------------------------------------------------------
13	// Rule Definition
14	//------------------------------------------------------------------------------
15
16	function containsNodeOrEqual(outerNode, innerNode) {
17	return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1];	76✔
18	}
19
20	function getScopeBody(scope) {	47✔
21	if (scope.block.type === 'SwitchStatement') {	47!
22	log('SwitchStatement scopes not supported');	×
23	return null;	×
24	}
25
26	const { body } = scope.block;
27	if (body && body.type === 'BlockStatement') {	47!
28	return body.body;	×
29	}
30
31	return body;	47✔
32	}
33
34	function findNodeIndexInScopeBody(body, nodeToFind) {
35	return body.findIndex((node) => containsNodeOrEqual(node, nodeToFind));	52✔
36	}
37
38	function getLineDifference(node, nextNode) {
39	return nextNode.loc.start.line - node.loc.end.line;	34✔
40	}
41
42	function isClassWithDecorator(node) {
43	return node.type === 'ClassDeclaration' && node.decorators && node.decorators.length;	34✔
44	}
45
46	function isExportDefaultClass(node) {
47	return node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'ClassDeclaration';	34✔
48	}
49
50	function isExportNameClass(node) {
51
52	return node.type === 'ExportNamedDeclaration' && node.declaration && node.declaration.type === 'ClassDeclaration';	30!
53	}
54
55	module.exports = {
56	meta: {
57	type: 'layout',
58	docs: {
59	url: docsUrl('newline-after-import'),
60	},
61	fixable: 'whitespace',
62	schema: [
63	{
64	'type': 'object',
65	'properties': {
66	'count': {
67	'type': 'integer',
68	'minimum': 1,
69	},
70	},
71	'additionalProperties': false,
72	},
73	],
74	},
75	create(context) {
76	let level = 0;	47✔
77	const requireCalls = [];	47✔
78
79	function checkForNewLine(node, nextNode, type) {
80	if (isExportDefaultClass(nextNode) \|\| isExportNameClass(nextNode)) {	64✔
81	const classNode = nextNode.declaration;	4✔
82
83	if (isClassWithDecorator(classNode)) {	4!
84	nextNode = classNode.decorators[0];	4✔
85	}
86	} else if (isClassWithDecorator(nextNode)) {
87	nextNode = nextNode.decorators[0];	3✔
88	}
89
90	const options = context.options[0] \|\| { count: 1 };	34✔
91	const lineDifference = getLineDifference(node, nextNode);	34✔
92	const EXPECTED_LINE_DIFFERENCE = options.count + 1;	34✔
93
94	if (lineDifference < EXPECTED_LINE_DIFFERENCE) {	34✔
95	let column = node.loc.start.column;	20✔
96
97	if (node.loc.start.line !== node.loc.end.line) {	20✔
98	column = 0;	1✔
99	}
100
101	context.report({
102	loc: {
103	line: node.loc.end.line,
104	column,
105	},
106	message: `Expected ${options.count} empty line${options.count > 1 ? 's' : ''} \	20✔
107	after ${type} statement not followed by another ${type}.`,
108	fix: fixer => fixer.insertTextAfter(	20✔
109	node,
110	'\n'.repeat(EXPECTED_LINE_DIFFERENCE - lineDifference)
111	),
112	});
113	}
114	}
115
116	function incrementLevel() {
117	level++;	28✔
118	}
119	function decrementLevel() {
120	level--;	28✔
121	}
122
123	function checkImport(node) {	26!
124	const { parent } = node;
125	const nodePosition = parent.body.indexOf(node);	26✔
126	const nextNode = parent.body[nodePosition + 1];	26✔
127
128	// skip "export import"s
129	if (node.type === 'TSImportEqualsDeclaration' && node.isExport) {
130	return;	×
131	}
132
133	if (nextNode && nextNode.type !== 'ImportDeclaration' && (nextNode.type !== 'TSImportEqualsDeclaration' \|\| nextNode.isExport)) {	26!
134	checkForNewLine(node, nextNode, 'import');	16✔
135	}
136	}
137
138	return {
139	ImportDeclaration: checkImport,
140	TSImportEqualsDeclaration: checkImport,
141	CallExpression(node) {
142	if (isStaticRequire(node) && level === 0) {	85✔
143	requireCalls.push(node);	35✔
144	}
145	},
146	'Program:exit': function () {
147	log('exit processing for', context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename());	47!
148	const scopeBody = getScopeBody(context.getScope());	47✔
149	log('got scope:', scopeBody);	47✔
150
151	requireCalls.forEach(function (node, index) {	47✔
152	const nodePosition = findNodeIndexInScopeBody(scopeBody, node);	35✔
153	log('node position in scope:', nodePosition);	35✔
154
155	const statementWithRequireCall = scopeBody[nodePosition];	35✔
156	const nextStatement = scopeBody[nodePosition + 1];	35✔
157	const nextRequireCall = requireCalls[index + 1];	35✔
158
159	if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) {	35✔
160	return;	6✔
161	}
162
163	if (nextStatement &&	29✔
164	(!nextRequireCall \|\| !containsNodeOrEqual(nextStatement, nextRequireCall))) {
165
166	checkForNewLine(statementWithRequireCall, nextStatement, 'require');	18✔
167	}
168	});
169	},
170	FunctionDeclaration: incrementLevel,
171	FunctionExpression: incrementLevel,
172	ArrowFunctionExpression: incrementLevel,
173	BlockStatement: incrementLevel,
174	ObjectExpression: incrementLevel,
175	Decorator: incrementLevel,
176	'FunctionDeclaration:exit': decrementLevel,
177	'FunctionExpression:exit': decrementLevel,
178	'ArrowFunctionExpression:exit': decrementLevel,
179	'BlockStatement:exit': decrementLevel,
180	'ObjectExpression:exit': decrementLevel,
181	'Decorator:exit': decrementLevel,
182	};
183	},
184	};

benmosher / eslint-plugin-import / #28398880

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous