Added logic to filter error messages from results based on disable ne… (#59)

* Added logic to filter error messages from results based on disable next line rule

* Prettier fix

* NIT Fix

Co-authored-by: Vivek Patil <vipati@microsoft.com>

packages/core/src/file-context.ts

@@ -56,10 +56,8 @@ export class FileContext {
 
   get ignoredChecksByLine(): Map<number, string[]> {
     if (this._parsedIgnoreChecksByLine) return this._ignoredChecksByLine;
-
-    this.source.forEachChild(n => {
-      const lineNumber = this.source.getLineAndCharacterOfPosition(n.pos).line;
-      const trimmedNodeText = n.getFullText().trim();
+    this.content.split(/\r?\n/).forEach((n, lineNumber) => {
+      const trimmedNodeText = n.trim();
       let ignoredChecks: string[] = [];
 
       trimmedNodeText.match(/boll-disable-next-line.*/g)?.forEach(line => {
@@ -71,7 +69,9 @@ export class FileContext {
             .forEach(rule => ignoredChecks.push(rule));
         }
       });
-      if (ignoredChecks.length > 0) this._ignoredChecksByLine.set(lineNumber, ignoredChecks);
+
+      if (ignoredChecks.length > 0) this._ignoredChecksByLine.set(lineNumber + 1, ignoredChecks);
+      lineNumber = lineNumber + 1;
     });
 
     this._parsedIgnoreChecksByLine = true;

packages/core/src/suite.ts

@@ -1,11 +1,12 @@
 import fs from "fs";
 import path from "path";
 import { asBollDirectory } from "./boll-directory";
-import { getSourceFile } from "./file-context";
+import { FileContext, getSourceFile } from "./file-context";
 import { Logger } from "./logger";
 import { Package } from "./package";
-import { ResultSet } from "./result-set";
+import { Failure, Result, ResultSet } from "./result-set";
 import { RuleSet } from "./rule-set";
+import { ResultStatus } from "./types";
 import { promisify } from "util";
 const readFileAsync = promisify(fs.readFile);
 
@@ -38,7 +39,8 @@ export class Suite {
       sourceFiles.forEach(async s => {
         if (s.shouldSkip(r)) return;
         const results = await r.check(s);
-        resultSet.add(results);
+        const filterResults = await this.filterIgnoredChecksByLine(results, s);
+        resultSet.add(filterResults);
       });
     });
     return true;
@@ -56,4 +58,24 @@ export class Suite {
       throw e;
     }
   }
+
+  async filterIgnoredChecksByLine(results: Result[], sourceFile: FileContext) {
+    const ignoredChecksByLine = sourceFile.ignoredChecksByLine;
+    const filteredResults: Result[] = [];
+    results.forEach(l => {
+      if (l.status === ResultStatus.failure) {
+        const failure = l as Failure;
+        const skipLineNumber = failure.line - 1;
+        if (
+          !(
+            ignoredChecksByLine.has(skipLineNumber) &&
+            ignoredChecksByLine.get(skipLineNumber)?.includes(failure.ruleName)
+          )
+        ) {
+          filteredResults.push(l);
+        }
+      }
+    });
+    return filteredResults;
+  }
 }

packages/core/src/tests/all.test.ts

@@ -6,5 +6,6 @@ import { test as GitUtilsTest } from "./git-utils.test";
 import { test as GlobTest } from "./glob.test";
 import { test as IgnoreTest } from "./ignore.test";
 import { test as PragmaTest } from "./pragma.test";
+import { test as SuiteTest } from "./suite.test";
 
-suite(ConfigTest, FormatTest, GitUtilsTest, GlobTest, IgnoreTest, PragmaTest);
+suite(ConfigTest, FormatTest, GitUtilsTest, GlobTest, IgnoreTest, PragmaTest, SuiteTest);

packages/core/src/tests/pragma.test.ts

@@ -19,11 +19,11 @@ test("should keep track of multiple disabled rules in a FileContext", async () =
   });
 });
 
-test("should keep track of a disabled next line rules in a FileContext", async () => {
+test("should keep track of a disabled next line rule in a FileContext", async () => {
   await inFixtureDir("standalone-source-files", __dirname, async cwd => {
     const sut = await getSourceFile(cwd, "simple-disable-next-line.ts", new Package({}, {}));
     const expectedResult = new Map();
-    expectedResult.set(1, ["MadeUpCheckName"]);
+    expectedResult.set(3, ["MadeUpCheckName"]);
     assert.deepStrictEqual(sut.ignoredChecksByLine, expectedResult);
   });
 });
@@ -32,8 +32,8 @@ test("should keep track of a disabled next line rules in a FileContext", async (
   await inFixtureDir("standalone-source-files", __dirname, async cwd => {
     const sut = await getSourceFile(cwd, "multiple-disable-next-line.ts", new Package({}, {}));
     const expectedResult = new Map();
-    expectedResult.set(0, ["MadeUpCheckName", "AlsoMadeUpName"]);
-    expectedResult.set(2, ["MadeUpCheckName"]);
+    expectedResult.set(1, ["MadeUpCheckName", "AlsoMadeUpName"]);
+    expectedResult.set(4, ["MadeUpCheckName"]);
     assert.deepStrictEqual(sut.ignoredChecksByLine, expectedResult);
   });
 });

packages/core/src/tests/suite.test.ts

@@ -0,0 +1,57 @@
+import * as assert from "assert";
+import baretest from "baretest";
+import { getSourceFile } from "../file-context";
+import { inFixtureDir } from "@boll/test-internal";
+import { Package } from "../package";
+import { Failure, Result, ResultSet } from "../result-set";
+import { Suite } from "../suite";
+import { asBollLineNumber } from "../boll-line-number";
+export const test: any = baretest("Source detector");
+
+test("should skip a single disabled next line rules in a FileContext", async () => {
+  await inFixtureDir("standalone-source-files", __dirname, async cwd => {
+    const sut = await getSourceFile(cwd, "simple-disable-next-line.ts", new Package({}, {}));
+    const suite = new Suite();
+    const results: Result[] = [];
+    const failure1: Failure = new Failure(
+      "MadeUpCheckName",
+      sut.filename,
+      asBollLineNumber(4),
+      "Failed due to MadeUpCheckName rule"
+    );
+    results.push(failure1);
+    const filteredResult = await suite.filterIgnoredChecksByLine(results, sut);
+    assert.strictEqual(0, filteredResult.length);
+  });
+});
+
+test("should skip a multiple disabled next line rules in a FileContext", async () => {
+  await inFixtureDir("standalone-source-files", __dirname, async cwd => {
+    const sut = await getSourceFile(cwd, "multiple-disable-next-line.ts", new Package({}, {}));
+    const suite = new Suite();
+    const results: Result[] = [];
+    const failure: Failure = new Failure(
+      "MadeUpCheckName",
+      sut.filename,
+      asBollLineNumber(2),
+      "Failed due to MadeUpCheckName rule"
+    );
+    results.push(failure);
+    const failure1: Failure = new Failure(
+      "AlsoMadeUpName",
+      sut.filename,
+      asBollLineNumber(2),
+      "Failed due to MadeUpCheckName rule"
+    );
+    results.push(failure1);
+    const failure2: Failure = new Failure(
+      "MadeUpCheckName",
+      sut.filename,
+      asBollLineNumber(5),
+      "Failed due to MadeUpCheckName rule"
+    );
+    results.push(failure2);
+    const filteredResult = await suite.filterIgnoredChecksByLine(results, sut);
+    assert.strictEqual(0, filteredResult.length);
+  });
+});