swanctl parser

Parsing custom formats like the one produced by swanctl --raw in JavaScript requires a custom parser since this format doesn’t adhere to standard serialization formats like JSON, XML, or YAML. You’ll need to write a parser that can interpret the specific structure of this output.

Here’s a basic approach to parse the example output you’ve given into a more structured JavaScript object. This approach involves:

1. Splitting the string into lines or segments based on specific delimiters (like spaces, braces, etc.).
2. Iteratively processing each segment to construct a hierarchical object structure.

This example parser is simplistic and may need adjustments to robustly handle all nuances of swanctl --raw output, especially for more complex configurations.

function parseSwanctlOutput(str) {
    const objStack = [{}];
    const contextStack = ['root'];
    let currentKey = null;

    // Helper function to add an item or initialize a new object/array
    const addItem = (key, value) => {
        const currentObj = objStack[objStack.length - 1];
        if (Array.isArray(currentObj[key])) {
            currentObj[key].push(value);
        } else if (currentObj[key] !== undefined) {
            currentObj[key] = [currentObj[key], value];
        } else {
            currentObj[key] = value;
        }
    };

    const tokens = str.match(/\{|\}|\[|\]|[^{}\[\]\s]+/g);

    for (const token of tokens) {
        switch (token) {
            case '{':
                const newObj = {};
                if (currentKey) {
                    addItem(currentKey, newObj);
                    contextStack.push(currentKey);
                    currentKey = null;
                }
                objStack.push(newObj);
                break;
            case '}':
                objStack.pop();
                contextStack.pop();
                currentKey = contextStack[contextStack.length - 1];
                break;
            case '[':
                objStack.push([]);
                contextStack.push(currentKey || 'array');
                break;
            case ']':
                const completedArray = objStack.pop();
                contextStack.pop();
                if (contextStack.length > 0) {
                    currentKey = contextStack[contextStack.length - 1];
                    addItem(currentKey, completedArray);
                }
                break;
            default:
                if (currentKey) {
                    addItem(currentKey, token);
                    currentKey = null;
                } else {
                    currentKey = token;
                }
                break;
        }
    }

    return objStack.length > 0 ? objStack[0] : {};
}

const rawOutput = "{ba1 {id=1 version=2 vips=[1 23 a] sas {ba1-v4 { id=3 version=6} ba1-v6 {id=3 version=9}}}}";
const parsedOutput = parseSwanctlOutput(rawOutput);
console.log(parsedOutput);

This script attempts to parse the structure into a JavaScript object, assuming the format is consistent (keys and values separated by =, arrays denoted by [], and nested objects by {}). However, the real-world output of swanctl --raw might include complexities not covered here, such as special characters, nested arrays, or different kinds of value representations.

Adjustments may be needed for specific cases or more complex structures. If the output format can vary widely or includes edge cases not considered in this example, you’ll need to enhance the parsing logic accordingly, possibly adding error handling, support for escape sequences, or more sophisticated state management.