31379199

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/a4fdd11b15a6f6e8e7027c5b152acedd3bf9b35f">a4fdd11b1<a href="https://github.com/benmosher/eslint-plugin-import/commit/a4fdd11b15a6f6e8e7027c5b152acedd3bf9b35f">">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/db319e3294b0d4b5834b067b1edd305fbae36320">db319e329</a>">db319e329</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/a4fdd11b15a6f6e8e7027c5b152acedd3bf9b35f"> into efd6be15a">efd6be15a</a>

Run Details

1531 of 1683 branches covered (90.97%)

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

2175 of 2287 relevant lines covered (95.1%)

67.57 hits per line

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

90.34

/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 visit from 'eslint-module-utils/visit'
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'

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, visitorKeys } = parse(path, content, context)
  } catch (err) {
    m.errors.push(err)
    return m // can't continue
  }

  let hasDynamicImports = false

  visit(ast, visitorKeys, {
    CallExpression(node) {
      if (node.callee.type === 'Import') {
        hasDynamicImports = true
        if (!node.arguments.length) {
          return null
        }
        if (node.arguments[0].type !== 'Literal') {
          return null
        }
        const literal = node.arguments[0]
        if (!literal) {
          return null
        }
        const p = remotePath(literal.value)
        if (p == null) {
          return null
        }
        const importedSpecifiers = new Set()
        importedSpecifiers.add('ImportNamespaceSpecifier')
        const getter = thunkFor(p, context)
        m.imports.set(p, {
          getter,
          source: {
            // capturing actual node reference holds full AST in memory!
            value: literal.value,
            loc: literal.loc,
          },
          importedSpecifiers,
        })
      }
    },
  })

  if (!unambiguous.isModule(ast) && !hasDynamicImports) 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)

  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) })
      })
    }

    // This doesn't declare anything, but changes what's being exported.
    if (n.type === 'TSExportAssignment') {
      const moduleDecls = ast.body.filter((bodyNode) =>
        bodyNode.type === 'TSModuleDeclaration' && bodyNode.id.name === n.expression.name
      )
      moduleDecls.forEach((moduleDecl) => {
        if (moduleDecl && moduleDecl.body && moduleDecl.body.body) {
          moduleDecl.body.body.forEach((moduleBlockNode) => {
            // Export-assignment exports all members in the namespace, explicitly exported or not.
            const exportedDecl = moduleBlockNode.type === 'ExportNamedDeclaration' ?
              moduleBlockNode.declaration :
              moduleBlockNode

            if (exportedDecl.type === 'VariableDeclaration') {
              exportedDecl.declarations.forEach((decl) =>
                recursivePatternCapture(decl.id,(id) => m.namespace.set(
                  id.name,
                  captureDoc(source, docStyleParsers, decl, exportedDecl, moduleBlockNode))
                )
              )
            } else {
              m.namespace.set(
                exportedDecl.id.name,
                captureDoc(source, docStyleParsers, moduleBlockNode))
            }
          })
        }
      })
    }
  })

  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 => {
        recursivePatternCapture(p.value, callback)
      })
      break

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

benmosher / eslint-plugin-import / 31379199

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