24531195

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/a5b569c1b771eeea1eee00c790514be1a543a12e">a5b569c1b<a href="https://github.com/benmosher/eslint-plugin-import/commit/a5b569c1b771eeea1eee00c790514be1a543a12e">">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/86f6b4203610974561482ddabd38dd517c682314">86f6b4203</a>">86f6b4203</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/a5b569c1b771eeea1eee00c790514be1a543a12e"> into 2f85fbea4">2f85fbea4</a>

Run Details

1317 of 1445 branches covered (91.14%)

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

1924 of 2018 relevant lines covered (95.34%)

50.46 hits per line

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

96.88

/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 != null &&  decl.id.type === 'Identifier') &&
    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)
  const firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot)
  const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot)

  const secondRoot = findRootNode(secondNode.node)
  const secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot)
  const 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')
}

function mutateRanksToAlphabetize(imported, order, ignoreCase) {
  const groupedByRanks = imported.reduce(function(acc, importedItem) {
    acc[importedItem.rank] = acc[importedItem.rank] || []
    acc[importedItem.rank].push(importedItem.name)
    return acc
  }, {})

  const groupRanks = Object.keys(groupedByRanks)

  // sort imports locally within their group
  groupRanks.forEach(function(groupRank) {
    groupedByRanks[groupRank].sort(function(importA, importB) {
      return ignoreCase
        ? importA.localeCompare(importB)
        : (importA < importB ? -1 : (importA === importB ? 0 : 1))
    })

    if (order === 'desc') {
      groupedByRanks[groupRank].reverse()
    }
  })

  // assign globally unique rank to each import
  let newRank = 0
  const alphabetizedRanks = groupRanks.sort().reduce(function(acc, groupRank) {
    groupedByRanks[groupRank].forEach(function(importedItemName) {
      acc[importedItemName] = newRank
      newRank += 1
    })
    return acc
  }, {})

  // mutate the original group-rank with alphabetized-rank
  imported.forEach(function(importedItem) {
    importedItem.rank = alphabetizedRanks[importedItem.name]
  })
}

// 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', '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
  })
}

function getAlphabetizeConfig(options) {
  const alphabetize = options.alphabetize || {}
  const order = alphabetize.order || 'ignore'
  const ignoreCase = alphabetize.ignoreCase || false
  
  if (typeof order !== 'string') {
    throw new Error('Incorrect alphabetize config: `order` property should be ' +
      'a string, but `' + JSON.stringify(typeof order) + '` found instead.')
  }
  else if (['ignore', 'asc', 'desc'].indexOf(order) === -1) {
    throw new Error('Incorrect alphabetize config: `order` property should be ' +
      'either `ignore`, `asc` or `desc`, but `' + JSON.stringify(order) + '` found instead.')
  }
  
  if (typeof ignoreCase !== 'boolean') {
    throw new Error('Incorrect alphabetize config: ignoreCase should be ' +
      'a boolean, but `' + JSON.stringify(typeof ignoreCase) + '` found instead.')
  }

  return {order, ignoreCase}
}

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',
            ],
          },
          alphabetize: {
            type: 'object',
            properties: {
              order: {
                enum: ['ignore', 'asc', 'desc'],
                default: 'ignore',
              },
              ignoreCase: {
                type: 'boolean',
                default: false,
              },
            },
          },
        },
        additionalProperties: false,
      },
    ],
  },

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

    try {
      alphabetize = getAlphabetizeConfig(options)
      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() {
        if (alphabetize.order !== 'ignore') {
          mutateRanksToAlphabetize(imported, alphabetize.order, alphabetize.ignoreCase)
        }

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

benmosher / eslint-plugin-import / 24531195

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