@lcap/nasl 1.0.0-alpha.8 → 1.0.1

package/src/server/getProcesses.ts

@@ -1,6 +1,6 @@
 import Constant from '@nasl/concepts/Constant__';
-import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param } from '..';
-
+import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem } from '..';
+import { getNodeByNodeCallee } from '../automate/engine/utils';
 function alphaUpper(name: string) {
     if (!name) {
         return '';
@@ -9,7 +9,7 @@ function alphaUpper(name: string) {
 }
 
 export function genLaunchProcess(process: Process) {
-    const l = new Logic({
+    const l: Logic = new Logic({
         name: 'launch',
         params: process.params,
         body: [],
@@ -20,6 +20,10 @@ export function genLaunchProcess(process: Process) {
             }),
         ],
     });
+    const path = `process.${process.name}.logics`;
+    l.getNamespace = function() {
+        return path;
+    }
     l.fake = true;
     return l;
 }
@@ -61,6 +65,10 @@ export function genUserTaskLogic(userTask: ProcessElement) {
         body: [],
         returns: [],
     });
+    const path = `elements.${userTask.name}.logics`;
+    l.getNamespace = function() {
+        return path;
+    }
     l.fake = true;
     return l;
 }
@@ -90,6 +98,242 @@ type VariableSuggestion = Array<Suggestion>;
 type CompletionPropertyEnhance = CompletionProperty & {
     children?: Array<CompletionProperty>;
 };
+const excludeKey = [
+    'app',
+    'module',
+    'structure',
+    'enumeration',
+    'entity',
+    'view',
+    'viewElement',
+    'processElement',
+    'element',
+    'viewComponent',
+    'logic',
+    'process',
+    'interface',
+    'nodePath',
+    'upperNode',
+    'rootNode',
+    'parentNode',
+];
+export function travelDown(node: any, callback: (node: any) => void) {
+    const stack = [node];
+    const checked = new WeakSet();
+    while (stack.length) {
+        const n = stack.pop();
+        if (!n) {
+            continue;
+        }
+        checked.add(n);
+        callback(n);
+        for (const k in n) {
+            if (!excludeKey.includes(k) && n.hasOwnProperty(k)) {
+                const t = n[k];
+                if (t && typeof t === 'object' && !checked.has(t)) {
+                    if (Array.isArray(t)) {
+                        for (const q in t) {
+                            const w = t[q];
+                            if (typeof w === 'object') {
+                                stack.push(w);
+                            }
+                        }
+                    } else {
+                        stack.push(t);
+                    }
+                }
+            }
+        }
+    }
+}
+
+export function syncMemberExpression(elem: ProcessElement | Process, callback: (node: MemberExpression) => void) {
+    const process = elem instanceof Process ? elem : elem.process;
+    process.elements.forEach((el) => {
+        if (el.type === 'UserTask') {
+            el.bindAttrs.forEach((attr) => {
+                if (attr.name === 'destination') {
+                    attr.destination.arguments.forEach((arg) => {
+                        travelDown(arg.expression, (node) => {
+                            if (node instanceof MemberExpression) {
+                                console.log('UserTask', node.getValue());
+                                callback(node);
+                                // if(node.property.name === oldName) {}
+                            }
+                        });
+                    });
+                }
+            });
+        }
+        if (el.type === 'ExclusiveGateway') {
+            travelDown(el.logic, (node) => {
+                if (node instanceof MemberExpression) {
+                    console.log('ExclusiveGateway', node.getValue());
+                    callback(node);
+                }
+            });
+        }
+    });
+}
+// ['a','b','c'] => a.b.c
+export function genCompletionProperty(prefix: string[] = []):(v: Variable | Param | Return | Constant) => CompletionProperty {
+    return (v) => {
+        let m: MemberExpression;
+        const p = new Identifier({ name: v.name });
+        const t = prefix.slice();
+        const q = prefix.slice();
+        while (q.length) {
+            const ns = q.shift();
+            const cv = new Identifier({ name: ns });
+            if (!m) {
+                m = new MemberExpression({
+                    object: cv,
+                });
+                cv.parentNode = m;
+            } else {
+                m.property = cv;
+                const tm = new MemberExpression({
+                    object: m,
+                });
+                m.parentKey = 'object';
+                m.parentNode = tm;
+                cv.parentKey = 'property';
+                cv.parentNode = tm;
+                m = tm;
+            }
+        }
+        if (m) {
+            m.property = p;
+            p.parentNode = m;
+            p.parentKey = 'property';
+        }
+        let prevalue = '';
+        if (t.length) {
+            prevalue = `${t.join('.')}.`;
+        }
+        const hasChild = ['reference', 'generic'].includes(v.typeAnnotation.typeKind);
+        const cp = new CompletionProperty({
+            expression: m || p,
+            noFurther: !hasChild,
+            name: v.name,
+            value: prevalue + v.name,
+
+        });
+        console.log(cp.value);
+        cp.icon = v.concept;
+
+        if (hasChild) {
+            cp.children = [new CompletionProperty()];
+        }
+        return cp;
+    };
+}
+
+export function getPreviousTask(node: ProcessElement) {
+    const process = node.process;
+    const elems = process.elements;
+    const elements: ProcessElement[] = [];
+    const visitedMap = new WeakMap();
+    function iterator(processElem: ProcessElement) {
+        if (visitedMap.has(processElem)) {
+            return;
+        }
+        if (processElem !== node && (processElem.type === 'UserTask')) {
+            elements.push(processElem);
+        }
+        visitedMap.set(processElem, true);
+        const links = elems.filter((e) => e.type === 'SequenceFlow' && e.targetRef === processElem.name);
+        links.forEach((l) => {
+            const s = l.sourceRef;
+            const t = elems.find((el) => el.name === s);
+            if (t) {
+                iterator(t);
+            }
+        });
+    }
+
+    iterator(node);
+    return elements;
+}
+
+export function getProcessVariableSuggestions(node: Logic, abandonConstant: boolean = false): CompletionProperty {
+    if (!node.processElement) {
+        return;
+    }
+    const processElem = node.processElement;
+    const process = node.process;
+
+    const elements: ProcessElement[] = getPreviousTask(processElem);
+    const prevtasks = elements.map((us) => {
+        const cp = new CompletionProperty({
+            name: us.name,
+            value: us.name,
+            noFurther: true,
+            children: [
+                ...us.returns.map(genCompletionProperty([process.name, us.name])),
+                ...(abandonConstant ? [] : us.constants.map(genCompletionProperty([process.name, us.name]))),
+            ],
+        });
+        cp.icon = us.type;
+        cp.isProcess = true;
+        return cp;
+    });
+
+    const processVariables = new CompletionProperty({
+        name: process.name,
+        value: process.name,
+        noFurther: true,
+        children: [
+            ...process.params.map(genCompletionProperty([process.name])),
+            ...process.returns.map(genCompletionProperty([process.name])),
+            ...process.constants.map(genCompletionProperty([process.name])),
+            ...prevtasks,
+        ],
+    });
+    processVariables.icon = 'Process';
+    if (processElem.type === 'ExclusiveGateway') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
+        });
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
+
+    if (processElem.type === 'UserTask') {
+        const scopeVariable = new CompletionProperty({
+            name: processElem.name,
+            value: processElem.name,
+            icon: processElem.type,
+            noFurther: true,
+            children: processElem.constants.map(genCompletionProperty([process.name, processElem.name])),
+        });
+        scopeVariable.isProcess = true;
+        scopeVariable.icon = processElem.type;
+        processVariables.children.push(scopeVariable);
+    }
+    // if(processElem.type === 'AutoTask') {
+    //     const scopeVariable = new CompletionProperty({
+    //         name: processElem.name,
+    //         value: processElem.name,
+    //         icon: processElem.type,
+    //         noFurther: true,
+    //         children: [
+    //             ...processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
+    //             ...processElem.returns.map(genCompletionProperty([process.name, processElem.name])),
+    //         ]
+    //     });
+    //     scopeVariable.isProcess = true;
+    //     scopeVariable.icon = processElem.type;
+    //     processVariables.children.push(scopeVariable);
+    // }
+    return processVariables;
+}
+
 export function getProcessVaraibleSelections(node: Logic, list: VariableSuggestion) {
     const process = node.process;
     const processElem = node.processElement;
@@ -111,7 +355,7 @@ export function getProcessVaraibleSelections(node: Logic, list: VariableSuggesti
     const varidx = list.findIndex((i) => i.name === '变量');
     const processVars = vars.children.find((v) => v.children && v.name === process.name) as CompletionPropertyEnhance;
     const elementVars = vars.children.filter((v) => exsitNames.includes(v.name));
-
+    // console.log(list);
     if (processVars) {
         processVars.children.forEach((p: CompletionProperty) => {
             processData.children.push(p as any as CompletionData);

package/src/server/getScope.ts

@@ -0,0 +1,62 @@
+import { Logic, View, Process } from '..';
+
+type wordScope = {
+    Param?: string[]
+    Return?: string[]
+    Variable?: string[]
+    Constant?: string[]
+}
+
+export function getLogicScopeWords(logic: Logic): wordScope {
+    const scope: wordScope = {
+        Param: logic.params.map((p) => p.name),
+        Return: logic.returns.map((p) => p.name),
+        Variable: logic.variables.map((p) => p.name),
+        Constant: [],
+    };
+    return scope;
+}
+
+export function getViewScopeWords(view: View): wordScope {
+    const scope: wordScope = {
+        Param: view.params.map((p) => p.name),
+        Variable: view.variables.map((p) => p.name),
+        Return: [],
+        Constant: [],
+    };
+    return scope;
+}
+
+export function getProcessScopeWords(process: Process): wordScope {
+    const processName = process.name;
+    const scope: wordScope = {
+        Param: process.params.map((p) => `${processName}.${p.name}`),
+        Return: process.returns.map((p) => `${processName}.${p.name}`),
+        Constant: process.constants.map((p) => `${processName}.${p.name}`),
+        Variable: [],
+    };
+
+    process.elements.forEach((el) => {
+        const elname = el.name;
+        el.variables.forEach((v) => {
+            scope.Variable.push(`${processName}.${elname}.${v.name}`);
+        });
+        el.returns.forEach((v) => {
+            scope.Return.push(`${processName}.${elname}.${v.name}`);
+        });
+        el.constants.forEach((v) => {
+            scope.Constant.push(`${processName}.${elname}.${v.name}`);
+        });
+    });
+    return scope;
+}
+
+export function combineScope(a: wordScope, b: wordScope) : wordScope {
+    const scope: wordScope = {
+        Param: [...a.Param, ...b.Param],
+        Return: [...a.Return, ...b.Return],
+        Constant: [...a.Constant, ...b.Constant],
+        Variable: [...a.Variable, ...b.Variable],
+    };
+    return scope;
+}

package/src/server/index.ts

@@ -3,7 +3,14 @@ import { getInterfaces } from './getInterfaces';
 import { getFunctions, getBuildInFunction } from './getFunctions';
 import { getValidates, getValidateFunction } from './getValidates';
 import { getProcessComponents, getProcessComponent } from './getProcessComponents';
-import { getMemberIdentifier, getSelectNextCompletionData } from './getMemberIdentifier';
+import {
+    getMemberIdentifier,
+    getVariableIdentifier,
+    getEnumsIdentifier,
+    getGlobalVariableIdentifier,
+    getLiteralsIdentifier,
+    getSelectNextCompletionData,
+} from './getMemberIdentifier';
 import naslServer from './naslServer';
 
 const server: any = {
@@ -19,5 +26,9 @@ const server: any = {
     getValidates,
     getValidateFunction,
     getSelectNextCompletionData,
+    getVariableIdentifier,
+    getEnumsIdentifier,
+    getGlobalVariableIdentifier,
+    getLiteralsIdentifier,
 };
 export default server;