tests: fix failing tests and introduce fix flag for better backward compatibility

Author: stephenjason89

src/rules/extensions.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import fs from 'fs';
+
 import minimatch from 'minimatch';
 import resolve from 'eslint-module-utils/resolve';
 import { isBuiltIn, isExternalModule, isScoped } from '../core/importType';
@@ -17,6 +17,7 @@ const properties = {
     pattern: patternProperties,
     checkTypeImports: { type: 'boolean' },
     ignorePackages: { type: 'boolean' },
+    fix: { type: 'boolean' },
     pathGroupOverrides: {
       type: 'array',
       items: {
@@ -46,6 +47,7 @@ function buildProperties(context) {
     defaultConfig: 'never',
     pattern: {},
     ignorePackages: false,
+    fix: false,
   };
 
   context.options.forEach((obj) => {
@@ -57,7 +59,7 @@ function buildProperties(context) {
     }
 
     // If this is not the new structure, transfer all props to result.pattern
-    if (obj.pattern === undefined && obj.ignorePackages === undefined && obj.checkTypeImports === undefined) {
+    if (obj.pattern === undefined && obj.ignorePackages === undefined && obj.checkTypeImports === undefined && obj.fix === undefined) {
       Object.assign(result.pattern, obj);
       return;
     }
@@ -76,6 +78,10 @@ function buildProperties(context) {
       result.checkTypeImports = obj.checkTypeImports;
     }
 
+    if (obj.fix !== undefined) {
+      result.fix = obj.fix;
+    }
+
     if (obj.pathGroupOverrides !== undefined) {
       result.pathGroupOverrides = obj.pathGroupOverrides;
     }
@@ -91,11 +97,10 @@ function buildProperties(context) {
 
 module.exports = {
   meta: {
-    type: 'problem',
+    type: 'suggestion',
     docs: {
-      description: 'Enforce that import statements either always include or never include allowed file extensions.',
-      category: 'Static Analysis',
-      recommended: false,
+      category: 'Style guide',
+      description: 'Ensure consistent use of file extension within the import path.',
       url: docsUrl('extensions'),
     },
     fixable: 'code',
@@ -134,18 +139,15 @@ module.exports = {
         },
       ],
     },
-    messages: {
-      missingExtension:
-        'Missing file extension for "{{importPath}}" (expected {{expected}}).',
-      unexpectedExtension:
-        'Unexpected file extension "{{extension}}" in import of "{{importPath}}".',
-    },
   },
 
   create(context) {
 
     const props = buildProperties(context);
 
+    // Check if fix is enabled in options
+    const isFixEnabled = !!props.fix;
+
     function getModifier(extension) {
       return props.pattern[extension] || props.defaultConfig;
     }
@@ -158,14 +160,9 @@ module.exports = {
       return getModifier(extension) === 'never';
     }
 
-    // Updated: This helper now determines resolvability based on the passed options.
-    // If the configured option for the extension is "never", we return true immediately.
-    function isResolvableWithoutExtension(file, ext) {
-      if (isUseOfExtensionForbidden(ext)) {
-        return true;
-      }
-      const fileExt = path.extname(file);
-      const fileWithoutExtension = file.slice(0, -fileExt.length);
+    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);
@@ -189,19 +186,11 @@ module.exports = {
       }
     }
 
-    function getCandidateExtension(importPath, currentDir) {
-      const basePath = path.resolve(currentDir, importPath);
-      const keys = Object.keys(props.pattern);
-      const valid = keys.filter((key) => fs.existsSync(`${basePath}.${key}`));
-      return valid.length === 1 ? `.${valid[0]}` : null;
-    }
-
     function checkFileExtension(source, node) {
       // bail if the declaration doesn't have a source, e.g. "export { foo };", or if it's only partially typed like in an editor
       if (!source || !source.value) { return; }
 
       const importPathWithQueryString = source.value;
-      const currentDir = path.dirname(context.getFilename());
 
       // If not undefined, the user decided if rules are enforced on this import
       const overrideAction = computeOverrideAction(
@@ -223,7 +212,8 @@ module.exports = {
       if (!overrideAction && isExternalRootModule(importPath)) { return; }
 
       const resolvedPath = resolve(importPath, context);
-      const extensionWithDot = path.extname(resolvedPath || importPath);
+
+      const extension = path.extname(resolvedPath || importPath).substring(1);
 
       // determine if this is a module
       const isPackage = isExternalModule(
@@ -232,38 +222,29 @@ module.exports = {
         context,
       ) || isScoped(importPath);
 
-      // Case 1: Missing extension.
-      if (!extensionWithDot || !importPath.endsWith(extensionWithDot)) {
+      if (!extension || !importPath.endsWith(`.${extension}`)) {
         // ignore type-only imports and exports
         if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) { return; }
-        const candidate = getCandidateExtension(importPath, currentDir);
-        if (candidate && isUseOfExtensionRequired(candidate.replace(/^\./, ''), isPackage)) {
+        const extensionRequired = isUseOfExtensionRequired(extension, !overrideAction && isPackage);
+        const extensionForbidden = isUseOfExtensionForbidden(extension);
+        if (extensionRequired && !extensionForbidden) {
           context.report({
-            node,
-            messageId: 'missingExtension',
-            data: {
-              importPath: importPathWithQueryString,
-              expected: candidate,
-            },
-            fix(fixer) {
-              return fixer.replaceText(source, JSON.stringify(importPathWithQueryString + candidate));
-            },
+            node: source,
+            message:
+              `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPathWithQueryString}"`,
+            fix: isFixEnabled && extension ? (fixer) => fixer.replaceText(source, JSON.stringify(`${importPathWithQueryString}.${extension}`)) : null,
           });
         }
-      } else {
-        // Case 2: Unexpected extension provided.
-        const extension = extensionWithDot.substring(1);
-        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath, extension)) {
+      } else if (extension) {
+        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {
           context.report({
             node: source,
-            messageId: 'unexpectedExtension',
-            data: {
-              extension,
-              importPath: importPathWithQueryString,
-            },
-            fix(fixer) {
-              return fixer.replaceText(source, JSON.stringify(importPath.slice(0, -extensionWithDot.length)));
-            },
+            message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
+            fix: isFixEnabled ? (fixer) => {
+              const extensionPattern = new RegExp(`\\.${extension}($|\\?)`, 'g');
+              const withoutExtension = importPathWithQueryString.replace(extensionPattern, '$1');
+              return fixer.replaceText(source, JSON.stringify(withoutExtension));
+            } : null,
           });
         }
       }