eslint-plugin-stratified-design 0.4.2 → 0.5.1

package/.github/workflows/release.yml

@@ -20,14 +20,6 @@ jobs:
       - name: Update package version
         run: npm run versioning
 
-      - name: Commit and push package.json
-        run: |
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
-          git commit -a -m "Update package version"
-          TARGET_COMMITISH=$(jq -r '.release.target_commitish' $GITHUB_EVENT_PATH)
-          git push origin HEAD:${TARGET_COMMITISH}
-
       - name: Install dependencies
         run: npm ci
 

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

@@ -2,6 +2,23 @@
 
 This rule prohibits calling functions at the same level in the same file.
 
+### Options
+
+You can register the files to apply the rule (`no-same-level-funcs`) using the `include` and `exclude` options:
+
+```json
+"no-same-level-funcs": ["error", { "include": ["**/*.js"], "exclude": ["**/*.test.js"] }]
+```
+
+The default is as follows:
+
+```json
+{
+  "include": ["**/*.{js,ts,jsx,tsx}"],
+  "exclude": ["**/*.{spec,test}.{js,ts,jsx,tsx}"]
+}
+```
+
 ## Rule Details
 
 Examples of **incorrect** code for this rule:
@@ -21,6 +38,14 @@ function func3(...) {
 
 Examples of **correct** code for this rule:
 
+```js
+function func1(...) {
+  ...
+}
+
+const func2(...) => { ... }
+```
+
 ```js
 function func1(...) {
   const func2(...) => { ... };

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

@@ -79,6 +79,7 @@ const reportHasProperLevelNumber = (context, options, rootDir, filePath) => {
    */
   return (node, modulePath) => {
     if (!options.useLevelNumber) return;
+    if (isNodeModule(rootDir)(modulePath)) return;
 
     const report = (messageId) =>
       reportError(context, rootDir, filePath)(node, messageId, modulePath);
@@ -184,12 +185,15 @@ const reportHasProperLevel = (
 
     const isNodeModulePath = isNodeModule(rootDir)(modulePath);
 
+    const moduleLevel = findLevel(modulePath);
+
     if (fileLevel === null) {
-      if (!isNodeModulePath) report("not-registered:file");
+      if (moduleLevel !== null || !isNodeModulePath) {
+        report("not-registered:file");
+      }
       return FINISHED;
     }
 
-    const moduleLevel = findLevel(modulePath);
     if (moduleLevel === null) {
       if (!isNodeModulePath) report("not-registered:module");
       return FINISHED;

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

@@ -4,6 +4,9 @@
  */
 "use strict";
 
+const { minimatch } = require("minimatch");
+const path = require("path");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -13,14 +16,51 @@ module.exports = {
   meta: {
     type: "problem",
     fixable: "code",
-    schema: [],
+    schema: {
+      type: "array",
+      items: [
+        {
+          type: "object",
+          properties: {
+            exclude: {
+              type: "array",
+              items: [{ type: "string" }],
+            },
+            include: {
+              type: "array",
+              items: [{ type: "string" }],
+            },
+          },
+        },
+      ],
+      additionalItems: false,
+    },
     messages: {
       "no-same-level-funcs": "Disallow calling {{func}} in the same file.",
     },
   },
 
   create(context) {
+    const options = {
+      exclude: ["**/*.{test,spec}.{js,ts,jsx,tsx}"],
+      include: ["**/*.{js,ts,jsx,tsx}"],
+      ...(context.options[0] || {}),
+    };
+
+    const fileSource = path.resolve(context.getFilename());
+
+    const isIncludedFile = options.include.find((pattern) =>
+      minimatch(fileSource, pattern)
+    );
+
+    const isExcludedFile =
+      !isIncludedFile ||
+      options.exclude.find((pattern) => minimatch(fileSource, pattern));
+
+    if (isExcludedFile) return {};
+
     let funcNames;
+
     return {
       Program(node) {
         funcNames = node.body.reduce((names, { type, id, declarations }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-stratified-design",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "ESlint rules for stratified design",
   "keywords": [
     "eslint",

package/scripts/versioning.js

@@ -1,16 +1,25 @@
 const fs = require("fs");
+const { execSync } = require("child_process");
+
+const noChange = "__NO_CHANGE__";
+
+function exec(command) {
+  const output = execSync(command, { encoding: "utf-8" });
+  console.log(output);
+}
 
 function updatePackageVersion() {
   const githubEventPath = process.env.GITHUB_EVENT_PATH || "";
   const packageJsonPath = "package.json";
 
-  const version = (() => {
+  const { version, targetCommitish } = (() => {
     try {
       const githubEventString = fs.readFileSync(githubEventPath, "utf-8");
       const githubEvent = JSON.parse(githubEventString);
       const tagName = githubEvent.release.tag_name;
+      const targetCommitish = githubEvent.release.target_commitish;
       const version = tagName.replace(/^v(.*)/, "$1");
-      return version;
+      return { version, targetCommitish };
     } catch (error) {
       throw new Error("Error parsing GITHUB_EVENT_PATH:", error);
     }
@@ -19,6 +28,7 @@ function updatePackageVersion() {
   const packageJson = (() => {
     try {
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      if (packageJson.version === version) return noChange;
       packageJson.version = version;
       const updatedPackageJson = JSON.stringify(packageJson, null, 2) + "\n";
       return updatedPackageJson;
@@ -27,12 +37,24 @@ function updatePackageVersion() {
     }
   })();
 
+  if (packageJson === noChange) return;
+
   try {
     fs.writeFileSync(packageJsonPath, packageJson, "utf8");
-    console.log(`Successfully updated version to ${version}`);
   } catch (error) {
     throw new Error("Error writing package.json:", error);
   }
+
+  try {
+    exec(`git config --local user.email "action@github.com"`);
+    exec(`git config --local user.name "GitHub Action"`);
+    exec(`git commit -a -m "Update package version: ${version}"`);
+    exec(`git push origin HEAD:${targetCommitish}`);
+  } catch (error) {
+    throw new Error("Error executing push package.json", error);
+  }
+
+  console.log(`Successfully updated version to ${version}`);
 }
 
 updatePackageVersion();

package/tests/lib/rules/lower-level-imports.js

@@ -58,7 +58,7 @@ ruleTester.run("lower-level-imports", rule, {
       options: [{ structure, root: "./src", aliases: { "@/": "./src/" } }],
     },
     {
-      code: "import { func } from 'node-module'",
+      code: "import { func } from 'other-node-module'",
       filename: "./src/otherLayerA.js",
       options: [{ structure, root: "./src" }],
     },
@@ -170,6 +170,23 @@ ruleTester.run("lower-level-imports", rule, {
         },
       ],
     },
+    {
+      code: "import { func } from 'other-node-module'",
+      filename: "./src/1 otherLayerA.js",
+      options: [{ structure, root: "./src", useLevelNumber: true }],
+    },
+    {
+      code: "import { func } from 'node-module'",
+      filename: "./src/layer2/subLayer1/1 layer.js",
+      options: [
+        {
+          structure,
+          root: "./src",
+          aliases: { "@/": "./src/" },
+          useLevelNumber: true,
+        },
+      ],
+    },
   ],
   invalid: [
     {
@@ -310,5 +327,16 @@ ruleTester.run("lower-level-imports", rule, {
         },
       ],
     },
+    {
+      code: "import { func } from 'node-module'",
+      filename: "./src/layer3/subLayer1/1 layer.js",
+      options: [{ structure, root: "./src", useLevelNumber: true }],
+      errors: [
+        {
+          messageId: "not-lower-level",
+          data: { module: "node-module", file: "./layer3/subLayer1/1 layer" },
+        },
+      ],
+    },
   ],
 });

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

@@ -20,26 +20,55 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run("no-same-level-funcs", rule, {
-  valid: [{ code: "function func1(){ function func2(){} func2() }" }],
+  valid: [
+    {
+      code: "function func1(){ function func2(){} func2() }",
+      filename: "./src/foo.js",
+    },
+    {
+      code: "function func1(){}; function func2(){ func1(); }",
+      filename: "./src/foo.test.js",
+    },
+    {
+      code: "function func1(){}; function func2(){ func1(); }",
+      filename: "./src/foo.js",
+      options: [{ exclude: ["**/foo.js"] }],
+    },
+    {
+      code: "function func1(){}; function func2(){ func1(); }",
+      filename: "./src/foo.js",
+      options: [{ include: ["**/*.ts"] }],
+    },
+    {
+      code: "function func1(){}; function func2(){ func1(); }",
+      filename: "./src/foo.js",
+      options: [{ include: ["**/src/**/*.*"], exclude: ["**/foo.js"] }],
+    },
+  ],
   invalid: [
     {
       code: "function func1(){}; function func2(){ func1(); }",
+      filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "func1" } }],
     },
     {
       code: "function func2(){ func1(); }; function func1(){}",
+      filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "func1" } }],
     },
     {
       code: "const func1 = () => {}; const func2 = () => { func1(); }",
+      filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "func1" } }],
     },
     {
       code: "const func1 = function(){}; const func2 = function(){ func1(); }",
+      filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "func1" } }],
     },
     {
       code: "const func1 = function func1(){}; const func2 = function func2(){ func1(); }",
+      filename: "./src/foo.js",
       errors: [{ messageId: "no-same-level-funcs", data: { func: "func1" } }],
     },
   ],