feat: new ignore arguments

zhlint-project · Jan 19, 2024 · c62ff9c · c62ff9c
1 parent 21e6c36
commit c62ff9c
Show file tree

Hide file tree

Showing 5 changed files with 107 additions and 35 deletions.
diff --git a/bin/index.js b/bin/index.js
@@ -3,6 +3,7 @@
 const fs = require('fs')
 const minimist = require('minimist')
 const glob = require('glob')
+const gitignore = require('./ignore')
 const { readRc, runWithConfig, report } = require('../')
 
 const helpMessage = `
@@ -24,7 +25,11 @@ Config arguments:
     .zhlintrc by default
 
   --ignore <filepath>
+  --file-ignore <filepath>
     .zhlintignore by default
+  
+  --case-ignore <filepath>
+    .zhlintcaseignore by default
 
   --dir    <path>
     current directory by default
@@ -69,11 +74,14 @@ const main = () => {
     const [filePattern] = [...argv._]
     const configDir = argv.dir
     const configPath = argv.config
-    const ignorePath = argv.ignore
-    const config = readRc(configDir, configPath, ignorePath)
+    const fileIgnorePath = argv.ignore || argv['file-ignore']
+    const caseIgnorePath = argv['case-ignore']
+    const config = readRc(configDir, configPath, fileIgnorePath, caseIgnorePath)
+    const fileIgnore = gitignore().add(config.fileIgnores)
+    const fileIgnoreFilter = fileIgnore.createFilter()
     try {
       const files = glob.sync(filePattern)
-      const resultList = files.map((file) => {
+      const resultList = files.filter(fileIgnoreFilter).map((file) => {
         console.log(`[start] ${file}`)
         const origin = fs.readFileSync(file, { encoding: 'utf8' })
         const { result, validations } = runWithConfig(origin, config)

diff --git a/package.json b/package.json
@@ -79,6 +79,7 @@
   "dependencies": {
     "chalk": "^4.0.0",
     "glob": "^7.1.6",
+    "ignore": "^5.3.0",
     "minimist": "^1.2.0",
     "node-stdlib-browser": "^1.2.0",
     "remark-frontmatter": "^1.3.2",

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/src/options.ts b/src/options.ts
@@ -157,8 +157,8 @@ export const normalizeConfig = (
   })
 
   // ignored cases
-  if (config.ignores) {
-    config.ignores.forEach((x) => {
+  if (config.caseIgnores) {
+    config.caseIgnores.forEach((x) => {
       const ignoredCase = parseIngoredCase(x)
       if (ignoredCase) {
         options.ignoredCases.push(ignoredCase)

diff --git a/src/rc/index.ts b/src/rc/index.ts
@@ -7,48 +7,69 @@ import { env } from '../report'
 
 type PathResult = {
   config: string | undefined
-  ignore: string | undefined
+  fileIgnore: string | undefined
+  caseIgnore: string | undefined
 }
 
+const DEFAULT_CONFIG_PATH = '.zhlintrc'
+const DEFAULT_FILE_IGNORE_PATH = '.zhlintignore'
+const DEFAULT_CASE_IGNORE_PATH = '.zhlintignore'
+
 const resolvePath = (
   dir: string,
   config: string,
-  ignore: string,
+  fileIgnore: string,
+  caseIgnore: string,
   logger: Console = env.defaultLogger
 ): PathResult => {
   const result: PathResult = {
     config: undefined,
-    ignore: undefined
+    fileIgnore: undefined,
+    caseIgnore: undefined,
   }
+
   dir = resolve(dir ?? '.')
   if (!existsSync(dir)) {
     logger.log(`"${dir}" does not exist.`)
     return result
   }
-  config = resolve(dir, config ?? '.zhlintrc')
+
+  config = resolve(dir, config ?? DEFAULT_CONFIG_PATH)
   if (existsSync(config)) {
     result.config = config
   } else {
     logger.log(
       `Config file "${config}" does not exist. Will proceed as default.`
     )
   }
-  ignore = resolve(dir, ignore ?? '.zhlintignore')
-  if (existsSync(ignore)) {
-    result.ignore = ignore
+
+  fileIgnore = resolve(dir, fileIgnore ?? DEFAULT_FILE_IGNORE_PATH)
+  if (existsSync(fileIgnore)) {
+    result.fileIgnore = fileIgnore
   } else {
     logger.log(
-      `Global ignored cases file "${ignore}" does not exist. Will proceed as none.`
+      `Global ignored cases file "${fileIgnore}" does not exist. Will proceed as none.`
     )
   }
+
+  caseIgnore = resolve(dir, caseIgnore ?? DEFAULT_CASE_IGNORE_PATH)
+  if (existsSync(caseIgnore)) {
+    result.caseIgnore = caseIgnore
+  } else {
+    logger.log(
+      `Global ignored cases file "${caseIgnore}" does not exist. Will proceed as none.`
+    )
+  }
+
   return result
 }
 
 export type Config = {
   preset?: string
   rules?: Options['rules']
   hyperParsers?: string[]
-  ignores?: string[]
+  fileIgnores?: string[]
+  caseIgnores?: string[]
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -59,15 +80,17 @@ const readJSONSync = (filepath: string): any => {
 
 const resolveConfig = (
   normalizedConfigPath: string | undefined,
-  normalizedIgnorePath: string | undefined,
+  normalizedFileIgnorePath: string | undefined,
+  normalizedCaseIgnorePath: string | undefined,
   logger: Console = env.defaultLogger
 ): Config => {
   const result: Config = {
     preset: 'default'
   }
+
   if (normalizedConfigPath) {
     try {
-      const config: Config = readJSONSync(normalizedConfigPath)
+      const config = readJSONSync(normalizedConfigPath) as Config
       if (typeof config.preset === 'string') {
         result.preset = config.preset
       }
@@ -77,48 +100,86 @@ const resolveConfig = (
       if (Array.isArray(config.hyperParsers)) {
         result.hyperParsers = config.hyperParsers
       }
-      if (Array.isArray(config.ignores)) {
-        result.ignores = config.ignores
+      if (Array.isArray(config.fileIgnores)) {
+        result.fileIgnores = config.fileIgnores
+      }
+      if (Array.isArray(config.caseIgnores)) {
+        result.caseIgnores = config.caseIgnores
       }
     } catch (error) {
       logger.log(
         `Failed to read "${normalizedConfigPath}": ${(error as Error).message}`
       )
     }
   }
-  if (normalizedIgnorePath) {
+
+  if (normalizedFileIgnorePath) {
+    try {
+      const fileIgnores = readFileSync(normalizedFileIgnorePath, { encoding: 'utf8' })
+      fileIgnores
+        .split(/\n/)
+        .map((x) => x.trim())
+        .forEach((x) => {
+          if (!x) {
+            return
+          }
+          if (!result.fileIgnores) {
+            result.fileIgnores = []
+          }
+          if (result.fileIgnores.indexOf(x) === -1) {
+            result.fileIgnores.push(x)
+          }
+        })
+    } catch (error) {
+      logger.log(
+        `Failed to read "${normalizedFileIgnorePath}": ${(error as Error).message}`
+      )
+    }
+  }
+
+  if (normalizedCaseIgnorePath) {
     try {
-      const ignores = readFileSync(normalizedIgnorePath, { encoding: 'utf8' })
-      ignores
+      const caseIgnores = readFileSync(normalizedCaseIgnorePath, { encoding: 'utf8' })
+      caseIgnores
         .split(/\n/)
         .map((x) => x.trim())
         .forEach((x) => {
           if (!x) {
             return
           }
-          if (!result.ignores) {
-            result.ignores = []
+          if (!result.caseIgnores) {
+            result.caseIgnores = []
           }
-          if (result.ignores.indexOf(x) === -1) {
-            result.ignores.push(x)
+          if (result.caseIgnores.indexOf(x) === -1) {
+            result.caseIgnores.push(x)
           }
         })
     } catch (error) {
       logger.log(
-        `Failed to read "${normalizedIgnorePath}": ${(error as Error).message}`
+        `Failed to read "${normalizedCaseIgnorePath}": ${(error as Error).message}`
       )
     }
   }
+
   return result
 }
 
 export const readRc = (
   dir: string,
   config: string,
-  ignore: string,
+  fileIgnore: string,
+  caseIgnore: string,
   logger: Console = env.defaultLogger
 ): Config => {
-  const { config: normalizedConfigPath, ignore: normalizedIgnorePath } =
-    resolvePath(dir, config, ignore, logger)
-  return resolveConfig(normalizedConfigPath, normalizedIgnorePath, logger)
+  const {
+    config: normalizedConfigPath,
+    fileIgnore: normalizedFileIgnorePath,
+    caseIgnore: normalizedCaseIgnorePath
+  } = resolvePath(dir, config, fileIgnore, caseIgnore, logger)
+  return resolveConfig(
+    normalizedConfigPath,
+    normalizedFileIgnorePath,
+    normalizedCaseIgnorePath,
+    logger
+  )
 }