feat: add command for converting between different opc types to cli (#905)

* Add function for converting between opc types

* Add function for writting cnfg to string

* Fix mapping of dummy tags in opc conversion

* Set default parameters for SopcProc

* Add opc command for converting opc objects

* Only convert proc when direction is correct

* Add missing test file

* Fix bugs with opc conversion

* Fix tests

Author: vetlek

packages/septic/src/cli/index.ts

@@ -9,12 +9,14 @@ import { hideBin } from "yargs/helpers";
 import { formatCommand } from "./format";
 import { lintCommand } from "./lint";
 import { compareCommand } from "./compare";
+import { opcCommand } from "./opc";
 
 yargs(hideBin(process.argv))
     .scriptName("sca")
     .command(formatCommand)
     .command(lintCommand)
     .command(compareCommand)
+    .command(opcCommand)
     .demandCommand(1, "You need to specify a command")
     .help()
     .version()

packages/septic/src/cli/opc.ts

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Equinor ASA
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import yargs, { CommandModule } from "yargs";
+import { SepticCnfg } from "../cnfg";
+import { convertOPCObjects } from "../opc";
+import { createDocumentFromFile } from "../configProvider";
+import * as fs from "fs";
+import * as path from "path";
+
+interface OpcOptions {
+    config: string;
+    output: string;
+    direction: "sopc-to-ua" | "ua-to-sopc";
+    simulator?: boolean;
+}
+
+async function loadSepticConfig(filePath: string): Promise<SepticCnfg> {
+    const document = await createDocumentFromFile(filePath);
+    const cnfg = new SepticCnfg(document);
+    cnfg.parse(undefined);
+    await cnfg.updateObjectParents();
+    return cnfg;
+}
+
+async function handler(options: OpcOptions): Promise<void> {
+    if (!fs.existsSync(options.config)) {
+        console.error(`Error: Config file not found: ${options.config}`);
+        process.exit(1);
+    }
+
+    if (!options.config.endsWith(".cnfg")) {
+        console.error(`Error: Config file must be a .cnfg file`);
+        process.exit(1);
+    }
+
+    console.log(`Loading config: ${options.config}`);
+    const cnfg = await loadSepticConfig(options.config);
+
+    console.log(`Converting OPC objects (${options.direction})...`);
+    const converted = convertOPCObjects(
+        cnfg,
+        options.direction,
+        options.simulator,
+    );
+
+    const outputPath = path.resolve(options.output);
+    const outputDir = path.dirname(outputPath);
+
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    fs.writeFileSync(outputPath, converted.toString(), "utf-8");
+    console.log(`Output written to: ${outputPath}`);
+}
+
+export const opcCommand: CommandModule<object, OpcOptions> = {
+    command: "opc <config> <output>",
+    describe:
+        "Convert OPC objects in a Septic config between Sopc and UA types",
+    builder: (yargs) => {
+        return yargs
+            .positional("config", {
+                type: "string",
+                description: "Path to the input config file",
+                demandOption: true,
+            })
+            .positional("output", {
+                type: "string",
+                description: "Path to the output config file",
+                demandOption: true,
+            })
+            .option("direction", {
+                alias: "d",
+                type: "string",
+                description: "Conversion direction",
+                choices: ["sopc-to-ua", "ua-to-sopc"],
+                demandOption: true,
+            })
+            .option("simulator", {
+                alias: "s",
+                type: "boolean",
+                description: "Enable simulator mode",
+                demandOption: false,
+            })
+            .example(
+                "$0 opc input.cnfg output.cnfg --direction sopc-to-ua",
+                "Convert Sopc objects to UA objects",
+            )
+            .example(
+                "$0 opc input.cnfg output.cnfg --direction sopc-to-ua --simulator",
+                "Convert Sopc objects to UA objects with simulator mode enabled",
+            )
+            .example(
+                "$0 opc input.cnfg output.cnfg -d ua-to-sopc",
+                "Convert UA objects to Sopc objects",
+            ) as unknown as yargs.Argv<OpcOptions>;
+    },
+    handler: (argv) => {
+        handler(argv).catch((error) => {
+            console.error("Unexpected error:", error);
+            process.exit(1);
+        });
+    },
+};

packages/septic/src/cnfg.ts

@@ -115,6 +115,9 @@ export class SepticCnfg implements SepticContext, TextDocument {
         return Promise.resolve();
     }
 
+    public toString(): string {
+        return this.objects.map((obj) => obj.toString()).join("\n");
+    }
     public get uri(): string {
         return this.doc.uri;
     }

packages/septic/src/elements.ts

@@ -24,6 +24,14 @@ export enum SepticTokenType {
     eof = "eof",
 }
 
+const indentsObjectDeclaration = 2;
+const startObjectName = 17;
+const spacesBetweenValues = 2;
+const spacesBetweenIntValues = 6;
+const indentsAttributeValuesStart = 17;
+const maxNumberAttrValuesPerLine = 5;
+const indentsAttributesDelimiter = 14;
+
 export type SepticToken = IToken<SepticTokenType>;
 
 export class SepticBase {
@@ -185,6 +193,28 @@ export class SepticObject extends SepticBase {
         }
         return { algExpr: expr, positionsMap: positionsMap };
     }
+
+    toString(): string {
+        const identifierStr = this.identifier ? ` ${this.identifier.name}` : "";
+        const objectTypeFormatted =
+            " ".repeat(indentsObjectDeclaration) + this.type + ":";
+        const indentsName = Math.max(
+            startObjectName - objectTypeFormatted.length - 1,
+            2,
+        );
+        const objectDeclartionFormatted =
+            objectTypeFormatted + " ".repeat(indentsName) + identifierStr;
+        return (
+            objectDeclartionFormatted +
+            "\n" +
+            this.attributes
+                .map((attr) => {
+                    return attr.toString();
+                })
+                .join("\n") +
+            "\n"
+        );
+    }
 }
 
 export class SepticAttribute extends SepticBase {
@@ -201,6 +231,10 @@ export class SepticAttribute extends SepticBase {
         this.values.push(value);
     }
 
+    setValues(values: SepticAttributeValue[]) {
+        this.values = values;
+    }
+
     updateEnd(): void {
         if (this.values.length) {
             this.end = this.values[this.values.length - 1]!.end;
@@ -261,6 +295,62 @@ export class SepticAttribute extends SepticBase {
     isKey(key: string) {
         return key === this.key;
     }
+
+    toString(): string {
+        const indentsKey = Math.max(
+            indentsAttributesDelimiter - this.key.length,
+            0,
+        );
+        const attrDefFormatted = " ".repeat(indentsKey) + this.key + "=  ";
+        if (this.getType() === SepticValueTypes.stringList) {
+            return (
+                attrDefFormatted +
+                formatStringList(this.values.map((val) => val.value))
+            );
+        } else if (this.getType() === SepticValueTypes.numericList) {
+            return (
+                attrDefFormatted +
+                formatNumericList(this.values.map((val) => val.value))
+            );
+        } else if (this.getValues().length > 1) {
+            return (
+                attrDefFormatted +
+                formatList(this.values.map((val) => val.value))
+            );
+        } else {
+            return attrDefFormatted + (this.values[0]?.value || "");
+        }
+    }
+}
+
+function formatStringList(values: string[]): string {
+    let formatted = `${values.length - 1}`;
+    values.slice(1).forEach((val, ind) => {
+        if (ind % maxNumberAttrValuesPerLine === 0) {
+            formatted += "\n" + " ".repeat(indentsAttributeValuesStart) + val;
+        } else {
+            formatted += " ".repeat(spacesBetweenValues) + val;
+        }
+    });
+    return formatted;
+}
+
+function formatNumericList(values: string[]): string {
+    let formatted = `${values.length - 1}`;
+    values.slice(1).forEach((val, ind) => {
+        const spaces = Math.max(spacesBetweenIntValues - val.length, 1);
+        formatted +=
+            ind === 0 ? " ".repeat(spaces - 1) + val : " ".repeat(spaces) + val;
+    });
+    return formatted;
+}
+
+function formatList(values: string[]): string {
+    let formatted = `${values.length - 1}`;
+    values.slice(1).forEach((val) => {
+        formatted += " ".repeat(spacesBetweenValues) + val;
+    });
+    return formatted;
 }
 
 export class SepticIdentifier extends SepticBase {

packages/septic/src/generator.ts

@@ -0,0 +1,78 @@
+import {
+    SepticAttribute,
+    SepticAttributeValue,
+    SepticIdentifier,
+    SepticObject,
+    SepticTokenType,
+} from "./elements";
+import { SepticMetaInfoProvider, SepticObjectDoc } from "./metaInfoProvider";
+
+export class SepticObjectGenerator {
+    private metaInfoProvider: SepticMetaInfoProvider;
+    constructor() {
+        this.metaInfoProvider = SepticMetaInfoProvider.getInstance();
+    }
+
+    public createObject(
+        type: string,
+        identifier: string,
+        attributes: {
+            key: string;
+            type: SepticTokenType;
+            values: string[];
+        }[] = [],
+    ): SepticObject {
+        const objectDoc = this.metaInfoProvider.getObjectDocumentation(type);
+        if (!objectDoc) {
+            throw new Error(`Unknown object type: ${type}`);
+        }
+        const obj = objectDocToObject(identifier, objectDoc);
+        for (const attr of attributes) {
+            const attribute = obj.getAttribute(attr.key);
+            if (attribute) {
+                attribute.setValues(createAttrValues(attr.values, attr.type));
+            }
+        }
+        return obj;
+    }
+}
+
+function objectDocToObject(
+    identifier: string,
+    doc: SepticObjectDoc,
+): SepticObject {
+    const obj = new SepticObject(doc.name, new SepticIdentifier(identifier));
+    for (const attrDoc of doc.attributes) {
+        if (attrDoc.noCnfg) {
+            continue;
+        }
+        const attr = new SepticAttribute(attrDoc.name);
+        const tokenType =
+            attrDoc.dataType == "string"
+                ? SepticTokenType.string
+                : SepticTokenType.numeric;
+        const attrValues = createAttrValues(attrDoc.default, tokenType);
+        attr.setValues(attrValues);
+        obj.addAttribute(attr);
+    }
+    return obj;
+}
+
+export function createAttrValues(
+    values: string[],
+    type: SepticTokenType,
+): SepticAttributeValue[] {
+    const attrValues: SepticAttributeValue[] = [];
+    if (values.length > 1) {
+        attrValues.push(
+            new SepticAttributeValue(
+                `${values.length}`,
+                SepticTokenType.numeric,
+            ),
+        );
+    }
+    values.forEach((val) => {
+        attrValues.push(new SepticAttributeValue(val, type));
+    });
+    return attrValues;
+}