25450484

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/294c800a7f75c4e61565c29e54f6fff70c1670b1">294c800a7<a href="https://github.com/benmosher/eslint-plugin-import/commit/294c800a7f75c4e61565c29e54f6fff70c1670b1">">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/4140870618e554c4458571a961056ad469381f59">414087061</a>">414087061</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/294c800a7f75c4e61565c29e54f6fff70c1670b1"> into 58b41c2cc">58b41c2cc</a>

Run Details

1315 of 1441 branches covered (91.26%)

1907 of 2003 relevant lines covered (95.21%)

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

benmosher / eslint-plugin-import / 25450484

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