drakongen 1.0.0

package/src/main.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+const {toTree, toPseudocode} = require("./index")
+
+const fs = require('fs').promises;
+const path = require('path');
+
+// Display usage summary
+function displayUsage() {
+    console.log(`Usage:
+    drakongen <path>                      Read from <path> and output to standard output
+    drakongen --language <lang> <path>    Read from <path> and output to standard output, use the provided language
+    drakongen --tree <path>               Read from <path> and output to standard output, use the JSON-tree format
+    drakongen --output <output folder> <path> 
+                                      Read from <path> and write to <output folder>
+    drakongen                             Display this usage summary.`);
+}
+
+
+
+// Main logic
+async function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0) {
+        displayUsage();
+        return;
+    }
+
+    let options = {
+        language: "en",
+        json: false,
+        output: null,
+        tree: false
+    };
+    let targetPath = null;
+
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--language':
+                options.language = args[++i];
+                break;
+            case '--tree':
+                options.tree = true;
+                break;                
+            case '--output':
+                options.output = args[++i];
+                break;
+            default:
+                if (!targetPath) {
+                    targetPath = args[i];
+                }
+        }
+    }
+
+    if (!targetPath) {
+        displayUsage();
+        return;
+    }
+
+    try {
+        const stats = await fs.lstat(targetPath);
+
+        if (stats.isDirectory()) {
+            await generate(targetPath, options);
+        } else {
+            await generateOne(targetPath, options);
+        }
+    } catch (err) {
+        console.error(`${err.message}`);
+        console.error(`Filename: ${err.filename}`);
+        console.error(`Node id: ${err.nodeId}`);
+        process.exit(1);
+    }
+}
+
+async function getDrakonFiles(dirPath) {    
+    // Read all entries in the directory
+    const files = await fs.readdir(dirPath, { withFileTypes: true });
+
+    // Filter files that are regular files and have a .txt extension, then map to full paths
+    const txtFiles = files
+        .filter(file => file.isFile() && path.extname(file.name) === '.drakon')
+        .map(file => path.join(dirPath, file.name));
+
+    return txtFiles;
+}
+
+// Placeholder functions (not implemented)
+async function generate(folderPath, options) {
+    var files = await getDrakonFiles(folderPath)
+    var output
+    if (options.tree) {
+        var obj = {procedures:[]}
+        for (var file of files) {
+            var json = await convertToTree(file, options)
+            obj.procedures.push(json)
+        }     
+        output = JSON.stringify(obj, null, 4)   
+    } else {
+        output = ""
+        for (var file of files) {
+            var pseudo = await convertToPseudo(file, options)
+            output += (pseudo + "\n\n\n")
+        }
+    }
+    await writeOut(output, folderPath, options.output)
+}
+
+async function generateOne(filePath, options) {
+    var output
+    if (options.tree) {
+        var json = await convertToTree(filePath, options)
+        output = JSON.stringify(json, null, 4)   
+    } else {
+        output = await convertToPseudo(filePath, options)
+    }
+    await writeOut(output, filePath, options.output)
+}
+
+async function writeOut(content, inputPath, outputFolder) {
+    if (outputFolder) {
+        var pname = path.parse(inputPath)
+        var fullName = path.join(outputFolder, pname.name + ".txt")
+        await fs.writeFile(fullName, content, 'utf8');
+    } else {
+        console.log(content)
+    }
+}
+
+async function convertToTree(filePath, options) {
+    // Read the content of the file with UTF-8 encoding
+    const content = await fs.readFile(filePath, 'utf8');
+
+    var pname = path.parse(filePath)
+    const name = pname.name    
+    var result = toTree(content, name, filePath, options.language)
+    return JSON.parse(result)
+}
+
+
+async function convertToPseudo(filePath, options) {
+    // Read the content of the file with UTF-8 encoding
+    const content = await fs.readFile(filePath, 'utf8');
+
+    var pname = path.parse(filePath)
+    const name = pname.name    
+    const result = toPseudocode(content, name, filePath, options.language);
+    return result
+}
+
+
+
+// Entry point
+main();
+
+

package/src/nodeTools.js

@@ -0,0 +1,38 @@
+const { parse } = require('node-html-parser');
+
+
+function htmlToString(html) {
+    if (!html) return '';
+    if (!html.startsWith('<') || !html.endsWith('>')) {
+        return html.split("\n").map(line => {return line.trim()})
+    }
+
+    const root = parse(html);
+    const output = [];
+
+    root.childNodes.forEach((node) => {
+        if (node.tagName === 'P') {
+            output.push(node.text.trim());
+        } else if (node.tagName === 'UL') {
+            output.push('');
+            node.childNodes.forEach((item) => {
+                if (item.tagName === 'LI') {
+                    output.push(`- ${item.text.trim()}`);
+                }
+            });
+            output.push('');
+        } else if (node.tagName === 'OL') {
+            output.push('');
+            node.childNodes.forEach((item, index) => {
+                if (item.tagName === 'LI') {
+                    output.push(`${index + 1}. ${item.text.trim()}`);
+                }
+            });
+            output.push('');
+        }
+    });
+
+    return output;
+}
+
+module.exports = {htmlToString}

package/src/printPseudo.js

@@ -0,0 +1,167 @@
+var {addRange} = require("./tools")
+
+function printPseudo(algorithm, translate, output, htmlToString) {
+
+
+
+    function printStructuredContent(content, indent, output) {
+        var lines = printStructuredContentNoIdent(content)
+        printWithIndent(lines, indent, output)
+    }
+
+    function printWithIndent(lines, indent, output) {
+        lines.forEach(line => output.push(indent + line))
+    }
+
+    function printStructuredContentNoIdent(content) {
+        var lines = []
+
+        if (typeof content === "string") {
+            return htmlToString(content);
+        } else if (content.operator === "not") {
+            lines = printStructuredContentNoIdent(content.operand)
+            if (lines.length > 0) {
+                lines[0] = translate("not") + " (" + lines[0] + ")"
+            }
+        } else if (content.operator === "and" || content.operator === "or") {
+            var operator = translate(content.operator)
+            printBinary(content, operator, lines)
+        } else if (content.operator === "equal") {
+            var operator = "=="
+            printBinary(content, operator, lines)
+        }
+
+        return lines;
+    }
+
+    function printBinary(content, operator, lines) {
+        const leftLines = printOperand(content.left);
+        const rightLines = printOperand(content.right);
+        if (leftLines.length === 1 && rightLines.length === 1) {
+            lines.push(leftLines[0] + " " + operator + " " + rightLines[0])
+        } else {
+            addRange(lines, leftLines)
+            lines.push(operator);
+            addRange(lines, rightLines)
+        }
+    }
+
+    function printOperand(content) {
+        var lines = printStructuredContentNoIdent(content)
+        if (typeof content === "string" || content.operator === "not") {
+            return lines
+        }
+        if (lines.length > 0) {
+            lines[0] = "(" + lines[0]
+            last = lines.length - 1
+            lines[last] = lines[last] + ")"
+        }
+        return lines
+    }
+
+    function makeIndent(depth) {
+        return " ".repeat(depth * 4); 
+    }
+
+    function printSteps(steps, depth, output) {
+        const indent = makeIndent(depth)
+        for (var step of steps) {
+            if (step.type === "end" || step.type === "branch" || step.type === "comment") { continue }
+            if (step.type === "question") {
+                printQuestion(step, depth, output)
+            } else if (step.type === "loop") {
+                printLoop(step, depth, output)    
+            } else if (step.type === "address") {
+                printAddress(step, indent, output)                                      
+            } else if (step.type === "error") {
+                printError(step, indent, output)
+            } else if (step.type === "break") {
+                output.push(indent + translate("break"))
+            } else {
+                printOther(step, indent, output)
+            }
+        }
+    }
+    
+    function printOther(step, indent, output) {
+        if (!step.content && !step.secondary) {return}
+        if (step.secondary) {            
+            printStructuredContent(step.secondary, indent, output)
+        }
+        if (step.content) {
+            printStructuredContent(step.content, indent, output)
+        }        
+        output.push("")
+    }
+
+    function printAddress(step, indent, output) {
+        var label
+        if (step.content) {
+            label = htmlToString(step.content);
+        } else {
+            label = translate("Subroutine") + " " + step.branch 
+        }
+        output.push(indent + translate("Call subroutine") + " \"" + label + "\"")
+    }
+
+    function printError(step, indent, output) {
+        output.push(indent + translate("error") + ":")
+        output.push(indent + step.message)
+        if (step.content) {
+            printStructuredContent(step.content, indent, output)
+        }        
+        output.push("")
+    }    
+
+    function empty(array) {
+        return array.length === 0
+    }
+
+    function printQuestion(step, depth, output) {
+        const indent = makeIndent(depth)
+        const indent2 = makeIndent(depth + 1)
+        var yesBody = []
+        printSteps(step.yes, depth + 1, yesBody)
+        var noBody = []
+        printSteps(step.no, depth + 1, noBody)        
+        if (empty(yesBody) && empty(noBody)) {
+            yesBody.push(indent2 + translate("pass"))
+        }
+        var content = step.content
+        if (empty(yesBody)) {
+            content = {operator:"not",operand:step.content}
+        }
+        var lines = printStructuredContentNoIdent(content)
+        lines[0] = translate("if") + " " + lines[0]
+        printWithIndent(lines, indent, output)
+        if (empty(yesBody)) {
+            addRange(output, noBody)           
+        } else {
+            addRange(output, yesBody)            
+            if (!empty(noBody)) {
+                output.push(indent + translate("else"))
+                addRange(output, noBody)
+            }
+        }    
+    }      
+
+    function printLoop(step, depth, output) {
+        const indent2 = makeIndent(depth + 1)
+        const indent = makeIndent(depth)
+        var body = []
+        printSteps(step.body, depth + 1, body)
+        if (empty(body)) {
+            body.push(indent2 + translate("pass"))
+        }
+        var content = step.content
+        if (!content) {
+            content = translate("loop forever")
+        }
+        printStructuredContent(content, indent, output)
+        addRange(output, body)
+    }      
+
+    printSteps(algorithm.body, 0, output)
+}
+
+module.exports = {printPseudo}