Refine Diagnostic Filters and adds human-readable diagnostic names

docs/bsconfig.md

@@ -70,22 +70,44 @@ If `true`, after a successful build, the project will be deployed to the Roku sp
 
 ## `diagnosticFilters`
 
-Type: `Array<string | number | {src: string; codes: number[]}`
+Type: `Array<string | number | {files: string | Array<string | {src: string} | {dest: string}>; codes?: Array<number | string>}`
 
 A list of filters used to hide diagnostics.
 
-- A `string` value should be a relative-to-root-dir or absolute file path or glob pattern of the files that should be excluded. Any file matching this pattern will have all diagnostics supressed. These file paths refer to the location of the source files pre-compilation and are relative to [`rootDir`](#rootdir). Absolute file paths may be used as well.
-    - A file glob may be prefixed with `!` to make it a negative pattern which "un-ignores" the files it matches. (See examples below).
-- A `number` value should be a diagnostic code. This will supress all diagnostics with that code for the whole project.
-- An object can also be provided to filter specific diagnostic codes for a file pattern. For example,
+- A `string` value should be a diagnostic code, or diagnostic shortname. This will supress all diagnostics with that code for the whole project. For example,
+    ```jsonc
+    "diagnosticFilters": [
+        "1000", 
+        "1011",
+        "BS1001"
+        "mismatch-argument-count"
+    ]
+    ```
+
+- A `number` value is treated as if it were a string, and matches all diagnostic codes that are the string representation of that number. For example, an entry of  `1234` would suppress any diagnostic with code `'1234'`.
+ - An object can also be provided to filter specific diagnostic codes for a file pattern. If no `files` property is included, any diagnostic that matches the values in the `codes` will b e suppressed. If a `string` if given for the `files` property, it is treated as a relative-to-root-dir or absolute file path or glob pattern of the files that should be excluded. These file paths refer to the location of the source files pre-compilation and are relative to [`rootDir`](#rootdir). Absolute file paths may be used as well. For example,
+
+    ```jsonc
+    "diagnosticFilters": [{
+        "files": "vendor/**/*",
+        "codes": ["1000", "1011"] //ignore these specific codes from vendor libraries
+    }]
+    ```
+- If an object is provided, the `files` property could also be an array, providing either a series of globs, or a specific set of files that match _either_ their `src` or `dest` paths. For example,
 
     ```jsonc
     "diagnosticFilters": [{
-        "src": "vendor/**/*",
-        "codes": [1000, 1011] //ignore these specific codes from vendor libraries
+        "files": [
+            "vendor/**/*", // all vendor files will be suppressed
+            { "src": "themes/theme1/**/*"}, // all files coming from `themes/theme1/` will be suppressed
+            { "dest": "source/common/**/*"}, // all files then will be placed in from `source/common/` will be suppressed
+        ]
+        "codes": ["1000", "1011"] //ignore these specific codes 
     }]
     ```
 
+- A file glob may be prefixed with `!` to make it a negative pattern which "un-ignores" the files it matches. (See examples below).
+
 Defaults to `undefined`.
 
 If a child bsconfig extends from a parent bsconfig, and both bsconfigs specify `diagnosticFilters`, the parent bsconfig's `diagnosticFilters` field will be completely overwritten.
@@ -96,17 +118,17 @@ A negative pattern can be used to un-ignore some files or codes which were previ
 
 ```jsonc
 "diagnosticFilters": [
-    { "src": "vendor/**/*" }, //ignore all codes from vendor libraries
-    { "src": "!vendor/unreliable/**/*" } //EXCEPT do show errors from this one specific library
+    { "files": "vendor/**/*" }, //ignore all codes from vendor libraries
+    { "files": "!vendor/unreliable/**/*" } //EXCEPT do show errors from this one specific library
 ]
 ```
 
 A specific error code can be unignored in multiple places by using a pattern which matches everything under `rootDir`. For example,
 
 ```jsonc
 "diagnosticFilters": [
-    { "src": "vendor/**/*" }, //ignore all errors from vendor libraries
-    { "src": "!*/**/*", "codes": [1000] } //EXCEPT do show this particular code everywhere
+    { "files": "vendor/**/*" }, //ignore all errors from vendor libraries
+    { "files": "!*/**/*", "codes": [1000] } //EXCEPT do show this particular code everywhere
 ]
 ```
 

src/BsConfig.ts

@@ -128,7 +128,7 @@ export interface BsConfig {
     /**
      * A list of filters used to exclude diagnostics from the output
      */
-    diagnosticFilters?: Array<number | string | { src: string; codes: (number | string)[] } | { src: string } | { codes: (number | string)[] }>;
+    diagnosticFilters?: Array<string | number | { files?: string | Array<string | { src: string } | { dest: string }>; codes?: Array<number | string> }>;
 
     /**
      * Specify what diagnostic types should be printed to the console. Defaults to 'warn'

src/DiagnosticFilterer.spec.ts

@@ -12,14 +12,15 @@ describe('DiagnosticFilterer', () => {
     let options = {
         rootDir: rootDir,
         diagnosticFilters: [
+            'codename',
             //ignore these codes globally
             { codes: [1, 2, 3, 'X4'] },
             //ignore all codes from lib
-            { src: 'lib/**/*.brs' },
+            { files: 'lib/**/*.brs' },
             //ignore all codes from `packages` with absolute path
-            { src: `${rootDir}/packages/**/*.brs` },
+            { files: `${rootDir}/packages/**/*.brs` },
             //ignore specific codes for main.brs
-            { src: 'source/main.brs', codes: [4] }
+            { files: 'source/main.brs', codes: [4] }
         ]
     };
 
@@ -86,24 +87,34 @@ describe('DiagnosticFilterer', () => {
             ).to.eql([11, 12, 13, 'X14']);
         });
 
+
+        it('works with single file src glob', () => {
+            expect(
+                filterer.filter(options, [
+                    getDiagnostic('codename', `${rootDir}/source/main.brs`) //remove
+                ]).map(x => x.code)
+            ).to.eql([]);
+        });
+
         describe('with negative globs', () => {
             let optionsWithNegatives = {
                 rootDir: rootDir,
                 diagnosticFilters: [
                     //ignore these codes globally
-                    { codes: [1, 2] },
+                    { codes: [1, 2, 'codename'] },
                     3,
                     4,
+                    'codename',
                     //ignore all codes from lib
-                    { src: 'lib/**/*.brs' },
+                    { files: 'lib/**/*.brs' },
                     //un-ignore specific errors from lib/special
-                    { src: '!lib/special/**/*.brs', codes: [1, 2, 3] },
+                    { files: '!lib/special/**/*.brs', codes: [1, 2, 3, 'codename'] },
                     //re-ignore errors from one extra special file
-                    { src: 'lib/special/all-reignored.brs' },
+                    { files: 'lib/special/all-reignored.brs' },
                     //un-ignore all codes from third special file
-                    { src: '!lib/special/all-unignored.brs' },
+                    { files: '!lib/special/all-unignored.brs' },
                     //un-ignore code 5 globally
-                    { src: '!*/**/*', codes: [5] },
+                    { files: '!*/**/*', codes: [5] },
                     //re-ignore code 10 globally, overriding previous unignores
                     { codes: [10] }
                 ]
@@ -180,15 +191,15 @@ describe('DiagnosticFilterer', () => {
         it('handles standard diagnostic filters', () => {
             expect(
                 filterer.getDiagnosticFilters({
-                    diagnosticFilters: [{ src: 'file.brs', codes: [1, 2, 'X3'] }]
+                    diagnosticFilters: [{ files: 'file.brs', codes: [1, 2, 'X3'] }]
                 })
             ).to.eql([{ src: 'file.brs', codes: [1, 2, 'X3'], isNegative: false }]);
         });
 
         it('handles string-only diagnostic filter object', () => {
             expect(
                 filterer.getDiagnosticFilters({
-                    diagnosticFilters: [{ src: 'file.brs' }]
+                    diagnosticFilters: [{ files: 'file.brs' }]
                 })
             ).to.eql([{ src: 'file.brs', isNegative: false }]);
         });
@@ -204,9 +215,9 @@ describe('DiagnosticFilterer', () => {
         it('handles string diagnostic filter', () => {
             expect(
                 filterer.getDiagnosticFilters({
-                    diagnosticFilters: ['file.brs']
+                    diagnosticFilters: ['cannot-find-name']
                 })
-            ).to.eql([{ src: 'file.brs', isNegative: false }]);
+            ).to.eql([{ codes: ['cannot-find-name'], isNegative: false }]);
         });
 
         it('converts ignoreErrorCodes to diagnosticFilters', () => {
@@ -217,19 +228,11 @@ describe('DiagnosticFilterer', () => {
             ]);
         });
 
-        it('handles negative globs in bare strings', () => {
-            expect(filterer.getDiagnosticFilters({
-                diagnosticFilters: ['!file.brs']
-            })).to.eql([
-                { src: 'file.brs', isNegative: true }
-            ]);
-        });
-
         it('handles negative globs in objects', () => {
             expect(filterer.getDiagnosticFilters({
                 diagnosticFilters: [
                     {
-                        src: '!file.brs'
+                        files: '!file.brs'
                     }
                 ]
             })).to.eql([
@@ -241,7 +244,7 @@ describe('DiagnosticFilterer', () => {
             expect(filterer.getDiagnosticFilters({
                 diagnosticFilters: [
                     {
-                        src: '!file.brs',
+                        files: '!file.brs',
                         codes: [1, 2, 3]
                     }
                 ]
@@ -251,6 +254,49 @@ describe('DiagnosticFilterer', () => {
         });
     });
 
+    describe('filtering by dest', () => {
+        it('will filter by a files destPath', () => {
+            const resultDiagnostics = filterer.filter({
+                rootDir: rootDir,
+                diagnosticFilters: [
+                    {
+                        files: [
+                            { dest: 'source/remove/**/*.*' }
+                        ],
+                        codes: ['diagCode']
+                    }
+                ]
+            }, [
+                getDiagnostic('diagCode', `${rootDir}/source/common.brs`), //keep
+                getDiagnostic('diagCode', `${rootDir}/source/utils.brs`, `${rootDir}/source/remove/utils.brs`), //remove
+                getDiagnostic('diagCode', `${rootDir}/components/utils.brs`, `${rootDir}/source/remove/utils2.brs`) //remove
+            ]);
+            expect(resultDiagnostics.map(x => x.code)).to.eql(['diagCode']);
+            expect(resultDiagnostics.map(x => x.file.srcPath)).to.eql([s`${rootDir}/source/common.brs`]);
+        });
+
+        it('respects order of ignores with negative globs', () => {
+            const resultDiagnostics = filterer.filter({
+                rootDir: rootDir,
+                diagnosticFilters: [{
+                    files: [
+                        { dest: 'source/**/*.*' } //ignore diagCode in files with destPath in /source/remove
+                    ],
+                    codes: ['diagCode']
+                }, {
+                    files: '!**/*.*', //unignore diagCode everywhere
+                    codes: ['diagCode']
+                }
+                ]
+            }, [
+                getDiagnostic('diagCode', `${rootDir}/source/common.brs`), //keep
+                getDiagnostic('diagCode', `${rootDir}/source/utils.brs`, `${rootDir}/source/remove/utils.brs`), //remove
+                getDiagnostic('diagCode', `${rootDir}/components/utils.brs`, `${rootDir}/source/remove/utils2.brs`) //remove
+            ]);
+            expect(resultDiagnostics.map(x => x.code)).to.eql(['diagCode', 'diagCode', 'diagCode']);
+        });
+    });
+
     it('only filters by file once per unique file (case-insensitive)', () => {
         const stub = sinon.stub(filterer as any, 'filterFile').returns(null);
         filterer.filter(options, [
@@ -259,19 +305,29 @@ describe('DiagnosticFilterer', () => {
             getDiagnostic(3, s`${rootDir}/source/common2.brs`),
             getDiagnostic(4, s`${rootDir}/source/Common2.brs`)
         ]);
-        expect(stub.callCount).to.eql(2);
+        const expectedCallCount = options.diagnosticFilters.reduce((acc, filter) => {
+            if (typeof filter === 'object' && 'files' in (filter as any)) {
+                return acc;
+            }
+            return acc + 1;
+        }, 0);
+        expect(stub.callCount).to.eql(expectedCallCount * 2); // 2 times for 'codename', 2 times for { codes: [1, 2, 3, 'X4'] }
         expect(stub.getCalls().map(x => x.args[1])).to.eql([
+            s`${rootDir.toLowerCase()}/source/common1.brs`,
+            s`${rootDir.toLowerCase()}/source/common2.brs`,
             s`${rootDir.toLowerCase()}/source/common1.brs`,
             s`${rootDir.toLowerCase()}/source/common2.brs`
         ]);
     });
 
 });
 
-function getDiagnostic(code: number | string, srcPath: string) {
+function getDiagnostic(code: number | string, srcPath: string, destPath?: string) {
+    destPath = destPath ?? srcPath;
     return {
         file: {
-            srcPath: s`${srcPath}`
+            srcPath: s`${srcPath}`,
+            destPath: s`${destPath}`
         },
         code: code
     } as BsDiagnostic;