28142343

Build Type

push

appveyor

Committed by GitHub

Commit Message

<a href="https://github.com/benmosher/eslint-plugin-import/commit/<a class=hub.com/benmosher/eslint-plugin-import/commit/9c3f61ac5b1e2329d58726e1f88ed5c620f02ef0">9c3f61ac5<a href="https://github.com/benmosher/eslint-plugin-import/commit/9c3f61ac5b1e2329d58726e1f88ed5c620f02ef0">">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/ea6019cb72fffc7e1cd6351e8bbf7354b3b41f0a">ea6019cb7</a>">ea6019cb7</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/9c3f61ac5b1e2329d58726e1f88ed5c620f02ef0"> into e62011f2f">e62011f2f</a>

Run Details

2809 of 3078 branches covered (91.26%)

1 of 1 new or added line in 1 file covered. (100.0%)

4028 of 4222 relevant lines covered (95.41%)

55.36 hits per line

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

98.66

/src/rules/order.js

'use strict'

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

const defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index']

// REPORTING AND FIXING

function reverse(array) {
  return array.map(function (v) {
    return {
      name: v.name,
      rank: -v.rank,
      node: v.node,
    }
  }).reverse()
}

function getTokensOrCommentsAfter(sourceCode, node, count) {
  let currentNodeOrToken = node
  const result = []
  for (let i = 0; i < count; i++) {
    currentNodeOrToken = sourceCode.getTokenOrCommentAfter(currentNodeOrToken)
    if (currentNodeOrToken == null) {
      break
    }
    result.push(currentNodeOrToken)
  }
  return result
}

function getTokensOrCommentsBefore(sourceCode, node, count) {
  let currentNodeOrToken = node
  const result = []
  for (let i = 0; i < count; i++) {
    currentNodeOrToken = sourceCode.getTokenOrCommentBefore(currentNodeOrToken)
    if (currentNodeOrToken == null) {
      break
    }
    result.push(currentNodeOrToken)
  }
  return result.reverse()
}

function takeTokensAfterWhile(sourceCode, node, condition) {
  const tokens = getTokensOrCommentsAfter(sourceCode, node, 100)
  const result = []
  for (let i = 0; i < tokens.length; i++) {
    if (condition(tokens[i])) {
      result.push(tokens[i])
    }
    else {
      break
    }
  }
  return result
}

function takeTokensBeforeWhile(sourceCode, node, condition) {
  const tokens = getTokensOrCommentsBefore(sourceCode, node, 100)
  const result = []
  for (let i = tokens.length - 1; i >= 0; i--) {
    if (condition(tokens[i])) {
      result.push(tokens[i])
    }
    else {
      break
    }
  }
  return result.reverse()
}

function findOutOfOrder(imported) {
  if (imported.length === 0) {
    return []
  }
  let maxSeenRankNode = imported[0]
  return imported.filter(function (importedModule) {
    const res = importedModule.rank < maxSeenRankNode.rank
    if (maxSeenRankNode.rank < importedModule.rank) {
      maxSeenRankNode = importedModule
    }
    return res
  })
}

function findRootNode(node) {
  let parent = node
  while (parent.parent != null && parent.parent.body == null) {
    parent = parent.parent
  }
  return parent
}

function findEndOfLineWithComments(sourceCode, node) {
  const tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node))
  let endOfTokens = tokensToEndOfLine.length > 0
    ? tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1]
    : node.range[1]
  let result = endOfTokens
  for (let i = endOfTokens; i < sourceCode.text.length; i++) {
    if (sourceCode.text[i] === '\n') {
      result = i + 1
      break
    }
    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t' && sourceCode.text[i] !== '\r') {
      break
    }
    result = i + 1
  }
  return result
}

function commentOnSameLineAs(node) {
  return token => (token.type === 'Block' ||  token.type === 'Line') &&
      token.loc.start.line === token.loc.end.line &&
      token.loc.end.line === node.loc.end.line
}

function findStartOfLineWithComments(sourceCode, node) {
  const tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node))
  let startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0]
  let result = startOfTokens
  for (let i = startOfTokens - 1; i > 0; i--) {
    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t') {
      break
    }
    result = i
  }
  return result
}

function isPlainRequireModule(node) {
  if (node.type !== 'VariableDeclaration') {
    return false
  }
  if (node.declarations.length !== 1) {
    return false
  }
  const decl = node.declarations[0]
  const result = decl.id &&
    (decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern') &&
    decl.init != null &&
    decl.init.type === 'CallExpression' &&
    decl.init.callee != null &&
    decl.init.callee.name === 'require' &&
    decl.init.arguments != null &&
    decl.init.arguments.length === 1 &&
    decl.init.arguments[0].type === 'Literal'
  return result
}

function isPlainImportModule(node) {
  return node.type === 'ImportDeclaration' && node.specifiers != null && node.specifiers.length > 0
}

function canCrossNodeWhileReorder(node) {
  return isPlainRequireModule(node) || isPlainImportModule(node)
}

function canReorderItems(firstNode, secondNode) {
  const parent = firstNode.parent
  const [firstIndex, secondIndex] = [
    parent.body.indexOf(firstNode),
    parent.body.indexOf(secondNode),
  ].sort()
  const nodesBetween = parent.body.slice(firstIndex, secondIndex + 1)
  for (var nodeBetween of nodesBetween) {
    if (!canCrossNodeWhileReorder(nodeBetween)) {
      return false
    }
  }
  return true
}

function fixOutOfOrder(context, firstNode, secondNode, order) {
  const sourceCode = context.getSourceCode()

  const firstRoot = findRootNode(firstNode.node)
  let firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot)
  const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot)

  const secondRoot = findRootNode(secondNode.node)
  let secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot)
  let secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot)
  const canFix = canReorderItems(firstRoot, secondRoot)

  let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd)
  if (newCode[newCode.length - 1] !== '\n') {
    newCode = newCode + '\n'
  }

  const message = '`' + secondNode.name + '` import should occur ' + order +
      ' import of `' + firstNode.name + '`'

  if (order === 'before') {
    context.report({
      node: secondNode.node,
      message: message,
      fix: canFix && (fixer =>
        fixer.replaceTextRange(
          [firstRootStart, secondRootEnd],
          newCode + sourceCode.text.substring(firstRootStart, secondRootStart)
        )),
    })
  } else if (order === 'after') {
    context.report({
      node: secondNode.node,
      message: message,
      fix: canFix && (fixer =>
        fixer.replaceTextRange(
          [secondRootStart, firstRootEnd],
          sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode
        )),
    })
  }
}

function reportOutOfOrder(context, imported, outOfOrder, order) {
  outOfOrder.forEach(function (imp) {
    const found = imported.find(function hasHigherRank(importedItem) {
      return importedItem.rank > imp.rank
    })
    fixOutOfOrder(context, found, imp, order)
  })
}

function makeOutOfOrderReport(context, imported) {
  const outOfOrder = findOutOfOrder(imported)
  if (!outOfOrder.length) {
    return
  }
  // There are things to report. Try to minimize the number of reported errors.
  const reversedImported = reverse(imported)
  const reversedOrder = findOutOfOrder(reversedImported)
  if (reversedOrder.length < outOfOrder.length) {
    reportOutOfOrder(context, reversedImported, reversedOrder, 'after')
    return
  }
  reportOutOfOrder(context, imported, outOfOrder, 'before')
}

// DETECTING

function computeRank(context, ranks, name, type) {
  return ranks[importType(name, context)] +
    (type === 'import' ? 0 : 100)
}

function registerNode(context, node, name, type, ranks, imported) {
  const rank = computeRank(context, ranks, name, type)
  if (rank !== -1) {
    imported.push({name, rank, node})
  }
}

function isInVariableDeclarator(node) {
  return node &&
    (node.type === 'VariableDeclarator' || isInVariableDeclarator(node.parent))
}

const types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index']

// Creates an object with type-rank pairs.
// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }
// Will throw an error if it contains a type that does not exist, or has a duplicate
function convertGroupsToRanks(groups) {
  const rankObject = groups.reduce(function(res, group, index) {
    if (typeof group === 'string') {
      group = [group]
    }
    group.forEach(function(groupItem) {
      if (types.indexOf(groupItem) === -1) {
        throw new Error('Incorrect configuration of the rule: Unknown type `' +
          JSON.stringify(groupItem) + '`')
      }
      if (res[groupItem] !== undefined) {
        throw new Error('Incorrect configuration of the rule: `' + groupItem + '` is duplicated')
      }
      res[groupItem] = index
    })
    return res
  }, {})

  const omittedTypes = types.filter(function(type) {
    return rankObject[type] === undefined
  })

  return omittedTypes.reduce(function(res, type) {
    res[type] = groups.length
    return res
  }, rankObject)
}

function fixNewLineAfterImport(context, previousImport) {
  const prevRoot = findRootNode(previousImport.node)
  const tokensToEndOfLine = takeTokensAfterWhile(
    context.getSourceCode(), prevRoot, commentOnSameLineAs(prevRoot))

  let endOfLine = prevRoot.range[1]
  if (tokensToEndOfLine.length > 0) {
    endOfLine = tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1]
  }
  return (fixer) => fixer.insertTextAfterRange([prevRoot.range[0], endOfLine], '\n')
}

function removeNewLineAfterImport(context, currentImport, previousImport) {
  const sourceCode = context.getSourceCode()
  const prevRoot = findRootNode(previousImport.node)
  const currRoot = findRootNode(currentImport.node)
  const rangeToRemove = [
    findEndOfLineWithComments(sourceCode, prevRoot),
    findStartOfLineWithComments(sourceCode, currRoot),
  ]
  if (/^\s*$/.test(sourceCode.text.substring(rangeToRemove[0], rangeToRemove[1]))) {
    return (fixer) => fixer.removeRange(rangeToRemove)
  }
  return undefined
}

function makeNewlinesBetweenReport (context, imported, newlinesBetweenImports) {
  const getNumberOfEmptyLinesBetween = (currentImport, previousImport) => {
    const linesBetweenImports = context.getSourceCode().lines.slice(
      previousImport.node.loc.end.line,
      currentImport.node.loc.start.line - 1
    )

    return linesBetweenImports.filter((line) => !line.trim().length).length
  }
  let previousImport = imported[0]

  imported.slice(1).forEach(function(currentImport) {
    const emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport)

    if (newlinesBetweenImports === 'always'
        || newlinesBetweenImports === 'always-and-inside-groups') {
      if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {
        context.report({
          node: previousImport.node,
          message: 'There should be at least one empty line between import groups',
          fix: fixNewLineAfterImport(context, previousImport, currentImport),
        })
      } else if (currentImport.rank === previousImport.rank
        && emptyLinesBetween > 0
        && newlinesBetweenImports !== 'always-and-inside-groups') {
        context.report({
          node: previousImport.node,
          message: 'There should be no empty line within import group',
          fix: removeNewLineAfterImport(context, currentImport, previousImport),
        })
      }
    } else if (emptyLinesBetween > 0) {
      context.report({
        node: previousImport.node,
        message: 'There should be no empty line between import groups',
        fix: removeNewLineAfterImport(context, currentImport, previousImport),
      })
    }

    previousImport = currentImport
  })
}

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      url: docsUrl('order'),
    },

    fixable: 'code',
    schema: [
      {
        type: 'object',
        properties: {
          groups: {
            type: 'array',
          },
          'newlines-between': {
            enum: [
              'ignore',
              'always',
              'always-and-inside-groups',
              'never',
            ],
          },
        },
        additionalProperties: false,
      },
    ],
  },

  create: function importOrderRule (context) {
    const options = context.options[0] || {}
    const newlinesBetweenImports = options['newlines-between'] || 'ignore'
    let ranks

    try {
      ranks = convertGroupsToRanks(options.groups || defaultGroups)
    } catch (error) {
      // Malformed configuration
      return {
        Program: function(node) {
          context.report(node, error.message)
        },
      }
    }
    let imported = []
    let level = 0

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

    return {
      ImportDeclaration: function handleImports(node) {
        if (node.specifiers.length) { // Ignoring unassigned imports
          const name = node.source.value
          registerNode(context, node, name, 'import', ranks, imported)
        }
      },
      CallExpression: function handleRequires(node) {
        if (level !== 0 || !isStaticRequire(node) || !isInVariableDeclarator(node.parent)) {
          return
        }
        const name = node.arguments[0].value
        registerNode(context, node, name, 'require', ranks, imported)
      },
      'Program:exit': function reportAndReset() {
        makeOutOfOrderReport(context, imported)

        if (newlinesBetweenImports !== 'ignore') {
          makeNewlinesBetweenReport(context, imported, newlinesBetweenImports)
        }

        imported = []
      },
      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	'use strict'
2
3	import importType from '../core/importType'
4	import isStaticRequire from '../core/staticRequire'
5	import docsUrl from '../docsUrl'
6
7	const defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index']	1✔
8
9	// REPORTING AND FIXING
10
11	function reverse(array) {
12	return array.map(function (v) {	45✔
13	return {	127✔
14	name: v.name,
15	rank: -v.rank,
16	node: v.node,
17	}
18	}).reverse()
19	}
20
21	function getTokensOrCommentsAfter(sourceCode, node, count) {
22	let currentNodeOrToken = node	116✔
23	const result = []	116✔
24	for (let i = 0; i < count; i++) {	116✔
25	currentNodeOrToken = sourceCode.getTokenOrCommentAfter(currentNodeOrToken)	1,362✔
26	if (currentNodeOrToken == null) {	1,362✔
27	break	116✔
28	}
29	result.push(currentNodeOrToken)	1,246✔
30	}
31	return result	116✔
32	}
33
34	function getTokensOrCommentsBefore(sourceCode, node, count) {
35	let currentNodeOrToken = node	107✔
36	const result = []	107✔
37	for (let i = 0; i < count; i++) {	107✔
38	currentNodeOrToken = sourceCode.getTokenOrCommentBefore(currentNodeOrToken)	1,320✔
39	if (currentNodeOrToken == null) {	1,320✔
40	break	107✔
41	}
42	result.push(currentNodeOrToken)	1,213✔
43	}
44	return result.reverse()	107✔
45	}
46
47	function takeTokensAfterWhile(sourceCode, node, condition) {
48	const tokens = getTokensOrCommentsAfter(sourceCode, node, 100)	116✔
49	const result = []	116✔
50	for (let i = 0; i < tokens.length; i++) {	116✔
51	if (condition(tokens[i])) {	91✔
52	result.push(tokens[i])	11✔
53	}
54	else {
55	break	80✔
56	}
57	}
58	return result	116✔
59	}
60
61	function takeTokensBeforeWhile(sourceCode, node, condition) {
62	const tokens = getTokensOrCommentsBefore(sourceCode, node, 100)	107✔
63	const result = []	107✔
64	for (let i = tokens.length - 1; i >= 0; i--) {	107✔
65	if (condition(tokens[i])) {	72✔
66	result.push(tokens[i])	8✔
67	}
68	else {
69	break	64✔
70	}
71	}
72	return result.reverse()	107✔
73	}
74
75	function findOutOfOrder(imported) {
76	if (imported.length === 0) {	164✔
77	return []	1✔
78	}
79	let maxSeenRankNode = imported[0]	163✔
80	return imported.filter(function (importedModule) {	163✔
81	const res = importedModule.rank < maxSeenRankNode.rank	516✔
82	if (maxSeenRankNode.rank < importedModule.rank) {	516✔
83	maxSeenRankNode = importedModule	118✔
84	}
85	return res	516✔
86	})
87	}
88
89	function findRootNode(node) {
90	let parent = node	123✔
91	while (parent.parent != null && parent.parent.body == null) {	123✔
92	parent = parent.parent	210✔
93	}
94	return parent	123✔
95	}
96
97	function findEndOfLineWithComments(sourceCode, node) {
98	const tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node))	107✔
99	let endOfTokens = tokensToEndOfLine.length > 0	107✔
100	? tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1]
101	: node.range[1]
102	let result = endOfTokens	107✔
103	for (let i = endOfTokens; i < sourceCode.text.length; i++) {	107✔
104	if (sourceCode.text[i] === '\n') {	112✔
105	result = i + 1	103✔
106	break	103✔
107	}
108	if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t' && sourceCode.text[i] !== '\r') {	9✔
109	break	3✔
110	}
111	result = i + 1	6✔
112	}
113	return result	107✔
114	}
115
116	function commentOnSameLineAs(node) {
117	return token => (token.type === 'Block' \|\| token.type === 'Line') &&	223✔
118	token.loc.start.line === token.loc.end.line &&
119	token.loc.end.line === node.loc.end.line
120	}
121
122	function findStartOfLineWithComments(sourceCode, node) {
123	const tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node))	107✔
124	let startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0]	107✔
125	let result = startOfTokens	107✔
126	for (let i = startOfTokens - 1; i > 0; i--) {	107✔
127	if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t') {	892✔
128	break	64✔
129	}
130	result = i	828✔
131	}
132	return result	107✔
133	}
134
135	function isPlainRequireModule(node) {
136	if (node.type !== 'VariableDeclaration') {	119✔
137	return false	27✔
138	}
139	if (node.declarations.length !== 1) {	92!
140	return false	×
141	}
142	const decl = node.declarations[0]	92✔
143	const result = decl.id &&	92✔
144	(decl.id.type === 'Identifier' \|\| decl.id.type === 'ObjectPattern') &&
145	decl.init != null &&
146	decl.init.type === 'CallExpression' &&
147	decl.init.callee != null &&
148	decl.init.callee.name === 'require' &&
149	decl.init.arguments != null &&
150	decl.init.arguments.length === 1 &&
151	decl.init.arguments[0].type === 'Literal'
152	return result	92✔
153	}
154
155	function isPlainImportModule(node) {
156	return node.type === 'ImportDeclaration' && node.specifiers != null && node.specifiers.length > 0	36✔
157	}
158
159	function canCrossNodeWhileReorder(node) {
160	return isPlainRequireModule(node) \|\| isPlainImportModule(node)	119✔
161	}
162
163	function canReorderItems(firstNode, secondNode) {
164	const parent = firstNode.parent	50✔
165	const [firstIndex, secondIndex] = [	50✔
166	parent.body.indexOf(firstNode),
167	parent.body.indexOf(secondNode),
168	].sort()
169	const nodesBetween = parent.body.slice(firstIndex, secondIndex + 1)	50✔
170	for (var nodeBetween of nodesBetween) {	50✔
171	if (!canCrossNodeWhileReorder(nodeBetween)) {	119✔
172	return false	23✔
173	}
174	}
175	return true	27✔
176	}
177
178	function fixOutOfOrder(context, firstNode, secondNode, order) {
179	const sourceCode = context.getSourceCode()	50✔
180
181	const firstRoot = findRootNode(firstNode.node)	50✔
182	let firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot)	50✔
183	const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot)	50✔
184
185	const secondRoot = findRootNode(secondNode.node)	50✔
186	let secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot)	50✔
187	let secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot)	50✔
188	const canFix = canReorderItems(firstRoot, secondRoot)	50✔
189
190	let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd)	50✔
191	if (newCode[newCode.length - 1] !== '\n') {	50✔
192	newCode = newCode + '\n'	2✔
193	}
194
195	const message = '`' + secondNode.name + '` import should occur ' + order +	50✔
196	' import of `' + firstNode.name + '`'
197
198	if (order === 'before') {	50✔
199	context.report({	37✔
200	node: secondNode.node,
201	message: message,
202	fix: canFix && (fixer =>	61✔
203	fixer.replaceTextRange(	24✔
204	[firstRootStart, secondRootEnd],
205	newCode + sourceCode.text.substring(firstRootStart, secondRootStart)
206	)),
207	})
208	} else if (order === 'after') {	13!
209	context.report({	13✔
210	node: secondNode.node,
211	message: message,
212	fix: canFix && (fixer =>	16✔
213	fixer.replaceTextRange(	3✔
214	[secondRootStart, firstRootEnd],
215	sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode
216	)),
217	})
218	}
219	}
220
221	function reportOutOfOrder(context, imported, outOfOrder, order) {
222	outOfOrder.forEach(function (imp) {	45✔
223	const found = imported.find(function hasHigherRank(importedItem) {	50✔
224	return importedItem.rank > imp.rank	55✔
225	})
226	fixOutOfOrder(context, found, imp, order)	50✔
227	})
228	}
229
230	function makeOutOfOrderReport(context, imported) {
231	const outOfOrder = findOutOfOrder(imported)	119✔
232	if (!outOfOrder.length) {	119✔
233	return	74✔
234	}
235	// There are things to report. Try to minimize the number of reported errors.
236	const reversedImported = reverse(imported)	45✔
237	const reversedOrder = findOutOfOrder(reversedImported)	45✔
238	if (reversedOrder.length < outOfOrder.length) {	45✔
239	reportOutOfOrder(context, reversedImported, reversedOrder, 'after')	9✔
240	return	9✔
241	}
242	reportOutOfOrder(context, imported, outOfOrder, 'before')	36✔
243	}
244
245	// DETECTING
246
247	function computeRank(context, ranks, name, type) {
248	return ranks[importType(name, context)] +	389✔
249	(type === 'import' ? 0 : 100)	389✔
250	}
251
252	function registerNode(context, node, name, type, ranks, imported) {
253	const rank = computeRank(context, ranks, name, type)	389✔
254	if (rank !== -1) {	389!
255	imported.push({name, rank, node})	389✔
256	}
257	}
258
259	function isInVariableDeclarator(node) {
260	return node &&	333✔
261	(node.type === 'VariableDeclarator' \|\| isInVariableDeclarator(node.parent))
262	}
263
264	const types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index']	1✔
265
266	// Creates an object with type-rank pairs.
267	// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }
268	// Will throw an error if it contains a type that does not exist, or has a duplicate
269	function convertGroupsToRanks(groups) {
270	const rankObject = groups.reduce(function(res, group, index) {	123✔
271	if (typeof group === 'string') {	561✔
272	group = [group]	514✔
273	}
274	group.forEach(function(groupItem) {	561✔
275	if (types.indexOf(groupItem) === -1) {	608✔
276	throw new Error('Incorrect configuration of the rule: Unknown type `' +	3✔
277	JSON.stringify(groupItem) + '`')
278	}
279	if (res[groupItem] !== undefined) {	605✔
280	throw new Error('Incorrect configuration of the rule: `' + groupItem + '` is duplicated')	1✔
281	}
282	res[groupItem] = index	604✔
283	})
284	return res	557✔
285	}, {})
286
287	const omittedTypes = types.filter(function(type) {	119✔
288	return rankObject[type] === undefined	833✔
289	})
290
291	return omittedTypes.reduce(function(res, type) {	119✔
292	res[type] = groups.length	241✔
293	return res	241✔
294	}, rankObject)
295	}
296
297	function fixNewLineAfterImport(context, previousImport) {
298	const prevRoot = findRootNode(previousImport.node)	9✔
299	const tokensToEndOfLine = takeTokensAfterWhile(	9✔
300	context.getSourceCode(), prevRoot, commentOnSameLineAs(prevRoot))
301
302	let endOfLine = prevRoot.range[1]	9✔
303	if (tokensToEndOfLine.length > 0) {	9✔
304	endOfLine = tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1]	2✔
305	}
306	return (fixer) => fixer.insertTextAfterRange([prevRoot.range[0], endOfLine], '\n')	9✔
307	}
308
309	function removeNewLineAfterImport(context, currentImport, previousImport) {
310	const sourceCode = context.getSourceCode()	7✔
311	const prevRoot = findRootNode(previousImport.node)	7✔
312	const currRoot = findRootNode(currentImport.node)	7✔
313	const rangeToRemove = [	7✔
314	findEndOfLineWithComments(sourceCode, prevRoot),
315	findStartOfLineWithComments(sourceCode, currRoot),
316	]
317	if (/^\s*$/.test(sourceCode.text.substring(rangeToRemove[0], rangeToRemove[1]))) {	7✔
318	return (fixer) => fixer.removeRange(rangeToRemove)	5✔
319	}
320	return undefined	2✔
321	}
322
323	function makeNewlinesBetweenReport (context, imported, newlinesBetweenImports) {
324	const getNumberOfEmptyLinesBetween = (currentImport, previousImport) => {	33✔
325	const linesBetweenImports = context.getSourceCode().lines.slice(	83✔
326	previousImport.node.loc.end.line,
327	currentImport.node.loc.start.line - 1
328	)
329
330	return linesBetweenImports.filter((line) => !line.trim().length).length	83✔
331	}
332	let previousImport = imported[0]	33✔
333
334	imported.slice(1).forEach(function(currentImport) {	33✔
335	const emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport)	83✔
336
337	if (newlinesBetweenImports === 'always'	83✔
338	\|\| newlinesBetweenImports === 'always-and-inside-groups') {
339	if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {	59✔
340	context.report({	9✔
341	node: previousImport.node,
342	message: 'There should be at least one empty line between import groups',
343	fix: fixNewLineAfterImport(context, previousImport, currentImport),
344	})
345	} else if (currentImport.rank === previousImport.rank	50✔
346	&& emptyLinesBetween > 0
347	&& newlinesBetweenImports !== 'always-and-inside-groups') {
348	context.report({	2✔
349	node: previousImport.node,
350	message: 'There should be no empty line within import group',
351	fix: removeNewLineAfterImport(context, currentImport, previousImport),
352	})
353	}
354	} else if (emptyLinesBetween > 0) {	24✔
355	context.report({	5✔
356	node: previousImport.node,
357	message: 'There should be no empty line between import groups',
358	fix: removeNewLineAfterImport(context, currentImport, previousImport),
359	})
360	}
361
362	previousImport = currentImport	83✔
363	})
364	}
365
366	module.exports = {	1✔
367	meta: {
368	type: 'suggestion',
369	docs: {
370	url: docsUrl('order'),
371	},
372
373	fixable: 'code',
374	schema: [
375	{
376	type: 'object',
377	properties: {
378	groups: {
379	type: 'array',
380	},
381	'newlines-between': {
382	enum: [
383	'ignore',
384	'always',
385	'always-and-inside-groups',
386	'never',
387	],
388	},
389	},
390	additionalProperties: false,
391	},
392	],
393	},
394
395	create: function importOrderRule (context) {
396	const options = context.options[0] \|\| {}	123✔
397	const newlinesBetweenImports = options['newlines-between'] \|\| 'ignore'	123✔
398	let ranks
399
400	try {	123✔
401	ranks = convertGroupsToRanks(options.groups \|\| defaultGroups)	123✔
402	} catch (error) {
403	// Malformed configuration
404	return {	4✔
405	Program: function(node) {
406	context.report(node, error.message)	4✔
407	},
408	}
409	}
410	let imported = []	119✔
411	let level = 0	119✔
412
413	function incrementLevel() {
414	level++	12✔
415	}
416	function decrementLevel() {
417	level--	12✔
418	}
419
420	return {	119✔
421	ImportDeclaration: function handleImports(node) {
422	if (node.specifiers.length) { // Ignoring unassigned imports	104✔
423	const name = node.source.value	91✔
424	registerNode(context, node, name, 'import', ranks, imported)	91✔
425	}
426	},
427	CallExpression: function handleRequires(node) {
428	if (level !== 0 \|\| !isStaticRequire(node) \|\| !isInVariableDeclarator(node.parent)) {	335✔
429	return	37✔
430	}
431	const name = node.arguments[0].value	298✔
432	registerNode(context, node, name, 'require', ranks, imported)	298✔
433	},
434	'Program:exit': function reportAndReset() {
435	makeOutOfOrderReport(context, imported)	119✔
436
437	if (newlinesBetweenImports !== 'ignore') {	119✔
438	makeNewlinesBetweenReport(context, imported, newlinesBetweenImports)	33✔
439	}
440
441	imported = []	119✔
442	},
443	FunctionDeclaration: incrementLevel,
444	FunctionExpression: incrementLevel,
445	ArrowFunctionExpression: incrementLevel,
446	BlockStatement: incrementLevel,
447	ObjectExpression: incrementLevel,
448	'FunctionDeclaration:exit': decrementLevel,
449	'FunctionExpression:exit': decrementLevel,
450	'ArrowFunctionExpression:exit': decrementLevel,
451	'BlockStatement:exit': decrementLevel,
452	'ObjectExpression:exit': decrementLevel,
453	}
454	},
455	}

benmosher / eslint-plugin-import / 28142343

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