chore: add cosmiconfig as config provider

package.json

@@ -182,6 +182,7 @@
   },
   "dependencies": {
     "convert-array-to-csv": "^2.0.0",
+    "cosmiconfig": "^9.0.0",
     "lightning-flow-scanner-core": "4.45.0",
     "tabulator-tables": "^6.3.1",
     "uuid": "^11.0.5",

src/commands/handlers.ts

@@ -9,6 +9,8 @@ import { CacheProvider } from '../providers/cache-provider';
 import { testdata } from '../store/testdata';
 import { OutputChannel } from '../providers/outputChannel';
 
+const { USE_NEW_CONFIG: isUseNewConfig } = process.env;
+
 export default class Commands {
   constructor(private context: vscode.ExtensionContext) {}
 
@@ -30,6 +32,10 @@ export default class Commands {
   }
 
   private async configRules() {
+    if (isUseNewConfig) {
+      await this.ruleConfiguration();
+      return;
+    }
     const allRules: core.IRuleDefinition[] = [
       ...core.getBetaRules(),
       ...core.getRules(),
@@ -94,6 +100,8 @@ export default class Commands {
     );
   }
 
+  private async ruleConfiguration() {}
+
   private async debugView() {
     let results = testdata as unknown as core.ScanResult[];
     await CacheProvider.instance.set('results', results);

src/providers/config-provider.ts

@@ -0,0 +1,28 @@
+import { cosmiconfig, CosmiconfigResult } from 'cosmiconfig';
+import { IRulesConfig } from 'lightning-flow-scanner-core';
+
+export class ConfigProvider {
+  public async loadConfig(configPath?: string): Promise<IRulesConfig> {
+    const moduleName = 'flow-scanner';
+    const searchPlaces = [
+      'package.json',
+      `.${moduleName}.yaml`,
+      `.${moduleName}.yml`,
+      `.${moduleName}.json`,
+      `config/.${moduleName}.yaml`,
+      `config/.${moduleName}.yml`,
+      `.flow-scanner`,
+    ];
+    const explorer = cosmiconfig(moduleName, {
+      searchPlaces,
+    });
+    let explorerResults: CosmiconfigResult;
+    if (configPath) {
+      // Forced config file name
+      explorerResults = await explorer.load(configPath);
+    }
+    // Let cosmiconfig look for a config file
+    explorerResults = explorerResults ?? (await explorer.search());
+    return explorerResults?.config ?? {};
+  }
+}

tests/commands/handlers.spec.ts

@@ -52,19 +52,25 @@ describe('Commands', () => {
       CacheProvider.instance = instanceMock as any;
 
       const outputMock = { logChannel: { debug: jest.fn() } };
-      const outputSpy = jest.spyOn(OutputChannel, 'getInstance'); //.getInstance = outputMock as any;
+      const outputSpy = jest.spyOn(OutputChannel, 'getInstance');
       outputSpy.mockReturnValue(outputMock as any);
 
       const extensionContext = jest.fn();
       const command = new cmd.default(
         extensionContext as unknown as ExtensionContext
       );
 
-      await command['configRules']();
+      await expect(async () => await command['configRules']()).not.toThrow();
     });
 
-    it('should read from configuration', async () => {});
+    it('should read from configuration', async () => {
+      const command = new cmd.default({} as any);
+      await expect(command['ruleConfiguration']()).resolves.not.toThrow();
+    });
 
-    it('should write to configuration', async () => {});
+    it('should write to configuration', async () => {
+      const command = new cmd.default({} as any);
+      await expect(command['ruleConfiguration']()).resolves.not.toThrow();
+    });
   });
 });

tests/providers/config-provider.spec.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, jest } from '@jest/globals';
+
+import { ConfigProvider } from '../../src/providers/config-provider';
+import * as cosmi from 'cosmiconfig';
+
+jest.mock('cosmiconfig');
+
+describe('Config-Provider', () => {
+  it('should be defined', () => {
+    expect(ConfigProvider).toBeDefined();
+  });
+
+  it('should not error when no config', async () => {
+    const cosmiMock = {
+      load: jest.fn(),
+      search: jest.fn(),
+    };
+    const cosmiSpy = jest.spyOn(cosmi, 'cosmiconfig');
+    cosmiSpy.mockReturnValue(cosmiMock as any);
+
+    const configProvider = new ConfigProvider();
+    await expect(configProvider.loadConfig()).resolves.toStrictEqual({});
+  });
+
+  it('should load config when directly passed from settings', async () => {
+    const cosmiMock = {
+      load: jest.fn().mockImplementation(() => ({
+        config: {
+          rules: {
+            FlowName: {
+              severity: 'error',
+            },
+          },
+          exceptions: {},
+        },
+        filepath: '',
+      })),
+      search: jest.fn(),
+    };
+    const cosmiSpy = jest.spyOn(cosmi, 'cosmiconfig');
+    cosmiSpy.mockReturnValue(cosmiMock as any);
+
+    const configProvider = new ConfigProvider();
+    await expect(
+      configProvider.loadConfig('some config')
+    ).resolves.toStrictEqual({
+      rules: {
+        FlowName: {
+          severity: 'error',
+        },
+      },
+      exceptions: {},
+    });
+    expect(cosmiMock.search).not.toHaveBeenCalled();
+  });
+
+  it('should resolve a config via workspace directory', async () => {
+    const cosmiMock = {
+      load: jest.fn(),
+      search: jest.fn().mockImplementation(() => ({
+        config: {
+          rules: {
+            APIVersion: {
+              severity: 'error',
+            },
+          },
+          exceptions: {},
+        },
+        filepath: '',
+      })),
+    };
+    const cosmiSpy = jest.spyOn(cosmi, 'cosmiconfig');
+    cosmiSpy.mockReturnValue(cosmiMock as any);
+
+    const configProvider = new ConfigProvider();
+    await expect(configProvider.loadConfig()).resolves.toStrictEqual({
+      rules: {
+        APIVersion: {
+          severity: 'error',
+        },
+      },
+      exceptions: {},
+    });
+    expect(cosmiMock.load).not.toHaveBeenCalled();
+  });
+});