#28362800

Build Type

push

Committed by

Commit Message

<a href="https://github.com/benmosher/eslint-plugin-import/commit/<a class=hub.com/benmosher/eslint-plugin-import/commit/5c877622a1973ac380fd2fffd11c7287e39fe691">5c877622a<a href="https://github.com/benmosher/eslint-plugin-import/commit/5c877622a1973ac380fd2fffd11c7287e39fe691">">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/142500287382efd29888ea9c715ae0916178eae8">142500287</a>">142500287</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/5c877622a1973ac380fd2fffd11c7287e39fe691"> into 3e65a70bc">3e65a70bc</a>

Run Details

1581 of 1738 branches covered (90.97%)

33 of 33 new or added lines in 5 files covered. (100.0%)

2231 of 2341 relevant lines covered (95.3%)

72.34 hits per line

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

91.0

/src/core/importType.js

import {isAbsolute as nodeIsAbsolute, relative, resolve as nodeResolve} from 'path'
import coreModules from 'resolve/lib/core'

import resolve from 'eslint-module-utils/resolve'
import { getContextPackagePath } from './packagePath'

function baseModule(name) {
  if (isScoped(name)) {
    const [scope, pkg] = name.split('/')
    return `${scope}/${pkg}`
  }
  const [pkg] = name.split('/')
  return pkg
}

export function isAbsolute(name) {
  return nodeIsAbsolute(name)
}

// path is defined only when a resolver resolves to a non-standard path
export function isBuiltIn(name, settings, path) {
  if (path || !name) return false
  const base = baseModule(name)
  const extras = (settings && settings['import/core-modules']) || []
  return coreModules[base] || extras.indexOf(base) > -1
}

export function isExternalModule(name, settings, path, context) {
  return isModule(name) && isExternalPath(name, settings, path, getContextPackagePath(context))
}

export function isExternalModuleMain(name, settings, path, context) {
  return isModuleMain(name) && isExternalPath(name, settings, path, getContextPackagePath(context))
}

function isExternalPath(name, settings, path, packagePath) {
  const internalScope = (settings && settings['import/internal-regex'])
  if (internalScope && new RegExp(internalScope).test(name)) {
    return false
  }

  if (!path || relative(packagePath, path).startsWith('..')) {
    return true
  }

  const folders = (settings && settings['import/external-module-folders']) || ['node_modules']
  return folders.some((folder) => {
    const folderPath = nodeResolve(packagePath, folder)
    const relativePath = relative(folderPath, path)
    return !relativePath.startsWith('..')
  })
}

const moduleRegExp = /^\w/
function isModule(name) {
  return name && moduleRegExp.test(name)
}

const moduleMainRegExp = /^[\w]((?!\/).)*$/
function isModuleMain(name) {
  return name && moduleMainRegExp.test(name)
}

const scopedRegExp = /^@[^/]*\/?[^/]+/
export function isScoped(name) {
  return name && scopedRegExp.test(name)
}

const scopedMainRegExp = /^@[^/]+\/?[^/]+$/
export function isScopedMain(name) {
  return name && scopedMainRegExp.test(name)
}

function isRelativeToParent(name) {
  return/^\.\.$|^\.\.[\\/]/.test(name)
}

const indexFiles = ['.', './', './index', './index.js']
function isIndex(name) {
  return indexFiles.indexOf(name) !== -1
}

function isRelativeToSibling(name) {
  return /^\.[\\/]/.test(name)
}

function typeTest(name, context, path) {
  const {settings} = context
  if (isAbsolute(name, settings, path)) { return 'absolute' }
  if (isBuiltIn(name, settings, path)) { return 'builtin' }
  if (isModule(name, settings, path) || isScoped(name, settings, path)) {
    const packagePath = getContextPackagePath(context)
    return isExternalPath(name, settings, path, packagePath) ? 'external' : 'internal'
  }
  if (isRelativeToParent(name, settings, path)) { return 'parent' }
  if (isIndex(name, settings, path)) { return 'index' }
  if (isRelativeToSibling(name, settings, path)) { return 'sibling' }
  return 'unknown'
}

export function isScopedModule(name) {
  return name.indexOf('@') === 0 && !name.startsWith('@/')
}

export default function resolveImportType(name, context) {
  return typeTest(name, context, resolve(name, context))
}

1	import {isAbsolute as nodeIsAbsolute, relative, resolve as nodeResolve} from 'path'
2	import coreModules from 'resolve/lib/core'
3
4	import resolve from 'eslint-module-utils/resolve'
5	import { getContextPackagePath } from './packagePath'
6
7	function baseModule(name) {
8	if (isScoped(name)) {	699✔
9	const [scope, pkg] = name.split('/')	24✔
10	return `${scope}/${pkg}`	24✔
11	}
12	const [pkg] = name.split('/')	675✔
13	return pkg	675✔
14	}
15
16	export function isAbsolute(name) {
17	return nodeIsAbsolute(name)	909✔
18	}
19
20	// path is defined only when a resolver resolves to a non-standard path
21	export function isBuiltIn(name, settings, path) {
22	if (path \|\| !name) return false	952✔
23	const base = baseModule(name)	699✔
24	const extras = (settings && settings['import/core-modules']) \|\| []	699✔
25	return coreModules[base] \|\| extras.indexOf(base) > -1	699✔
26	}
27
28	export function isExternalModule(name, settings, path, context) {
29	return isModule(name) && isExternalPath(name, settings, path, getContextPackagePath(context))	75✔
30	}
31
32	export function isExternalModuleMain(name, settings, path, context) {
33	return isModuleMain(name) && isExternalPath(name, settings, path, getContextPackagePath(context))	×
34	}
35
36	function isExternalPath(name, settings, path, packagePath) {
37	const internalScope = (settings && settings['import/internal-regex'])	406✔
38	if (internalScope && new RegExp(internalScope).test(name)) {	406✔
39	return false	1✔
40	}
41
42	if (!path \|\| relative(packagePath, path).startsWith('..')) {	405✔
43	return true	343✔
44	}
45
46	const folders = (settings && settings['import/external-module-folders']) \|\| ['node_modules']	62✔
47	return folders.some((folder) => {	62✔
48	const folderPath = nodeResolve(packagePath, folder)	61✔
49	const relativePath = relative(folderPath, path)	61✔
50	return !relativePath.startsWith('..')	61✔
51	})
52	}
53
54	const moduleRegExp = /^\w/	1✔
55	function isModule(name) {
56	return name && moduleRegExp.test(name)	783✔
57	}
58
59	const moduleMainRegExp = /^[\w]((?!\/).)*$/	1✔
60	function isModuleMain(name) {
61	return name && moduleMainRegExp.test(name)	×
62	}
63
64	const scopedRegExp = /^@[^/]*\/?[^/]+/	1✔
65	export function isScoped(name) {
66	return name && scopedRegExp.test(name)	1,127✔
67	}
68
69	const scopedMainRegExp = /^@[^/]+\/?[^/]+$/	1✔
70	export function isScopedMain(name) {
71	return name && scopedMainRegExp.test(name)	×
72	}
73
74	function isRelativeToParent(name) {
75	return/^\.\.$\|^\.\.[\\/]/.test(name)	314✔
76	}
77
78	const indexFiles = ['.', './', './index', './index.js']	1✔
79	function isIndex(name) {
80	return indexFiles.indexOf(name) !== -1	232✔
81	}
82
83	function isRelativeToSibling(name) {
84	return /^\.[\\/]/.test(name)	165✔
85	}
86
87	function typeTest(name, context, path) {
88	const {settings} = context	876✔
89	if (isAbsolute(name, settings, path)) { return 'absolute' }	876✔
90	if (isBuiltIn(name, settings, path)) { return 'builtin' }	865✔
91	if (isModule(name, settings, path) \|\| isScoped(name, settings, path)) {	708✔
92	const packagePath = getContextPackagePath(context)	394✔
93	return isExternalPath(name, settings, path, packagePath) ? 'external' : 'internal'	394✔
94	}
95	if (isRelativeToParent(name, settings, path)) { return 'parent' }	314✔
96	if (isIndex(name, settings, path)) { return 'index' }	232✔
97	if (isRelativeToSibling(name, settings, path)) { return 'sibling' }	165✔
98	return 'unknown'	44✔
99	}
100
101	export function isScopedModule(name) {
102	return name.indexOf('@') === 0 && !name.startsWith('@/')	74✔
103	}
104
105	export default function resolveImportType(name, context) {
106	return typeTest(name, context, resolve(name, context))	876✔
107	}

benmosher / eslint-plugin-import / #28362800

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