eslint-plugin-stratified-design 0.12.8 → 0.12.10

package/docs/rules/no-same-level-funcs.md

@@ -85,6 +85,11 @@ const funcC = (...) => {
 }
 ```
 
+```js
+const func = () => "a";
+const obj = { a: func() };
+```
+
 Examples of **correct** code for this rule:
 
 ```js
@@ -116,3 +121,16 @@ const funcC = (...) => {
   ...
 }
 ```
+
+```js
+const func = () => "a";
+// @data
+const obj = { a: func() };
+```
+
+```js
+import { lib } from "module";
+//@import
+const { fn2 } = lib;
+const fn1 = () => fn2();
+```

package/lib/helpers/common.js

@@ -134,6 +134,24 @@ const match = (path) => {
   return (pattern) => minimatch(path, pattern);
 };
 
+/**
+ * @template T
+ * @param  {...(() => T)} args
+ * @returns {T | undefined}
+ */
+const or = (...args) => {
+  for (const arg of args) {
+    try {
+      const result = arg();
+      if (result !== undefined) return result;
+      else continue;
+    } catch (e) {
+      continue;
+    }
+  }
+  return undefined;
+};
+
 module.exports = {
   toRelative,
   toSegments,
@@ -149,4 +167,5 @@ module.exports = {
   replaceAlias,
   fromCwd,
   match,
+  or,
 };

package/lib/rules/no-same-level-funcs.js

@@ -1,150 +1,146 @@
 /**
  * @fileoverview Disallow calling functions in the same file.
  * @author Hodoug Joung
+ * @description 최상위에 있는 node가 함수인지 데이터인지 구분하지 않고 모두 함수로 취급힌다. (데이터인 경우에는 주석으로 '@data'를 붙여줘야 한다. 단, 명백하게 데이터인 경우에는 그 주석을 붙여주지 않아도 된다.)
  */
 "use strict";
 
 const path = require("path");
-const { fromCwd, match } = require("../helpers/common");
+const { fromCwd, match, or } = require("../helpers/common");
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-// FIXME: const Body = styled.div``; const Body2 = styled(Body)`` (TaggedTemplateExpression)
-
 /**
  * @typedef {import('eslint').Rule.Node} Node
  * @typedef {import('eslint').AST.Token} Token
  * @typedef {import('eslint').SourceCode} SourceCode
  * @typedef {({[name: string]: number})} Levels
+ * @typedef {({[name: string]: boolean})} DataNames
  */
 
-const hasArrFunction = (elements, levels) => {
-  return elements.reduce((hasFunc, element) => {
-    if (hasFunc) return true;
-    const type = element.type;
-    if (type === "FunctionExpression" || type === "ArrowFunctionExpression")
-      return true;
-    if (type === "ObjectExpression")
-      return hasObjFunction(element.properties, levels);
-    if (type === "ArrayExpression")
-      return hasArrFunction(element.elements, levels);
-    if ("name" in element && element.name in levels) return true;
-    return false;
-  }, false);
-};
-
-const hasObjFunction = (properties, levels) => {
-  return properties.reduce((hasFunc, property) => {
-    if (hasFunc) return true;
-    if (!("value" in property)) return false;
-    const type = property.value.type;
-    if (type === "FunctionExpression" || type === "ArrowFunctionExpression")
-      return true;
-    if (type === "ObjectExpression")
-      return hasObjFunction(property.value.properties, levels);
-    if (type === "ArrayExpression")
-      return hasArrFunction(property.value.elements, levels);
-    if ("name" in property.value && property.value.name in levels) return true;
-    return false;
-  }, false);
-};
-
 /**
  * @param {Node | Token} nodeOrToken
  */
 const deriveDeclaration = (nodeOrToken) => {
-  return (nodeOrToken.type === "ExportNamedDeclaration" ||
-    nodeOrToken.type === "ExportDefaultDeclaration") &&
+  const declaration =
+    (nodeOrToken.type === "ExportNamedDeclaration" ||
+      nodeOrToken.type === "ExportDefaultDeclaration") &&
     Boolean(nodeOrToken.declaration)
-    ? nodeOrToken.declaration
-    : nodeOrToken;
+      ? nodeOrToken.declaration
+      : nodeOrToken;
+  return or(
+    () => declaration.declarations[0],
+    () => declaration
+  );
 };
 
 /**
- * @param {Node | Token} nodeOrToken
- * @returns {string | null}
+ * @param {any} declarationInit
+ * @param {DataNames} dataNames
+ * @returns {boolean}
  */
-const deriveFuncName = (nodeOrToken) => {
-  const declaration = deriveDeclaration(nodeOrToken);
-
-  if (declaration.type === "FunctionDeclaration") return declaration.id.name;
-  if (declaration.type !== "VariableDeclaration") return null;
+const isData = (declarationInit, dataNames) => {
+  const expression = or(
+    () => declarationInit.expression,
+    () => declarationInit
+  );
+  if (!expression) return false;
 
-  const { init, id } = declaration.declarations[0];
-  if (
-    [
-      "ArrowFunctionExpression",
-      "FunctionExpression",
-      "CallExpression",
-      "TaggedTemplateExpression",
-    ].includes(init.type)
-  ) {
-    return id.name;
+  const type = expression.type;
+  if (type === "Literal") return true;
+  if (type === "Identifier") {
+    const name = or(() => expression.name);
+    return name && dataNames[name];
   }
-
-  return null;
+  if (type === "MemberExpression") {
+    const name = or(() => expression.object.name);
+    return name && dataNames[name];
+  }
+  if (type === "CallExpression") {
+    const name = or(() => expression.callee.name);
+    return name && dataNames[name];
+  }
+  if (type === "JSXElement") {
+    const name = or(() => expression.openingElement.name.name);
+    return name && dataNames[name];
+  }
+  if (type === "SpreadElement") return isData(expression.argument, dataNames);
+  if (type === "ArrayExpression")
+    return expression.elements.every((init) => isData(init, dataNames));
+  if (type === "ObjectExpression")
+    return expression.properties.every(({ value }) => isData(value, dataNames));
+  return false;
 };
 
 /**
  * @param {Node | Token} nodeOrToken
- * @param {Levels} levels
- * @returns {string | null}
+ * @param {DataNames} dataNames
+ * @returns {boolean}
  */
-const deriveVarName = (nodeOrToken, levels) => {
+const isNodeData = (nodeOrToken, dataNames) => {
   const declaration = deriveDeclaration(nodeOrToken);
-  if (declaration.type !== "VariableDeclaration") return null;
-  const { init, id } = declaration.declarations[0];
-  if (
-    init.type === "ObjectExpression" &&
-    hasObjFunction(init.properties, levels)
-  ) {
-    return id.name;
-  } else if (
-    init.type === "ArrayExpression" &&
-    hasArrFunction(init.elements, levels)
-  ) {
-    return id.name;
-  } else {
-    return null;
-  }
-};
-
-const or = (...args) => {
-  for (const arg of args) {
-    try {
-      const result = arg();
-      if (result) return result;
-      else continue;
-    } catch (e) {
-      continue;
-    }
-  }
-  return undefined;
+  return isData(declaration.init, dataNames);
 };
 
+/**
+ * @param {Node | Token} nodeOrToken
+ * @param {Levels} levels
+ * @returns {string[] | undefined}
+ */
 const deriveNames = (nodeOrToken) => {
   const declaration = deriveDeclaration(nodeOrToken);
   const names = or(
     () => declaration.id.name,
-    () => declaration.declarations[0].id.name,
-    () => declaration.declarations[0].id.elements.map(({ name }) => name),
-    () =>
-      declaration.declarations[0].id.properties.map(({ value }) => value.name)
+    () => declaration.id.elements.map(({ name }) => name),
+    () => declaration.id.properties.map(({ value }) => value.name)
   );
   return names === undefined ? [] : Array.isArray(names) ? names : [names];
 };
 
+/**
+ * @param {Node | Token} nodeOrToken
+ * @returns {string | undefined}
+ */
+const deriveCallerName = (nodeOrToken) =>
+  or(() => deriveDeclaration(nodeOrToken).id.name);
+
+/**
+ * @param {SourceCode} sourceCode
+ * @param {Node | Token} nodeOrToken
+ * @returns {boolean}
+ */
+const hasDataComment = (sourceCode, nodeOrToken) => {
+  const comments = sourceCode.getCommentsBefore(nodeOrToken);
+  for (const { value: comment } of comments) {
+    if (comment.includes("@data")) return true;
+  }
+  return false;
+};
+
 /**
  * @param {SourceCode} sourceCode
  * @param {Node | Token} nodeOrToken
- *
+ * @returns {boolean}
+ */
+const hasImportComment = (sourceCode, nodeOrToken) => {
+  const comments = sourceCode.getCommentsBefore(nodeOrToken);
+  for (const { value: comment } of comments) {
+    if (comment.includes("@import")) return true;
+  }
+  return false;
+};
+
+/**
+ * @param {SourceCode} sourceCode
+ * @param {Node | Token} nodeOrToken
+ * @returns {number}
  */
 const deriveLevel = (sourceCode, nodeOrToken) => {
   const comments = sourceCode.getCommentsBefore(nodeOrToken);
-  for (const { value } of comments) {
-    const levelInStr = value.replace(/^[^]*@level\s+?([0-9]+)[^0-9]*$/, "$1");
+  for (const { value: comment } of comments) {
+    const levelInStr = comment.replace(/^[^]*@level\s+?([0-9]+)[^0-9]*$/, "$1");
     const levelInNum = Number(levelInStr);
     if (levelInStr && !Number.isNaN(levelInNum)) {
       return levelInNum;
@@ -154,6 +150,7 @@ const deriveLevel = (sourceCode, nodeOrToken) => {
 };
 
 /**
+ * root node(Program) 바로 아래에 있는 부모 노드를 리턴한다.
  * @param {SourceCode} sourceCode
  * @param {Node} node
  */
@@ -175,7 +172,7 @@ const isCalleeLowerLevel = (sourceCode, levels) => {
     if (calleeLevel === undefined) return true; // 호출되는 함수가 존재하지 않으면 true 리턴. 함수 내의 함수의 경우에는 항상 calleeLevel 이 undefined 이다.
 
     const caller = traceAncestor(sourceCode, node);
-    const callerName = deriveFuncName(caller) || deriveVarName(caller, levels);
+    const callerName = deriveCallerName(caller);
     const callerLevel = levels[callerName];
 
     if (callerLevel === undefined) return true;
@@ -248,6 +245,12 @@ module.exports = {
      */
     const levels = {};
 
+    /**
+     * 선언된 것이 데이터인지 여부를 나타내는 객체.
+     * @type {DataNames}
+     */
+    const dataNames = {};
+
     const sourceCode = context.sourceCode;
 
     /**
@@ -269,10 +272,27 @@ module.exports = {
       Program(node) {
         node.body.forEach((token) => {
           deriveNames(token).forEach((name) => {
-            if (name) levels[name] = deriveLevel(sourceCode, token);
+            if (!name || hasImportComment(sourceCode, token)) return;
+            if (
+              hasDataComment(sourceCode, token) ||
+              isNodeData(token, dataNames)
+            ) {
+              dataNames[name] = true;
+              return;
+            }
+            const level = deriveLevel(sourceCode, token);
+            levels[name] = level;
           });
         });
       },
+      VariableDeclarator(node) {
+        const init = or(() => node.init.name);
+        const id = or(() => node.id.name);
+        if (!init || !id) return;
+        if (levels[init] && !levels[id]) {
+          levels[id] = levels[init];
+        }
+      },
       CallExpression(node) {
         for (const { name } of node.arguments) {
           const isReported = report(node, name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-stratified-design",
-  "version": "0.12.8",
+  "version": "0.12.10",
   "description": "ESlint rules for stratified design",
   "keywords": [
     "eslint",
@@ -21,6 +21,7 @@
     "lint": "eslint .",
     "test": "mocha tests --recursive",
     "test:watch": "mocha tests --recursive --watch",
+    "test:single": "mocha tests --watch",
     "versioning": "node ./scripts/versioning"
   },
   "dependencies": {

package/tests/lib/rules/no-same-level-funcs.js

@@ -9,13 +9,18 @@
 //------------------------------------------------------------------------------
 
 const rule = require("../../../lib/rules/no-same-level-funcs"),
-  RuleTester = require("eslint").RuleTester;
+  RuleTester = require("eslint").RuleTester,
+  path = require("path");
 
 //------------------------------------------------------------------------------
 // Tests
 //------------------------------------------------------------------------------
 
 const ruleTester = new RuleTester({
+  parser: path.resolve(
+    __dirname,
+    "../../../node_modules/@typescript-eslint/parser/dist/index.js"
+  ),
   parserOptions: {
     ecmaVersion: 2022,
     sourceType: "module",
@@ -116,12 +121,10 @@ ruleTester.run("no-same-level-funcs", rule, {
     {
       code: "// @level 2\nfunction func2(){};\nfunction func1(){ func2(); }",
       filename: "./src/foo.js",
-      errors: [{ messageId: "no-same-level-funcs", data: { func: "func2" } }],
     },
     {
       code: "// @level 2\nexport function func2(){};\nfunction func1(){ func2(); }",
       filename: "./src/foo.js",
-      errors: [{ messageId: "no-same-level-funcs", data: { func: "func2" } }],
     },
 
     {
@@ -160,14 +163,14 @@ ruleTester.run("no-same-level-funcs", rule, {
     },
 
     {
-      code: "const func = () => 'a'; const obj = { a: func() } ",
+      code: "/*@level 2*/const func = () => 'a'; const obj = { a: func() }",
       filename: "./src/foo.js",
     },
     {
-      code: "/*@level 2*/const func = () => 'a'; /*@level 1*/const obj = { func: () => { func() } } ",
+      code: "const func = () => 'a'; /*@data*/const obj = { a: func() }",
       filename: "./src/foo.js",
-      errors: [{ messageId: "no-same-level-funcs", data: { func: "obj" } }],
     },
+
     {
       code: "/*@level 2*/const obj = { func2: () => {} }; /*@level 1*/const func1 = () => { obj.func2() } ",
       filename: "./src/foo.js",
@@ -179,11 +182,10 @@ ruleTester.run("no-same-level-funcs", rule, {
     {
       code: "/*@level 3*/const func3 = () => 'a'; /*@level 2*/const obj = { func2: func3 }; /*@level 1*/const func1 = () => { obj.func2() } ",
       filename: "./src/foo.js",
-      errors: [{ messageId: "no-same-level-funcs", data: { func: "obj" } }],
     },
 
     {
-      code: "const func = () => 'a'; const arr = [func()];",
+      code: "/*@level 2*/const func = () => 'a'; const arr = [func()];",
       filename: "./src/foo.js",
     },
     {
@@ -231,6 +233,44 @@ ruleTester.run("no-same-level-funcs", rule, {
       code: "//@level 2\nconst {dat, fn2: func2} = someFn()\nconst fn1 = () => { func2() }\n",
       filename: "./src/foo.js",
     },
+
+    {
+      code: "const arr = []; const fn = () => arr.push(1)",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "const arr = [{ a: 1 }]; const fn = () => arr.push(1)",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "const obj = { arr: [] }; const fn = () => obj.arr.push(1)",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "const arr = [1, 2, 3] as const; const fn = () => arr.some(v => v === 1)",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "const data = ''; /*@level 2*/const fn2 = (param) => param; const fn1 = () => fn2(data)",
+      filename: "./src/foo.js",
+    },
+
+    {
+      code: "const CONST = 1; const data = CONST; const fn = () => data.replace(/a/g, 'b')",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "const CONST = 1; const arr = [CONST]; const fn = () => arr.some(v => v === CONST)",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "const CONST = 1; const obj = { a: [CONST] }; const fn = () => obj.a.some(v => v === CONST)",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "import { lib } from 'lib'; /*@import*/const { fn2 } = lib; const fn1 = () => fn2()",
+      filename: "./src/foo.js",
+    },
   ],
   invalid: [
     {
@@ -309,17 +349,15 @@ ruleTester.run("no-same-level-funcs", rule, {
       errors: [{ messageId: "no-same-level-funcs", data: { func: "hof" } }],
     },
     {
-      code: "const fnByHof = hof(() => 1); const value = fnByHof()",
-      filename: "./src/foo.js",
-      errors: [{ messageId: "no-same-level-funcs", data: { func: "fnByHof" } }],
-    },
-    {
-      code: "const fnByHof = hof(() => 1); const fn = fnByHof(() => 1)",
+      code: "const hof = (fn) => () => fn(); const fnByHof = hof(() => 1); const value = fnByHof()",
       filename: "./src/foo.js",
-      errors: [{ messageId: "no-same-level-funcs", data: { func: "fnByHof" } }],
+      errors: [
+        { messageId: "no-same-level-funcs", data: { func: "hof" } },
+        { messageId: "no-same-level-funcs", data: { func: "fnByHof" } },
+      ],
     },
     {
-      code: "const fn = () => 1; const fnByHof = hof(fn)",
+      code: "const hof = (f) => () => f(); const fn = () => 1; const fnByHof = hof(fn)",
       filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "fn" } }],
     },
@@ -392,19 +430,76 @@ ruleTester.run("no-same-level-funcs", rule, {
     },
 
     {
-      code: "const [dat, fn2] = someFn()\nconst fn1 = () => { fn2() }\n",
+      code: "const someFn = () => [1, () => 2]; const [dat, fn2] = someFn(); const fn1 = () => { fn2() }",
       filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "fn2" } }],
     },
     {
-      code: "const {dat, fn2} = someFn()\nconst fn1 = () => { fn2() }\n",
+      code: "const someFn = () => ({ dat: 1, fn2: () => 2 }); const {dat, fn2} = someFn(); const fn1 = () => { fn2() };",
       filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "fn2" } }],
     },
     {
-      code: "const {dat, fn2: func2} = someFn()\nconst fn1 = () => { func2() }\n",
+      code: "const someFn = () => ({ dat: 1, fn2: () => 2 }); const {dat, fn2: func2} = someFn(); const fn1 = () => { func2() };",
       filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "func2" } }],
     },
+
+    {
+      code: "const fn2 = () => {}; const fn1 = () => { const _fn2 = fn2; _fn2()}",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "_fn2" } }],
+    },
+    {
+      code: "const fn2 = () => {}; const fn1 = () => { const _fn2 = fn2; const __fn2 = _fn2; __fn2()}",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "__fn2" } }],
+    },
+
+    {
+      code: "import { lib } from 'lib'; const { fn2 } = lib; const fn1 = () => fn2()",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "fn2" } }],
+    },
+    {
+      code: "import { lib } from 'lib'; const fn2 = lib.fn2; const fn1 = () => fn2()",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "fn2" } }],
+    },
+    {
+      code: "import { fn2 } from 'lib'; const arr = [fn2]; const fn1 = () => arr[0]()",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "arr" } }],
+    },
+    {
+      code: "import { hof1, hof2 } from 'lib'; const fn2 = hof2(); const fn1 = () => hof1(fn2)",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "fn2" } }],
+    },
+    {
+      code: "import { fn2 } from 'lib'; const arr = [fn2()]; const fn1 = () => arr.push(1)",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "arr" } }],
+    },
+    {
+      code: "import { fn2 } from 'lib'; const data = [...fn2()]; const fn1 = () => data.push(1)",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "data" } }],
+    },
+    {
+      code: "import { fn2 } from 'lib'; const arr = [fn2]; const fn1 = () => arr.push(1)",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "arr" } }],
+    },
+    {
+      code: "import { Comp2 } from 'lib'; const arr = [<Comp2 />]; const fn1 = () => arr.push(1)",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "arr" } }],
+    },
+    {
+      code: "import { Comp2 } from 'lib'; const arr = [Comp2]; const fn1 = () => arr.push(1)",
+      filename: "./src/foo.js",
+      errors: [{ messageId: "no-same-level-funcs", data: { func: "arr" } }],
+    },
   ],
 });