drakongen 1.0.0

package/prompts/printPseudo.txt

@@ -0,0 +1,116 @@
+Write a JavaScript function printPseudo(algorithm, translations) that prints an algorithm as pseudo code
+and returns it as a string.
+
+"algorithm" is an object these properties:
+- name: string, the name of the algorithm
+- params: string, some textual description of the algorithm in HTML
+- body: array, the steps of the algorithm
+
+Types of steps:
+- question
+- non-question
+
+A non-question step contains properties:
+- id: string
+- content: string with HTML
+- secondary: string with HTML
+- message: string with plain text
+
+A question step contains properties:
+- id: string
+- content: either string with HTML or a structured object
+- yes: an array with child nodes
+- no: an array with child nodes
+
+Examples of structured objects in the "content" property.
+"operator" property is mandatory.
+"operand", "left", "right" properties contain either an HTML string or another structured object
+
+{operator:"not",operand:"<p>Hello</p>"}
+{
+    "operator": "and",
+    "left": {
+        "operator": "and",
+        "left": "<p>One</p>",
+        "right": {
+            "operator": "not",
+            "operand": "<p>Two</p>"
+        }
+    }
+    "right": "<p>Three</p>"
+}
+
+The algorithm of printPseudo:
+- start with an empty output list of lines
+- run printPseudoSteps(algorithm.body, 0, output)
+- joint the output with newline as separator and return it
+
+printPseudoSteps(body, depth, output)
+    for each node in body
+        print node with indentation
+        
+
+Indentation contains "depth" * 4 spaces. Every line in the printed node should have the indentation.
+
+how to print a non-question node
+    if neither node.secondary or node.content have a value, do not print the node
+    if node.type === "branch" or node.type === "comment", do not print the node
+    Else            
+        if node.type === "error"
+            print a string: translated "Error" + ":"
+            print node.message
+        print node.secondary if it has a value
+        print node.content if it has a value
+        print an empty line
+
+how to print a question node
+    if both node.yes and node.no are empty, do not print the node
+    if node.yes is empty
+        content = {operator:"not", operand:node.content}
+    print the translated string "If 
+    print the structured content
+    if node.yes is empty
+        print the node.no using printPseudoSteps and incremented depth
+    Else
+        print the node.yes using printPseudoSteps and incremented depth
+        if node.no is not empty
+            print the translated string "Else"
+            print the node.no using printPseudoSteps and incremented depth
+
+How to translate strings:
+If a string is in "translations", take it. Otherwise do not translate the string, leave it as it is.
+
+How to print structured content:
+    If the content is a string
+        convert the HTML to text
+    Else
+        if content.operator === "not"
+            print content.operand as operand, but prepend the first line with this string: tranlated "not" + " "
+        else if content.operator === "and"
+            print content.left as operand
+            print the translated string "and"
+            print content.right as operand
+        else if content.operator === "or"
+            print content.left as operand
+            print the translated string "or"
+            print content.right as operand
+
+How to print content as operand:
+    if the content is a string
+        convert the HTML to text and print line by line, prepend each line with indentation
+    else
+        convert the HTML to text and print line by line, prepend each line with indentation, but prepend the first line with "(" (after indentation), and append the last line with ")"
+
+How to convert HTML to string
+    if the string is empty, return the translated string "empty".
+    if the string is not HTML, split it by line end
+    else
+        ignore <script> tags alltogether
+        for every <p> tag create a line from the text content of the tag
+        for every <li> tag in an unordred list, create a line from the text content of the tag, prepend the line with "- "
+        for every <li> tag in an ordred list, create a line from the text content of the tag, prepend the line with the ordinal number: "1. ", "2. ", "3. ", etc.
+        skip all other tags
+
+The code with run in Node Js.
+Do not use the ... operator.
+Use node-html-parser for HTML parsing.

package/src/browserTools.js

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

package/src/drakonToPromptStruct.js

@@ -0,0 +1,44 @@
+const {drakonToStruct} = require("./drakonToStruct");
+const {printPseudo} = require('./printPseudo');
+const {addRange} = require("./tools")
+
+function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate) {
+    var diagram = drakonToStruct(drakonJson, name, filename, translate)
+    var lines = []
+    if (diagram.params) {
+        addRange(lines, htmlToString(diagram.params))
+        lines.push("")
+    }
+
+    lines.push(translate("Procedure") + " \"" + diagram.name + "\"")
+    lines.push("")
+    lines.push(translate("Algorithm") + ":")    
+    
+    if (diagram.branches.length === 0) {
+        lines.push(translate("Empty"))
+    } else if (diagram.branches.length === 1) {
+        var first = diagram.branches[0]
+        printPseudo(first, translate, lines, htmlToString)
+    } else {
+        var first = diagram.branches[0]
+        lines.push(translate("Call subroutine") + ": \"" + htmlToString(first.name) + "\"")
+        diagram.branches.forEach(branch => {
+            lines.push("")
+            lines.push(translate("Subroutine") + ": \"" + htmlToString(branch.name) + "\"")
+            printPseudo(branch, translate, lines, htmlToString)
+            lines.push(translate("End of subroutine"))
+        })
+    }  
+    lines.push(translate("End of procedure"))
+    if (diagram.description) {
+        lines.push("")       
+        addRange(lines, htmlToString(diagram.description))
+        lines.push("")       
+    }      
+    var text = lines.join("\n")
+    
+    var str = JSON.stringify(diagram, null, 4)
+    return {text:text,json:str}
+}
+
+module.exports = { drakonToPseudocode };

package/src/drakonToStruct.js

@@ -0,0 +1,416 @@
+const { structFlow, redirectNode } = require("./structFlow");
+const { createError } = require("./tools");
+
+var translate
+
+function drakonToStruct(drakonJson, name, filename, translateFunction) {
+    translate = translateFunction
+    let drakonGraph;
+    try {
+        drakonJson = drakonJson || ""
+        drakonJson = drakonJson.trim()
+        drakonJson = drakonJson || "{}"
+        drakonGraph = JSON.parse(drakonJson);
+    } catch (error) {
+        var message = translate("Error parsing JSON") + ": " + error.message
+        throw createError(message, filename)
+    }
+
+    const nodes = drakonGraph.items || {};
+
+    var branches = []
+    var firstNodeId = findStartNode(nodes, filename, branches)
+
+    if (!firstNodeId) {
+        return {
+            name: name,
+            params: drakonGraph.params || "",
+            description: drakonGraph.description || "",
+            branches: []
+        }
+    }
+
+    buildTwoWayConnections(nodes, firstNodeId)
+
+    rewireSelectsMarkLoops(nodes, filename)
+    branches.forEach(branch => checkBranchIsReferenced(branch, firstNodeId, filename))
+    rewireShortcircuit(nodes, filename)
+    branches.forEach(branch => cutOffBranch(nodes, branch))
+    
+    var branchTrees = structFlow(nodes, branches, filename, translate)
+
+    return {
+        name: name,
+        params: drakonGraph.params || "",
+        description: drakonGraph.description || "",
+        branches: branchTrees
+    }
+}
+
+function drakonToGraph(drakonJson, name, filename, translateFunction) {
+    translate = translateFunction
+    let drakonGraph;
+    try {
+        drakonGraph = JSON.parse(drakonJson);
+    } catch (error) {
+        var message = translate("Error parsing JSON") + ": " + error.message
+        throw createError(message, filename)
+    }
+
+    const nodes = drakonGraph.items || {};
+
+    var branches = []
+    var firstNodeId = findStartNode(nodes, filename, branches)
+
+    if (!firstNodeId) {
+        return undefined
+    }
+
+    buildTwoWayConnections(nodes, firstNodeId)
+
+    rewireSelectsMarkLoops(nodes, filename)
+    rewireShortcircuit(nodes, filename)
+    branches.forEach(branch => checkBranchIsReferenced(branch, firstNodeId, filename))
+    branches.forEach(branch => cutOffBranch(nodes, branch))
+    
+    var branchTrees = structFlow(nodes, branches, filename, translate)
+
+    return {
+        name: name,
+        params: drakonGraph.params || "",
+        description: drakonGraph.description || "",
+        branches: branchTrees
+    }
+}
+
+
+function checkBranchIsReferenced(branch, firstNodeId, filename) {
+    if (branch.id === firstNodeId) {
+        return
+    }
+    if (branch.prev.length === 0) {
+        throw createError(translate("A silhouette branch is not referenced"), filename, branch.id)
+    }
+}
+
+function cutOffBranch(nodes, branch) {
+    var end = {
+        type: "end",
+        id: branch.id + "-end",
+        prev: []
+    }
+    nodes[end.id] = end
+    branch.next = branch.one
+    var addresses = []
+    traverseToHitBranch(nodes, branch.id, {}, (prev, node) => addFakeEnd(nodes, prev, node, end, addresses))
+}
+
+function traverseToHitBranch(nodes, nodeId, visited, action) {
+    if (!nodeId) {return}
+    if (nodeId in visited) {return}
+    visited[nodeId] = true
+    var node = nodes[nodeId]
+    if (!node) {return}
+    if (node.one) {
+        var one = nodes[node.one]
+        if (one.type === "branch") {
+            action(node, one)
+        } else {
+            traverseToHitBranch(nodes, node.one, visited, action)
+        }
+    }
+    if (node.two) {
+        var two = nodes[node.two]
+        if (two.type === "branch") {
+            action(node, two)
+        } else {
+            traverseToHitBranch(nodes, node.two, visited, action)
+        }
+    }    
+}
+
+var idCounter = 1000
+function addFakeEnd(nodes, prev, node, end, addresses) {
+    var lastAddress = undefined
+    if (addresses.length > 0) {
+        lastAddress = addresses[addresses.length - 1]
+    }        
+    var address
+    if (lastAddress && lastAddress.branch === node.id) {
+        address = lastAddress
+    } else {
+        address = {
+            type: "address",
+            content: node.content,
+            id: "ad-" + idCounter,
+            branch: node.id,
+            one: end.id,
+            prev: []
+        }   
+        idCounter++
+        nodes[address.id] = address
+        end.prev.push(address.id)
+        addresses.push(address)
+    }
+    redirectNode(nodes, prev, node.id, address.id)
+}
+
+function buildTwoWayConnections(nodes, firstNodeId) {
+    for (var id in nodes) {
+        var node = nodes[id]
+        node.id = id
+        node.prev = []        
+    }
+
+    traverse(nodes, firstNodeId, {}, connectBack)
+}
+
+function findStartNode(nodes, filename, branches) {
+    var firstNodeId = undefined
+    var minBranchId = 10000    
+    for (var id in nodes) {
+        var node = nodes[id]
+        if (node.type === "branch") {
+            if (node.branchId < minBranchId) {
+                firstNodeId = id
+                minBranchId = node.branchId
+            }
+            branches.push(node)
+        } else if (node.type === "select") {
+            if (!node.content) {
+                throw createError(translate("A Select icon must have content"), filename, id)
+            }            
+            node.cases = [];
+        } else if (node.type === "loopbegin") {
+            if (!node.content) {
+                throw createError(translate("A Loop begin icon must have content"), filename, id)
+            }             
+        } else if (node.type === "question") {
+            if (!node.content) {
+                throw createError(translate("A Question icon must have content"), filename, id)
+            }             
+        }
+    }
+
+    return firstNodeId
+}
+
+function rewireSelectsMarkLoops(nodes, filename) {
+    for (var id of Object.keys(nodes)) {
+        var node = nodes[id]
+        if (!node) { continue }
+        if (node.type === "select") {
+            rewireSelect(nodes, node, filename)
+        } else if (node.type === "loopbegin") {
+            markLoopBody(nodes, node, filename)
+        }
+    }
+}
+
+function rewireSelect(nodes, selectNode, filename) {
+    var caseNodeId = selectNode.one
+    while (caseNodeId) {
+        var caseNode = nodes[caseNodeId]
+        caseNodeId = caseNode.two
+        if (caseNode.content) {
+            caseNode.type = "question"
+            caseNode.flag1 = 1
+            caseNode.content = {operator: "equal", left:selectNode.content, right:caseNode.content}
+            if (!caseNode.two) {
+                var errorId = caseNode.id + "-unexpected"
+                var errorAction = insertIcon(nodes, "error", errorId,  selectNode.content)
+                errorAction.message = "Unexpected case value"
+
+                caseNode.two = errorId
+                errorAction.prev.push(caseNode.id)
+                errorAction.one = caseNode.one
+
+                var next = nodes[caseNode.one]
+                next.prev.push(errorId)
+            }
+        } else {
+            if (caseNode.two) {
+                throw createError(translate("Only the rightmost Case icon can be empty"), filename, caseNode.id)
+            }
+            removeNodeOne(nodes, caseNode.id)
+        }
+    }
+    removeNodeOne(nodes, selectNode.id)
+}
+
+function insertIcon(nodes, type, id, content) {
+    var node = {
+        type: type,
+        id: id,
+        content: content,
+        prev: []
+    }
+    nodes[id] = node
+    return node
+}
+
+function removeNodeOne(nodes, nodeId) {
+    var node = nodes[nodeId]
+    redirectPrev(nodes, node, node.one)
+    redirectNext(nodes, node, node.one)
+    delete nodes[nodeId]
+}
+
+function removeFromNext(node, next) {
+    next.prev = next.prev.filter(prevId => prevId !== node.id)
+}
+
+function redirectPrev(nodes, node, newTarget) {
+    for (var prevId of node.prev) {
+        var prev = nodes[prevId]
+        if (prev.one === node.id) {
+            prev.one = newTarget
+        }
+        if (prev.two === node.id) {
+            prev.two = newTarget
+        }      
+    }
+}
+
+function redirectNext(nodes, node, newTarget) {
+    var target = nodes[newTarget]
+    removeFromNext(node, target)
+    for (var prevId of node.prev) {
+        target.prev.push(prevId)
+    }
+}
+
+function rewireShortcircuit(nodes) {
+    while (findShortcusts(nodes)) {
+
+    }
+}
+
+function findShortcusts(nodes) {
+    for (var id in nodes) {
+        var node = nodes[id]
+        if (node.type === "question") {
+            var andOperand = findAndOperand(nodes, node)
+            if (andOperand) {
+                writeAndShortcut(nodes, node, andOperand)
+                return true
+            }
+            var orOperand = findOrOperand(nodes, node)
+            if (orOperand) {
+                writeOrShortcut(nodes, node, orOperand)
+                return true
+            }            
+        }
+    }
+    return false
+}
+
+function findAndOperand(nodes, node) {
+    var below = nodes[node.one]
+    if (below.type === "question") {
+        if (below.prev.length === 1 && below.two === node.two) {
+            return below
+        }
+    }
+    return undefined
+}
+
+function findOrOperand(nodes, node) {
+    var right = nodes[node.two]
+    if (right.type === "question") {
+        if (right.prev.length === 1 && right.one === node.one) {
+            return right
+        }
+    }
+    return undefined
+}
+
+function writeAndShortcut(nodes, node, andOperand) {
+    var right = nodes[node.two]
+    var down = nodes[andOperand.one]
+    removeFromNext(andOperand, right)
+    removeFromNext(andOperand, down)
+    node.content = {
+        operator: "and",
+        left: normalizeContent(node),
+        right: normalizeContent(andOperand)
+    }
+    node.one = down.id
+    node.flag1 = 1
+    down.prev.push(node.id)
+    delete nodes[andOperand.id]
+}
+
+function writeOrShortcut(nodes, node, orOperand) {
+    var right = nodes[orOperand.two]
+    var down = nodes[orOperand.one]
+    removeFromNext(orOperand, right)
+    removeFromNext(orOperand, down)
+    node.content = {
+        operator: "or",
+        left: normalizeContent(node),
+        right: normalizeContent(orOperand)
+    }
+    node.two = right.id
+    node.flag1 = 1
+    right.prev.push(node.id)
+    delete nodes[orOperand.id]
+}
+
+function normalizeContent(question) {
+    if (question.flag1 === 1) {
+        return question.content
+    }
+
+    return {
+        operator: "not",
+        operand: question.content
+    }
+}
+
+
+function traverse(nodes, nodeId, visited, action) {
+    if (!nodeId) {
+        return
+    }
+
+    if (nodeId in visited) {
+        return
+    }
+    visited[nodeId] = true
+    var node = nodes[nodeId]
+    action(nodes, node)
+    traverse(nodes, node.one, visited, action)
+    traverse(nodes, node.two, visited, action)
+}
+
+function connectBack(nodes, node) {
+    if (node.one) {
+        var one = nodes[node.one]
+        one.prev.push(node.id)
+    }
+    if (node.two) {
+        var two = nodes[node.two]
+        two.prev.push(node.id)
+    }    
+}
+
+function markLoopBody(nodes, start, filename) {
+    var nextNodeId = start.one
+    while (nextNodeId) {
+        var current = nodes[nextNodeId]
+        nextNodeId = current.one
+        current.parentLoopId = start.id
+        if (current.type === "loopbegin") {
+            nextNodeId = markLoopBody(nodes, current, filename)
+        } else if (current.type === "loopend") {
+            start.end = current.id
+            start.next = current.one
+            current.start = start.id
+            return nextNodeId
+        }
+    }
+    throw createError(translate("Loop end expected here"), filename, start.one)
+}
+
+module.exports = { drakonToStruct, drakonToGraph };

package/src/drakongen.js

@@ -0,0 +1,16 @@
+const { drakonToPseudocode } = require('./drakonToPromptStruct');
+const {htmlToString} = require("./browserTools")
+const { setUpLanguage, translate } = require("./translate")
+const {drakonToStruct} = require("./drakonToStruct");
+
+
+window.toPseudocode = function(drakonJson, name, filename, language) {
+    setUpLanguage(language)
+    return drakonToPseudocode(drakonJson, name, filename, htmlToString, translate).text
+}
+
+window.toTree = function(drakonJson, name, filename, language) {
+    setUpLanguage(language)
+    var result = drakonToStruct(drakonJson, name, filename, translate)
+    return JSON.stringify(result, null, 4)
+}

package/src/index.js

@@ -0,0 +1,17 @@
+const { drakonToPseudocode } = require('./drakonToPromptStruct');
+const { htmlToString } = require("./nodeTools")
+const { setUpLanguage, translate } = require("./translate")
+const { drakonToStruct } = require("./drakonToStruct");
+
+function toPseudocode(drakonJson, name, filename, language) {
+    setUpLanguage(language)
+    var result = drakonToPseudocode(drakonJson, name, filename, htmlToString, translate)
+    return result.text
+}
+
+function toTree(drakonJson, name, filename, language) {
+    setUpLanguage(language)
+    var result = drakonToStruct(drakonJson, name, filename, translate)
+    return JSON.stringify(result, null, 4)
+}
+module.exports = { toPseudocode, toTree }