36209065

Build # 36209065

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/c80fc993d2e9c6690d6dbc7e497ceef50f7f0b48">c80fc993d<a href="https://github.com/benmosher/eslint-plugin-import/commit/c80fc993d2e9c6690d6dbc7e497ceef50f7f0b48">">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/2dc33c84fb1172bb8254d76606f12a39523a3c7e">2dc33c84f</a>">2dc33c84f</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/c80fc993d2e9c6690d6dbc7e497ceef50f7f0b48"> into 13aa29c4d">13aa29c4d</a>

Run Details

1605 of 1754 branches covered (91.51%)

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

2232 of 2339 relevant lines covered (95.43%)

77.63 hits per line

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

92.84

/src/ExportMap.js

import fs from 'fs'

import doctrine from 'doctrine'

import debug from 'debug'

import { SourceCode } from 'eslint'

import parse from 'eslint-module-utils/parse'
import resolve from 'eslint-module-utils/resolve'
import isIgnored, { hasValidExtension } from 'eslint-module-utils/ignore'

import { hashObject } from 'eslint-module-utils/hash'
import * as unambiguous from 'eslint-module-utils/unambiguous'

import { tsConfigLoader } from 'tsconfig-paths/lib/tsconfig-loader'

import includes from 'array-includes'

let parseConfigFileTextToJson

const log = debug('eslint-plugin-import:ExportMap')

const exportCache = new Map()

export default class ExportMap {
  constructor(path) {
    this.path = path
    this.namespace = new Map()
    // todo: restructure to key on path, value is resolver + map of names
    this.reexports = new Map()
    /**
     * star-exports
     * @type {Set} of () => ExportMap
     */
    this.dependencies = new Set()
    /**
     * dependencies of this module that are not explicitly re-exported
     * @type {Map} from path = () => ExportMap
     */
    this.imports = new Map()
    this.errors = []
  }

  get hasDefault() { return this.get('default') != null } // stronger than this.has

  get size() {
    let size = this.namespace.size + this.reexports.size
    this.dependencies.forEach(dep => {
      const d = dep()
      // CJS / ignored dependencies won't exist (#717)
      if (d == null) return
      size += d.size
    })
    return size
  }

  /**
   * Note that this does not check explicitly re-exported names for existence
   * in the base namespace, but it will expand all `export * from '...'` exports
   * if not found in the explicit namespace.
   * @param  {string}  name
   * @return {Boolean} true if `name` is exported by this module.
   */
  has(name) {
    if (this.namespace.has(name)) return true
    if (this.reexports.has(name)) return true

    // default exports must be explicitly re-exported (#328)
    if (name !== 'default') {
      for (let dep of this.dependencies) {
        let innerMap = dep()

        // todo: report as unresolved?
        if (!innerMap) continue

        if (innerMap.has(name)) return true
      }
    }

    return false
  }

  /**
   * ensure that imported name fully resolves.
   * @param  {[type]}  name [description]
   * @return {Boolean}      [description]
   */
  hasDeep(name) {
    if (this.namespace.has(name)) return { found: true, path: [this] }

    if (this.reexports.has(name)) {
      const reexports = this.reexports.get(name)
          , imported = reexports.getImport()

      // if import is ignored, return explicit 'null'
      if (imported == null) return { found: true, path: [this] }

      // safeguard against cycles, only if name matches
      if (imported.path === this.path && reexports.local === name) {
        return { found: false, path: [this] }
      }

      const deep = imported.hasDeep(reexports.local)
      deep.path.unshift(this)

      return deep
    }


    // default exports must be explicitly re-exported (#328)
    if (name !== 'default') {
      for (let dep of this.dependencies) {
        let innerMap = dep()
        if (innerMap == null) return { found: true, path: [this] }
        // todo: report as unresolved?
        if (!innerMap) continue

        // safeguard against cycles
        if (innerMap.path === this.path) continue

        let innerValue = innerMap.hasDeep(name)
        if (innerValue.found) {
          innerValue.path.unshift(this)
          return innerValue
        }
      }
    }

    return { found: false, path: [this] }
  }

  get(name) {
    if (this.namespace.has(name)) return this.namespace.get(name)

    if (this.reexports.has(name)) {
      const reexports = this.reexports.get(name)
          , imported = reexports.getImport()

      // if import is ignored, return explicit 'null'
      if (imported == null) return null

      // safeguard against cycles, only if name matches
      if (imported.path === this.path && reexports.local === name) return undefined

      return imported.get(reexports.local)
    }

    // default exports must be explicitly re-exported (#328)
    if (name !== 'default') {
      for (let dep of this.dependencies) {
        let innerMap = dep()
        // todo: report as unresolved?
        if (!innerMap) continue

        // safeguard against cycles
        if (innerMap.path === this.path) continue

        let innerValue = innerMap.get(name)
        if (innerValue !== undefined) return innerValue
      }
    }

    return undefined
  }

  forEach(callback, thisArg) {
    this.namespace.forEach((v, n) =>
      callback.call(thisArg, v, n, this))

    this.reexports.forEach((reexports, name) => {
      const reexported = reexports.getImport()
      // can't look up meta for ignored re-exports (#348)
      callback.call(thisArg, reexported && reexported.get(reexports.local), name, this)
    })

    this.dependencies.forEach(dep => {
      const d = dep()
      // CJS / ignored dependencies won't exist (#717)
      if (d == null) return

      d.forEach((v, n) =>
        n !== 'default' && callback.call(thisArg, v, n, this))
    })
  }

  // todo: keys, values, entries?

  reportErrors(context, declaration) {
    context.report({
      node: declaration.source,
      message: `Parse errors in imported module '${declaration.source.value}': ` +
                  `${this.errors
                        .map(e => `${e.message} (${e.lineNumber}:${e.column})`)
                        .join(', ')}`,
    })
  }
}

/**
 * parse docs from the first node that has leading comments
 */
function captureDoc(source, docStyleParsers, ...nodes) {
  const metadata = {}

  // 'some' short-circuits on first 'true'
  nodes.some(n => {
    try {

      let leadingComments

      // n.leadingComments is legacy `attachComments` behavior
      if ('leadingComments' in n) {
        leadingComments = n.leadingComments
      } else if (n.range) {
        leadingComments = source.getCommentsBefore(n)
      }

      if (!leadingComments || leadingComments.length === 0) return false

      for (let name in docStyleParsers) {
        const doc = docStyleParsers[name](leadingComments)
        if (doc) {
          metadata.doc = doc
        }
      }

      return true
    } catch (err) {
      return false
    }
  })

  return metadata
}

const availableDocStyleParsers = {
  jsdoc: captureJsDoc,
  tomdoc: captureTomDoc,
}

/**
 * parse JSDoc from leading comments
 * @param  {...[type]} comments [description]
 * @return {{doc: object}}
 */
function captureJsDoc(comments) {
  let doc

  // capture XSDoc
  comments.forEach(comment => {
    // skip non-block comments
    if (comment.type !== 'Block') return
    try {
      doc = doctrine.parse(comment.value, { unwrap: true })
    } catch (err) {
      /* don't care, for now? maybe add to `errors?` */
    }
  })

  return doc
}

/**
  * parse TomDoc section from comments
  */
function captureTomDoc(comments) {
  // collect lines up to first paragraph break
  const lines = []
  for (let i = 0; i < comments.length; i++) {
    const comment = comments[i]
    if (comment.value.match(/^\s*$/)) break
    lines.push(comment.value.trim())
  }

  // return doctrine-like object
  const statusMatch = lines.join(' ').match(/^(Public|Internal|Deprecated):\s*(.+)/)
  if (statusMatch) {
    return {
      description: statusMatch[2],
      tags: [{
        title: statusMatch[1].toLowerCase(),
        description: statusMatch[2],
      }],
    }
  }
}

ExportMap.get = function (source, context) {
  const path = resolve(source, context)
  if (path == null) return null

  return ExportMap.for(childContext(path, context))
}

ExportMap.for = function (context) {
  const { path } = context

  const cacheKey = hashObject(context).digest('hex')
  let exportMap = exportCache.get(cacheKey)

  // return cached ignore
  if (exportMap === null) return null

  const stats = fs.statSync(path)
  if (exportMap != null) {
    // date equality check
    if (exportMap.mtime - stats.mtime === 0) {
      return exportMap
    }
    // future: check content equality?
  }

  // check valid extensions first
  if (!hasValidExtension(path, context)) {
    exportCache.set(cacheKey, null)
    return null
  }

  // check for and cache ignore
  if (isIgnored(path, context)) {
    log('ignored path due to ignore settings:', path)
    exportCache.set(cacheKey, null)
    return null
  }

  const content = fs.readFileSync(path, { encoding: 'utf8' })

  // check for and cache unambiguous modules
  if (!unambiguous.test(content)) {
    log('ignored path due to unambiguous regex:', path)
    exportCache.set(cacheKey, null)
    return null
  }

  log('cache miss', cacheKey, 'for path', path)
  exportMap = ExportMap.parse(path, content, context)

  // ambiguous modules return null
  if (exportMap == null) return null

  exportMap.mtime = stats.mtime

  exportCache.set(cacheKey, exportMap)
  return exportMap
}


ExportMap.parse = function (path, content, context) {
  var m = new ExportMap(path)

  try {
    var ast = parse(path, content, context)
  } catch (err) {
    log('parse error:', path, err)
    m.errors.push(err)
    return m // can't continue
  }

  if (!unambiguous.isModule(ast)) return null

  const docstyle = (context.settings && context.settings['import/docstyle']) || ['jsdoc']
  const docStyleParsers = {}
  docstyle.forEach(style => {
    docStyleParsers[style] = availableDocStyleParsers[style]
  })

  // attempt to collect module doc
  if (ast.comments) {
    ast.comments.some(c => {
      if (c.type !== 'Block') return false
      try {
        const doc = doctrine.parse(c.value, { unwrap: true })
        if (doc.tags.some(t => t.title === 'module')) {
          m.doc = doc
          return true
        }
      } catch (err) { /* ignore */ }
      return false
    })
  }

  const namespaces = new Map()

  function remotePath(value) {
    return resolve.relative(value, path, context.settings)
  }

  function resolveImport(value) {
    const rp = remotePath(value)
    if (rp == null) return null
    return ExportMap.for(childContext(rp, context))
  }

  function getNamespace(identifier) {
    if (!namespaces.has(identifier.name)) return

    return function () {
      return resolveImport(namespaces.get(identifier.name))
    }
  }

  function addNamespace(object, identifier) {
    const nsfn = getNamespace(identifier)
    if (nsfn) {
      Object.defineProperty(object, 'namespace', { get: nsfn })
    }

    return object
  }

  function captureDependency(declaration) {
    if (declaration.source == null) return null
    if (declaration.importKind === 'type') return null // skip Flow type imports
    const importedSpecifiers = new Set()
    const supportedTypes = new Set(['ImportDefaultSpecifier', 'ImportNamespaceSpecifier'])
    let hasImportedType = false
    if (declaration.specifiers) {
      declaration.specifiers.forEach(specifier => {
        const isType = specifier.importKind === 'type'
        hasImportedType = hasImportedType || isType

        if (supportedTypes.has(specifier.type) && !isType) {
          importedSpecifiers.add(specifier.type)
        }
        if (specifier.type === 'ImportSpecifier' && !isType) {
          importedSpecifiers.add(specifier.imported.name)
        }
      })
    }

    // only Flow types were imported
    if (hasImportedType && importedSpecifiers.size === 0) return null

    const p = remotePath(declaration.source.value)
    if (p == null) return null
    const existing = m.imports.get(p)
    if (existing != null) return existing.getter

    const getter = thunkFor(p, context)
    m.imports.set(p, {
      getter,
      source: {  // capturing actual node reference holds full AST in memory!
        value: declaration.source.value,
        loc: declaration.source.loc,
      },
      importedSpecifiers,
    })
    return getter
  }

  const source = makeSourceCode(content, ast)

  function isEsModuleInterop() {
    const tsConfigInfo = tsConfigLoader({
      cwd: context.parserOptions && context.parserOptions.tsconfigRootDir || process.cwd(),
      getEnv: (key) => process.env[key],
    })
    try {
      if (tsConfigInfo.tsConfigPath !== undefined) {
        const jsonText = fs.readFileSync(tsConfigInfo.tsConfigPath).toString()
        if (!parseConfigFileTextToJson) {
          // this is because projects not using TypeScript won't have typescript installed
          ({parseConfigFileTextToJson} = require('typescript'))
        }
        const tsConfig = parseConfigFileTextToJson(tsConfigInfo.tsConfigPath, jsonText).config
        return tsConfig.compilerOptions.esModuleInterop
      }
    } catch (e) {
      return false
    }
  }

  ast.body.forEach(function (n) {
    if (n.type === 'ExportDefaultDeclaration') {
      const exportMeta = captureDoc(source, docStyleParsers, n)
      if (n.declaration.type === 'Identifier') {
        addNamespace(exportMeta, n.declaration)
      }
      m.namespace.set('default', exportMeta)
      return
    }

    if (n.type === 'ExportAllDeclaration') {
      const getter = captureDependency(n)
      if (getter) m.dependencies.add(getter)
      return
    }

    // capture namespaces in case of later export
    if (n.type === 'ImportDeclaration') {
      captureDependency(n)
      let ns
      if (n.specifiers.some(s => s.type === 'ImportNamespaceSpecifier' && (ns = s))) {
        namespaces.set(ns.local.name, n.source.value)
      }
      return
    }

    if (n.type === 'ExportNamedDeclaration') {
      // capture declaration
      if (n.declaration != null) {
        switch (n.declaration.type) {
          case 'FunctionDeclaration':
          case 'ClassDeclaration':
          case 'TypeAlias': // flowtype with babel-eslint parser
          case 'InterfaceDeclaration':
          case 'DeclareFunction':
          case 'TSDeclareFunction':
          case 'TSEnumDeclaration':
          case 'TSTypeAliasDeclaration':
          case 'TSInterfaceDeclaration':
          case 'TSAbstractClassDeclaration':
          case 'TSModuleDeclaration':
            m.namespace.set(n.declaration.id.name, captureDoc(source, docStyleParsers, n))
            break
          case 'VariableDeclaration':
            n.declaration.declarations.forEach((d) =>
              recursivePatternCapture(d.id,
                id => m.namespace.set(id.name, captureDoc(source, docStyleParsers, d, n))))
            break
        }
      }

      const nsource = n.source && n.source.value
      n.specifiers.forEach((s) => {
        const exportMeta = {}
        let local

        switch (s.type) {
          case 'ExportDefaultSpecifier':
            if (!n.source) return
            local = 'default'
            break
          case 'ExportNamespaceSpecifier':
            m.namespace.set(s.exported.name, Object.defineProperty(exportMeta, 'namespace', {
              get() { return resolveImport(nsource) },
            }))
            return
          case 'ExportSpecifier':
            if (!n.source) {
              m.namespace.set(s.exported.name, addNamespace(exportMeta, s.local))
              return
            }
            // else falls through
          default:
            local = s.local.name
            break
        }

        // todo: JSDoc
        m.reexports.set(s.exported.name, { local, getImport: () => resolveImport(nsource) })
      })
    }

    const isEsModuleInteropTrue = isEsModuleInterop()

    const exports = ['TSExportAssignment']
    if (isEsModuleInteropTrue) {
      exports.push('TSNamespaceExportDeclaration')
    }

    // This doesn't declare anything, but changes what's being exported.
    if (includes(exports, n.type)) {
      const exportedName = n.type === 'TSNamespaceExportDeclaration'
        ? n.id.name
        : (n.expression && n.expression.name || (n.expression.id && n.expression.id.name) || null)
      const declTypes = [
        'VariableDeclaration',
        'ClassDeclaration',
        'TSDeclareFunction',
        'TSEnumDeclaration',
        'TSTypeAliasDeclaration',
        'TSInterfaceDeclaration',
        'TSAbstractClassDeclaration',
        'TSModuleDeclaration',
      ]
      const exportedDecls = ast.body.filter(({ type, id, declarations }) => includes(declTypes, type) && (
        (id && id.name === exportedName) || (declarations && declarations.find((d) => d.id.name === exportedName))
      ))
      if (exportedDecls.length === 0) {
        // Export is not referencing any local declaration, must be re-exporting
        m.namespace.set('default', captureDoc(source, docStyleParsers, n))
        return
      }
      if (isEsModuleInteropTrue) {
        m.namespace.set('default', {})
      }
      exportedDecls.forEach((decl) => {
        if (decl.type === 'TSModuleDeclaration') {
          if (decl.body && decl.body.type === 'TSModuleDeclaration') {
            m.namespace.set(decl.body.id.name, captureDoc(source, docStyleParsers, decl.body))
          } else if (decl.body && decl.body.body) {
            decl.body.body.forEach((moduleBlockNode) => {
              // Export-assignment exports all members in the namespace,
              // explicitly exported or not.
              const namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration' ?
                moduleBlockNode.declaration :
                moduleBlockNode

              if (!namespaceDecl) {
                // TypeScript can check this for us; we needn't
              } else if (namespaceDecl.type === 'VariableDeclaration') {
                namespaceDecl.declarations.forEach((d) =>
                  recursivePatternCapture(d.id, (id) => m.namespace.set(
                    id.name,
                    captureDoc(source, docStyleParsers, decl, namespaceDecl, moduleBlockNode)
                  ))
                )
              } else {
                m.namespace.set(
                  namespaceDecl.id.name,
                  captureDoc(source, docStyleParsers, moduleBlockNode))
              }
            })
          }
        } else {
          // Export as default
          m.namespace.set('default', captureDoc(source, docStyleParsers, decl))
        }
      })
    }
  })

  return m
}

/**
 * The creation of this closure is isolated from other scopes
 * to avoid over-retention of unrelated variables, which has
 * caused memory leaks. See #1266.
 */
function thunkFor(p, context) {
  return () => ExportMap.for(childContext(p, context))
}


/**
 * Traverse a pattern/identifier node, calling 'callback'
 * for each leaf identifier.
 * @param  {node}   pattern
 * @param  {Function} callback
 * @return {void}
 */
export function recursivePatternCapture(pattern, callback) {
  switch (pattern.type) {
    case 'Identifier': // base case
      callback(pattern)
      break

    case 'ObjectPattern':
      pattern.properties.forEach(p => {
        if (p.type === 'ExperimentalRestProperty' || p.type === 'RestElement') {
          callback(p.argument)
          return
        }
        recursivePatternCapture(p.value, callback)
      })
      break

    case 'ArrayPattern':
      pattern.elements.forEach((element) => {
        if (element == null) return
        if (element.type === 'ExperimentalRestProperty' || element.type === 'RestElement') {
          callback(element.argument)
          return
        }
        recursivePatternCapture(element, callback)
      })
      break

    case 'AssignmentPattern':
      callback(pattern.left)
      break
  }
}

/**
 * don't hold full context object in memory, just grab what we need.
 */
function childContext(path, context) {
  const { settings, parserOptions, parserPath } = context
  return {
    settings,
    parserOptions,
    parserPath,
    path,
  }
}


/**
 * sometimes legacy support isn't _that_ hard... right?
 */
function makeSourceCode(text, ast) {
  if (SourceCode.length > 1) {
    // ESLint 3
    return new SourceCode(text, ast)
  } else {
    // ESLint 4, 5
    return new SourceCode({ text, ast })
  }
}

1	import fs from 'fs'
2
3	import doctrine from 'doctrine'
4
5	import debug from 'debug'
6
7	import { SourceCode } from 'eslint'
8
9	import parse from 'eslint-module-utils/parse'
10	import resolve from 'eslint-module-utils/resolve'
11	import isIgnored, { hasValidExtension } from 'eslint-module-utils/ignore'
12
13	import { hashObject } from 'eslint-module-utils/hash'
14	import * as unambiguous from 'eslint-module-utils/unambiguous'
15
16	import { tsConfigLoader } from 'tsconfig-paths/lib/tsconfig-loader'
17
18	import includes from 'array-includes'
19
20	let parseConfigFileTextToJson
21
22	const log = debug('eslint-plugin-import:ExportMap')	1✔
23
24	const exportCache = new Map()	1✔
25
26	export default class ExportMap {
27	constructor(path) {
28	this.path = path	225✔
29	this.namespace = new Map()	225✔
30	// todo: restructure to key on path, value is resolver + map of names
31	this.reexports = new Map()	225✔
32	/**
33	* star-exports
34	* @type {Set} of () => ExportMap
35	*/
36	this.dependencies = new Set()	225✔
37	/**
38	* dependencies of this module that are not explicitly re-exported
39	* @type {Map} from path = () => ExportMap
40	*/
41	this.imports = new Map()	225✔
42	this.errors = []	225✔
43	}
44
45	get hasDefault() { return this.get('default') != null } // stronger than this.has	×
46
47	get size() {
48	let size = this.namespace.size + this.reexports.size	65✔
49	this.dependencies.forEach(dep => {	65✔
50	const d = dep()	3✔
51	// CJS / ignored dependencies won't exist (#717)
52	if (d == null) return	3!
53	size += d.size	3✔
54	})
55	return size	65✔
56	}
57
58	/**
59	* Note that this does not check explicitly re-exported names for existence
60	* in the base namespace, but it will expand all `export * from '...'` exports
61	* if not found in the explicit namespace.
62	* @param {string} name
63	* @return {Boolean} true if `name` is exported by this module.
64	*/
65	has(name) {
66	if (this.namespace.has(name)) return true	146✔
67	if (this.reexports.has(name)) return true	35✔
68
69	// default exports must be explicitly re-exported (#328)
70	if (name !== 'default') {	29✔
71	for (let dep of this.dependencies) {	28✔
72	let innerMap = dep()	1✔
73
74	// todo: report as unresolved?
75	if (!innerMap) continue	1!
76
77	if (innerMap.has(name)) return true	1!
78	}
79	}
80
81	return false	28✔
82	}
83
84	/**
85	* ensure that imported name fully resolves.
86	* @param {[type]} name [description]
87	* @return {Boolean} [description]
88	*/
89	hasDeep(name) {
90	if (this.namespace.has(name)) return { found: true, path: [this] }	133✔
91
92	if (this.reexports.has(name)) {	58✔
93	const reexports = this.reexports.get(name)	15✔
94	, imported = reexports.getImport()	15✔
95
96	// if import is ignored, return explicit 'null'
97	if (imported == null) return { found: true, path: [this] }	15✔
98
99	// safeguard against cycles, only if name matches
100	if (imported.path === this.path && reexports.local === name) {	12!
101	return { found: false, path: [this] }	×
102	}
103
104	const deep = imported.hasDeep(reexports.local)	12✔
105	deep.path.unshift(this)	12✔
106
107	return deep	12✔
108	}
109
110
111	// default exports must be explicitly re-exported (#328)
112	if (name !== 'default') {	43✔
113	for (let dep of this.dependencies) {	41✔
114	let innerMap = dep()	14✔
115	if (innerMap == null) return { found: true, path: [this] }	14✔
116	// todo: report as unresolved?
117	if (!innerMap) continue	10!
118
119	// safeguard against cycles
120	if (innerMap.path === this.path) continue	10!
121
122	let innerValue = innerMap.hasDeep(name)	10✔
123	if (innerValue.found) {	10✔
124	innerValue.path.unshift(this)	7✔
125	return innerValue	7✔
126	}
127	}
128	}
129
130	return { found: false, path: [this] }	32✔
131	}
132
133	get(name) {
134	if (this.namespace.has(name)) return this.namespace.get(name)	228✔
135
136	if (this.reexports.has(name)) {	24✔
137	const reexports = this.reexports.get(name)	14✔
138	, imported = reexports.getImport()	14✔
139
140	// if import is ignored, return explicit 'null'
141	if (imported == null) return null	14✔
142
143	// safeguard against cycles, only if name matches
144	if (imported.path === this.path && reexports.local === name) return undefined	7!
145
146	return imported.get(reexports.local)	7✔
147	}
148
149	// default exports must be explicitly re-exported (#328)
150	if (name !== 'default') {	10!
151	for (let dep of this.dependencies) {	×
152	let innerMap = dep()	×
153	// todo: report as unresolved?
154	if (!innerMap) continue	×
155
156	// safeguard against cycles
157	if (innerMap.path === this.path) continue	×
158
159	let innerValue = innerMap.get(name)	×
160	if (innerValue !== undefined) return innerValue	×
161	}
162	}
163
164	return undefined	10✔
165	}
166
167	forEach(callback, thisArg) {
168	this.namespace.forEach((v, n) =>	10✔
169	callback.call(thisArg, v, n, this))	7✔
170
171	this.reexports.forEach((reexports, name) => {	10✔
172	const reexported = reexports.getImport()	1✔
173	// can't look up meta for ignored re-exports (#348)
174	callback.call(thisArg, reexported && reexported.get(reexports.local), name, this)	1!
175	})
176
177	this.dependencies.forEach(dep => {	10✔
178	const d = dep()	3✔
179	// CJS / ignored dependencies won't exist (#717)
180	if (d == null) return	3!
181
182	d.forEach((v, n) =>	3✔
183	n !== 'default' && callback.call(thisArg, v, n, this))	3✔
184	})
185	}
186
187	// todo: keys, values, entries?
188
189	reportErrors(context, declaration) {
190	context.report({	5✔
191	node: declaration.source,
192	message: `Parse errors in imported module '${declaration.source.value}': ` +
193	`${this.errors
194	.map(e => `${e.message} (${e.lineNumber}:${e.column})`)	5✔
195	.join(', ')}`,
196	})
197	}
198	}
199
200	/**
201	* parse docs from the first node that has leading comments
202	*/
203	function captureDoc(source, docStyleParsers, ...nodes) {
204	const metadata = {}	280✔
205
206	// 'some' short-circuits on first 'true'
207	nodes.some(n => {	280✔
208	try {	381✔
209
210	let leadingComments
211
212	// n.leadingComments is legacy `attachComments` behavior
213	if ('leadingComments' in n) {	381✔
214	leadingComments = n.leadingComments	36✔
215	} else if (n.range) {	345!
216	leadingComments = source.getCommentsBefore(n)	345✔
217	}
218
219	if (!leadingComments \|\| leadingComments.length === 0) return false	381✔
220
221	for (let name in docStyleParsers) {	105✔
222	const doc = docStyleParsers[name](leadingComments)	112✔
223	if (doc) {	112✔
224	metadata.doc = doc	52✔
225	}
226	}
227
228	return true	105✔
229	} catch (err) {
230	return false	×
231	}
232	})
233
234	return metadata	280✔
235	}
236
237	const availableDocStyleParsers = {	1✔
238	jsdoc: captureJsDoc,
239	tomdoc: captureTomDoc,
240	}
241
242	/**
243	* parse JSDoc from leading comments
244	* @param {...[type]} comments [description]
245	* @return {{doc: object}}
246	*/
247	function captureJsDoc(comments) {
248	let doc
249
250	// capture XSDoc
251	comments.forEach(comment => {	94✔
252	// skip non-block comments
253	if (comment.type !== 'Block') return	123✔
254	try {	53✔
255	doc = doctrine.parse(comment.value, { unwrap: true })	53✔
256	} catch (err) {
257	/* don't care, for now? maybe add to `errors?` */
258	}
259	})
260
261	return doc	94✔
262	}
263
264	/**
265	* parse TomDoc section from comments
266	*/
267	function captureTomDoc(comments) {
268	// collect lines up to first paragraph break
269	const lines = []	18✔
270	for (let i = 0; i < comments.length; i++) {	18✔
271	const comment = comments[i]	28✔
272	if (comment.value.match(/^\s*$/)) break	28✔
273	lines.push(comment.value.trim())	25✔
274	}
275
276	// return doctrine-like object
277	const statusMatch = lines.join(' ').match(/^(Public\|Internal\|Deprecated):\s*(.+)/)	18✔
278	if (statusMatch) {	18✔
279	return {	4✔
280	description: statusMatch[2],
281	tags: [{
282	title: statusMatch[1].toLowerCase(),
283	description: statusMatch[2],
284	}],
285	}
286	}
287	}
288
289	ExportMap.get = function (source, context) {	1✔
290	const path = resolve(source, context)	447✔
291	if (path == null) return null	447✔
292
293	return ExportMap.for(childContext(path, context))	433✔
294	}
295
296	ExportMap.for = function (context) {	1✔
297	const { path } = context	606✔
298
299	const cacheKey = hashObject(context).digest('hex')	606✔
300	let exportMap = exportCache.get(cacheKey)	606✔
301
302	// return cached ignore
303	if (exportMap === null) return null	606✔
304
305	const stats = fs.statSync(path)	575✔
306	if (exportMap != null) {	575✔
307	// date equality check
308	if (exportMap.mtime - stats.mtime === 0) {	343✔
309	return exportMap	341✔
310	}
311	// future: check content equality?
312	}
313
314	// check valid extensions first
315	if (!hasValidExtension(path, context)) {	234✔
316	exportCache.set(cacheKey, null)	7✔
317	return null	7✔
318	}
319
320	// check for and cache ignore
321	if (isIgnored(path, context)) {	227✔
322	log('ignored path due to ignore settings:', path)	4✔
323	exportCache.set(cacheKey, null)	4✔
324	return null	4✔
325	}
326
327	const content = fs.readFileSync(path, { encoding: 'utf8' })	223✔
328
329	// check for and cache unambiguous modules
330	if (!unambiguous.test(content)) {	223✔
331	log('ignored path due to unambiguous regex:', path)	11✔
332	exportCache.set(cacheKey, null)	11✔
333	return null	11✔
334	}
335
336	log('cache miss', cacheKey, 'for path', path)	212✔
337	exportMap = ExportMap.parse(path, content, context)	212✔
338
339	// ambiguous modules return null
340	if (exportMap == null) return null	212!
341
342	exportMap.mtime = stats.mtime	212✔
343
344	exportCache.set(cacheKey, exportMap)	212✔
345	return exportMap	212✔
346	}
347
348
349	ExportMap.parse = function (path, content, context) {	1✔
350	var m = new ExportMap(path)	225✔
351
352	try {	225✔
353	var ast = parse(path, content, context)	225✔
354	} catch (err) {
355	log('parse error:', path, err)	8✔
356	m.errors.push(err)	8✔
357	return m // can't continue	8✔
358	}
359
360	if (!unambiguous.isModule(ast)) return null	217!
361
362	const docstyle = (context.settings && context.settings['import/docstyle']) \|\| ['jsdoc']	217✔
363	const docStyleParsers = {}	217✔
364	docstyle.forEach(style => {	217✔
365	docStyleParsers[style] = availableDocStyleParsers[style]	218✔
366	})
367
368	// attempt to collect module doc
369	if (ast.comments) {	217!
370	ast.comments.some(c => {	217✔
371	if (c.type !== 'Block') return false	125✔
372	try {	57✔
373	const doc = doctrine.parse(c.value, { unwrap: true })	57✔
374	if (doc.tags.some(t => t.title === 'module')) {	91✔
375	m.doc = doc	5✔
376	return true	5✔
377	}
378	} catch (err) { /* ignore */ }
379	return false	52✔
380	})
381	}
382
383	const namespaces = new Map()	217✔
384
385	function remotePath(value) {
386	return resolve.relative(value, path, context.settings)	216✔
387	}
388
389	function resolveImport(value) {
390	const rp = remotePath(value)	128✔
391	if (rp == null) return null	128!
392	return ExportMap.for(childContext(rp, context))	128✔
393	}
394
395	function getNamespace(identifier) {
396	if (!namespaces.has(identifier.name)) return	92✔
397
398	return function () {	13✔
399	return resolveImport(namespaces.get(identifier.name))	50✔
400	}
401	}
402
403	function addNamespace(object, identifier) {
404	const nsfn = getNamespace(identifier)	92✔
405	if (nsfn) {	92✔
406	Object.defineProperty(object, 'namespace', { get: nsfn })	13✔
407	}
408
409	return object	92✔
410	}
411
412	function captureDependency(declaration) {
413	if (declaration.source == null) return null	97!
414	if (declaration.importKind === 'type') return null // skip Flow type imports	97✔
415	const importedSpecifiers = new Set()	90✔
416	const supportedTypes = new Set(['ImportDefaultSpecifier', 'ImportNamespaceSpecifier'])	90✔
417	let hasImportedType = false	90✔
418	if (declaration.specifiers) {	90✔
419	declaration.specifiers.forEach(specifier => {	79✔
420	const isType = specifier.importKind === 'type'	84✔
421	hasImportedType = hasImportedType \|\| isType	84✔
422
423	if (supportedTypes.has(specifier.type) && !isType) {	84✔
424	importedSpecifiers.add(specifier.type)	38✔
425	}
426	if (specifier.type === 'ImportSpecifier' && !isType) {	84✔
427	importedSpecifiers.add(specifier.imported.name)	42✔
428	}
429	})
430	}
431
432	// only Flow types were imported
433	if (hasImportedType && importedSpecifiers.size === 0) return null	90✔
434
435	const p = remotePath(declaration.source.value)	88✔
436	if (p == null) return null	88✔
437	const existing = m.imports.get(p)	86✔
438	if (existing != null) return existing.getter	86✔
439
440	const getter = thunkFor(p, context)	82✔
441	m.imports.set(p, {	82✔
442	getter,
443	source: { // capturing actual node reference holds full AST in memory!
444	value: declaration.source.value,
445	loc: declaration.source.loc,
446	},
447	importedSpecifiers,
448	})
449	return getter	82✔
450	}
451
452	const source = makeSourceCode(content, ast)	217✔
453
454	function isEsModuleInterop() {
455	const tsConfigInfo = tsConfigLoader({	361✔
456	cwd: context.parserOptions && context.parserOptions.tsconfigRootDir \|\| process.cwd(),	1,056✔
457	getEnv: (key) => process.env[key],	361✔
458	})
459	try {	361✔
460	if (tsConfigInfo.tsConfigPath !== undefined) {	361✔
461	const jsonText = fs.readFileSync(tsConfigInfo.tsConfigPath).toString()	4✔
462	if (!parseConfigFileTextToJson) {	4✔
463	// this is because projects not using TypeScript won't have typescript installed
464	({parseConfigFileTextToJson} = require('typescript'))	1✔
465	}
466	const tsConfig = parseConfigFileTextToJson(tsConfigInfo.tsConfigPath, jsonText).config	4✔
467	return tsConfig.compilerOptions.esModuleInterop	4✔
468	}
469	} catch (e) {
470	return false	×
471	}
472	}
473
474	ast.body.forEach(function (n) {	217✔
475	if (n.type === 'ExportDefaultDeclaration') {	513✔
476	const exportMeta = captureDoc(source, docStyleParsers, n)	55✔
477	if (n.declaration.type === 'Identifier') {	55✔
478	addNamespace(exportMeta, n.declaration)	4✔
479	}
480	m.namespace.set('default', exportMeta)	55✔
481	return	55✔
482	}
483
484	if (n.type === 'ExportAllDeclaration') {	458✔
485	const getter = captureDependency(n)	11✔
486	if (getter) m.dependencies.add(getter)	11✔
487	return	11✔
488	}
489
490	// capture namespaces in case of later export
491	if (n.type === 'ImportDeclaration') {	447✔
492	captureDependency(n)	86✔
493	let ns
494	if (n.specifiers.some(s => s.type === 'ImportNamespaceSpecifier' && (ns = s))) {	92✔
495	namespaces.set(ns.local.name, n.source.value)	16✔
496	}
497	return	86✔
498	}
499
500	if (n.type === 'ExportNamedDeclaration') {	361✔
501	// capture declaration
502	if (n.declaration != null) {	249✔
503	switch (n.declaration.type) {	152✔
504	case 'FunctionDeclaration':
505	case 'ClassDeclaration':
506	case 'TypeAlias': // flowtype with babel-eslint parser
507	case 'InterfaceDeclaration':
508	case 'DeclareFunction':
509	case 'TSDeclareFunction':
510	case 'TSEnumDeclaration':
511	case 'TSTypeAliasDeclaration':
512	case 'TSInterfaceDeclaration':
513	case 'TSAbstractClassDeclaration':
514	case 'TSModuleDeclaration':
515	m.namespace.set(n.declaration.id.name, captureDoc(source, docStyleParsers, n))	87✔
516	break	87✔
517	case 'VariableDeclaration':
518	n.declaration.declarations.forEach((d) =>	64✔
519	recursivePatternCapture(d.id,	103✔
520	id => m.namespace.set(id.name, captureDoc(source, docStyleParsers, d, n))))	113✔
521	break	64✔
522	}
523	}
524
525	const nsource = n.source && n.source.value	249✔
526	n.specifiers.forEach((s) => {	249✔
527	const exportMeta = {}	135✔
528	let local
529
530	switch (s.type) {	135✔
531	case 'ExportDefaultSpecifier':
532	if (!n.source) return	8!
533	local = 'default'	8✔
534	break	8✔
535	case 'ExportNamespaceSpecifier':
536	m.namespace.set(s.exported.name, Object.defineProperty(exportMeta, 'namespace', {	5✔
537	get() { return resolveImport(nsource) },	30✔
538	}))
539	return	5✔
540	case 'ExportSpecifier':
541	if (!n.source) {	122✔
542	m.namespace.set(s.exported.name, addNamespace(exportMeta, s.local))	88✔
543	return	88✔
544	}
545	// else falls through
546	default:
547	local = s.local.name	34✔
548	break	34✔
549	}
550
551	// todo: JSDoc
552	m.reexports.set(s.exported.name, { local, getImport: () => resolveImport(nsource) })	48✔
553	})
554	}
555
556	const isEsModuleInteropTrue = isEsModuleInterop()	361✔
557
558	const exports = ['TSExportAssignment']	361✔
559	if (isEsModuleInteropTrue) {	361✔
560	exports.push('TSNamespaceExportDeclaration')	4✔
561	}
562
563	// This doesn't declare anything, but changes what's being exported.
564	if (includes(exports, n.type)) {	361✔
565	const exportedName = n.type === 'TSNamespaceExportDeclaration'	12✔
566	? n.id.name
567	: (n.expression && n.expression.name \|\| (n.expression.id && n.expression.id.name) \|\| null)	24!
568	const declTypes = [	12✔
569	'VariableDeclaration',
570	'ClassDeclaration',
571	'TSDeclareFunction',
572	'TSEnumDeclaration',
573	'TSTypeAliasDeclaration',
574	'TSInterfaceDeclaration',
575	'TSAbstractClassDeclaration',
576	'TSModuleDeclaration',
577	]
578	const exportedDecls = ast.body.filter(({ type, id, declarations }) => includes(declTypes, type) && (	27✔
579	(id && id.name === exportedName) \|\| (declarations && declarations.find((d) => d.id.name === exportedName))	1✔
580	))
581	if (exportedDecls.length === 0) {	12✔
582	// Export is not referencing any local declaration, must be re-exporting
583	m.namespace.set('default', captureDoc(source, docStyleParsers, n))	3✔
584	return	3✔
585	}
586	if (isEsModuleInteropTrue) {	9✔
587	m.namespace.set('default', {})	1✔
588	}
589	exportedDecls.forEach((decl) => {	9✔
590	if (decl.type === 'TSModuleDeclaration') {	12✔
591	if (decl.body && decl.body.type === 'TSModuleDeclaration') {	10✔
592	m.namespace.set(decl.body.id.name, captureDoc(source, docStyleParsers, decl.body))	1✔
593	} else if (decl.body && decl.body.body) {	9!
594	decl.body.body.forEach((moduleBlockNode) => {	9✔
595	// Export-assignment exports all members in the namespace,
596	// explicitly exported or not.
597	const namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration' ?	20✔
598	moduleBlockNode.declaration :
599	moduleBlockNode
600
601	if (!namespaceDecl) {	20✔
602	// TypeScript can check this for us; we needn't
603	} else if (namespaceDecl.type === 'VariableDeclaration') {	19✔
604	namespaceDecl.declarations.forEach((d) =>	1✔
605	recursivePatternCapture(d.id, (id) => m.namespace.set(	1✔
606	id.name,
607	captureDoc(source, docStyleParsers, decl, namespaceDecl, moduleBlockNode)
608	))
609	)
610	} else {
611	m.namespace.set(	18✔
612	namespaceDecl.id.name,
613	captureDoc(source, docStyleParsers, moduleBlockNode))
614	}
615	})
616	}
617	} else {
618	// Export as default
619	m.namespace.set('default', captureDoc(source, docStyleParsers, decl))	2✔
620	}
621	})
622	}
623	})
624
625	return m	217✔
626	}
627
628	/**
629	* The creation of this closure is isolated from other scopes
630	* to avoid over-retention of unrelated variables, which has
631	* caused memory leaks. See #1266.
632	*/
633	function thunkFor(p, context) {
634	return () => ExportMap.for(childContext(p, context))	82✔
635	}
636
637
638	/**
639	* Traverse a pattern/identifier node, calling 'callback'
640	* for each leaf identifier.
641	* @param {node} pattern
642	* @param {Function} callback
643	* @return {void}
644	*/
645	export function recursivePatternCapture(pattern, callback) {
646	switch (pattern.type) {	173✔
647	case 'Identifier': // base case
648	callback(pattern)	121✔
649	break	121✔
650
651	case 'ObjectPattern':
652	pattern.properties.forEach(p => {	26✔
653	if (p.type === 'ExperimentalRestProperty' \|\| p.type === 'RestElement') {	32✔
654	callback(p.argument)	5✔
655	return	5✔
656	}
657	recursivePatternCapture(p.value, callback)	27✔
658	})
659	break	26✔
660
661	case 'ArrayPattern':
662	pattern.elements.forEach((element) => {	16✔
663	if (element == null) return	32✔
664	if (element.type === 'ExperimentalRestProperty' \|\| element.type === 'RestElement') {	22✔
665	callback(element.argument)	5✔
666	return	5✔
667	}
668	recursivePatternCapture(element, callback)	17✔
669	})
670	break	16✔
671
672	case 'AssignmentPattern':
673	callback(pattern.left)	10✔
674	break	10✔
675	}
676	}
677
678	/**
679	* don't hold full context object in memory, just grab what we need.
680	*/
681	function childContext(path, context) {
682	const { settings, parserOptions, parserPath } = context	606✔
683	return {	606✔
684	settings,
685	parserOptions,
686	parserPath,
687	path,
688	}
689	}
690
691
692	/**
693	* sometimes legacy support isn't _that_ hard... right?
694	*/
695	function makeSourceCode(text, ast) {
696	if (SourceCode.length > 1) {	217!
697	// ESLint 3
698	return new SourceCode(text, ast)	217✔
699	} else {
700	// ESLint 4, 5
701	return new SourceCode({ text, ast })	×
702	}
703	}

benmosher / eslint-plugin-import / 36209065

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