Add no-shallow-imports rule

CHANGELOG.md

@@ -21,6 +21,7 @@ This change log adheres to standards from [Keep a CHANGELOG](https://keepachange
 - [`no-named-default`, `no-default-export`, `prefer-default-export`, `no-named-export`, `export`, `named`, `namespace`, `no-unused-modules`]: support arbitrary module namespace names ([#2358], thanks [@sosukesuzuki])
 - [`no-dynamic-require`]: support dynamic import with espree ([#2371], thanks [@sosukesuzuki])
 - [`no-relative-packages`]: add fixer ([#2381], thanks [@forivall])
+- Add [`no-shallow-imports`] rule
 
 ### Fixed
 - [`default`]: `typescript-eslint-parser`: avoid a crash on exporting as namespace (thanks [@ljharb])

README.md

@@ -29,6 +29,7 @@ This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, a
 * Prevent unnecessary path segments in import and require statements ([`no-useless-path-segments`])
 * Forbid importing modules from parent directories ([`no-relative-parent-imports`])
 * Prevent importing packages through relative paths ([`no-relative-packages`])
+* Prevent the use of shallow (barrel) imports ([`no-shallow-imports`])
 
 [`no-unresolved`]: ./docs/rules/no-unresolved.md
 [`named`]: ./docs/rules/named.md
@@ -44,6 +45,7 @@ This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, a
 [`no-useless-path-segments`]: ./docs/rules/no-useless-path-segments.md
 [`no-relative-parent-imports`]: ./docs/rules/no-relative-parent-imports.md
 [`no-relative-packages`]: ./docs/rules/no-relative-packages.md
+[`no-shallow-imports`]: ./docs/rules/no-shallow-imports.md
 
 ### Helpful warnings
 

docs/rules/no-shallow-imports.md

@@ -0,0 +1,64 @@
+# import/no-shallow-imports
+
+Prevent the use of shallow (barrel) imports.
+
+
+## Options
+
+There's one option available:
+* `allow`:  an array of minimatch/glob patterns that match paths which allow shallow importing (exempt from the rule)
+
+### Example rule (barebones)
+
+```js
+"import/no-shallow-imports": "error"
+```
+
+### Example rule (with option) 
+
+```js
+"import/no-shallow-imports": ["error", {
+    "allow": ["**/index.test.*"]
+}]
+```
+
+## Examples
+
+Given the following structure, along with the example rule (with option) above....
+
+```
+my-project
+├── dir1 
+│   └── example1.js
+│   └── index.js
+└── dir2
+│   └── example2.js
+│   └── index.js
+└── index.js
+└── index.test.js
+```
+
+
+### Examples of **incorrect** code for this rule:
+
+```js
+//  dir1/example1.js
+
+import example2 from '..';                  // imports from /index.js
+import example2 from '../dir2';             // imports from /dir2/index.js
+import example2 from '../dir2/index';       // same as above but explicit
+```
+
+### Examples of **correct** code for this rule:
+
+```js
+//  dir1/example1.js
+
+import example2 from '../dir2/example2';    // deep import :D
+```
+
+```js
+//  index.test.js
+
+import * as index from './index';          // allowed
+```

src/index.js

@@ -12,6 +12,7 @@ export const rules = {
   'group-exports': require('./rules/group-exports'),
   'no-relative-packages': require('./rules/no-relative-packages'),
   'no-relative-parent-imports': require('./rules/no-relative-parent-imports'),
+  'no-shallow-imports': require('./rules/no-shallow-imports'),
 
   'no-self-import': require('./rules/no-self-import'),
   'no-cycle': require('./rules/no-cycle'),

src/rules/no-shallow-imports.js

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import minimatch from 'minimatch';
+import docsUrl from '../docsUrl';
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Prevent the use of shallow imports',
+      recommended: true,
+      url: docsUrl('no-shallow-imports'),
+    },
+    schema: [
+      {
+        oneOf: [
+          {
+            type: 'object',
+            properties: {
+              allow: {
+                type: 'array',
+                items: {
+                  type: 'string',
+                },
+              },
+            },
+            additionalProperties: false,
+          },
+        ],
+      },
+    ],
+  },
+  create: context => {
+    return {
+      ImportDeclaration: node => maybeReportShallowImport(node, context),
+    };
+  },
+};
+
+const maybeReportShallowImport = (node, context) => {
+  const filenamePath = context.getFilename();
+
+  const options = context.options[0] || {};
+  const allowRegexps = (options.allow || []).map(p => minimatch.makeRe(p));
+
+  const doesFileMatchAllowRegexps = allowRegexps.some(regex => regex.test(filenamePath));
+
+  // If the file does not match the regexps and is a shallow import, then report it
+  if (!doesFileMatchAllowRegexps && isShallowImport(node, context)) {
+    return context.report({
+      node,
+      message: 'Please deep import!',
+    });
+  }
+};
+
+const isCalledIndex = filename => filename.slice(0, 5) === 'index';
+
+const isShallowImport = (node, context) => {
+  const filenamePath = context.getFilename();
+  const sourcePath = node.source.value;
+  const segments = sourcePath.split('/');
+  const lastSegment = segments[segments.length - 1];
+
+  if (sourcePath[0] !== '.') {
+    return false; // not a relative path, ie. it does not start with '.' or '..'
+  }
+
+  // Source ends in '..' (eg. '..', '../..', etc.)
+  if (lastSegment === '..') return true;
+
+  // Source ends in 'index(\..*)?' (eg. 'index', 'index.js', 'index.etc')
+  if (isCalledIndex(lastSegment)) return true;
+
+  // Source is a directory
+  if (isDirectory(filenamePath, sourcePath)) return true;
+
+  return false;
+};
+
+const isDirectory = (filename, source) => {
+  const filenameSegments = filename.split('/');
+  const sourceSegments = source.split('/');
+
+  if (sourceSegments[0] === '.') {
+    sourceSegments.shift();
+  }
+
+  while (sourceSegments[0] === '..') {
+    filenameSegments.pop();
+    sourceSegments.shift();
+  }
+
+  // Swap out the last element in filenameSegments with the remaining sourceSegments
+  filenameSegments.splice(filenameSegments.length - 1, 1, ...sourceSegments);
+
+  const absoluteSource = filenameSegments.join('/');
+
+  try {
+    const stat = fs.statSync(absoluteSource);
+    return stat.isDirectory();
+  } catch (e) {
+    return false;
+  }
+};

tests/src/rules/no-shallow-imports.js

@@ -0,0 +1,47 @@
+import { test, testFilePath } from '../utils';
+const rule = require('../../../src/rules/no-shallow-imports');
+const { RuleTester } = require('eslint');
+
+const ruleTester = new RuleTester();
+const errors = [{ message: 'Please deep import!' }];
+const options = [{ 'allow': ['**/index.test.js'] }];
+const filename = testFilePath('./index.test.js');
+
+ruleTester.run('no-shallow-imports', rule, {
+  valid: [
+    test({
+      code: 'import { module } from "package"',
+    }),
+    test({
+      code: 'import { module } from "@scope/package"',
+    }),
+    test({
+      code: 'import * as index from "../index"',
+      options,
+      filename,
+    }),
+  ],
+
+  invalid: [
+    test({
+      code: 'import { barrel } from ".."',
+      errors,
+    }),
+    test({
+      code: 'import { barrel } from "../.."',
+      errors,
+    }),
+    // test({
+    //   code: `import { barrel } from '../../dir';`,
+    //   errors,
+    // }),
+    test({
+      code: 'import { barrel } from "../dir/index"',
+      errors,
+    }),
+    test({
+      code: 'import { barrel } from "./dir/index.js"',
+      errors,
+    }),
+  ],
+});