24191410

Build # 24191410

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/6a61248c4ed06c3422aa5f4a405f5bf93f6cf79b">6a61248c4<a href="https://github.com/benmosher/eslint-plugin-import/commit/6a61248c4ed06c3422aa5f4a405f5bf93f6cf79b">">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/7bc181e8d91872c4fa23391d35421006268f4109">7bc181e8d</a>">7bc181e8d</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/6a61248c4ed06c3422aa5f4a405f5bf93f6cf79b"> into f63dd2618">f63dd2618</a>

Run Details

1303 of 1427 branches covered (91.31%)

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

1905 of 1996 relevant lines covered (95.44%)

49.79 hits per line

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

95.83

/src/rules/extensions.js

import path from 'path'

import resolve from 'eslint-module-utils/resolve'
import { isBuiltIn, isExternalModuleMain, isScopedMain } from '../core/importType'
import isStaticRequire from '../core/staticRequire'
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,
      commonjs: 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 &&
        obj.commonjs === 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
      }

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

    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(importPath, node) {
      // 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,
            message:
              `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPath}"`,
          })
        }
      } else if (extension) {
        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {
          context.report({
            node,
            message: `Unexpected use of file extension "${extension}" for "${importPath}"`,
          })
        }
      }
    }

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

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

      const importPath = source.value

      checkFileExtension(importPath, source)
    }

    function checkCommonJSFileExtension(node) {
      if (!isStaticRequire(node)) return

      const importPath = node.arguments[0].value

      checkFileExtension(importPath, node)
    }

    const ext = {
      ImportDeclaration: checkImportFileExtension,
      ExportNamedDeclaration: checkImportFileExtension,
    }

    if (props.commonjs) {
      ext.CallExpression = checkCommonJSFileExtension
    }

    return ext
  },
}

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

benmosher / eslint-plugin-import / 24191410

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