24074980

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/17601d8c2ff5a104ce3374a69f53e4ab3439232a">17601d8c2<a href="https://github.com/benmosher/eslint-plugin-import/commit/17601d8c2ff5a104ce3374a69f53e4ab3439232a">">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/fbe5c30cf85e4a2c9fd9e8d29a12903c46a86b45">fbe5c30cf</a>">fbe5c30cf</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/17601d8c2ff5a104ce3374a69f53e4ab3439232a"> into 174afbbff">174afbbff</a>

Run Details

1290 of 1414 branches covered (91.23%)

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

1892 of 1983 relevant lines covered (95.41%)

45.78 hits per line

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

96.42

/src/rules/no-unused-modules.js

/**
 * @fileOverview Ensures that modules contain exports and/or all 
 * modules are consumed within other modules.
 * @author René Fermann
 */

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

// eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3
let listFilesToProcess
try {
  listFilesToProcess = require('eslint/lib/util/glob-utils').listFilesToProcess
} catch (err) {
  listFilesToProcess = require('eslint/lib/util/glob-util').listFilesToProcess
}

const EXPORT_DEFAULT_DECLARATION = 'ExportDefaultDeclaration'
const EXPORT_NAMED_DECLARATION = 'ExportNamedDeclaration'
const EXPORT_ALL_DECLARATION = 'ExportAllDeclaration'
const IMPORT_DECLARATION = 'ImportDeclaration' 
const IMPORT_NAMESPACE_SPECIFIER = 'ImportNamespaceSpecifier'
const IMPORT_DEFAULT_SPECIFIER = 'ImportDefaultSpecifier' 
const VARIABLE_DECLARATION = 'VariableDeclaration'
const FUNCTION_DECLARATION = 'FunctionDeclaration'
const DEFAULT = 'default'

let preparationDone = false
const importList = new Map()
const exportList = new Map()
const ignoredFiles = new Set()

const isNodeModule = path => {
  return /\/(node_modules)\//.test(path)
}

/**
 * read all files matching the patterns in src and ignoreExports
 * 
 * return all files matching src pattern, which are not matching the ignoreExports pattern
 */
const resolveFiles = (src, ignoreExports) => {
  const srcFiles = new Set()
  const srcFileList = listFilesToProcess(src)

  // prepare list of ignored files
  const ignoredFilesList =  listFilesToProcess(ignoreExports)
  ignoredFilesList.forEach(({ filename }) => ignoredFiles.add(filename))

  // prepare list of source files, don't consider files from node_modules
  srcFileList.filter(({ filename }) => !isNodeModule(filename)).forEach(({ filename }) => {
    srcFiles.add(filename)
  })
  return srcFiles
}

/**
 * parse all source files and build up 2 maps containing the existing imports and exports
 */
const prepareImportsAndExports = (srcFiles, context) => {
  const exportAll = new Map()
  srcFiles.forEach(file => {
    const exports = new Map()
    const imports = new Map()
    const currentExports = Exports.get(file, context)
    if (currentExports) {
      const { dependencies, reexports, imports: localImportList, namespace  } = currentExports

      // dependencies === export * from 
      const currentExportAll = new Set()
      dependencies.forEach(value => {
        currentExportAll.add(value().path)
      })
      exportAll.set(file, currentExportAll)
      
      reexports.forEach((value, key) => {
        if (key === DEFAULT) {
          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() })
        } else {
          exports.set(key, { whereUsed: new Set() })
        }
        const reexport =  value.getImport()
        if (!reexport) {
          return
        }
        let localImport = imports.get(reexport.path)
        let currentValue
        if (value.local === DEFAULT) {
          currentValue = IMPORT_DEFAULT_SPECIFIER
        } else {
          currentValue = value.local
        }
        if (typeof localImport !== 'undefined') {
          localImport = new Set([...localImport, currentValue])
        } else {
          localImport = new Set([currentValue])
        }
        imports.set(reexport.path, localImport)
      })

      localImportList.forEach((value, key) => {
        if (isNodeModule(key)) {
          return
        }
        imports.set(key, value.importedSpecifiers)
      })
      importList.set(file, imports)
      
      // build up export list only, if file is not ignored
      if (ignoredFiles.has(file)) {
        return
      }
      namespace.forEach((value, key) => {
        if (key === DEFAULT) {
          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() })
        } else {
          exports.set(key, { whereUsed: new Set() })
        }
      })
    }
    exports.set(EXPORT_ALL_DECLARATION, { whereUsed: new Set() })
    exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed: new Set() })
    exportList.set(file, exports)
  })
  exportAll.forEach((value, key) => {
    value.forEach(val => {
      const currentExports = exportList.get(val)
      const currentExport = currentExports.get(EXPORT_ALL_DECLARATION)
      currentExport.whereUsed.add(key)
    })
  })
}

/**
 * traverse through all imports and add the respective path to the whereUsed-list 
 * of the corresponding export
 */
const determineUsage = () => {
  importList.forEach((listValue, listKey) => {
    listValue.forEach((value, key) => {
      const exports = exportList.get(key)
      if (typeof exports !== 'undefined') {
        value.forEach(currentImport => {
          let specifier
          if (currentImport === IMPORT_NAMESPACE_SPECIFIER) {
            specifier = IMPORT_NAMESPACE_SPECIFIER
          } else if (currentImport === IMPORT_DEFAULT_SPECIFIER) {
            specifier = IMPORT_DEFAULT_SPECIFIER
          } else {
            specifier = currentImport
          }
          if (typeof specifier !== 'undefined') {
            const exportStatement = exports.get(specifier)
            if (typeof exportStatement !== 'undefined') {
              const { whereUsed } = exportStatement
              whereUsed.add(listKey)
              exports.set(specifier, { whereUsed })
            }
          }
        })
      }
    })
  })
}

const getSrc = src => {
  if (src) {
    return src
  }
  return [process.cwd()]
}

/**
 * prepare the lists of existing imports and exports - should only be executed once at
 * the start of a new eslint run
 */
const doPreparation = (src, ignoreExports, context) => {
  const srcFiles = resolveFiles(getSrc(src), ignoreExports)
  prepareImportsAndExports(srcFiles, context)
  determineUsage()
  preparationDone = true
}

const newNamespaceImportExists = specifiers =>
  specifiers.some(({ type }) => type === IMPORT_NAMESPACE_SPECIFIER)

const newDefaultImportExists = specifiers =>
  specifiers.some(({ type }) => type === IMPORT_DEFAULT_SPECIFIER)

module.exports = {
  meta: {
    docs: { url: docsUrl('no-unused-modules') },
    schema: [{
      properties: {
        src: {
          description: 'files/paths to be analyzed (only for unused exports)',
          type: 'array',
          minItems: 1,
          items: {
            type: 'string',
            minLength: 1,
          },
        },
        ignoreExports: {
          description:
            'files/paths for which unused exports will not be reported (e.g module entry points)',
          type: 'array',
          minItems: 1,
          items: {
            type: 'string',
            minLength: 1,
          },
        },
        missingExports: {
          description: 'report modules without any exports',
          type: 'boolean',
        },
        unusedExports: {
          description: 'report exports without any usage',
          type: 'boolean',
        },
      },
      not: {
        properties: {
          unusedExports: { enum: [false] },
          missingExports: { enum: [false] },
        },
      },
      anyOf:[{
        not: {
          properties: {
            unusedExports: { enum: [true] },
          },
        },
        required: ['missingExports'],
      }, {
        not: {
          properties: {
            missingExports: { enum: [true] },
          },
        },
        required: ['unusedExports'],
      }, {
        properties: {
          unusedExports: { enum: [true] },
        },
        required: ['unusedExports'],
      }, {
        properties: {
          missingExports: { enum: [true] },
        },
        required: ['missingExports'],
      }],
    }],
  },

  create: context => {
    const {
      src,
      ignoreExports = [],
      missingExports,
      unusedExports,
    } = context.options[0] || {}

    if (unusedExports && !preparationDone) {
      doPreparation(src, ignoreExports, context)
    }
    
    const file = context.getFilename()

    const checkExportPresence = node => {
      if (!missingExports) {
        return
      }

      if (ignoredFiles.has(file)) {
        return
      }

      const exportCount = exportList.get(file)
      const exportAll = exportCount.get(EXPORT_ALL_DECLARATION)
      const namespaceImports = exportCount.get(IMPORT_NAMESPACE_SPECIFIER)

      exportCount.delete(EXPORT_ALL_DECLARATION)
      exportCount.delete(IMPORT_NAMESPACE_SPECIFIER)
      if (missingExports && exportCount.size < 1) {
        // node.body[0] === 'undefined' only happens, if everything is commented out in the file
        // being linted
        context.report(node.body[0] ? node.body[0] : node, 'No exports found')
      }
      exportCount.set(EXPORT_ALL_DECLARATION, exportAll)
      exportCount.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports)
    }

    const checkUsage = (node, exportedValue) => {
      if (!unusedExports) {
        return
      }

      if (ignoredFiles.has(file)) {
        return
      }

      exports = exportList.get(file)

      // special case: export * from 
      const exportAll = exports.get(EXPORT_ALL_DECLARATION)
      if (typeof exportAll !== 'undefined' && exportedValue !== IMPORT_DEFAULT_SPECIFIER) {
        if (exportAll.whereUsed.size > 0) {
          return
        }
      }

      // special case: namespace import
      const namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER)
      if (typeof namespaceImports !== 'undefined') {
        if (namespaceImports.whereUsed.size > 0) {
          return
        }
      }

      const exportStatement = exports.get(exportedValue)
      
      const value = exportedValue === IMPORT_DEFAULT_SPECIFIER ? DEFAULT : exportedValue
      
      if (typeof exportStatement !== 'undefined'){
        if (exportStatement.whereUsed.size < 1) {
          context.report(
            node,
            `exported declaration '${value}' not used within other modules`
          )
        }
      } else {
        context.report(
          node,
          `exported declaration '${value}' not used within other modules`
        )
      }
    }

    /**
     * only useful for tools like vscode-eslint
     * 
     * update lists of existing exports during runtime
     */
    const updateExportUsage = node => {
      if (ignoredFiles.has(file)) {
        return
      }

      let exports = exportList.get(file)

      // new module has been created during runtime
      // include it in further processing
      if (typeof exports === 'undefined') {
        exports = new Map()
      }

      const newExports = new Map()
      const newExportIdentifiers = new Set()

      node.body.forEach(({ type, declaration, specifiers }) => {
        if (type === EXPORT_DEFAULT_DECLARATION) {
          newExportIdentifiers.add(IMPORT_DEFAULT_SPECIFIER)
        } 
        if (type === EXPORT_NAMED_DECLARATION) {
          if (specifiers.length > 0) {
            specifiers.forEach(specifier => {
              if (specifier.exported) {
                newExportIdentifiers.add(specifier.exported.name)
              }
            })
          }
          if (declaration) {
            if (declaration.type === FUNCTION_DECLARATION) {
              newExportIdentifiers.add(declaration.id.name)
            }   
            if (declaration.type === VARIABLE_DECLARATION) {
              declaration.declarations.forEach(({ id }) => {
                newExportIdentifiers.add(id.name)
              })
            }
          }
        }
      })

      // old exports exist within list of new exports identifiers: add to map of new exports
      exports.forEach((value, key) => {
        if (newExportIdentifiers.has(key)) {
          newExports.set(key, value)
        }
      })

      // new export identifiers added: add to map of new exports
      newExportIdentifiers.forEach(key => {
        if (!exports.has(key)) {
          newExports.set(key, { whereUsed: new Set() })
        }
      })

      // preserve information about namespace imports
      let exportAll = exports.get(EXPORT_ALL_DECLARATION)
      let namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER)
      
      if (typeof namespaceImports === 'undefined') {
        namespaceImports = { whereUsed: new Set() }
      }

      newExports.set(EXPORT_ALL_DECLARATION, exportAll)
      newExports.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports)
      exportList.set(file, newExports)
    }

    /**
     * only useful for tools like vscode-eslint
     * 
     * update lists of existing imports during runtime
     */
    const updateImportUsage = node => {
      if (!unusedExports) {
        return
      }

      let oldImportPaths = importList.get(file)
      if (typeof oldImportPaths === 'undefined') {
        oldImportPaths = new Map()
      }
      
      const oldNamespaceImports = new Set()
      const newNamespaceImports = new Set()

      const oldExportAll = new Set()
      const newExportAll = new Set()
      
      const oldDefaultImports = new Set()
      const newDefaultImports = new Set()

      const oldImports = new Map()
      const newImports = new Map()
      oldImportPaths.forEach((value, key) => {
        if (value.has(EXPORT_ALL_DECLARATION)) {
          oldExportAll.add(key)
        }
        if (value.has(IMPORT_NAMESPACE_SPECIFIER)) {
          oldNamespaceImports.add(key)
        }
        if (value.has(IMPORT_DEFAULT_SPECIFIER)) {
          oldDefaultImports.add(key)
        }
        value.forEach(val => {
          if (val !== IMPORT_NAMESPACE_SPECIFIER &&
              val !== IMPORT_DEFAULT_SPECIFIER) {
               oldImports.set(val, key)
             }
        })
      })

      node.body.forEach(astNode => {
        let resolvedPath

        // support for export { value } from 'module'
        if (astNode.type === EXPORT_NAMED_DECLARATION) {
          if (astNode.source) {
            resolvedPath = resolve(astNode.source.raw.replace(/('|")/g, ''), context)
            astNode.specifiers.forEach(specifier => {
              let name
              if (specifier.exported.name === DEFAULT) {
                name = IMPORT_DEFAULT_SPECIFIER
              } else {
                name = specifier.local.name
              }
              newImports.set(name, resolvedPath)
            })
          }
        }

        if (astNode.type === EXPORT_ALL_DECLARATION) {
          resolvedPath = resolve(astNode.source.raw.replace(/('|")/g, ''), context)
          newExportAll.add(resolvedPath)
        }

        if (astNode.type === IMPORT_DECLARATION) {
          resolvedPath = resolve(astNode.source.raw.replace(/('|")/g, ''), context)
          if (!resolvedPath) {
            return
          }
          
          if (isNodeModule(resolvedPath)) {
            return
          }

          if (newNamespaceImportExists(astNode.specifiers)) {
            newNamespaceImports.add(resolvedPath)
          }

          if (newDefaultImportExists(astNode.specifiers)) {
            newDefaultImports.add(resolvedPath)
          }

          astNode.specifiers.forEach(specifier => {
            if (specifier.type === IMPORT_DEFAULT_SPECIFIER ||
                specifier.type === IMPORT_NAMESPACE_SPECIFIER) {
              return
            }
            newImports.set(specifier.imported.name, resolvedPath)
          })
        }
      })

      newExportAll.forEach(value => {
        if (!oldExportAll.has(value)) {
          let imports = oldImportPaths.get(value)
          if (typeof imports === 'undefined') {
            imports = new Set()
          }
          imports.add(EXPORT_ALL_DECLARATION)
          oldImportPaths.set(value, imports)

          let exports = exportList.get(value)
          let currentExport
          if (typeof exports !== 'undefined') {
            currentExport = exports.get(EXPORT_ALL_DECLARATION)
          } else {
            exports = new Map()
            exportList.set(value, exports)
          }

          if (typeof currentExport !== 'undefined') {
            currentExport.whereUsed.add(file)
          } else {
            const whereUsed = new Set()
            whereUsed.add(file)
            exports.set(EXPORT_ALL_DECLARATION, { whereUsed })
          }
        }
      })

      oldExportAll.forEach(value => {
        if (!newExportAll.has(value)) {
          const imports = oldImportPaths.get(value)
          imports.delete(EXPORT_ALL_DECLARATION)

          const exports = exportList.get(value)
          if (typeof exports !== 'undefined') {
            const currentExport = exports.get(EXPORT_ALL_DECLARATION)
            if (typeof currentExport !== 'undefined') {
              currentExport.whereUsed.delete(file)
            }
          }
        }
      })

      newDefaultImports.forEach(value => {
        if (!oldDefaultImports.has(value)) {
          let imports = oldImportPaths.get(value)
          if (typeof imports === 'undefined') {
            imports = new Set()
          }
          imports.add(IMPORT_DEFAULT_SPECIFIER)
          oldImportPaths.set(value, imports)

          let exports = exportList.get(value)
          let currentExport
          if (typeof exports !== 'undefined') {
            currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER)
          } else {
            exports = new Map()
            exportList.set(value, exports)
          }

          if (typeof currentExport !== 'undefined') {
            currentExport.whereUsed.add(file)
          } else {
            const whereUsed = new Set()
            whereUsed.add(file)
            exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed })
          }
        }
      })

      oldDefaultImports.forEach(value => {
        if (!newDefaultImports.has(value)) {
          const imports = oldImportPaths.get(value)
          imports.delete(IMPORT_DEFAULT_SPECIFIER)

          const exports = exportList.get(value)
          if (typeof exports !== 'undefined') {
            const currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER)
            if (typeof currentExport !== 'undefined') {
              currentExport.whereUsed.delete(file)
            }
          }
        }
      })

      newNamespaceImports.forEach(value => {
        if (!oldNamespaceImports.has(value)) {
          let imports = oldImportPaths.get(value)
          if (typeof imports === 'undefined') {
            imports = new Set()
          }
          imports.add(IMPORT_NAMESPACE_SPECIFIER)
          oldImportPaths.set(value, imports)

          let exports = exportList.get(value)
          let currentExport
          if (typeof exports !== 'undefined') {
            currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER)
          } else {
            exports = new Map()
            exportList.set(value, exports)
          }

          if (typeof currentExport !== 'undefined') {
            currentExport.whereUsed.add(file)
          } else {
            const whereUsed = new Set()
            whereUsed.add(file)
            exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed })
          }
        }
      })

      oldNamespaceImports.forEach(value => {
        if (!newNamespaceImports.has(value)) {
          const imports = oldImportPaths.get(value)
          imports.delete(IMPORT_NAMESPACE_SPECIFIER)

          const exports = exportList.get(value)
          if (typeof exports !== 'undefined') {
            const currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER)
            if (typeof currentExport !== 'undefined') {
              currentExport.whereUsed.delete(file)
            }
          }
        }
      })

      newImports.forEach((value, key) => {
        if (!oldImports.has(key)) {
          let imports = oldImportPaths.get(value)
          if (typeof imports === 'undefined') {
            imports = new Set()
          }
          imports.add(key)
          oldImportPaths.set(value, imports)

          let exports = exportList.get(value)
          let currentExport
          if (typeof exports !== 'undefined') {
            currentExport = exports.get(key)
          } else {
            exports = new Map()
            exportList.set(value, exports)
          }

          if (typeof currentExport !== 'undefined') {
            currentExport.whereUsed.add(file)
          } else {
            const whereUsed = new Set()
            whereUsed.add(file)
            exports.set(key, { whereUsed })
          }
        }
      })

      oldImports.forEach((value, key) => {
        if (!newImports.has(key)) {
          const imports = oldImportPaths.get(value)
          imports.delete(key)

          const exports = exportList.get(value)
          if (typeof exports !== 'undefined') {
            const currentExport = exports.get(key)
            if (typeof currentExport !== 'undefined') {
              currentExport.whereUsed.delete(file)
            }
          }
        }
      })
    }

    return {
      'Program:exit': node => {
        updateExportUsage(node)
        updateImportUsage(node)
        checkExportPresence(node)
      },
      'ExportDefaultDeclaration': node => {
        checkUsage(node, IMPORT_DEFAULT_SPECIFIER)
      },
      'ExportNamedDeclaration': node => {
        node.specifiers.forEach(specifier => {
            checkUsage(node, specifier.exported.name)
        })
        if (node.declaration) {
          if (node.declaration.type === FUNCTION_DECLARATION) {
            checkUsage(node, node.declaration.id.name)
          }
          if (node.declaration.type === VARIABLE_DECLARATION) {
            node.declaration.declarations.forEach(declaration => {
              checkUsage(node, declaration.id.name)
            })
          }
        }
      },
    }
  },
}

1	/**
2	* @fileOverview Ensures that modules contain exports and/or all
3	* modules are consumed within other modules.
4	* @author René Fermann
5	*/
6
7	import Exports from '../ExportMap'
8	import resolve from 'eslint-module-utils/resolve'
9	import docsUrl from '../docsUrl'
10
11	// eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3
12	let listFilesToProcess
13	try {	1✔
14	listFilesToProcess = require('eslint/lib/util/glob-utils').listFilesToProcess	1✔
15	} catch (err) {
16	listFilesToProcess = require('eslint/lib/util/glob-util').listFilesToProcess	×
17	}
18
19	const EXPORT_DEFAULT_DECLARATION = 'ExportDefaultDeclaration'	1✔
20	const EXPORT_NAMED_DECLARATION = 'ExportNamedDeclaration'	1✔
21	const EXPORT_ALL_DECLARATION = 'ExportAllDeclaration'	1✔
22	const IMPORT_DECLARATION = 'ImportDeclaration'	1✔
23	const IMPORT_NAMESPACE_SPECIFIER = 'ImportNamespaceSpecifier'	1✔
24	const IMPORT_DEFAULT_SPECIFIER = 'ImportDefaultSpecifier'	1✔
25	const VARIABLE_DECLARATION = 'VariableDeclaration'	1✔
26	const FUNCTION_DECLARATION = 'FunctionDeclaration'	1✔
27	const DEFAULT = 'default'	1✔
28
29	let preparationDone = false	1✔
30	const importList = new Map()	1✔
31	const exportList = new Map()	1✔
32	const ignoredFiles = new Set()	1✔
33
34	const isNodeModule = path => {	1✔
35	return /\/(node_modules)\//.test(path)	62✔
36	}
37
38	/**
39	* read all files matching the patterns in src and ignoreExports
40	*
41	* return all files matching src pattern, which are not matching the ignoreExports pattern
42	*/
43	const resolveFiles = (src, ignoreExports) => {	1✔
44	const srcFiles = new Set()	1✔
45	const srcFileList = listFilesToProcess(src)	1✔
46
47	// prepare list of ignored files
48	const ignoredFilesList = listFilesToProcess(ignoreExports)	1✔
49	ignoredFilesList.forEach(({ filename }) => ignoredFiles.add(filename))	6✔
50
51	// prepare list of source files, don't consider files from node_modules
52	srcFileList.filter(({ filename }) => !isNodeModule(filename)).forEach(({ filename }) => {	25✔
53	srcFiles.add(filename)	25✔
54	})
55	return srcFiles	1✔
56	}
57
58	/**
59	* parse all source files and build up 2 maps containing the existing imports and exports
60	*/
61	const prepareImportsAndExports = (srcFiles, context) => {	1✔
62	const exportAll = new Map()	1✔
63	srcFiles.forEach(file => {	1✔
64	const exports = new Map()	25✔
65	const imports = new Map()	25✔
66	const currentExports = Exports.get(file, context)	25✔
67	if (currentExports) {	25✔
68	const { dependencies, reexports, imports: localImportList, namespace } = currentExports	23✔
69
70	// dependencies === export * from
71	const currentExportAll = new Set()	23✔
72	dependencies.forEach(value => {	23✔
73	currentExportAll.add(value().path)	1✔
74	})
75	exportAll.set(file, currentExportAll)	23✔
76
77	reexports.forEach((value, key) => {	23✔
78	if (key === DEFAULT) {	4✔
79	exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() })	1✔
80	} else {
81	exports.set(key, { whereUsed: new Set() })	3✔
82	}
83	const reexport = value.getImport()	4✔
84	if (!reexport) {	4!
85	return	×
86	}
87	let localImport = imports.get(reexport.path)	4✔
88	let currentValue
89	if (value.local === DEFAULT) {	4✔
90	currentValue = IMPORT_DEFAULT_SPECIFIER	1✔
91	} else {
92	currentValue = value.local	3✔
93	}
94	if (typeof localImport !== 'undefined') {	4✔
95	localImport = new Set([...localImport, currentValue])	2✔
96	} else {
97	localImport = new Set([currentValue])	2✔
98	}
99	imports.set(reexport.path, localImport)	4✔
100	})
101
102	localImportList.forEach((value, key) => {	23✔
103	if (isNodeModule(key)) {	11!
104	return	×
105	}
106	imports.set(key, value.importedSpecifiers)	11✔
107	})
108	importList.set(file, imports)	23✔
109
110	// build up export list only, if file is not ignored
111	if (ignoredFiles.has(file)) {	23✔
112	return	6✔
113	}
114	namespace.forEach((value, key) => {	17✔
115	if (key === DEFAULT) {	27✔
116	exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() })	6✔
117	} else {
118	exports.set(key, { whereUsed: new Set() })	21✔
119	}
120	})
121	}
122	exports.set(EXPORT_ALL_DECLARATION, { whereUsed: new Set() })	19✔
123	exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed: new Set() })	19✔
124	exportList.set(file, exports)	19✔
125	})
126	exportAll.forEach((value, key) => {	1✔
127	value.forEach(val => {	23✔
128	const currentExports = exportList.get(val)	1✔
129	const currentExport = currentExports.get(EXPORT_ALL_DECLARATION)	1✔
130	currentExport.whereUsed.add(key)	1✔
131	})
132	})
133	}
134
135	/**
136	* traverse through all imports and add the respective path to the whereUsed-list
137	* of the corresponding export
138	*/
139	const determineUsage = () => {	1✔
140	importList.forEach((listValue, listKey) => {	1✔
141	listValue.forEach((value, key) => {	23✔
142	const exports = exportList.get(key)	13✔
143	if (typeof exports !== 'undefined') {	13✔
144	value.forEach(currentImport => {	12✔
145	let specifier
146	if (currentImport === IMPORT_NAMESPACE_SPECIFIER) {	14✔
147	specifier = IMPORT_NAMESPACE_SPECIFIER	1✔
148	} else if (currentImport === IMPORT_DEFAULT_SPECIFIER) {	13✔
149	specifier = IMPORT_DEFAULT_SPECIFIER	2✔
150	} else {
151	specifier = currentImport	11✔
152	}
153	if (typeof specifier !== 'undefined') {	14!
154	const exportStatement = exports.get(specifier)	14✔
155	if (typeof exportStatement !== 'undefined') {	14✔
156	const { whereUsed } = exportStatement	12✔
157	whereUsed.add(listKey)	12✔
158	exports.set(specifier, { whereUsed })	12✔
159	}
160	}
161	})
162	}
163	})
164	})
165	}
166
167	const getSrc = src => {	1✔
168	if (src) {	1!
169	return src	1✔
170	}
171	return [process.cwd()]	×
172	}
173
174	/**
175	* prepare the lists of existing imports and exports - should only be executed once at
176	* the start of a new eslint run
177	*/
178	const doPreparation = (src, ignoreExports, context) => {	1✔
179	const srcFiles = resolveFiles(getSrc(src), ignoreExports)	1✔
180	prepareImportsAndExports(srcFiles, context)	1✔
181	determineUsage()	1✔
182	preparationDone = true	1✔
183	}
184
185	const newNamespaceImportExists = specifiers =>	1✔
186	specifiers.some(({ type }) => type === IMPORT_NAMESPACE_SPECIFIER)	28✔
187
188	const newDefaultImportExists = specifiers =>	1✔
189	specifiers.some(({ type }) => type === IMPORT_DEFAULT_SPECIFIER)	28✔
190
191	module.exports = {	1✔
192	meta: {
193	docs: { url: docsUrl('no-unused-modules') },
194	schema: [{
195	properties: {
196	src: {
197	description: 'files/paths to be analyzed (only for unused exports)',
198	type: 'array',
199	minItems: 1,
200	items: {
201	type: 'string',
202	minLength: 1,
203	},
204	},
205	ignoreExports: {
206	description:
207	'files/paths for which unused exports will not be reported (e.g module entry points)',
208	type: 'array',
209	minItems: 1,
210	items: {
211	type: 'string',
212	minLength: 1,
213	},
214	},
215	missingExports: {
216	description: 'report modules without any exports',
217	type: 'boolean',
218	},
219	unusedExports: {
220	description: 'report exports without any usage',
221	type: 'boolean',
222	},
223	},
224	not: {
225	properties: {
226	unusedExports: { enum: [false] },
227	missingExports: { enum: [false] },
228	},
229	},
230	anyOf:[{
231	not: {
232	properties: {
233	unusedExports: { enum: [true] },
234	},
235	},
236	required: ['missingExports'],
237	}, {
238	not: {
239	properties: {
240	missingExports: { enum: [true] },
241	},
242	},
243	required: ['unusedExports'],
244	}, {
245	properties: {
246	unusedExports: { enum: [true] },
247	},
248	required: ['unusedExports'],
249	}, {
250	properties: {
251	missingExports: { enum: [true] },
252	},
253	required: ['missingExports'],
254	}],
255	}],
256	},
257
258	create: context => {
259	const {
260	src,
261	ignoreExports = [],	9✔
262	missingExports,
263	unusedExports,
264	} = context.options[0] \|\| {}	78✔
265
266	if (unusedExports && !preparationDone) {	78✔
267	doPreparation(src, ignoreExports, context)	1✔
268	}
269
270	const file = context.getFilename()	78✔
271
272	const checkExportPresence = node => {	78✔
273	if (!missingExports) {	78✔
274	return	69✔
275	}
276
277	if (ignoredFiles.has(file)) {	9✔
278	return	1✔
279	}
280
281	const exportCount = exportList.get(file)	8✔
282	const exportAll = exportCount.get(EXPORT_ALL_DECLARATION)	8✔
283	const namespaceImports = exportCount.get(IMPORT_NAMESPACE_SPECIFIER)	8✔
284
285	exportCount.delete(EXPORT_ALL_DECLARATION)	8✔
286	exportCount.delete(IMPORT_NAMESPACE_SPECIFIER)	8✔
287	if (missingExports && exportCount.size < 1) {	8✔
288	// node.body[0] === 'undefined' only happens, if everything is commented out in the file
289	// being linted
290	context.report(node.body[0] ? node.body[0] : node, 'No exports found')	2✔
291	}
292	exportCount.set(EXPORT_ALL_DECLARATION, exportAll)	8✔
293	exportCount.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports)	8✔
294	}
295
296	const checkUsage = (node, exportedValue) => {	78✔
297	if (!unusedExports) {	95✔
298	return	9✔
299	}
300
301	if (ignoredFiles.has(file)) {	86✔
302	return	9✔
303	}
304
305	exports = exportList.get(file)	77✔
306
307	// special case: export * from
308	const exportAll = exports.get(EXPORT_ALL_DECLARATION)	77✔
309	if (typeof exportAll !== 'undefined' && exportedValue !== IMPORT_DEFAULT_SPECIFIER) {	77✔
310	if (exportAll.whereUsed.size > 0) {	53✔
311	return	7✔
312	}
313	}
314
315	// special case: namespace import
316	const namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER)	70✔
317	if (typeof namespaceImports !== 'undefined') {	70✔
318	if (namespaceImports.whereUsed.size > 0) {	67✔
319	return	11✔
320	}
321	}
322
323	const exportStatement = exports.get(exportedValue)	59✔
324
325	const value = exportedValue === IMPORT_DEFAULT_SPECIFIER ? DEFAULT : exportedValue	59✔
326
327	if (typeof exportStatement !== 'undefined'){	59✔
328	if (exportStatement.whereUsed.size < 1) {	49✔
329	context.report(	27✔
330	node,
331	`exported declaration '${value}' not used within other modules`
332	)
333	}
334	} else {
335	context.report(	10✔
336	node,
337	`exported declaration '${value}' not used within other modules`
338	)
339	}
340	}
341
342	/**
343	* only useful for tools like vscode-eslint
344	*
345	* update lists of existing exports during runtime
346	*/
347	const updateExportUsage = node => {	78✔
348	if (ignoredFiles.has(file)) {	78✔
349	return	7✔
350	}
351
352	let exports = exportList.get(file)	71✔
353
354	// new module has been created during runtime
355	// include it in further processing
356	if (typeof exports === 'undefined') {	71✔
357	exports = new Map()	2✔
358	}
359
360	const newExports = new Map()	71✔
361	const newExportIdentifiers = new Set()	71✔
362
363	node.body.forEach(({ type, declaration, specifiers }) => {	71✔
364	if (type === EXPORT_DEFAULT_DECLARATION) {	138✔
365	newExportIdentifiers.add(IMPORT_DEFAULT_SPECIFIER)	25✔
366	}
367	if (type === EXPORT_NAMED_DECLARATION) {	138✔
368	if (specifiers.length > 0) {	41✔
369	specifiers.forEach(specifier => {	25✔
370	if (specifier.exported) {	44!
371	newExportIdentifiers.add(specifier.exported.name)	44✔
372	}
373	})
374	}
375	if (declaration) {	41✔
376	if (declaration.type === FUNCTION_DECLARATION) {	16✔
377	newExportIdentifiers.add(declaration.id.name)	2✔
378	}
379	if (declaration.type === VARIABLE_DECLARATION) {	16✔
380	declaration.declarations.forEach(({ id }) => {	14✔
381	newExportIdentifiers.add(id.name)	14✔
382	})
383	}
384	}
385	}
386	})
387
388	// old exports exist within list of new exports identifiers: add to map of new exports
389	exports.forEach((value, key) => {	71✔
390	if (newExportIdentifiers.has(key)) {	223✔
391	newExports.set(key, value)	66✔
392	}
393	})
394
395	// new export identifiers added: add to map of new exports
396	newExportIdentifiers.forEach(key => {	71✔
397	if (!exports.has(key)) {	85✔
398	newExports.set(key, { whereUsed: new Set() })	19✔
399	}
400	})
401
402	// preserve information about namespace imports
403	let exportAll = exports.get(EXPORT_ALL_DECLARATION)	71✔
404	let namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER)	71✔
405
406	if (typeof namespaceImports === 'undefined') {	71✔
407	namespaceImports = { whereUsed: new Set() }	5✔
408	}
409
410	newExports.set(EXPORT_ALL_DECLARATION, exportAll)	71✔
411	newExports.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports)	71✔
412	exportList.set(file, newExports)	71✔
413	}
414
415	/**
416	* only useful for tools like vscode-eslint
417	*
418	* update lists of existing imports during runtime
419	*/
420	const updateImportUsage = node => {	78✔
421	if (!unusedExports) {	78✔
422	return	10✔
423	}
424
425	let oldImportPaths = importList.get(file)	68✔
426	if (typeof oldImportPaths === 'undefined') {	68✔
427	oldImportPaths = new Map()	13✔
428	}
429
430	const oldNamespaceImports = new Set()	68✔
431	const newNamespaceImports = new Set()	68✔
432
433	const oldExportAll = new Set()	68✔
434	const newExportAll = new Set()	68✔
435
436	const oldDefaultImports = new Set()	68✔
437	const newDefaultImports = new Set()	68✔
438
439	const oldImports = new Map()	68✔
440	const newImports = new Map()	68✔
441	oldImportPaths.forEach((value, key) => {	68✔
442	if (value.has(EXPORT_ALL_DECLARATION)) {	241✔
443	oldExportAll.add(key)	3✔
444	}
445	if (value.has(IMPORT_NAMESPACE_SPECIFIER)) {	241✔
446	oldNamespaceImports.add(key)	3✔
447	}
448	if (value.has(IMPORT_DEFAULT_SPECIFIER)) {	241✔
449	oldDefaultImports.add(key)	12✔
450	}
451	value.forEach(val => {	241✔
452	if (val !== IMPORT_NAMESPACE_SPECIFIER &&	50✔
453	val !== IMPORT_DEFAULT_SPECIFIER) {
454	oldImports.set(val, key)	35✔
455	}
456	})
457	})
458
459	node.body.forEach(astNode => {	68✔
460	let resolvedPath
461
462	// support for export { value } from 'module'
463	if (astNode.type === EXPORT_NAMED_DECLARATION) {	137✔
464	if (astNode.source) {	42✔
465	resolvedPath = resolve(astNode.source.raw.replace(/('\|")/g, ''), context)	6✔
466	astNode.specifiers.forEach(specifier => {	6✔
467	let name
468	if (specifier.exported.name === DEFAULT) {	10✔
469	name = IMPORT_DEFAULT_SPECIFIER	2✔
470	} else {
471	name = specifier.local.name	8✔
472	}
473	newImports.set(name, resolvedPath)	10✔
474	})
475	}
476	}
477
478	if (astNode.type === EXPORT_ALL_DECLARATION) {	137✔
479	resolvedPath = resolve(astNode.source.raw.replace(/('\|")/g, ''), context)	4✔
480	newExportAll.add(resolvedPath)	4✔
481	}
482
483	if (astNode.type === IMPORT_DECLARATION) {	137✔
484	resolvedPath = resolve(astNode.source.raw.replace(/('\|")/g, ''), context)	28✔
485	if (!resolvedPath) {	28✔
486	return	2✔
487	}
488
489	if (isNodeModule(resolvedPath)) {	26!
490	return	×
491	}
492
493	if (newNamespaceImportExists(astNode.specifiers)) {	26✔
494	newNamespaceImports.add(resolvedPath)	4✔
495	}
496
497	if (newDefaultImportExists(astNode.specifiers)) {	26✔
498	newDefaultImports.add(resolvedPath)	8✔
499	}
500
501	astNode.specifiers.forEach(specifier => {	26✔
502	if (specifier.type === IMPORT_DEFAULT_SPECIFIER \|\|	28✔
503	specifier.type === IMPORT_NAMESPACE_SPECIFIER) {
504	return	12✔
505	}
506	newImports.set(specifier.imported.name, resolvedPath)	16✔
507	})
508	}
509	})
510
511	newExportAll.forEach(value => {	68✔
512	if (!oldExportAll.has(value)) {	4!
513	let imports = oldImportPaths.get(value)	4✔
514	if (typeof imports === 'undefined') {	4✔
515	imports = new Set()	1✔
516	}
517	imports.add(EXPORT_ALL_DECLARATION)	4✔
518	oldImportPaths.set(value, imports)	4✔
519
520	let exports = exportList.get(value)	4✔
521	let currentExport
522	if (typeof exports !== 'undefined') {	4✔
523	currentExport = exports.get(EXPORT_ALL_DECLARATION)	3✔
524	} else {
525	exports = new Map()	1✔
526	exportList.set(value, exports)	1✔
527	}
528
529	if (typeof currentExport !== 'undefined') {	4✔
530	currentExport.whereUsed.add(file)	2✔
531	} else {
532	const whereUsed = new Set()	2✔
533	whereUsed.add(file)	2✔
534	exports.set(EXPORT_ALL_DECLARATION, { whereUsed })	2✔
535	}
536	}
537	})
538
539	oldExportAll.forEach(value => {	68✔
540	if (!newExportAll.has(value)) {	3!
541	const imports = oldImportPaths.get(value)	3✔
542	imports.delete(EXPORT_ALL_DECLARATION)	3✔
543
544	const exports = exportList.get(value)	3✔
545	if (typeof exports !== 'undefined') {	3!
546	const currentExport = exports.get(EXPORT_ALL_DECLARATION)	3✔
547	if (typeof currentExport !== 'undefined') {	3!
548	currentExport.whereUsed.delete(file)	3✔
549	}
550	}
551	}
552	})
553
554	newDefaultImports.forEach(value => {	68✔
555	if (!oldDefaultImports.has(value)) {	8✔
556	let imports = oldImportPaths.get(value)	6✔
557	if (typeof imports === 'undefined') {	6✔
558	imports = new Set()	3✔
559	}
560	imports.add(IMPORT_DEFAULT_SPECIFIER)	6✔
561	oldImportPaths.set(value, imports)	6✔
562
563	let exports = exportList.get(value)	6✔
564	let currentExport
565	if (typeof exports !== 'undefined') {	6✔
566	currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER)	4✔
567	} else {
568	exports = new Map()	2✔
569	exportList.set(value, exports)	2✔
570	}
571
572	if (typeof currentExport !== 'undefined') {	6✔
573	currentExport.whereUsed.add(file)	3✔
574	} else {
575	const whereUsed = new Set()	3✔
576	whereUsed.add(file)	3✔
577	exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed })	3✔
578	}
579	}
580	})
581
582	oldDefaultImports.forEach(value => {	68✔
583	if (!newDefaultImports.has(value)) {	12✔
584	const imports = oldImportPaths.get(value)	10✔
585	imports.delete(IMPORT_DEFAULT_SPECIFIER)	10✔
586
587	const exports = exportList.get(value)	10✔
588	if (typeof exports !== 'undefined') {	10✔
589	const currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER)	9✔
590	if (typeof currentExport !== 'undefined') {	9✔
591	currentExport.whereUsed.delete(file)	8✔
592	}
593	}
594	}
595	})
596
597	newNamespaceImports.forEach(value => {	68✔
598	if (!oldNamespaceImports.has(value)) {	4✔
599	let imports = oldImportPaths.get(value)	3✔
600	if (typeof imports === 'undefined') {	3!
601	imports = new Set()	3✔
602	}
603	imports.add(IMPORT_NAMESPACE_SPECIFIER)	3✔
604	oldImportPaths.set(value, imports)	3✔
605
606	let exports = exportList.get(value)	3✔
607	let currentExport
608	if (typeof exports !== 'undefined') {	3✔
609	currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER)	2✔
610	} else {
611	exports = new Map()	1✔
612	exportList.set(value, exports)	1✔
613	}
614
615	if (typeof currentExport !== 'undefined') {	3✔
616	currentExport.whereUsed.add(file)	2✔
617	} else {
618	const whereUsed = new Set()	1✔
619	whereUsed.add(file)	1✔
620	exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed })	1✔
621	}
622	}
623	})
624
625	oldNamespaceImports.forEach(value => {	68✔
626	if (!newNamespaceImports.has(value)) {	3✔
627	const imports = oldImportPaths.get(value)	2✔
628	imports.delete(IMPORT_NAMESPACE_SPECIFIER)	2✔
629
630	const exports = exportList.get(value)	2✔
631	if (typeof exports !== 'undefined') {	2!
632	const currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER)	2✔
633	if (typeof currentExport !== 'undefined') {	2!
634	currentExport.whereUsed.delete(file)	2✔
635	}
636	}
637	}
638	})
639
640	newImports.forEach((value, key) => {	68✔
641	if (!oldImports.has(key)) {	26✔
642	let imports = oldImportPaths.get(value)	15✔
643	if (typeof imports === 'undefined') {	15✔
644	imports = new Set()	3✔
645	}
646	imports.add(key)	15✔
647	oldImportPaths.set(value, imports)	15✔
648
649	let exports = exportList.get(value)	15✔
650	let currentExport
651	if (typeof exports !== 'undefined') {	15✔
652	currentExport = exports.get(key)	14✔
653	} else {
654	exports = new Map()	1✔
655	exportList.set(value, exports)	1✔
656	}
657
658	if (typeof currentExport !== 'undefined') {	15✔
659	currentExport.whereUsed.add(file)	8✔
660	} else {
661	const whereUsed = new Set()	7✔
662	whereUsed.add(file)	7✔
663	exports.set(key, { whereUsed })	7✔
664	}
665	}
666	})
667
668	oldImports.forEach((value, key) => {	68✔
669	if (!newImports.has(key)) {	35✔
670	const imports = oldImportPaths.get(value)	24✔
671	imports.delete(key)	24✔
672
673	const exports = exportList.get(value)	24✔
674	if (typeof exports !== 'undefined') {	24!
675	const currentExport = exports.get(key)	24✔
676	if (typeof currentExport !== 'undefined') {	24✔
677	currentExport.whereUsed.delete(file)	16✔
678	}
679	}
680	}
681	})
682	}
683
684	return {	78✔
685	'Program:exit': node => {
686	updateExportUsage(node)	78✔
687	updateImportUsage(node)	78✔
688	checkExportPresence(node)	78✔
689	},
690	'ExportDefaultDeclaration': node => {
691	checkUsage(node, IMPORT_DEFAULT_SPECIFIER)	27✔
692	},
693	'ExportNamedDeclaration': node => {
694	node.specifiers.forEach(specifier => {	47✔
695	checkUsage(node, specifier.exported.name)	49✔
696	})
697	if (node.declaration) {	47✔
698	if (node.declaration.type === FUNCTION_DECLARATION) {	19✔
699	checkUsage(node, node.declaration.id.name)	3✔
700	}
701	if (node.declaration.type === VARIABLE_DECLARATION) {	19✔
702	node.declaration.declarations.forEach(declaration => {	16✔
703	checkUsage(node, declaration.id.name)	16✔
704	})
705	}
706	}
707	},
708	}
709	},
710	}

benmosher / eslint-plugin-import / 24074980

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