#1776

pending completion

Build # #1776

Build Type

push

appveyor

Committed by

web-flow

Commit Message

<a href="https://github.com/benmosher/eslint-plugin-import/commit/<a class=hub.com/benmosher/eslint-plugin-import/commit/5e29baf92ae4a6678a7b5c536945ae37de20db47">5e29baf92<a href="https://github.com/benmosher/eslint-plugin-import/commit/5e29baf92ae4a6678a7b5c536945ae37de20db47">">Merge </a><a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/<a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/b85b9658afef45b95c20f35e3fb201f12c4cd55f">b85b9658a</a>">b85b9658a</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/5e29baf92ae4a6678a7b5c536945ae37de20db47"> into e3c41ca40">e3c41ca40</a>

Run Details

20 of 20 new or added lines in 2 files covered. (100.0%)

1511 of 1548 relevant lines covered (97.61%)

67.03 hits per line

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

92.86

/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 findIndex from 'lodash.findindex'

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 findIndex(body, (node) => containsNodeOrEqual(node, nodeToFind))
}

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


module.exports = {
  meta: {
    docs: {},
  },
  create: function (context) {
    let level = 0
    const requireCalls = []

    function checkForNewLine(node, nextNode, type) {
      if (getLineDifference(node, nextNode) < 2) {
        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 empty line after ${type} statement not followed by another ${type}.`,
        })
      }
    }

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

    return {
      ImportDeclaration: function (node) {
        const { parent } = node
        const nodePosition = parent.body.indexOf(node)
        const nextNode = parent.body[nodePosition + 1]

        if (nextNode && nextNode.type !== 'ImportDeclaration') {
          checkForNewLine(node, nextNode, 'import')
        }
      },
      CallExpression: function(node) {
        if (isStaticRequire(node) && level === 0) {
          requireCalls.push(node)
        }
      },
      'Program:exit': function () {
        log('exit processing for', 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,
      'FunctionDeclaration:exit': decrementLevel,
      'FunctionExpression:exit': decrementLevel,
      'ArrowFunctionExpression:exit': decrementLevel,
      'BlockStatement:exit': decrementLevel,
      'ObjectExpression: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 findIndex from 'lodash.findindex'
8
9	import debug from 'debug'
10
11	const log = debug('eslint-plugin-import:rules:newline-after-import')	1✔
12
13	//------------------------------------------------------------------------------
14	// Rule Definition
15	//------------------------------------------------------------------------------
16
17	function containsNodeOrEqual(outerNode, innerNode) {
18	return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1]	70✔
19	}
20
21	function getScopeBody(scope) {
22	if (scope.block.type === 'SwitchStatement') {	32✔
23	log('SwitchStatement scopes not supported')	×
24	return null	×
25	}
26
27	const { body } = scope.block	32✔
28	if (body && body.type === 'BlockStatement') {	32✔
29	return body.body	×
30	}
31
32	return body	32✔
33	}
34
35	function findNodeIndexInScopeBody(body, nodeToFind) {
36	return findIndex(body, (node) => containsNodeOrEqual(node, nodeToFind))	46✔
37	}
38
39	function getLineDifference(node, nextNode) {
40	return nextNode.loc.start.line - node.loc.end.line	20✔
41	}
42
43
44	module.exports = {	1✔
45	meta: {
46	docs: {},
47	},
48	create: function (context) {
49	let level = 0	32✔
50	const requireCalls = []	32✔
51
52	function checkForNewLine(node, nextNode, type) {
53	if (getLineDifference(node, nextNode) < 2) {	20✔
54	let column = node.loc.start.column	14✔
55
56	if (node.loc.start.line !== node.loc.end.line) {	14✔
57	column = 0	1✔
58	}
59
60	context.report({	14✔
61	loc: {
62	line: node.loc.end.line,
63	column,
64	},
65	message: `Expected empty line after ${type} statement not followed by another ${type}.`,
66	})
67	}
68	}
69
70	function incrementLevel() {
71	level++	16✔
72	}
73	function decrementLevel() {
74	level--	16✔
75	}
76
77	return {	32✔
78	ImportDeclaration: function (node) {
79	const { parent } = node	18✔
80	const nodePosition = parent.body.indexOf(node)	18✔
81	const nextNode = parent.body[nodePosition + 1]	18✔
82
83	if (nextNode && nextNode.type !== 'ImportDeclaration') {	18✔
84	checkForNewLine(node, nextNode, 'import')	8✔
85	}
86	},
87	CallExpression: function(node) {
88	if (isStaticRequire(node) && level === 0) {	70✔
89	requireCalls.push(node)	29✔
90	}
91	},
92	'Program:exit': function () {
93	log('exit processing for', context.getFilename())	32✔
94	const scopeBody = getScopeBody(context.getScope())	32✔
95	log('got scope:', scopeBody)	32✔
96
97	requireCalls.forEach(function (node, index) {	32✔
98	const nodePosition = findNodeIndexInScopeBody(scopeBody, node)	29✔
99	log('node position in scope:', nodePosition)	29✔
100
101	const statementWithRequireCall = scopeBody[nodePosition]	29✔
102	const nextStatement = scopeBody[nodePosition + 1]	29✔
103	const nextRequireCall = requireCalls[index + 1]	29✔
104
105	if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) {	29✔
106	return	6✔
107	}
108
109	if (nextStatement &&	23✔
110	(!nextRequireCall \|\| !containsNodeOrEqual(nextStatement, nextRequireCall))) {
111
112	checkForNewLine(statementWithRequireCall, nextStatement, 'require')	12✔
113	}
114	})
115	},
116	FunctionDeclaration: incrementLevel,
117	FunctionExpression: incrementLevel,
118	ArrowFunctionExpression: incrementLevel,
119	BlockStatement: incrementLevel,
120	ObjectExpression: incrementLevel,
121	'FunctionDeclaration:exit': decrementLevel,
122	'FunctionExpression:exit': decrementLevel,
123	'ArrowFunctionExpression:exit': decrementLevel,
124	'BlockStatement:exit': decrementLevel,
125	'ObjectExpression:exit': decrementLevel,
126	}
127	},
128	}

benmosher / eslint-plugin-import / #1776

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