feat: implement rule folder-naming-convention

Author: dukeluo

lib/rules/folder-naming-convention.js

@@ -4,7 +4,15 @@
  */
 'use strict';
 
+const micromatch = require('micromatch');
+const { getFolder, getSubPaths } = require('../utils/filename');
+const {
+  checkSettings,
+  namingPatternValidator,
+  globPatternValidator,
+} = require('../utils/settings');
 const { getDocUrl } = require('../utils/doc');
+const NAMING_CONVENTION = require('../constants/naming-convention');
 
 /**
  * @type {import('eslint').Rule.RuleModule}
@@ -19,10 +27,71 @@ module.exports = {
       url: getDocUrl('folder-naming-convention'),
     },
     fixable: null,
-    schema: [],
+    schema: [
+      {
+        additionalProperties: {
+          type: 'string',
+        },
+      },
+    ],
   },
 
-  create() {
-    return {};
+  create(context) {
+    return {
+      Program: (node) => {
+        const rules = context.options[0];
+        const invalidPattern = checkSettings(
+          rules,
+          globPatternValidator,
+          namingPatternValidator
+        );
+
+        if (invalidPattern) {
+          context.report({
+            node,
+            message:
+              'There is an invalid pattern "{{invalidPattern}}", please check it',
+            data: {
+              invalidPattern,
+            },
+          });
+          return;
+        }
+
+        const filenameWithPath = context.getFilename();
+        const folder = getFolder(filenameWithPath);
+        const subPaths = getSubPaths(folder);
+
+        for (const path of subPaths) {
+          for (const [folderPattern, namingPattern] of Object.entries(rules)) {
+            if (!micromatch.isMatch(path, folderPattern)) {
+              continue;
+            } else {
+              const matchedValue = micromatch.capture(folderPattern, path);
+
+              for (const value of matchedValue) {
+                if (
+                  !micromatch.isMatch(
+                    value,
+                    NAMING_CONVENTION[namingPattern] || namingPattern
+                  )
+                ) {
+                  context.report({
+                    node,
+                    message:
+                      'The folder "{{value}}" does not match the "{{namingPattern}}" style',
+                    data: {
+                      value,
+                      namingPattern,
+                    },
+                  });
+                  return;
+                }
+              }
+            }
+          }
+        }
+      },
+    };
   },
 };

lib/utils/filename.js

@@ -11,7 +11,7 @@
 const getFilename = (path) => path.substring(path.lastIndexOf('/') + 1);
 
 /**
- * @type {string} folder
+ * @type {string} path of folder
  * @param {string} path filename concat with path
  */
 const getFolder = (path) => path.substring(0, path.lastIndexOf('/') + 1);
@@ -23,8 +23,32 @@ const getFolder = (path) => path.substring(0, path.lastIndexOf('/') + 1);
 const getBasename = (filename) =>
   filename.substring(0, filename.lastIndexOf('.'));
 
+/**
+ * @type {string[]} all sub paths
+ * @param {string} folder path of folder
+ */
+const getSubPaths = (path) => {
+  const folders = path.split('/').filter((folder) => folder !== '');
+  let subPaths = [];
+
+  const handler = (array) =>
+    array.reduce((acc, folder, index) => {
+      if (folder) {
+        acc.push(index === 0 ? folder : `${acc[acc.length - 1]}/${folder}`);
+      }
+      return acc;
+    }, []);
+
+  for (let i = 0; i < folders.length; i++) {
+    subPaths = subPaths.concat(handler(folders.slice(i)));
+  }
+
+  return subPaths;
+};
+
 module.exports = {
   getFolder,
   getFilename,
   getBasename,
+  getSubPaths,
 };

tests/lib/rules/folder-naming-convention.js

@@ -9,13 +9,107 @@ const RuleTester = require('eslint').RuleTester;
 
 const ruleTester = new RuleTester();
 
-ruleTester.run('folder-naming-convention', rule, {
-  valid: [],
-
-  invalid: [
-    {
-      code: '',
-      errors: [{ message: 'Fill me in.', type: 'Me too' }],
-    },
-  ],
-});
+ruleTester.run(
+  "folder-naming-convention with option: [{ '*/__tests__': 'PASCAL_CASE', 'src/*': 'CAMEL_CASE' }]",
+  rule,
+  {
+    valid: [
+      {
+        code: "var foo = 'bar';",
+        filename: 'src/components/DisplayLabel/__tests__/displayLabel.test.js',
+        options: [{ '*/__tests__': 'PASCAL_CASE', 'src/*': 'CAMEL_CASE' }],
+      },
+    ],
+
+    invalid: [
+      {
+        code: "var foo = 'bar';",
+        filename: 'src/Components/DisplayLabel/__tests__/displayLabel.test.js',
+        options: [{ '*/__tests__': 'PASCAL_CASE', 'src/*': 'CAMEL_CASE' }],
+        errors: [
+          {
+            message:
+              'The folder "Components" does not match the "CAMEL_CASE" style',
+            column: 1,
+            line: 1,
+          },
+        ],
+      },
+      {
+        code: "var foo = 'bar';",
+        filename: 'src/components/displayLabel/__tests__/displayLabel.test.js',
+        options: [{ '*/__tests__': 'PASCAL_CASE', 'src/*': 'CAMEL_CASE' }],
+        errors: [
+          {
+            message:
+              'The folder "displayLabel" does not match the "PASCAL_CASE" style',
+            column: 1,
+            line: 1,
+          },
+        ],
+      },
+    ],
+  }
+);
+
+ruleTester.run(
+  'folder-naming-convention with folder that has not been set',
+  rule,
+  {
+    valid: [
+      {
+        code: "var foo = 'bar';",
+        filename: 'scripts/build.js',
+        options: [{ '*/__tests__': 'PASCAL_CASE', 'src/*': 'CAMEL_CASE' }],
+      },
+    ],
+
+    invalid: [],
+  }
+);
+
+ruleTester.run(
+  "folder-naming-convention with option: [{ '*/__tests__': 'FOO', 'src/*': 'CAMEL_CASE' }]",
+  rule,
+  {
+    valid: [],
+
+    invalid: [
+      {
+        code: "var foo = 'bar';",
+        filename: 'src/utils/calculatePrice.js',
+        options: [{ '*/__tests__': 'FOO', 'src/*': 'CAMEL_CASE' }],
+        errors: [
+          {
+            message: 'There is an invalid pattern "FOO", please check it',
+            column: 1,
+            line: 1,
+          },
+        ],
+      },
+    ],
+  }
+);
+
+ruleTester.run(
+  "filename-naming-convention with option: [{ '*/__tests__': 'PASCAL_CASE', 'src/': 'CAMEL_CASE' }]",
+  rule,
+  {
+    valid: [],
+
+    invalid: [
+      {
+        code: "var foo = 'bar';",
+        filename: 'src/utils/calculatePrice.js',
+        options: [{ '*/__tests__': 'PASCAL_CASE', 'src/': 'CAMEL_CASE' }],
+        errors: [
+          {
+            message: 'There is an invalid pattern "src/", please check it',
+            column: 1,
+            line: 1,
+          },
+        ],
+      },
+    ],
+  }
+);