eslint-plugin-stratified-design 0.8.0-beta.2 → 0.8.0

package/lib/helpers/stratifiedImports/1 layer.js

@@ -3,9 +3,7 @@
 const { minimatch } = require("minimatch");
 const { resolvePath, reducedPaths, parsePath } = require("../common");
 const {
-  toStructure,
   replaceAlias,
-  readRawStructure,
   findLevel,
   findLayerWithReducedPath,
   readStructure,
@@ -30,6 +28,7 @@ const BARRIER = "barrier";
  * }} Options
  */
 
+// @level 2
 /**
  * @param {Options} options
  * @param {string} contextFileSource
@@ -52,6 +51,7 @@ const parseFileSource = (options, contextFileSource) => {
   };
 };
 
+// @level 2
 /**
  * @param {string} cwd
  * @param {string[]} excludeImports
@@ -79,6 +79,7 @@ const createModulePath = (cwd, excludeImports, fileDir, aliases) => {
   };
 };
 
+// @level 2
 /**
  * @param {import('./2 layer').Structure} structure
  * @param {number} fileLevel
@@ -94,6 +95,7 @@ const findLevelInCurrent = (structure, fileLevel) => {
   };
 };
 
+// @level 2
 /**
  * @param {import('./2 layer').Structure} structure
  */
@@ -105,13 +107,13 @@ const findLevelInChild = (structure) => {
     const layer = findLayerWithReducedPath(structure)(modulePath);
     if (!layer) return null;
     const fileDir = layer.name;
-    const rawChildStructure = readRawStructure(fileDir);
-    const childStructure = toStructure(rawChildStructure, fileDir);
+    const childStructure = readStructure(fileDir);
     const childLevel = findLevel(childStructure)(modulePath);
     return childLevel !== null ? findLevel(structure)(fileDir) : null;
   };
 };
 
+// @level 1
 /**
  * @param {string} cwd
  * @param {string} fileDir
@@ -147,14 +149,17 @@ const findLevelInParent = (cwd, fileDir, fileLevel) => {
       }
 
       const fileLevel = findLevel(structure)(filePath);
-      const moduleLevel = findLevel(structure)(modulePath);
+      if (fileLevel === null) return result(FAIL);
 
-      if (hasBarrier(structure, fileLevel)(moduleLevel)) {
-        return result(BARRIER);
-      } else if (fileLevel === null) {
-        return result(FAIL);
-      } else if (moduleLevel === null) {
+      const moduleLevel = (() => {
+        const level = findLevel(structure)(modulePath);
+        return level !== null ? level : findLevelInChild(structure)(modulePath);
+      })();
+
+      if (moduleLevel === null) {
         return result(null);
+      } else if (hasBarrier(structure, fileLevel)(moduleLevel)) {
+        return result(BARRIER);
       } else {
         return result(originalFileLevel + moduleLevel - fileLevel);
       }

package/lib/helpers/stratifiedImports/2 layer.js

@@ -212,7 +212,19 @@ const isInParent = (fileDir) => {
   /**
    * @param {string} modulePath
    */
-  return (modulePath) => toRelative(fileDir, modulePath).startsWith("..");
+  return (modulePath) =>
+    toSegments(toRelative(fileDir, modulePath))[0] === "..";
+};
+
+// @level 2
+/**
+ * @param {string} fileDir
+ */
+const isInChildren = (fileDir) => {
+  /**
+   * @param {string} modulePath
+   */
+  return (modulePath) => toSegments(toRelative(fileDir, modulePath))[0] === ".";
 };
 
 // @level 1
@@ -234,5 +246,6 @@ module.exports = {
   readStructure,
   hasBarrier,
   isInParent,
+  isInChildren,
   validateRawStructure,
 };

package/lib/helpers/stratifiedImports/index.js

@@ -17,6 +17,7 @@ const {
   findLevel,
   isNotRegisteredNodeModule,
   isInParent,
+  isInChildren,
   validateRawStructure,
   readRawStructure,
 } = require("./2 layer");
@@ -34,6 +35,7 @@ module.exports = {
   findLevelInChild,
   findLevelInParent,
   isInParent,
+  isInChildren,
   validateRawStructure,
   FAIL,
   SUCCESS,

package/lib/rules/stratified-imports.js

@@ -90,7 +90,7 @@ module.exports = {
       helper.createAliases(options.aliases)
     );
 
-    const isInParent = helper.isInParent(fileDir);
+    const isInChildren = helper.isInChildren(fileDir);
 
     const findLevelInCurrent = helper.findLevelInCurrent(structure, fileLevel);
 
@@ -102,10 +102,6 @@ module.exports = {
       fileLevel
     );
 
-    const isNotRegisteredNodeModule = helper.isNotRegisteredNodeModule(
-      context.cwd
-    );
-
     /**
      * @param {import('../helpers/type').Node} node
      * @param {'not-lower-level'|'barrier'|'not-registered'|'invalid-json'} messageId
@@ -145,10 +141,10 @@ module.exports = {
       const moduleLevel = (() => {
         const level = findLevelInCurrent(modulePath);
         if (level !== null) return level;
-        if (isInParent(modulePath) || isNotRegisteredNodeModule(modulePath)) {
-          return findLevelInParent(modulePath);
+        if (isInChildren(modulePath)) {
+          return findLevelInChild(modulePath);
         }
-        return findLevelInChild(modulePath);
+        return findLevelInParent(modulePath);
       })();
 
       if (moduleLevel === helper.SUCCESS) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-stratified-design",
-  "version": "0.8.0-beta.2",
+  "version": "0.8.0",
   "description": "ESlint rules for stratified design",
   "keywords": [
     "eslint",

package/tests/lib/helpers/stratified-imports.js

@@ -16,6 +16,8 @@ const {
   createAliases,
   replaceAlias,
   validateRawStructure,
+  isInParent,
+  isInChildren,
 } = require("../../../lib/helpers/stratifiedImports/2 layer");
 const {
   createModulePath,
@@ -289,4 +291,54 @@ describe("helpers/stratified-imports", () => {
       });
     });
   });
+
+  describe("isInParent()", () => {
+    const testCases = [
+      {
+        fileDir: "src/layerA",
+        modulePath: "src/layerB/layerBA",
+        expected: true,
+      },
+      {
+        fileDir: "src/layerA",
+        modulePath: "src/layerA/layerAA",
+        expected: false,
+      },
+      {
+        fileDir: "src/layerA",
+        modulePath: "nodeModule",
+        expected: true,
+      },
+    ];
+    testCases.forEach(({ fileDir, modulePath, expected }) => {
+      it(`${fileDir}, ${modulePath} -> ${expected}`, () => {
+        assert.equal(isInParent(fileDir)(modulePath), expected);
+      });
+    });
+  });
+
+  describe("isInChildren()", () => {
+    const testCases = [
+      {
+        fileDir: "src/layerA",
+        modulePath: "src/layerA/layerAA",
+        expected: true,
+      },
+      {
+        fileDir: "src/layerA",
+        modulePath: "src/layerB/layerBA",
+        expected: false,
+      },
+      {
+        fileDir: "src/layerA",
+        modulePath: "nodeModule",
+        expected: false,
+      },
+    ];
+    testCases.forEach(({ fileDir, modulePath, expected }) => {
+      it(`${fileDir}, ${modulePath} -> ${expected}`, () => {
+        assert.equal(isInChildren(fileDir)(modulePath), expected);
+      });
+    });
+  });
 });

package/tests/lib/rules/stratified-imports.js

@@ -106,6 +106,11 @@ ruleTester.run("stratified-imports", rule, {
       filename: "./mocked/stratified-imports/layerJ/entryJA.js",
       options: [],
     },
+    {
+      code: "import { func } from '../layerJ/entryJA'",
+      filename: "./mocked/stratified-imports/layerD/layerDA.js",
+      options: [],
+    },
     {
       code: "import { func } from './layerJC'",
       filename: "./mocked/stratified-imports/layerJ/entryJB.js",