26419176

Build # 26419176

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/8635697af5212b6f10c2f963e581c05f7890ecf7">8635697af<a href="https://github.com/benmosher/eslint-plugin-import/commit/8635697af5212b6f10c2f963e581c05f7890ecf7">">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/639f4411b8f97a713ab2e413073ea728b60e6e45">639f4411b</a>">639f4411b</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/8635697af5212b6f10c2f963e581c05f7890ecf7"> into 989f6cc39">989f6cc39</a>

Run Details

1330 of 1465 branches covered (90.78%)

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

1941 of 2038 relevant lines covered (95.24%)

58.06 hits per line

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

94.07

/src/rules/no-duplicates.js

import resolve from 'eslint-module-utils/resolve'
import docsUrl from '../docsUrl'

function checkImports(imported, context) {
  for (const [module, nodes] of imported.entries()) {
    if (nodes.length > 1) {
      const message = `'${module}' imported multiple times.`
      const [first, ...rest] = nodes
      const sourceCode = context.getSourceCode()
      const fix = getFix(nodes, sourceCode)

      context.report({
        node: first.source,
        message,
        fix, // Attach the autofix (if any) to the first import.
      })

      for (const node of rest) {
        context.report({
          node: node.source,
          message,
        })
      }
    }
  }
}

function getFix(nodes, sourceCode) {
  // Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports
  // requires multiple `fixer.whatever()` calls in the `fix`: We both need to
  // update the first one, and remove the rest. Support for multiple
  // `fixer.whatever()` in a single `fix` was added in ESLint 4.1.
  // `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to
  // check for.
  if (typeof sourceCode.getCommentsBefore !== 'function') {
    return undefined
  }

  // Do not try to fix namespace imports or ones surrounded by comments.
  const fixableNodes = nodes.filter(node =>
    !hasNamespace(node) && !hasProblematicComments(node, sourceCode))

  // Bail if we can not fix anything.
  if (fixableNodes.length <= 1) {
    return undefined
  }

  return fixer => {
    const first = fixableNodes.find(node => node.specifiers.length > 0)

    // If there are no imports with specifiers, keep only first.
    if (!first) {
      return fixableNodes.slice(1).map((node) => fixer.remove(node))
    }

    const rest = fixableNodes.filter(node => node !== first)
    const tokens = sourceCode.getTokens(first)
    const firstDefaultSpecifier = first.specifiers
      .find(specifier => specifier.type === 'ImportDefaultSpecifier')
    const firstNamedSpecifierTexts = new Set(
      first.specifiers
        .filter(specifier => specifier.type === 'ImportSpecifier')
        .map(specifier => sourceCode.getText(specifier))
    )

    let defaultSpecifierText
    let namedSpecifierTexts = new Set()

    rest.forEach((node) => {
      node.specifiers.forEach((specifier) => {
        const specifierText = sourceCode.getText(specifier)

        if (specifier.type === 'ImportSpecifier' && !firstNamedSpecifierTexts.has(specifierText)) {
          namedSpecifierTexts.add(specifierText)
        }

        if (specifier.type === 'ImportDefaultSpecifier') {
          // Imports can't have multiple default specifiers, so we add this as
          // named specifier with alias.
          if (defaultSpecifierText || firstDefaultSpecifier) {
            const namedSpecifierText = `default as ${specifierText}`

            if (!firstNamedSpecifierTexts.has(namedSpecifierText)) {
              namedSpecifierTexts.add(namedSpecifierText)
            }
          } else if (!defaultSpecifierText && !firstDefaultSpecifier) {
            defaultSpecifierText = specifierText
          }
        }
      })
    })

    const fixes = []

    const importToken = tokens.find(token => token.value === 'import')
    const fromToken = tokens.find(token => token.value === 'from')
    const closeBraceToken = tokens.find(token => isPunctuator(token, '}'))

    if (defaultSpecifierText) {
      let text = ` ${defaultSpecifierText}`

      if (closeBraceToken) {
        text = `${text},`
      }

      fixes.push(fixer.insertTextAfter(importToken, text))
    }

    if (namedSpecifierTexts.size > 0) {
      let text = Array.from(namedSpecifierTexts).join(',')

      if (closeBraceToken) {
        const tokenBeforeCloseBrace = sourceCode.getTokenBefore(closeBraceToken)

        // Prepend comma if the last specifier didn't have it, or there are
        // empty braces.
        if (tokenBeforeCloseBrace.value !== '{' && tokenBeforeCloseBrace.value !== ',') {
          text = `,${text}`
        }

        fixes.push(fixer.insertTextBefore(closeBraceToken, text))
      } else {
        // Wrap specifiers in `{`, `}`
        text = `{${text}}`

        // Add after `default` specifier or before `from` token.
        if (firstDefaultSpecifier) {
          // Add coma if there already `import def`.
          text = `,${text}`

          fixes.push(fixer.insertTextAfter(firstDefaultSpecifier, text))
        } else {
          fixes.push(fixer.insertTextBefore(fromToken, text))
        }
      }
    }

    rest.forEach((node) => {
      fixes.push(fixer.remove(node))
    })

    return fixes
  }
}

function isPunctuator(node, value) {
  return node.type === 'Punctuator' && node.value === value
}

// Checks whether `node` has a namespace import.
function hasNamespace(node) {
  return node.specifiers
    .some(specifier => specifier.type === 'ImportNamespaceSpecifier')
}

// It's not obvious what the user wants to do with comments associated with
// duplicate imports, so skip imports with comments when autofixing.
function hasProblematicComments(node, sourceCode) {
  return (
    hasCommentBefore(node, sourceCode) ||
    hasCommentAfter(node, sourceCode) ||
    hasCommentsInside(node, sourceCode)
  )
}

// Checks whether `node` has a comment (that ends) on the previous line or on
// the same line as `node` (starts).
function hasCommentBefore(node, sourceCode) {
  return sourceCode.getCommentsBefore(node)
    .some(comment => comment.loc.end.line >= node.loc.start.line - 1)
}

// Checks whether `node` has a comment (that starts) on the same line as `node`
// (ends).
function hasCommentAfter(node, sourceCode) {
  return sourceCode.getCommentsAfter(node)
    .some(comment => comment.loc.start.line === node.loc.end.line)
}

// Checks whether `node` has any comments _inside_.
function hasCommentsInside(node, sourceCode) {
  const tokens = sourceCode.getTokens(node)

  return tokens.some(token => sourceCode.getCommentsBefore(token).length > 0)
}

module.exports = {
  meta: {
    type: 'problem',
    docs: {
      url: docsUrl('no-duplicates'),
    },
    fixable: 'code',
  },

  create: function (context) {
    const imported = new Map()
    const typesImported = new Map()
    return {
      'ImportDeclaration': function (n) {
        // resolved path will cover aliased duplicates
        const resolvedPath = resolve(n.source.value, context) || n.source.value
        const importMap = n.importKind === 'type' ? typesImported : imported

        if (importMap.has(resolvedPath)) {
          importMap.get(resolvedPath).push(n)
        } else {
          importMap.set(resolvedPath, [n])
        }
      },

      'Program:exit': function () {
        checkImports(imported, context)
        checkImports(typesImported, context)
      },
    }
  },
}

1	import resolve from 'eslint-module-utils/resolve'
2	import docsUrl from '../docsUrl'
3
4	function checkImports(imported, context) {
5	for (const [module, nodes] of imported.entries()) {	132✔
6	if (nodes.length > 1) {	69✔
7	const message = `'${module}' imported multiple times.`	41✔
8	const [first, ...rest] = nodes	41✔
9	const sourceCode = context.getSourceCode()	41✔
10	const fix = getFix(nodes, sourceCode)	41✔
11
12	context.report({	41✔
13	node: first.source,
14	message,
15	fix, // Attach the autofix (if any) to the first import.
16	})
17
18	for (const node of rest) {	41✔
19	context.report({	49✔
20	node: node.source,
21	message,
22	})
23	}
24	}
25	}
26	}
27
28	function getFix(nodes, sourceCode) {
29	// Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports
30	// requires multiple `fixer.whatever()` calls in the `fix`: We both need to
31	// update the first one, and remove the rest. Support for multiple
32	// `fixer.whatever()` in a single `fix` was added in ESLint 4.1.
33	// `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to
34	// check for.
35	if (typeof sourceCode.getCommentsBefore !== 'function') {	41!
36	return undefined	×
37	}
38
39	// Do not try to fix namespace imports or ones surrounded by comments.
40	const fixableNodes = nodes.filter(node =>	41✔
41	!hasNamespace(node) && !hasProblematicComments(node, sourceCode))	90✔
42
43	// Bail if we can not fix anything.
44	if (fixableNodes.length <= 1) {	41✔
45	return undefined	17✔
46	}
47
48	return fixer => {	24✔
49	const first = fixableNodes.find(node => node.specifiers.length > 0)	31✔
50
51	// If there are no imports with specifiers, keep only first.
52	if (!first) {	24✔
53	return fixableNodes.slice(1).map((node) => fixer.remove(node))	1✔
54	}
55
56	const rest = fixableNodes.filter(node => node !== first)	49✔
57	const tokens = sourceCode.getTokens(first)	23✔
58	const firstDefaultSpecifier = first.specifiers	23✔
59	.find(specifier => specifier.type === 'ImportDefaultSpecifier')	24✔
60	const firstNamedSpecifierTexts = new Set(	23✔
61	first.specifiers
62	.filter(specifier => specifier.type === 'ImportSpecifier')	26✔
63	.map(specifier => sourceCode.getText(specifier))	20✔
64	)
65
66	let defaultSpecifierText
67	let namedSpecifierTexts = new Set()	23✔
68
69	rest.forEach((node) => {	23✔
70	node.specifiers.forEach((specifier) => {	26✔
71	const specifierText = sourceCode.getText(specifier)	19✔
72
73	if (specifier.type === 'ImportSpecifier' && !firstNamedSpecifierTexts.has(specifierText)) {	19✔
74	namedSpecifierTexts.add(specifierText)	13✔
75	}
76
77	if (specifier.type === 'ImportDefaultSpecifier') {	19✔
78	// Imports can't have multiple default specifiers, so we add this as
79	// named specifier with alias.
80	if (defaultSpecifierText \|\| firstDefaultSpecifier) {	5✔
81	const namedSpecifierText = `default as ${specifierText}`	2✔
82
83	if (!firstNamedSpecifierTexts.has(namedSpecifierText)) {	2!
84	namedSpecifierTexts.add(namedSpecifierText)	2✔
85	}
86	} else if (!defaultSpecifierText && !firstDefaultSpecifier) {	3!
87	defaultSpecifierText = specifierText	3✔
88	}
89	}
90	})
91	})
92
93	const fixes = []	23✔
94
95	const importToken = tokens.find(token => token.value === 'import')	23✔
96	const fromToken = tokens.find(token => token.value === 'from')	116✔
97	const closeBraceToken = tokens.find(token => isPunctuator(token, '}'))	104✔
98
99	if (defaultSpecifierText) {	23✔
100	let text = ` ${defaultSpecifierText}`	3✔
101
102	if (closeBraceToken) {	3!
103	text = `${text},`	3✔
104	}
105
106	fixes.push(fixer.insertTextAfter(importToken, text))	3✔
107	}
108
109	if (namedSpecifierTexts.size > 0) {	23✔
110	let text = Array.from(namedSpecifierTexts).join(',')	14✔
111
112	if (closeBraceToken) {	14✔
113	const tokenBeforeCloseBrace = sourceCode.getTokenBefore(closeBraceToken)	11✔
114
115	// Prepend comma if the last specifier didn't have it, or there are
116	// empty braces.
117	if (tokenBeforeCloseBrace.value !== '{' && tokenBeforeCloseBrace.value !== ',') {	11!
118	text = `,${text}`	11✔
119	}
120
121	fixes.push(fixer.insertTextBefore(closeBraceToken, text))	11✔
122	} else {
123	// Wrap specifiers in `{`, `}`
124	text = `{${text}}`	3✔
125
126	// Add after `default` specifier or before `from` token.
127	if (firstDefaultSpecifier) {	3!
128	// Add coma if there already `import def`.
129	text = `,${text}`	3✔
130
131	fixes.push(fixer.insertTextAfter(firstDefaultSpecifier, text))	3✔
132	} else {
133	fixes.push(fixer.insertTextBefore(fromToken, text))	×
134	}
135	}
136	}
137
138	rest.forEach((node) => {	23✔
139	fixes.push(fixer.remove(node))	26✔
140	})
141
142	return fixes	23✔
143	}
144	}
145
146	function isPunctuator(node, value) {
147	return node.type === 'Punctuator' && node.value === value	104✔
148	}
149
150	// Checks whether `node` has a namespace import.
151	function hasNamespace(node) {
152	return node.specifiers	90✔
153	.some(specifier => specifier.type === 'ImportNamespaceSpecifier')	79✔
154	}
155
156	// It's not obvious what the user wants to do with comments associated with
157	// duplicate imports, so skip imports with comments when autofixing.
158	function hasProblematicComments(node, sourceCode) {
159	return (	87✔
160	hasCommentBefore(node, sourceCode) \|\|	250✔
161	hasCommentAfter(node, sourceCode) \|\|
162	hasCommentsInside(node, sourceCode)
163	)
164	}
165
166	// Checks whether `node` has a comment (that ends) on the previous line or on
167	// the same line as `node` (starts).
168	function hasCommentBefore(node, sourceCode) {
169	return sourceCode.getCommentsBefore(node)	87✔
170	.some(comment => comment.loc.end.line >= node.loc.start.line - 1)	5✔
171	}
172
173	// Checks whether `node` has a comment (that starts) on the same line as `node`
174	// (ends).
175	function hasCommentAfter(node, sourceCode) {
176	return sourceCode.getCommentsAfter(node)	83✔
177	.some(comment => comment.loc.start.line === node.loc.end.line)	7✔
178	}
179
180	// Checks whether `node` has any comments _inside_.
181	function hasCommentsInside(node, sourceCode) {
182	const tokens = sourceCode.getTokens(node)	80✔
183
184	return tokens.some(token => sourceCode.getCommentsBefore(token).length > 0)	440✔
185	}
186
187	module.exports = {	1✔
188	meta: {
189	type: 'problem',
190	docs: {
191	url: docsUrl('no-duplicates'),
192	},
193	fixable: 'code',
194	},
195
196	create: function (context) {
197	const imported = new Map()	66✔
198	const typesImported = new Map()	66✔
199	return {	66✔
200	'ImportDeclaration': function (n) {
201	// resolved path will cover aliased duplicates
202	const resolvedPath = resolve(n.source.value, context) \|\| n.source.value	118✔
203	const importMap = n.importKind === 'type' ? typesImported : imported	118✔
204
205	if (importMap.has(resolvedPath)) {	118✔
206	importMap.get(resolvedPath).push(n)	49✔
207	} else {
208	importMap.set(resolvedPath, [n])	69✔
209	}
210	},
211
212	'Program:exit': function () {
213	checkImports(imported, context)	66✔
214	checkImports(typesImported, context)	66✔
215	},
216	}
217	},
218	}

benmosher / eslint-plugin-import / 26419176

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