24325662

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/1b452fc234000193cf4de0cf7c19f561a7e10c14">1b452fc23<a href="https://github.com/benmosher/eslint-plugin-import/commit/1b452fc234000193cf4de0cf7c19f561a7e10c14">">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/297d9379bad916d86558e18dcc2d300742dcf987">297d9379b</a>">297d9379b</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/1b452fc234000193cf4de0cf7c19f561a7e10c14"> into f63dd2618">f63dd2618</a>

Run Details

1296 of 1420 branches covered (91.27%)

1896 of 1987 relevant lines covered (95.42%)

49.33 hits per line

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

95.0

/src/rules/extensions.js

import path from 'path'

import resolve from 'eslint-module-utils/resolve'
import { isBuiltIn, isExternalModuleMain, isScopedMain } from '../core/importType'
import docsUrl from '../docsUrl'

const enumValues = { enum: [ 'always', 'ignorePackages', 'never' ] }
const patternProperties = {
  type: 'object',
  patternProperties: { '.*': enumValues },
}
const properties = {
  type: 'object',
  properties: {
    'pattern': patternProperties,
    'ignorePackages': { type: 'boolean' },
  },
}

function buildProperties(context) {

    const result = {
      defaultConfig: 'never',
      pattern: {},
      ignorePackages: false,
    }

    context.options.forEach(obj => {

      // If this is a string, set defaultConfig to its value
      if (typeof obj === 'string') {
        result.defaultConfig = obj
        return
      }

      // If this is not the new structure, transfer all props to result.pattern
      if (obj.pattern === undefined && obj.ignorePackages === undefined) {
        Object.assign(result.pattern, obj)
        return
      }

      // If pattern is provided, transfer all props
      if (obj.pattern !== undefined) {
        Object.assign(result.pattern, obj.pattern)
      }

      // If ignorePackages is provided, transfer it to result
      if (obj.ignorePackages !== undefined) {
        result.ignorePackages = obj.ignorePackages
      }
    })

    return result
}

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      url: docsUrl('extensions'),
    },

    schema: {
      anyOf: [
        {
          type: 'array',
          items: [enumValues],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [
            enumValues,
            properties,
          ],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [properties],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [patternProperties],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [
            enumValues,
            patternProperties,
          ],
          additionalItems: false,
        },
      ],
    },
  },

  create: function (context) {

    const props = buildProperties(context)

    function getModifier(extension) {
      return props.pattern[extension] || props.defaultConfig
    }

    function isUseOfExtensionRequired(extension, isPackageMain) {
      return getModifier(extension) === 'always' && (!props.ignorePackages || !isPackageMain)
    }

    function isUseOfExtensionForbidden(extension) {
      return getModifier(extension) === 'never'
    }

    function isResolvableWithoutExtension(file) {
      const extension = path.extname(file)
      const fileWithoutExtension = file.slice(0, -extension.length)
      const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context)

      return resolvedFileWithoutExtension === resolve(file, context)
    }

    function checkFileExtension(node) {
      const { source } = node

      // bail if the declaration doesn't have a source, e.g. "export { foo };"
      if (!source) return

      const importPath = source.value

      // don't enforce anything on builtins
      if (isBuiltIn(importPath, context.settings)) return

      const resolvedPath = resolve(importPath, context)

      // get extension from resolved path, if possible.
      // for unresolved, use source value.
      const extension = path.extname(resolvedPath || importPath).substring(1)

      // determine if this is a module
      const isPackageMain = isExternalModuleMain(importPath, context.settings)
        || isScopedMain(importPath)

      if (!extension || !importPath.endsWith(`.${extension}`)) {
        const extensionRequired = isUseOfExtensionRequired(extension, isPackageMain)
        const extensionForbidden = isUseOfExtensionForbidden(extension)
        if (extensionRequired && !extensionForbidden) {
          context.report({
            node: source,
            message:
              `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPath}"`,
          })
        }
      } else if (extension) {
        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {
          context.report({
            node: source,
            message: `Unexpected use of file extension "${extension}" for "${importPath}"`,
          })
        }
      }
    }

    return {
      ImportDeclaration: checkFileExtension,
      ExportNamedDeclaration: checkFileExtension,
    }
  },
}

1	import path from 'path'
2
3	import resolve from 'eslint-module-utils/resolve'
4	import { isBuiltIn, isExternalModuleMain, isScopedMain } from '../core/importType'
5	import docsUrl from '../docsUrl'
6
7	const enumValues = { enum: [ 'always', 'ignorePackages', 'never' ] }	1✔
8	const patternProperties = {	1✔
9	type: 'object',
10	patternProperties: { '.*': enumValues },
11	}
12	const properties = {	1✔
13	type: 'object',
14	properties: {
15	'pattern': patternProperties,
16	'ignorePackages': { type: 'boolean' },
17	},
18	}
19
20	function buildProperties(context) {
21
22	const result = {	35✔
23	defaultConfig: 'never',
24	pattern: {},
25	ignorePackages: false,
26	}
27
28	context.options.forEach(obj => {	35✔
29
30	// If this is a string, set defaultConfig to its value
31	if (typeof obj === 'string') {	41✔
32	result.defaultConfig = obj	27✔
33	return	27✔
34	}
35
36	// If this is not the new structure, transfer all props to result.pattern
37	if (obj.pattern === undefined && obj.ignorePackages === undefined) {	14✔
38	Object.assign(result.pattern, obj)	10✔
39	return	10✔
40	}
41
42	// If pattern is provided, transfer all props
43	if (obj.pattern !== undefined) {	4!
44	Object.assign(result.pattern, obj.pattern)	×
45	}
46
47	// If ignorePackages is provided, transfer it to result
48	if (obj.ignorePackages !== undefined) {	4!
49	result.ignorePackages = obj.ignorePackages	4✔
50	}
51	})
52
53	return result	35✔
54	}
55
56	module.exports = {	1✔
57	meta: {
58	type: 'suggestion',
59	docs: {
60	url: docsUrl('extensions'),
61	},
62
63	schema: {
64	anyOf: [
65	{
66	type: 'array',
67	items: [enumValues],
68	additionalItems: false,
69	},
70	{
71	type: 'array',
72	items: [
73	enumValues,
74	properties,
75	],
76	additionalItems: false,
77	},
78	{
79	type: 'array',
80	items: [properties],
81	additionalItems: false,
82	},
83	{
84	type: 'array',
85	items: [patternProperties],
86	additionalItems: false,
87	},
88	{
89	type: 'array',
90	items: [
91	enumValues,
92	patternProperties,
93	],
94	additionalItems: false,
95	},
96	],
97	},
98	},
99
100	create: function (context) {
101
102	const props = buildProperties(context)	35✔
103
104	function getModifier(extension) {
105	return props.pattern[extension] \|\| props.defaultConfig	91✔
106	}
107
108	function isUseOfExtensionRequired(extension, isPackageMain) {
109	return getModifier(extension) === 'always' && (!props.ignorePackages \|\| !isPackageMain)	27✔
110	}
111
112	function isUseOfExtensionForbidden(extension) {
113	return getModifier(extension) === 'never'	64✔
114	}
115
116	function isResolvableWithoutExtension(file) {
117	const extension = path.extname(file)	18✔
118	const fileWithoutExtension = file.slice(0, -extension.length)	18✔
119	const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context)	18✔
120
121	return resolvedFileWithoutExtension === resolve(file, context)	18✔
122	}
123
124	function checkFileExtension(node) {
125	const { source } = node	71✔
126
127	// bail if the declaration doesn't have a source, e.g. "export { foo };"
128	if (!source) return	71✔
129
130	const importPath = source.value	67✔
131
132	// don't enforce anything on builtins
133	if (isBuiltIn(importPath, context.settings)) return	67✔
134
135	const resolvedPath = resolve(importPath, context)	64✔
136
137	// get extension from resolved path, if possible.
138	// for unresolved, use source value.
139	const extension = path.extname(resolvedPath \|\| importPath).substring(1)	64✔
140
141	// determine if this is a module
142	const isPackageMain = isExternalModuleMain(importPath, context.settings)	64✔
143	\|\| isScopedMain(importPath)
144
145	if (!extension \|\| !importPath.endsWith(`.${extension}`)) {	64✔
146	const extensionRequired = isUseOfExtensionRequired(extension, isPackageMain)	27✔
147	const extensionForbidden = isUseOfExtensionForbidden(extension)	27✔
148	if (extensionRequired && !extensionForbidden) {	27✔
149	context.report({	7✔
150	node: source,
151	message:
152	`Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPath}"`,	7✔
153	})
154	}
155	} else if (extension) {	37!
156	if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {	37✔
157	context.report({	12✔
158	node: source,
159	message: `Unexpected use of file extension "${extension}" for "${importPath}"`,
160	})
161	}
162	}
163	}
164
165	return {	35✔
166	ImportDeclaration: checkFileExtension,
167	ExportNamedDeclaration: checkFileExtension,
168	}
169	},
170	}

benmosher / eslint-plugin-import / 24325662

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