chore: add granular config file parsing for each module

Different modules require different data, so having single function to
parse all seems to overhead. Moreover we need to keep track of custom
typedefs provided in configuration for formatter.

So now this logic is splitted - we have 2 parsing function: for
variables and formatter. Each function run before this module starts:
parse variables before debug session starts and parse formatter part
when formatting is requested.

This can add some overhead, but the only thing that vscode API gives is
to track *all* file changes events and of course such thing will affect
everyone even if we just add some kind of 'dirty' flag.

Author: ashenBlade

src/extension.ts

@@ -421,7 +421,28 @@ class ConfigFile {
     formatter?: PgindentConfiguration;
 }
 
-function parseConfigurationFile(configFile: any): ConfigFile | undefined {
+export function parseFormatterConfiguration(configFile: any): PgindentConfiguration | undefined {
+    const parseTypedefs = (obj: any): string[] | undefined => {
+        if (!obj) {
+            return;
+        }
+
+        if (typeof obj === 'string') {
+            return [obj.trim()];
+        } else if (Array.isArray(obj)) {
+            return obj.map(x => x.toString());
+        }
+    }
+    const typedefs = parseTypedefs(configFile.typedefs);
+
+    if (typedefs?.length) {
+        return {
+            typedefs,
+        }
+    }
+}
+
+function parseVariablesConfiguration(configFile: any): VariablesConfiguration | undefined {
     const parseArrayMember = (obj: any): vars.ArraySpecialMemberInfo | undefined => {
         if (!(obj && typeof obj === 'object' && obj !== null)) {
             return;
@@ -519,18 +540,6 @@ function parseConfigurationFile(configFile: any): ConfigFile | undefined {
         }
     }
 
-    const parseTypedefs = (obj: any): string[] | undefined => {
-        if (!obj) {
-            return;
-        }
-
-        if (typeof obj === 'string') {
-            return [obj.trim()];
-        } else if (Array.isArray(obj)) {
-            return obj.map(x => x.toString());
-        }
-    }
-    
     const normalizeFuncName = (name: string) => {
         /*
          * Earlier extension versions used solib prefix in function name
@@ -832,16 +841,14 @@ function parseConfigurationFile(configFile: any): ConfigFile | undefined {
     const htabTypes = parseHtabTypes(configFile.htab);
     const simpleHashTableTypes = parseSimplehashTypes(configFile.simplehash);   
     const bitmaskEnumMembers = parseEnumBitmasks(configFile.enums);
-    const typedefs = parseTypedefs(configFile.typedefs);
 
-    let variables = undefined;
     if (   arrayInfos?.length
         || aliasInfos?.length
         || customListTypes?.length
         || htabTypes?.length
         || simpleHashTableTypes?.length
         || bitmaskEnumMembers?.length) {
-        variables = {
+        return {
             arrayInfos,
             aliasInfos,
             customListTypes,
@@ -850,17 +857,6 @@ function parseConfigurationFile(configFile: any): ConfigFile | undefined {
             bitmaskEnumMembers,
         }
     }
-    let formatter = undefined;
-    if (typedefs?.length) {
-        formatter = {
-            typedefs,
-        }
-    }
-
-    return {
-        variables,
-        formatter,
-    }
 }
 
 async function promptWorkspace() {
@@ -1129,6 +1125,41 @@ async function bootstrapExtensionCommand() {
     await vscode.window.showTextDocument(td);
 }
 
+export async function readConfigFile(workspace: vscode.WorkspaceFolder,
+                                     logger: utils.ILogger) {
+    const path = Configuration.getConfigFile(workspace.uri);
+    let document;
+    try {
+        document = await vscode.workspace.openTextDocument(path);
+    } catch (err: any) {
+        /* the file might not exist, this is ok */
+        return;
+    }
+
+    let text;
+    try {
+        text = document.getText();
+    } catch (err: any) {
+        logger.error('could not read settings file %s', document.uri.fsPath, err);
+        return;
+    }
+
+    if (text.length === 0) {
+        /* JSON file can be used as activation event */
+        return;
+    }
+
+    let data;
+    try {
+        data = JSON.parse(text);
+    } catch (err: any) {
+        logger.error('could not parse JSON settings file %s', document.uri.fsPath, err);
+        return;
+    }
+    
+    return data;
+}
+
 export function setupExtension(context: vscode.ExtensionContext,
                                nodeVars: vars.NodeVarRegistry,  logger: utils.ILogger,
                                nodesView: NodePreviewTreeViewProvider) {
@@ -1138,61 +1169,22 @@ export function setupExtension(context: vscode.ExtensionContext,
         context.subscriptions.push(disposable);
     }
 
-    const processSingleConfigFile = async (pathToFile: vscode.Uri) => {
-        let doc = undefined;
-        try {
-            doc = await vscode.workspace.openTextDocument(pathToFile);
-        } catch (err: any) {
-            logger.error('failed to read settings file %s', pathToFile, err);
+    const refreshWorkspaceConfiguration = async (workspace: vscode.WorkspaceFolder) => {
+        const config = await readConfigFile(workspace, logger);
+        if (!config) {
             return;
         }
 
-        let text;
-        try {
-            text = doc.getText();
-        } catch (err: any) {
-            logger.error('failed to read settings file %s', doc.uri.fsPath, err);
-            return;
-        }
-
-        if (text.length === 0) {
-            /* JSON file can be used as activation event */
-            logger.debug('JSON settings file %s is empty', doc.uri.fsPath);
-            return;
-        }
-
-        let data;
-        try {
-            data = JSON.parse(text);
-        } catch (err: any) {
-            logger.error('failed to parse JSON settings file %s', doc.uri.fsPath, err);
-            return;
-        }
-
-        let parsedConfigFile: ConfigFile | undefined;
-        try {
-            parsedConfigFile = parseConfigurationFile(data);
-        } catch (err: any) {
-            logger.error('failed to parse JSON settings file %s', doc.uri.fsPath, err);
-            return;
-        }
-        
-        if (parsedConfigFile?.variables) {
-            nodesView.configFile = parsedConfigFile.variables;
-        }
-
-        if (parsedConfigFile?.formatter) {
-            FormatterConfiguration.typedefs = parsedConfigFile.formatter.typedefs;
-        }
+        let parsedConfigFile = parseVariablesConfiguration(config);
+        nodesView.configFile = parsedConfigFile;
     }
-
+    
     const refreshConfigurationFromFolders = async (folders: readonly vscode.WorkspaceFolder[]) => {
         for (const folder of folders) {
-            const pathToFile = utils.joinPath(
-                folder.uri, '.vscode', Configuration.ExtensionSettingsFileName);
-
-            if (await utils.fileExists(pathToFile)) {
-                await processSingleConfigFile(pathToFile);
+            try {
+                await refreshWorkspaceConfiguration(folder);
+            } catch (err) {
+                logger.error('could not refresh configuration in workspace %s', folder.uri.fsPath);
             }
         }
     }
@@ -1335,29 +1327,7 @@ export function setupExtension(context: vscode.ExtensionContext,
         }
 
         logger.info('refreshing config file due to command execution');
-        for (const folder of vscode.workspace.workspaceFolders) {
-            const configFilePath = utils.joinPath(
-                folder.uri,
-                '.vscode',
-                Configuration.ExtensionSettingsFileName);
-            if (!await utils.fileExists(configFilePath)) {
-                const answer = await vscode.window.showWarningMessage(
-                    'Config file does not exist. Create?',
-                    'Yes', 'No');
-                if (answer !== 'Yes') {
-                    return;
-                }
-
-                await vscode.commands.executeCommand(Configuration.Commands.OpenConfigFile);
-                return;
-            }
-
-            try {
-                await processSingleConfigFile(configFilePath);
-            } catch (err: any) {
-                logger.error('failed to update config file', err);
-            }
-        }
+        await refreshConfigurationFromFolders(vscode.workspace.workspaceFolders);
     };
 
     const refreshVariablesCmd = () => {
@@ -1544,6 +1514,10 @@ export class Configuration {
         NodePreviewTreeView: `${this.ExtensionName}.node-tree-view`,
     };
     static ExtensionSettingsFileName = 'pgsql_hacker_helper.json';
+    
+    static getConfigFile(workspace: vscode.Uri) {
+        return vscode.Uri.joinPath(workspace, '.vscode', this.ExtensionSettingsFileName);
+    }
 
     static getLogLevel() {
         return this.getConfig<string>(this.ConfigSections.LogLevel);

src/formatter.ts

@@ -1,7 +1,7 @@
 import * as vscode from 'vscode';
 import {languages} from 'vscode';
 import * as utils from './utils';
-import { Configuration } from './extension';
+import { Configuration, parseFormatterConfiguration, readConfigFile } from './extension';
 import { PghhError } from './error';
 import * as path from 'path';
 import * as os from 'os';
@@ -260,21 +260,31 @@ class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEdit
         await utils.writeFile(typedefsFile, content);
     }
 
-    private async getListOfTypedefs(workspace: vscode.WorkspaceFolder) {
-        const files = FormatterConfiguration.typedefs;
-        if (!files?.length) {
-            return '';
+    private async getCustomTypedefs(workspace: vscode.WorkspaceFolder) {
+        const configObj = await readConfigFile(workspace, this.logger);
+        if (!configObj) {
+            return [];
+        }
+
+        const config = parseFormatterConfiguration(configObj);
+        if (!config?.typedefs?.length) {
+            return [];
         }
 
+        /*
+         * pgindent accepts multiple --typedefs=s arguments. There is
+         * another argument `--list-of-typedefs` - this is content of
+         * a file itself and we do not use it.
+         */
         const typedefs = [];
-        for (const f of files) {
+        for (const t of config.typedefs) {
             let typedefFile;
-            if (path.isAbsolute(f)) {
-                typedefFile = vscode.Uri.file(f);
+            if (path.isAbsolute(t)) {
+                typedefFile = vscode.Uri.file(t);
             } else {
-                typedefFile = utils.getWorkspacePgSrcFile(workspace.uri, f);
+                typedefFile = utils.getWorkspacePgSrcFile(workspace.uri, t);
             }
-            
+
             if (!await utils.fileExists(typedefFile)) {
                 this.logger.warn('could not find file %s', typedefFile);
                 continue;
@@ -325,7 +335,7 @@ class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEdit
                                       pg_bsd_indent: vscode.Uri,
                                       pgindent: vscode.Uri,
                                       workspace: vscode.WorkspaceFolder) {
-        const typedefs = await this.getListOfTypedefs(workspace);
+        const typedefs = await this.getCustomTypedefs(workspace);
 
         /* Work in pgindent dir, so it can find default typedefs.list */
         const cwd = path.resolve(pgindent.fsPath, '..');
@@ -425,43 +435,6 @@ class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEdit
         }
     }
 
-    private async getDefaultTypedefs(workspace: vscode.WorkspaceFolder) {
-        /* 
-         * Newer pg versions have 'src/tools/pgindent/typedefs.list' already
-         * present in repository, so just read it. But older versions does not
-         * have it installed, so we must download it manually.
-         * 
-         * NOTE: extension's supported pg versions start from 9.6 which have
-         *       it installed - logic for downloading it is not tested, so I
-         *       expect that it is working (tested only once, manually on my PC)
-         */
-        const typedefsFile = utils.getWorkspacePgSrcFile(
-                    workspace.uri, 'src', 'tools', 'pgindent', 'typedefs.list');
-        if (await utils.fileExists(typedefsFile)) {
-            this.logger.info('found default typedefs.list in %s', typedefsFile.fsPath);
-            return await utils.readFile(typedefsFile);
-        }
-
-        /* Version is not known, so just download latest */
-        const url = 'https://buildfarm.postgresql.org/cgi-bin/typedefs.pl';
-        this.logger.info('downloading typedefs file from %s', url);
-        let content;
-        try {
-            content = await utils.downloadFile(url);
-        } catch (err) {
-            throw new Error(`failed to download typedefs: ${err}`);
-        }
-
-        this.logger.info('saving typedefs.list to file %s', typedefsFile.fsPath);
-        try {
-            await utils.writeFile(typedefsFile, content);
-        } catch (err) {
-            throw new Error(`could not save typedef file: ${err}`);
-        }
-
-        return content;
-    }
-    
     private getWholeDocumentRange(document: vscode.TextDocument) {
         const start = new vscode.Position(0, 0);
         const lastLine = document.lineAt(document.lineCount - 1);