gd2puml.html

<style>
    * {
        padding: 0;
        margin: 0;
    }
    #source, #result {
        width: 50%;
        height: 100%
    }
    #button {
        width: 5rem;
        height: 5rem;
        position: fixed;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
        font-size: 3em;
    }
</style>
<button id="button" onclick="convert()">▶️</button>
<form spellcheck="false"><textarea id="source"></textarea><textarea id="result"></textarea></form>
<script>
    result.value = ""
    function convert(){
        
        result.value = "@startuml\nscale 2\n\n"
        
        let classes = {}
        let globalNames = []
        
        let code = source.value.replace(/#global (.*)/gm, (m, g1) => {
            globalNames.push(g1.trim())
            return 'class_name ' + g1
        })
        .replace(/#.*/gm, '')
        .replace(/([[{,\\])\n\s*/g, '$1 ').replace(/\s*\n}/g, ' }')

        {
            let lastClass
            let prevMatchEnd
            let lastMatchIndex
            for(const match of code.matchAll(/^(?:class_name (.*?)(?:,\s*['"](.*)["'])?\n\s*)?extends (.*)/gm)){
                if(lastClass)
                    lastClass.body = code.substring(prevMatchEnd + 1, match.index)
                prevMatchEnd = match.index + match[0].length - 1
                lastMatchIndex = match.index
                let [_, className, iconPath, classExtends, subclassName, subclassExtends, subclassBody] = match
                lastClass = {
                    name: className || subclassName || ("Class" + Object.keys(classes).length),
                    extends: classExtends || subclassExtends
                }
                if(subclassName)
                    lastClass.subclass = true
                else if(globalNames.includes(lastClass.name))
                    lastClass.static = true
                classes[lastClass.name] = lastClass
            }
            if(lastClass) //TODO: unduplicate
                lastClass.body = code.substring(prevMatchEnd + 1, code.length)
        }

        for(let cls of Object.values(classes)){
            for(const match of cls.body.matchAll(/class ([^\s]+)(?: extends ([^\s]+)):((?:\t{1,}.*|\n)*)/gm)){
                let [_, subclassName, subclassExtends, subclassBody] = match
                let newSubclass = {
                    name: subclassName,
                    extends: subclassExtends,
                    body: subclassBody,
                    subclass: true
                }
                if(!cls.subclasses)
                    cls.subclasses = {}
                cls.subclasses[newSubclass.name] = newSubclass
                classes[subclassName] = newSubclass
            }
        }

        for(let name of Object.keys(classes)){
            let nameRegex = new RegExp('\\b' + name + '\\b')
            for(let cls of Object.values(classes)){
                if(name == cls.name)
                    continue
                if(nameRegex.test(cls.body)){
                    if(!cls.uses)
                        cls.uses = []
                    cls.uses.push(name)
                }
            }
        }

        for(let cls of Object.values(classes)){
            for(const match of cls.body.matchAll(/^(\t*)(?:((?:puppet(?:sync)?|master(?:sync)?|remote(?:sync)?)\s+)?func\s+(.*):|(export(?:\s*\(.*?\))?\s+)?(?:onready\s+)?(var|const)\s+(.*?)(?: setget(?: *(\w+))?(?:, *(\w+))?)?$|enum\s+(.*?)\s+{(.*?)})/gm)){
                let [_, indentationLevel, remoteMode, func, propExport, propType, prop, propSetter, propGetter, enumName, enumKeys] = match
                if(!indentationLevel || (cls.subclass && indentationLevel.length == 1)){
                    if(func){
                        if(!cls.funcs)
                            cls.funcs = {}
                        let newFunc = { name: func.match(/^\w+/)[0], sign: func }
                        if(remoteMode)
                            newFunc.remote = true
                        cls.funcs[newFunc.name] = newFunc
                    } else if(prop){
                        if(!cls.props)
                            cls.props = {}
                        let newProp = { name: prop.match(/^\w+/)[0], decl: prop }
                        if(propType == 'const')
                            newProp.const = true
                        if(propExport)
                            newProp.exported = true
                        if(propSetter)
                            newProp.setter = propSetter
                        if(propGetter)
                            newProp.getter = propGetter
                        cls.props[newProp.name] = newProp
                    } else if(enumName){
                        if(!cls.enums)
                            cls.enums = {}
                        let newEnum = { name: enumName, keys: enumKeys.split(/\s*,\s*/g) }
                        cls.enums[newEnum.name] = newEnum
                    }
                }
            }
        }

        for(let cls of Object.values(classes)){
            if(cls.funcs){
                let currentParent = cls
                //console.log('class', cls.name)
                while(currentParent.extends && classes[currentParent.extends]){
                    currentParent = classes[currentParent.extends]
                    //console.log('extends', currentParent.name)
                    if(currentParent.funcs)
                    for(let func of Object.values(cls.funcs)){
                        if(currentParent.funcs[func.name]){
                            currentParent.funcs[func.name].virtual = true
                            //console.log(func.name, 'is virtual')
                        }
                    }
                    if(!cls.parents)
                        cls.parents = []
                    cls.parents.push(currentParent)
                }
            }
        }

        for(let cls of Object.values(classes)){
            if(cls.parents)
            for(let parent of cls.parents){
                if(!parent.childs)
                    parent.childs = []
                parent.childs.push(cls)
            }
        }

        for(let cls of Object.values(classes)){
            if(cls.props && cls.funcs){
                for(let prop of Object.values(cls.props)){
                    for(let setterOrGetter of [prop.setter, prop.getter]){
                        if(setterOrGetter && cls.funcs[setterOrGetter]){
                            var setterOrGetterOverrriden = false
                            if(cls.childs)
                            for(let child of cls.childs){
                                if(child.funcs && child.funcs[setterOrGetter]){
                                    setterOrGetterOverrriden = true
                                    break
                                }
                            }
                            if(!setterOrGetterOverrriden){
                                delete cls.funcs[setterOrGetter]
                                console.log(cls.name + '.' + setterOrGetter, 'removed')
                            } else
                                console.log(cls.name + '.' + setterOrGetter, 'overriden')
                        }
                    }
                }
            }
        }

        let oneIsParentOfAnother = (classA, classB) => {
            return (classA.parents && classA.parents.includes(classB)) || (classB.parents && classB.parents.includes(classA))
        }
                        
        let definesName = (classB, name) => {
            return (classB.funcs && classB.funcs[name]) || (classB.props && classB.props[name])
        }


        for(let classA of Object.values(classes)){
            if(classA.props || classA.funcs){
                let propRegexTemplate = /(?<=[\w})\]][\t ]*)\.test\b|\.(?:has|get|set|rpc|rset|call(?:v|_deferred)?)\((["'])test\1|\[(['"])test\2|\.rpc(?:_unreliable)?_id\(.*?,\s*(["'])test\3/.source //.replace(/^\/|\/$/g, '')
                
                let allProps = []
                if(classA.props){
                    allProps = Object.values(classA.props)
                    if(classA.funcs)
                        allProps = allProps.concat(Object.values(classA.funcs))
                } else if(classA.funcs)
                    allProps = Object.values(classA.funcs)
                
                for(let prop of allProps){
                    //if(prop.exported || ["_ready", "_process", "_physics_process"].includes(prop.name))
                    //    continue
                    let propRegex = new RegExp(propRegexTemplate.replace(/test/g, prop.name))
                    let foundInAnotherClass = false
                    for(let classB of Object.values(classes)){
                        if(classB.body && propRegex.test(classB.body)){
                            foundInAnotherClass = true
                            break
                        }
                    }

                    let foundNamesake = false
                    /*
                    for(let classB of Object.values(classes)){

                        if(classB == classA)
                            continue

                        if(!oneIsParentOfAnother(classA, classB)){
                            let boothHaveParentWithFunc = false
                            if(classA.parents)
                            for(let parent of classA.parents)
                                if(parent.funcs && parent.funcs[prop.name] && classB.parents && classB.parents.includes(parent)){
                                    boothHaveParentWithFunc = true
                                    break
                                }
                            if(!boothHaveParentWithFunc){
                                let namesake = definesName(classB, prop.name)
                                if(namesake)
                                    console.log(classA.name, 'and', classB.name, 'booth define', prop.name)
                                foundNamesake ||= !!namesake
                            }
                        }
                    }
                    */
                    if(!foundInAnotherClass){
                        //console.log(classA.name, '->', prop.name, 'may be protected')
                        prop.protected = true
                        let usedInRelative = false
                        let nameRegex = new RegExp('\\b' + prop.name + '\\b')
                        for(let classB of Object.values(classes))
                            if(classB != classA && classB.body && oneIsParentOfAnother(classA, classB) && nameRegex.test(classB.body)){
                                usedInRelative = true
                                break
                            }
                        if(!usedInRelative){
                            //console.log(classA.name, '->', prop.name, 'may be private')
                            prop.private = true
                        }
                    } else if(foundNamesake){
                        console.log(prop.name, 'collision')
                    }
                }
            }
        }
        /*
        let mergeClasses = (a, b) => {
            for(let prop of Object.keys(b)){
                if(a[prop] !== undefined && a[prop] != b[prop]){
                    if(Array.isArray(a[prop]) && Array.isArray(b[prop]))
                        a[prop] = a[prop].concat(b[prop])
                    else if(typeof(a[prop]) == "object" && typeof(b[prop]) == "object"){
                        //console.log('->', prop)
                        a[prop] = mergeClasses(a[prop], b[prop])
                        //console.log('<-', prop)
                    } else
                        console.log('merging conflict', prop)
                } else
                    a[prop] = b[prop]
            }
            return a
        }

        if(classes.AvatarOwner && classes.Hiding){
            classes.AvatarOwner = mergeClasses(classes.Hiding, classes.AvatarOwner)
            classes.AvatarOwner.name = "AvatarOwner"
            delete classes.Hiding
        }
        */
        var firstClass = true
        for(let cls of Object.values(classes)){
            if(!firstClass)
                result.value += '}\n\n'
            firstClass = false
            result.value += 'class ' + cls.name + ' {\n'

            if(cls.props)
            for(let prop of Object.values(cls.props)){
                result.value += '    '
                //if(cls.static)
                //    result.value += '{static} '
                if((/[()]/).test(prop.decl))
                    result.value += '{field} '
                if(prop.name.startsWith('_') || prop.protected){
                    if(prop.private)
                        result.value += '-'
                    else
                        result.value += '#'
                } else
                    result.value += '+'
                result.value += (prop.const ? 'const' : 'var') + ' ' + prop.decl + '\n'
            }

            if(cls.funcs)
            for(let func of Object.values(cls.funcs)){
                result.value += '    '
                if(func.virtual)
                    result.value += '{abstract} '
                //else if(cls.static)
                //    result.value += '{static} '
                if(func.name.startsWith('_') || func.protected){
                    if(func.private)
                        result.value += '-'
                    else
                        result.value += '#'
                } else
                    result.value += '+'
                result.value += 'func ' + func.sign + '\n'
            }

            if(cls.enums){
                for(let enm of Object.values(cls.enums)){
                    result.value += '}\n'
                    result.value += 'enum ' + enm.name + ' {\n'
                    for(let key of enm.keys)
                        result.value += '    ' + key + '\n'
                }
            }

            //delete cls.body
        }

        if(!firstClass)
            result.value += '}\n\n'

        for(let cls of Object.values(classes)){
            if(cls.extends)
                result.value += cls.extends + ' <|-- ' + cls.name + '\n'
        }
        /*
        for(let cls of Object.values(classes)){
            if(cls.uses)
            for(let used of cls.uses)
                result.value += used + ' o-- ' + cls.name + '\n'
        }
        */
        for(let cls of Object.values(classes)){
            if(cls.enums)
            for(let enm of Object.values(cls.enums))
                result.value += cls.name + ' *-- ' + enm.name + '\n'
        }

        result.value += "\n@enduml"
        
        /*
            var (.*?) = get_node\(\1\) as (.*)
            var $1: $2

            var (.*?) = get_node\(\1\)\s*$
            var $1: Node

            var (.*?) = get_node\(\1\) if \1 else null$
            var $1: Node = null
        */

        return classes
    }
</script>