Add support for linting scg projects

Author: vetlek

packages/extension/server/src/scgContextManager.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Connection, Emitter, Event } from "vscode-languageserver";
+import { Emitter, Event } from "vscode-languageserver";
 import { DocumentProvider } from "./documentProvider";
 import * as path from "path";
 import { scgConfigFromYAML, ScgContext } from "@equinor/septic-config-lib";
@@ -14,8 +14,6 @@ export class ScgContextManager {
 
     private contexts: Map<string, ScgContext> = new Map<string, ScgContext>();
 
-    private connection: Connection;
-
     private cnfgProvider: SepticConfigProvider;
 
     private _onDidUpdateContext: Emitter<string> = new Emitter<string>();
@@ -29,11 +27,9 @@ export class ScgContextManager {
     constructor(
         docProvider: DocumentProvider,
         cnfgProvider: SepticConfigProvider,
-        connection: Connection,
     ) {
         this.docProvider = docProvider;
         this.cnfgProvider = cnfgProvider;
-        this.connection = connection;
         this.docProvider.onDidChangeDoc(async (uri) => {
             this.onDidChangeDoc(uri);
         });

packages/extension/server/src/server.ts

@@ -65,7 +65,6 @@ const langService: ILanguageService = createLanguageService(
 const scgContextManager = new ScgContextManager(
     documentProvider,
     langService.cnfgProvider,
-    connection,
 );
 
 const contextManager = new ContextManager(

packages/septic/src/cli/format.ts

@@ -9,7 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { SepticCnfg } from "../cnfg";
 import { SepticCnfgFormatter } from "../formatter";
-import { validateFileExists, createDocumentFromFile } from "./utils";
+import { createDocumentFromFile } from "../configProvider";
 
 interface FormatOptions {
     file: string;
@@ -75,9 +75,7 @@ function checkFormatting(
 }
 
 async function handler(options: FormatOptions): Promise<void> {
-    validateFileExists(options.file);
-
-    const document = createDocumentFromFile(options.file);
+    const document = await createDocumentFromFile(options.file);
     const originalContent = document.getText();
 
     const edits = formatSepticConfig(document);

packages/septic/src/cli/lint.ts

@@ -4,25 +4,29 @@
  *--------------------------------------------------------------------------------------------*/
 
 import yargs, { CommandModule } from "yargs";
-import { TextDocument } from "vscode-languageserver-textdocument";
 import { SepticCnfg } from "../cnfg";
 import {
     getDiagnostics,
     SepticDiagnostic,
     SepticDiagnosticLevel,
 } from "../diagnostics";
 import { SepticMetaInfoProvider } from "../metaInfoProvider";
-import { validateFileExists, createDocumentFromFile } from "./utils";
+import {
+    createDocumentFromFile,
+    SepticConfigProviderFs,
+} from "../configProvider";
+import * as fs from "fs";
+import * as path from "path";
+import { scgConfigFromYAML, ScgContext } from "../scg";
 
 interface LintOptions {
     file: string;
     ignore?: string[];
     septicversion?: string;
 }
 
-async function lintSepticConfig(
-    document: TextDocument,
-): Promise<SepticDiagnostic[]> {
+async function lintSepticConfig(filePath: string): Promise<SepticDiagnostic[]> {
+    const document = await createDocumentFromFile(filePath);
     const cnfg = new SepticCnfg(document);
     cnfg.parse(undefined);
     await cnfg.updateObjectParents();
@@ -31,50 +35,97 @@ async function lintSepticConfig(
     );
 }
 
+async function lintScg(scgConfigPath: string): Promise<SepticDiagnostic[]> {
+    let scgConfig;
+    try {
+        const content = await fs.promises.readFile(scgConfigPath, {
+            encoding: "utf-8",
+        });
+        scgConfig = scgConfigFromYAML(content);
+    } catch (error) {
+        console.error(`Failed to read or parse SCG config: ${error}`);
+        process.exit(1);
+    }
+    const configProvider = new SepticConfigProviderFs();
+    const scgContext = new ScgContext(
+        "SCG Context",
+        scgConfigPath,
+        scgConfig,
+        configProvider,
+    );
+    await scgContext.load();
+    await scgContext.updateObjectParents();
+    const diagnostics: SepticDiagnostic[] = [];
+    for (const file of scgContext.files) {
+        const cnfg = await configProvider.get(file);
+        if (cnfg === undefined) {
+            continue;
+        }
+        const templateDiagnostics = getDiagnostics(cnfg, scgContext).filter(
+            (diagnostic) => diagnostic.level !== SepticDiagnosticLevel.hint,
+        );
+        diagnostics.push(...templateDiagnostics);
+    }
+    return diagnostics;
+}
+
 function filterDiagnostics(
     diagnostics: SepticDiagnostic[],
     ignoreCodes?: string[],
 ): SepticDiagnostic[] {
     if (!ignoreCodes || ignoreCodes.length === 0) {
         return diagnostics;
     }
-
     const ignoreSet = new Set(ignoreCodes.map((code) => code.toUpperCase()));
     return diagnostics.filter(
         (diagnostic) => !ignoreSet.has(diagnostic.code.toUpperCase()),
     );
 }
 
-function formatDiagnostic(diagnostic: SepticDiagnostic, uri: string): string {
+function formatDiagnostic(diagnostic: SepticDiagnostic): string {
     const line = diagnostic.range.start.line + 1;
     const character = diagnostic.range.start.character + 1;
     const level = diagnostic.level.toUpperCase();
     const code = diagnostic.code;
-    return `${level} [${code}]: ${diagnostic.message} ${uri}#${line}:${character}`;
+    return `${level} [${code}]: ${diagnostic.message} ${diagnostic.uri}#${line}:${character}`;
 }
 
-function printDiagnostics(diagnostics: SepticDiagnostic[], uri: string): void {
+function printDiagnostics(diagnostics: SepticDiagnostic[]): void {
     if (diagnostics.length === 0) {
-        console.log("No issues found.");
+        console.log("No issues found!");
         return;
     }
-
-    console.log(`${diagnostics.length} issue(s) found:`);
-    for (const diagnostic of diagnostics) {
-        console.log(formatDiagnostic(diagnostic, uri));
+    const files = diagnostics.map((diag) => diag.uri);
+    const uniqueFiles = Array.from(new Set(files));
+    for (const file of uniqueFiles) {
+        const diagsForFile = diagnostics.filter((diag) => diag.uri === file);
+        console.log(`\nLinting results for file: ${file}`);
+        console.log(`${diagsForFile.length} issue(s) found:`);
+        for (const diagnostic of diagsForFile) {
+            console.log(formatDiagnostic(diagnostic));
+        }
     }
 }
 
 async function handler(options: LintOptions): Promise<void> {
-    validateFileExists(options.file);
-
-    // Set the version to use for linting
     if (options.septicversion) {
         SepticMetaInfoProvider.setVersion(options.septicversion);
     }
+    const allDiagnostics: SepticDiagnostic[] = [];
+    if (options.file.endsWith(".cnfg")) {
+        const fileDiagnostics = await lintSepticConfig(options.file);
+        allDiagnostics.push(...fileDiagnostics);
+    } else if (options.file.endsWith(".yaml")) {
+        console.log(`Linting SCG project ${path.resolve(options.file)}`);
+        const scgDiagnostics = await lintScg(options.file);
+        allDiagnostics.push(...scgDiagnostics);
+    } else {
+        console.error(
+            "Unsupported file type. Please provide a .cnfg or .yaml file.",
+        );
+        process.exit(1);
+    }
 
-    const document = createDocumentFromFile(options.file);
-    const allDiagnostics = await lintSepticConfig(document);
     const diagnostics = filterDiagnostics(allDiagnostics, options.ignore);
 
     if (options.ignore && options.ignore.length > 0) {
@@ -86,7 +137,7 @@ async function handler(options: LintOptions): Promise<void> {
         }
     }
 
-    printDiagnostics(diagnostics, document.uri);
+    printDiagnostics(diagnostics);
 
     const exitCode = diagnostics.length === 0 ? 0 : 1;
     process.exit(exitCode);
@@ -102,7 +153,8 @@ export const lintCommand: CommandModule<object, LintOptions> = {
         return yargs
             .positional("file", {
                 type: "string",
-                description: "Path to Septic config file to lint",
+                description:
+                    "Path to Septic config file or SCG config file to lint",
                 demandOption: true,
             })
             .option("ignore", {
@@ -118,6 +170,7 @@ export const lintCommand: CommandModule<object, LintOptions> = {
                 default: "latest",
             })
             .example("$0 lint config.cnfg", "Lint a config file")
+            .example("$0 lint scg.yaml", "Lint all templates in an SCG project")
             .example(
                 "$0 lint config.cnfg --ignore W101 W203",
                 "Lint and ignore specific diagnostic codes",

packages/septic/src/cli/utils.ts

@@ -63,7 +63,9 @@ export class SepticCnfg implements SepticContext, TextDocument {
         });
     }
 
-    public async parseAsync(token: CancellationToken): Promise<void> {
+    public async parseAsync(
+        token: CancellationToken | undefined,
+    ): Promise<void> {
         const scanner = new SepticScanner(this.doc.getText());
         const tokens = scanner.scanTokens();
         if (!tokens.tokens.length) {

packages/septic/src/cnfg.ts

@@ -1,5 +1,38 @@
+import { TextDocument } from "vscode-languageserver-textdocument";
 import { SepticCnfg } from "./cnfg";
+import * as path from "path";
+import * as fs from "fs";
 
 export interface ISepticConfigProvider {
     get(resource: string): Promise<SepticCnfg | undefined>;
 }
+
+export async function createDocumentFromFile(
+    filePath: string,
+): Promise<TextDocument> {
+    const fileContent = await fs.promises.readFile(filePath, {
+        encoding: "utf-8",
+    });
+    return TextDocument.create(
+        path.resolve(filePath),
+        "septic",
+        0,
+        fileContent,
+    );
+}
+
+export class SepticConfigProviderFs implements ISepticConfigProvider {
+    private cache: Map<string, SepticCnfg> = new Map<string, SepticCnfg>();
+    constructor() {}
+
+    async get(resource: string): Promise<SepticCnfg | undefined> {
+        if (this.cache.has(resource)) {
+            return this.cache.get(resource);
+        }
+        const doc = await createDocumentFromFile(resource);
+        const septicCnfg = new SepticCnfg(doc);
+        await septicCnfg.parseAsync(undefined);
+        this.cache.set(resource, septicCnfg);
+        return septicCnfg;
+    }
+}

packages/septic/src/configProvider.ts

@@ -121,19 +121,22 @@ export interface SepticDiagnostic {
     code: SepticDiagnosticCode;
     message: string;
     range: Range;
+    uri?: string | undefined;
 }
 
 function createDiagnostic(
     level: SepticDiagnosticLevel,
     range: Range,
     message: string,
     code: SepticDiagnosticCode,
+    uri?: string,
 ): SepticDiagnostic {
     return {
         level: level,
         range: range,
         message: message,
         code: code,
+        uri: uri,
     };
 }
 
@@ -152,7 +155,7 @@ export function validateStandAloneCalc(
 export function getDiagnostics(
     cnfg: SepticCnfg,
     contextProvider: SepticContext,
-) {
+): SepticDiagnostic[] {
     const diagnostics: SepticDiagnostic[] = [];
     diagnostics.push(...validateObjects(cnfg, contextProvider));
     diagnostics.push(...validateAlgs(cnfg, contextProvider));
@@ -173,7 +176,10 @@ export function getDiagnostics(
         }
         return true;
     });
-    return filteredDiags;
+    return filteredDiags.map((diag) => {
+        diag.uri = cnfg.uri;
+        return diag;
+    });
 }
 
 export function validateComments(cnfg: SepticCnfg): SepticDiagnostic[] {

packages/septic/src/diagnostics.ts

@@ -30,3 +30,7 @@ export {
 } from "./diagnostics";
 export { compareCnfgs } from "./compare";
 export { SepticCnfgFormatter } from "./formatter";
+export {
+    SepticConfigProviderFs,
+    createDocumentFromFile,
+} from "./configProvider";

packages/septic/src/index.ts

@@ -85,16 +85,32 @@ export class ScgContext implements SepticContext {
 
     private getFiles(scgConfig: ScgConfigSchema): string[] {
         return scgConfig.layout.map((layout) => {
-            return (
-                path.dirname(this.filePath) +
-                "/" +
-                scgConfig.templatepath +
-                "/" +
-                layout.name
-            );
+            if (this.filePath.startsWith("file:")) {
+                return this.resolveUrlPath(scgConfig.templatepath, layout.name);
+            }
+            return this.resolveFilePath(scgConfig.templatepath, layout.name);
         });
     }
 
+    private resolveUrlPath(templatePath: string, layoutName: string): string {
+        const baseUrl = new URL(this.filePath);
+        const dirUrl = new URL(".", baseUrl);
+        const relativePath = path.posix.join(templatePath, layoutName);
+        const resolvedUrl = new URL(relativePath, dirUrl);
+        return resolvedUrl.href;
+    }
+
+    private resolveFilePath(templatePath: string, layoutName: string): string {
+        const absoluteBasePath = path.isAbsolute(this.filePath)
+            ? this.filePath
+            : path.resolve(this.filePath);
+        return path.join(
+            path.dirname(absoluteBasePath),
+            templatePath,
+            layoutName,
+        );
+    }
+
     public async load(): Promise<void> {
         await Promise.all(
             this.files.map(async (file) => {