26799820

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/0ae6384efbd0c3e8c7ab965b1fea45bb856d5efd">0ae6384ef<a href="https://github.com/benmosher/eslint-plugin-import/commit/0ae6384efbd0c3e8c7ab965b1fea45bb856d5efd">">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/f117aef391455e736f14b6dbfd6f7a372f5b1d58">f117aef39</a>">f117aef39</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/0ae6384efbd0c3e8c7ab965b1fea45bb856d5efd"> into 7ffbf03fc">7ffbf03fc</a>

Run Details

1393 of 1528 branches covered (91.16%)

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

2006 of 2104 relevant lines covered (95.34%)

51.52 hits per line

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

91.95

/src/rules/no-namespace.js

/**
 * @fileoverview Rule to disallow namespace import
 * @author Radek Benkel
 */

import docsUrl from '../docsUrl'

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------


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

  create: function (context) {
    return {
      'ImportNamespaceSpecifier': function (node) {
        const scopeVariables = context.getScope().variables
        const namespaceVariable = scopeVariables.find((variable) =>
          variable.defs[0].node === node
        )
        const namespaceReferences = namespaceVariable.references
        const namespaceIdentifiers = namespaceReferences.map(reference => reference.identifier)
        const canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers)

        context.report({
          node,
          message: `Unexpected namespace import.`,
          fix: canFix && (fixer => {
            const scopeManager = context.getSourceCode().scopeManager
            const fixes = []

            // Pass 1: Collect variable names that are already in scope for each reference we want
            // to transform, so that we can be sure that we choose non-conflicting import names
            const importNameConflicts = {}
            namespaceIdentifiers.forEach((identifier) => {
              const parent = identifier.parent
              if (parent && parent.type === 'MemberExpression') {
                const importName = getMemberPropertyName(parent)
                const localConflicts = getVariableNamesInScope(scopeManager, parent)
                if (!importNameConflicts[importName]) {
                  importNameConflicts[importName] = localConflicts
                } else {
                  localConflicts.forEach((c) => importNameConflicts[importName].add(c))
                }
              }
            })

            // Choose new names for each import
            const importNames = Object.keys(importNameConflicts)
            const importLocalNames = generateLocalNames(
              importNames,
              importNameConflicts,
              namespaceVariable.name
            )

            // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers
            const namedImportSpecifiers = importNames.map((importName) =>
              importName === importLocalNames[importName]
                ? importName
                : `${importName} as ${importLocalNames[importName]}`
            )
            fixes.push(fixer.replaceText(node, `{ ${namedImportSpecifiers.join(', ')} }`))

            // Pass 2: Replace references to the namespace with references to the named imports
            namespaceIdentifiers.forEach((identifier) => {
              const parent = identifier.parent
              if (parent && parent.type === 'MemberExpression') {
                const importName = getMemberPropertyName(parent)
                fixes.push(fixer.replaceText(parent, importLocalNames[importName]))
              }
            })

            return fixes
          }),
        })
      },
    }
  },
}

/**
 * @param {Identifier[]} namespaceIdentifiers
 * @returns {boolean} `true` if the namespace variable is more than just a glorified constant
 */
function usesNamespaceAsObject(namespaceIdentifiers) {
  return namespaceIdentifiers.some((identifier) => {
    const parent = identifier.parent

    // `namespace.x` or `namespace['x']`
    if (
      parent && parent.type === 'MemberExpression' &&
      (parent.property.type === 'Identifier' || parent.property.type === 'Literal')
    ) {
      return false
    }

    return true
  })
}

/**
 * @param {MemberExpression} memberExpression
 * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`
 */
function getMemberPropertyName(memberExpression) {
  return memberExpression.property.type === 'Identifier'
    ? memberExpression.property.name
    : memberExpression.property.value
}

/**
 * @param {ScopeManager} scopeManager
 * @param {ASTNode} node
 * @return {Set<string>}
 */
function getVariableNamesInScope(scopeManager, node) {
  let currentNode = node
  let scope = scopeManager.acquire(currentNode)
  while (scope == null) {
    currentNode = currentNode.parent
    scope = scopeManager.acquire(currentNode, true)
  }
  return new Set([
    ...scope.variables.map(variable => variable.name),
    ...scope.upper.variables.map(variable => variable.name),
  ])
}

/**
 *
 * @param {*} names
 * @param {*} nameConflicts
 * @param {*} namespaceName
 */
function generateLocalNames(names, nameConflicts, namespaceName) {
  const localNames = {}
  names.forEach((name) => {
    let localName
    if (!nameConflicts[name].has(name)) {
      localName = name
    } else if (!nameConflicts[name].has(`${namespaceName}_${name}`)) {
      localName = `${namespaceName}_${name}`
    } else {
      for (let i = 1; i < Infinity; i++) {
        if (!nameConflicts[name].has(`${namespaceName}_${name}_${i}`)) {
          localName = `${namespaceName}_${name}_${i}`
          break
        }
      }
    }
    localNames[name] = localName
  })
  return localNames
}

1	/**
2	* @fileoverview Rule to disallow namespace import
3	* @author Radek Benkel
4	*/
5
6	import docsUrl from '../docsUrl'
7
8	//------------------------------------------------------------------------------
9	// Rule Definition
10	//------------------------------------------------------------------------------
11
12
13	module.exports = {	1✔
14	meta: {
15	type: 'suggestion',
16	docs: {
17	url: docsUrl('no-namespace'),
18	},
19	fixable: 'code',
20	},
21
22	create: function (context) {
23	return {	13✔
24	'ImportNamespaceSpecifier': function (node) {
25	const scopeVariables = context.getScope().variables	6✔
26	const namespaceVariable = scopeVariables.find((variable) =>	6✔
27	variable.defs[0].node === node	7✔
28	)
29	const namespaceReferences = namespaceVariable.references	6✔
30	const namespaceIdentifiers = namespaceReferences.map(reference => reference.identifier)	6✔
31	const canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers)	6✔
32
33	context.report({	6✔
34	node,
35	message: `Unexpected namespace import.`,
36	fix: canFix && (fixer => {	9✔
37	const scopeManager = context.getSourceCode().scopeManager	3✔
38	const fixes = []	3✔
39
40	// Pass 1: Collect variable names that are already in scope for each reference we want
41	// to transform, so that we can be sure that we choose non-conflicting import names
42	const importNameConflicts = {}	3✔
43	namespaceIdentifiers.forEach((identifier) => {	3✔
44	const parent = identifier.parent	6✔
45	if (parent && parent.type === 'MemberExpression') {	6!
46	const importName = getMemberPropertyName(parent)	6✔
47	const localConflicts = getVariableNamesInScope(scopeManager, parent)	6✔
48	if (!importNameConflicts[importName]) {	6!
49	importNameConflicts[importName] = localConflicts	6✔
50	} else {
51	localConflicts.forEach((c) => importNameConflicts[importName].add(c))	×
52	}
53	}
54	})
55
56	// Choose new names for each import
57	const importNames = Object.keys(importNameConflicts)	3✔
58	const importLocalNames = generateLocalNames(	3✔
59	importNames,
60	importNameConflicts,
61	namespaceVariable.name
62	)
63
64	// Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers
65	const namedImportSpecifiers = importNames.map((importName) =>	3✔
66	importName === importLocalNames[importName]	6✔
67	? importName
68	: `${importName} as ${importLocalNames[importName]}`
69	)
70	fixes.push(fixer.replaceText(node, `{ ${namedImportSpecifiers.join(', ')} }`))	3✔
71
72	// Pass 2: Replace references to the namespace with references to the named imports
73	namespaceIdentifiers.forEach((identifier) => {	3✔
74	const parent = identifier.parent	6✔
75	if (parent && parent.type === 'MemberExpression') {	6!
76	const importName = getMemberPropertyName(parent)	6✔
77	fixes.push(fixer.replaceText(parent, importLocalNames[importName]))	6✔
78	}
79	})
80
81	return fixes	3✔
82	}),
83	})
84	},
85	}
86	},
87	}
88
89	/**
90	* @param {Identifier[]} namespaceIdentifiers
91	* @returns {boolean} `true` if the namespace variable is more than just a glorified constant
92	*/
93	function usesNamespaceAsObject(namespaceIdentifiers) {
94	return namespaceIdentifiers.some((identifier) => {	3✔
95	const parent = identifier.parent	6✔
96
97	// `namespace.x` or `namespace['x']`
98	if (	6!
99	parent && parent.type === 'MemberExpression' &&	21✔
100	(parent.property.type === 'Identifier' \|\| parent.property.type === 'Literal')
101	) {
102	return false	6✔
103	}
104
105	return true	×
106	})
107	}
108
109	/**
110	* @param {MemberExpression} memberExpression
111	* @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`
112	*/
113	function getMemberPropertyName(memberExpression) {
114	return memberExpression.property.type === 'Identifier'	12✔
115	? memberExpression.property.name
116	: memberExpression.property.value
117	}
118
119	/**
120	* @param {ScopeManager} scopeManager
121	* @param {ASTNode} node
122	* @return {Set<string>}
123	*/
124	function getVariableNamesInScope(scopeManager, node) {
125	let currentNode = node	6✔
126	let scope = scopeManager.acquire(currentNode)	6✔
127	while (scope == null) {	6✔
128	currentNode = currentNode.parent	20✔
129	scope = scopeManager.acquire(currentNode, true)	20✔
130	}
131	return new Set([	6✔
132	...scope.variables.map(variable => variable.name),	14✔
133	...scope.upper.variables.map(variable => variable.name),	156✔
134	])
135	}
136
137	/**
138	*
139	* @param {*} names
140	* @param {*} nameConflicts
141	* @param {*} namespaceName
142	*/
143	function generateLocalNames(names, nameConflicts, namespaceName) {
144	const localNames = {}	3✔
145	names.forEach((name) => {	3✔
146	let localName
147	if (!nameConflicts[name].has(name)) {	6✔
148	localName = name	2✔
149	} else if (!nameConflicts[name].has(`${namespaceName}_${name}`)) {	4✔
150	localName = `${namespaceName}_${name}`	3✔
151	} else {
152	for (let i = 1; i < Infinity; i++) {	1✔
153	if (!nameConflicts[name].has(`${namespaceName}_${name}_${i}`)) {	1!
154	localName = `${namespaceName}_${name}_${i}`	1✔
155	break	1✔
156	}
157	}
158	}
159	localNames[name] = localName	6✔
160	})
161	return localNames	3✔
162	}

benmosher / eslint-plugin-import / 26799820

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