Support for global RPGLINT configuration path

extension/client/src/configuration.ts

@@ -6,4 +6,5 @@ export function get<T>(prop: string) {
 }
 
 export const RULER_ENABLED_BY_DEFAULT = `rulerEnabledByDefault`;
+export const GLOBAL_LINT_CONFIG_PATH = `globalLintConfigPath`;
 export const projectFilesGlob = `**/*.{rpgle,RPGLE,sqlrpgle,SQLRPGLE,rpgleinc,RPGLEINC}`;

extension/client/src/extension.ts

@@ -37,14 +37,22 @@ export function activate(context: ExtensionContext) {
 
 	// If the extension is launched in debug mode then the debug server options are used
 	// Otherwise the run options are used
-	const serverOptions: ServerOptions = {
-		run: { module: serverModule, transport: TransportKind.ipc },
-		debug: {
-			module: serverModule,
-			transport: TransportKind.ipc,
-			options: debugOptions
-		}
-	};
+        const globalLintPath = workspace.getConfiguration('vscode-rpgle').get<string>('globalLintConfigPath');
+        const env = { ...process.env } as NodeJS.ProcessEnv;
+        if (globalLintPath) env.GLOBAL_LINT_CONFIG_PATH = globalLintPath;
+
+        const serverOptions: ServerOptions = {
+                run: {
+                        module: serverModule,
+                        transport: TransportKind.ipc,
+                        options: { env }
+                },
+                debug: {
+                        module: serverModule,
+                        transport: TransportKind.ipc,
+                        options: { ...debugOptions, env }
+                }
+        };
 
 	loadBase();
 

extension/client/src/linter.ts

@@ -1,6 +1,7 @@
 import path = require('path');
 import { commands, ExtensionContext, Uri, ViewColumn, window, workspace } from 'vscode';
 import {getInstance} from './base';
+import * as Configuration from './configuration';
 
 import {DEFAULT_SCHEMA} from "./schemas/linter"
 
@@ -46,8 +47,34 @@ export function initialise(context: ExtensionContext) {
 				}
 
 			} else if (instance && instance.getConnection()) {
-				const connection = instance.getConnection();
-				const content = instance.getContent();
+                        const connection = instance.getConnection();
+                        const content = instance.getContent();
+
+                        let globalPath = Configuration.get<string>(Configuration.GLOBAL_LINT_CONFIG_PATH);
+
+			if (globalPath?.startsWith('/')) {
+			  globalPath = globalPath.substring(1);
+			}
+
+                        if (globalPath) {
+                                try {
+                                        const parts = connection.parserMemberPath(globalPath);
+                                        const existsRes = await connection.runCommand({
+                                                command: `CHKOBJ OBJ(${parts.library}/${parts.file}) OBJTYPE(*FILE) MBR(${parts.name})`,
+                                                noLibList: true
+                                        });
+
+                                        if (existsRes.code === 0) {
+                                                await commands.executeCommand(`code-for-ibmi.openEditable`, globalPath);
+                                        } else {
+                                                window.showErrorMessage(`Global lint config does not exist at ${globalPath}.`);
+                                        }
+                                } catch (e) {
+                                        console.log(e);
+                                        window.showErrorMessage(`Failed to open global lint configuration.`);
+                                }
+                                return;
+                        }
 
 				/** @type {"member"|"streamfile"} */
 				let type = `member`;
@@ -117,8 +144,22 @@ export function initialise(context: ExtensionContext) {
 					} else {
 						window.showErrorMessage(`RPGLE linter config doesn't exist for this file. Would you like to create a default at ${configPath}?`, `Yes`, `No`).then
 							(async (value) => {
-								if (value === `Yes`) {
-									const jsonString = JSON.stringify(DEFAULT_SCHEMA, null, 2);
+                                                                if (value === `Yes`) {
+                                                                        let jsonString: string | undefined;
+
+                                                                        if (type === `member`) {
+                                                                                const globalPath = Configuration.get<string>(Configuration.GLOBAL_LINT_CONFIG_PATH);
+                                                                                if (globalPath) {
+                                                                                        try {
+                                                                                                const globalParts = connection.parserMemberPath(globalPath);
+                                                                                                jsonString = await content.downloadMemberContent(globalParts.library, globalParts.file, globalParts.name);
+                                                                                        } catch (e) {
+                                                                                                console.log(`Failed to load global lint config: ${e}`);
+                                                                                        }
+                                                                                }
+                                                                        }
+
+                                                                        if (!jsonString) jsonString = JSON.stringify(DEFAULT_SCHEMA, null, 2);
 
 									switch (type) {
 										case `member`:
@@ -184,4 +225,4 @@ function parseMemberUri(fullPath: string): {asp?: string, library?: string, file
 		library: parts[parts.length - 3],
 		asp: parts[parts.length - 4]
 	}
-};
+};

extension/client/tsconfig.json

@@ -1,18 +1,24 @@
 {
-	"extends": "../tsconfig.base.json",
-	"compilerOptions": {
-		"module": "commonjs",
-		"target": "es2020",
-		"outDir": "out",
-		"rootDir": "src",
-		"lib": [ "es2020" ],
-		"sourceMap": true,
-		"composite": true
-	},
-	"include": [
-		"src"
-	],
-	"exclude": [
-		"node_modules", ".vscode-test", "src/test"
-	]
-}
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "../../out/client",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "noUnusedLocals": false,
+    "moduleResolution": "node",
+    "types": [],
+    "typeRoots": ["node_modules/@types"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "**/node_modules",
+    "**/vscode-ibmi-types/**/*",
+    "**/node-ssh/**/*"
+  ]
+}

extension/server/src/providers/linter/index.ts

@@ -101,14 +101,29 @@ enum ResolvedState {
 let boundLintConfig: {[workingUri: string]: {resolved: ResolvedState, uri: string}} = {};
 
 export async function getLintConfigUri(workingUri: string) {
-	const uri = URI.parse(workingUri);
-	let cleanString: string | undefined;
-
-	const cached = boundLintConfig[workingUri];
-
-	if (cached) {
-		return cached.resolved === ResolvedState.Found ? cached.uri : undefined;
-	}
+        const uri = URI.parse(workingUri);
+        let cleanString: string | undefined;
+
+        const cached = boundLintConfig[workingUri];
+
+        if (cached) {
+                return cached.resolved === ResolvedState.Found ? cached.uri : undefined;
+        }
+
+        if (uri.scheme === `member`) {
+                const globalPath = process.env.GLOBAL_LINT_CONFIG_PATH;
+                if (globalPath) {
+                        cleanString = URI.from({ scheme: `member`, path: globalPath }).toString();
+                        cleanString = await validateUri(cleanString, `member`);
+                        if (cleanString) {
+                                boundLintConfig[workingUri] = {
+                                        resolved: ResolvedState.Found,
+                                        uri: cleanString
+                                };
+                                return cleanString;
+                        }
+                }
+        }
 
 	switch (uri.scheme) {
 		case `member`:

package.json

@@ -36,13 +36,18 @@
 		"configuration": {
 			"title": "RPGLE language tools",
 			"properties": {
-				"vscode-rpgle.rulerEnabledByDefault": {
-					"type": "boolean",
-					"default": true,
-					"description": "Whether to show the fixed-format ruler by default."
-				}
-			}
-		},
+                                "vscode-rpgle.rulerEnabledByDefault": {
+                                        "type": "boolean",
+                                        "default": true,
+                                        "description": "Whether to show the fixed-format ruler by default."
+                                },
+                                "vscode-rpgle.globalLintConfigPath": {
+                                        "type": "string",
+                                        "default": "",
+                                        "description": "QSYS.LIB path for global RPGLINT.JSON."
+                                }
+                        }
+                },
 		"snippets": [
 			{
 				"path": "./schemas/rpgle.code-snippets",

tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "../../out/client",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "noUnusedLocals": false,
+    "moduleResolution": "node",
+    "forceConsistentCasingInFileNames": false
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/node_modules"]
+}