minor changes/fixes

Author: codacy-vrhpires

src/convertResults.ts

@@ -1,5 +1,4 @@
 import { ESLint } from "eslint"
-import { flatMap } from "lodash"
 
 import { CodacyResult, LineComplexity } from "./model/codacyResult"
 
@@ -8,21 +7,21 @@ const ComplexityRegex = /.*has a complexity of (\d+).*/
 export function convertResults(eslintResults: ESLint.LintResult[]): CodacyResult[] {
   const convertedResults: CodacyResult[] = []
 
-  eslintResults.forEach((r) => {
-    const filename = r.filePath
+  eslintResults.forEach((result) => {
+    const filename = result.filePath
     const lineComplexities: LineComplexity[] = []
 
-    r.messages
-      .filter((m) => 
-        m.ruleId === "complexity"
-        && m.message?.match(ComplexityRegex)?.length === 2
+    result.messages
+      .filter((message) => 
+        message.ruleId === "complexity"
+        && message.message?.match(ComplexityRegex)?.length === 2
       )
-      .forEach((m) => {
-        const complexityMatch = m.message.match(ComplexityRegex)
+      .forEach((message) => {
+        const complexityMatch = message.message.match(ComplexityRegex)
 
-        if (complexityMatch) {
-          lineComplexities.push(new LineComplexity(m.line, parseInt(complexityMatch[1], 10)))
-        }
+        if (complexityMatch === null) return
+        
+        lineComplexities.push(new LineComplexity(message.line, parseInt(complexityMatch[1], 10)))
       })
 
     const complexity = lineComplexities.reduce((acc, lc) => Math.max(acc, lc.value), 0)

src/eslintDefaultOptions.ts

@@ -21,7 +21,7 @@ export const defaultOptions: ESLint.Options = {
     parserOptions: {
       sourceType: "script",
       allowAutomaticSingleRunInference: true,
-      ecmaVersion: 12,
+      ecmaVersion: 2022,
       errorOnTypeScriptSyntacticAndSemanticIssues: false,
     },
     root: true,

src/fileUtils.ts

@@ -1,11 +1,13 @@
-import { readFile, readdir } from "fs/promises";
-import path from "path";
+import { readFile, readdir } from "fs/promises"
+import path from "path"
 
-import { Codacyrc } from "./model/codacyInput";
+import { Codacyrc } from "./model/codacyInput"
 
 export async function readCodacyrcFile(file: string): Promise<Codacyrc | undefined> {
   try {
-    return parseCodacyrcFile(await readFile(file, { encoding: "utf8" }))
+    const content = await readFile(file, { encoding: 'utf8' })
+
+    return parseCodacyrcFile(content)
   } catch (e) {
     console.error(`Error reading ${file} file`)
     return undefined
@@ -18,11 +20,13 @@ export function parseCodacyrcFile(content: string): Codacyrc {
 
 export async function allFilesNames(dir: string): Promise<string[]> {
   try {
-    return (await readdir(dir, { withFileTypes: true, recursive: true }))
+    const entries = await readdir(dir, { withFileTypes: true, recursive: true })
+
+    return entries
       .filter((entry) => entry.isFile() || entry.isSymbolicLink())
       .map((entry) => path.relative(dir, entry.name))
   } catch (error) {
-    console.error(`Error reading directory ${dir}`);
+    console.error(`Error reading directory ${dir}`)
     return []
   }
 }

src/index.ts

@@ -4,15 +4,16 @@ import { convertResults } from "./convertResults"
 import { createEslintConfig } from "./configCreator"
 import { parseTimeoutSeconds } from "./parseTimeoutSeconds"
 
+const srcDirPath = "/src"
+const timeoutSeconds = parseTimeoutSeconds(process.env.TIMEOUT_SECONDS)
+
 const timeoutHandle = setTimeout(() => {
   console.error("Timeout occurred. Exiting.")
   process.exit(2)
-}, parseTimeoutSeconds(process.env.TIMEOUT_SECONDS) * 1000)
+}, timeoutSeconds * 1000)
 
 async function run() {
-  const srcDirPath = "/src"
   const [options, files] = await createEslintConfig(srcDirPath)
-
   const eslint = new ESLint(options)
   const eslintResults = await eslint.lintFiles(files)
 
@@ -24,8 +25,8 @@ async function run() {
 }
 
 run()
-  .catch(e => {
-    console.error(e)
+  .catch((error) => {
+    console.error(error)
     process.exit(1)
   })
   .finally(() => clearTimeout(timeoutHandle))

src/parseTimeoutSeconds.ts

@@ -1,8 +1,8 @@
 export const defaultTimeout = 15 * 60
 
 export function parseTimeoutSeconds(timeoutString?: string): number {
-  if (!timeoutString) return defaultTimeout
-  const number = parseInt(timeoutString)
-  if (isNaN(number) || number < 0) return defaultTimeout
-  return number
+  return Math.max(
+    (parseInt(timeoutString, 10) || defaultTimeout),
+    0
+  )
 }