22867527

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/a4494c5addfbdfbc50e87cbbe36f102d0c84d9e5">a4494c5ad<a href="https://github.com/benmosher/eslint-plugin-import/commit/a4494c5addfbdfbc50e87cbbe36f102d0c84d9e5">">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/480894200e800d5e4f5cf90c4bf3d06d76fb2338">480894200</a>">480894200</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/a4494c5addfbdfbc50e87cbbe36f102d0c84d9e5"> into 246be822e">246be822e</a>

Run Details

1023 of 1138 branches covered (89.89%)

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

1449 of 1539 relevant lines covered (94.15%)

45.19 hits per line

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

91.62

/src/ExportMap.js

import fs from 'fs'

import doctrine from 'doctrine'

import debug from 'debug'

import SourceCode from 'eslint/lib/util/source-code'

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'

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()
        // 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.value.slice(0, 4) !== '*\n *') 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
  }

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

  // check for and cache ignore
  if (isIgnored(path, context) || !unambiguous.test(content)) {
    log('ignored path due to unambiguous regex or ignore settings:', 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

    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,
      },
    })
    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 'TSEnumDeclaration':
          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) })
      })
    }
  })

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

benmosher / eslint-plugin-import / 22867527

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