@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/breakpoint/generator/BreakpointNode.ts

@@ -3,309 +3,357 @@ import { BaseNode, Argument } from '../../concepts';
 import { getUniqueIdFromNode, getRealNode } from '../shared/utils';
 
 type Options = {
-    logic?: BaseNode;
-    variable?: BaseNode;
-}
+  logic?: BaseNode;
+  variable?: BaseNode;
+};
 
 const MATCH_CONCEPT = 'Match';
 const MATCH_CASE_CONCEPT = 'MatchCase';
 const ASSIGNMENT_CONCEPT = 'Assignment';
 const CALL_LOGIC_CONCEPT = 'CallLogic';
 const CALL_FUNCTION_CONCEPT = 'CallFunction';
+const CALL_INTERFACE_CONCEPT = 'CallInterface';
 const WHILE_STATEMENT_CONCEPT = 'WhileStatement';
 const DESTINATION_CONCPETS = ['ExternalDestination', 'Destination'];
 const LOG_CALLER_NAMES = ['showMessage', 'consoleLog'];
 
 const BEFORE_LOGIC_CONCEPTS = [
-    MATCH_CONCEPT,
-    'JSBlock',
-    'New',
-    'NewMap',
-    'NewList',
-    'NewComposite',
-    'ForEachStatement',
-    'SwitchStatement',
-    'IfStatement',
+  MATCH_CONCEPT,
+  'JSBlock',
+  'New',
+  'NewMap',
+  'NewList',
+  'NewComposite',
+  'ForEachStatement',
+  'SwitchStatement',
+  'IfStatement',
 ];
 
 const attribute = '[Symbol.for(\'breakpoint\')]';
-const parse = `(code) => eval(code)`;
+const parse = '(code) => eval(code)';
+
+const assemble = (instance: BreakpointNode) => (code: string) => {
+  if (!instance || !code) {
+    return code;
+  }
+
+  const { _nodePath } = instance;
+
+  if (!_nodePath) {
+    return code;
+  }
+
+  return `await $breaker.assembleFragment('${_nodePath}')(${code})`;
+};
 
 const callLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { _nodePath, logic, variable } = instance;
-    const node = logic || variable;
+  const { _nodePath, logic, variable } = instance;
+  const node = logic || variable;
 
-    if (!node) {
-        return breaker;
-    }
+  if (!node) {
+    return breaker;
+  }
 
-    const source = node as any;
-    const { concept, calleeName, isViewLogic } = source;
+  const source = node as any;
+  const { concept, calleeName, isViewLogic } = source;
 
-    if (concept !== CALL_LOGIC_CONCEPT) {
-        return;
-    }
+  if (concept !== CALL_LOGIC_CONCEPT) {
+    return;
+  }
 
-    if (LOG_CALLER_NAMES.includes(calleeName)) {
-        return;
-    }
+  if (LOG_CALLER_NAMES.includes(calleeName)) {
+    return;
+  }
 
-    const { arguments: args } = source;
+  const { arguments: args } = source;
 
-    const wrapper = <T extends Function>(callback: T) => {
-        if (isViewLogic) {
-            return callback();
-        }
+  const wrapper = <T extends Function>(callback: T) => {
+    if (isViewLogic) {
+      return callback();
+    }
 
-        const logic = source.getCallNode() || {};
-        const { params: logicParams } = logic;
+    const logic = source.getCallNode() || {};
+    const { params: logicParams } = logic;
 
-        const logicBase = logicParams || [];
-        logic.params = logicBase.concat({ name: attribute });
+    const logicBase = logicParams || [];
+    logic.params = logicBase.concat({ name: attribute });
 
-        const result = callback();
-        logic.params = logicParams;
+    const result = callback();
+    logic.params = logicParams;
 
-        return result;
-    };
+    return result;
+  };
 
-    const breakpointExpression = new BreakpointNode();
-    const breakpointArgument = new Argument();
-    const base = args || [];
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  const breakpointExpression = new BreakpointNode();
+  const breakpointArgument = new Argument();
+  const base = args || [];
 
-    breakpointArgument.name = attribute;
-    breakpointArgument.expression = breakpointExpression as any;
-    breakpointExpression._nodePath = _nodePath;
-    source.arguments = base.concat(breakpointArgument);
+  breakpointArgument.name = attribute;
+  breakpointArgument.expression = breakpointExpression as any;
+  breakpointExpression._nodePath = _nodePath;
+  source.arguments = base.concat(breakpointArgument);
 
-    const callback = () => source.toJS();
-    const code = wrapper(callback);
-    source.arguments = args;
+  const callback = () => source.toJS();
+  const code = wrapper(callback);
+  source.arguments = args;
 
-    return code;
+  return assemble(instance)(code);
 };
 
 const callFunctionGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { _nodePath, logic, variable } = instance;
-    const node = logic || variable;
+  const { _nodePath, logic, variable } = instance;
+  const node = logic || variable;
 
-    if (!node) {
-        return breaker;
-    }
+  if (!node) {
+    return breaker;
+  }
 
-    const source = node as any;
-    const { concept } = source;
+  const source = node as any;
+  const { concept } = source;
 
-    if (concept !== CALL_FUNCTION_CONCEPT) {
-        return;
-    }
+  if (concept !== CALL_FUNCTION_CONCEPT) {
+    return;
+  }
 
-    const { typeArguments } = source;
+  const { typeArguments } = source;
 
-    const breakpointExpression = new BreakpointNode();
-    const breakpointArgument = new Argument();
-    const base = typeArguments || [];
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  const breakpointExpression = new BreakpointNode();
+  const breakpointArgument = new Argument();
+  const base = typeArguments || [];
 
-    breakpointArgument.name = attribute;
-    breakpointArgument.expression = breakpointExpression as any;
-    breakpointExpression._nodePath = _nodePath;
-    source.typeArguments = base.concat(breakpointArgument);
+  breakpointArgument.name = attribute;
+  breakpointArgument.expression = breakpointExpression as any;
+  breakpointExpression._nodePath = _nodePath;
+  source.typeArguments = base.concat(breakpointArgument);
 
-    const code = source.toJS();
-    source.typeArguments = typeArguments;
+  const code = source.toJS();
+  source.typeArguments = typeArguments;
 
-    return code;
+  return assemble(instance)(code);
 };
 
-const variableGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { _nodePath, variable } = instance;
+const callInterfaceGenerator = (instance: BreakpointNode) => (breaker: string) => {
+  const { logic } = instance;
 
-    if (!variable) {
-        return;
-    }
+  if (!logic) {
+    return;
+  }
+
+  const source = logic as any;
+  const { concept } = source;
+
+  if (concept !== CALL_INTERFACE_CONCEPT) {
+    return;
+  }
+
+  const code = source.toJS();
+  const assembled = assemble(instance)(code);
 
-    const promise = (variable as any)?.toJS() || '';
-    return `await $breaker.generateBreakpoint('${_nodePath}', ${parse})(${promise})`;
+  return `${assembled}\n${breaker}`;
 };
 
-const assignmentGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { _nodePath, logic } = instance;
+const variableGenerator = (instance: BreakpointNode) => () => {
+  const { _nodePath, variable } = instance;
 
-    if (!logic) {
-        return;
-    }
+  if (!variable) {
+    return;
+  }
 
-    const source = logic as any;
-    const { concept, right } = source;
+  const promise = (variable as any)?.toJS() || '';
+  return `await $breaker.generateBreakpoint('${_nodePath}', ${parse})(${promise})`;
+};
 
-    if (concept !== ASSIGNMENT_CONCEPT) {
-        return;
-    }
+const assignmentGenerator = (instance: BreakpointNode) => () => {
+  const { _nodePath, logic } = instance;
 
-    const options = { variable: right };
-    const breakpointRight = new BreakpointNode(options);
+  if (!logic) {
+    return;
+  }
 
-    breakpointRight._nodePath = _nodePath;
-    source.right = breakpointRight as any;
+  const source = logic as any;
+  const { concept, right } = source;
 
-    const code = source.toJS();
-    source.right = right;
+  if (concept !== ASSIGNMENT_CONCEPT) {
+    return;
+  }
 
-    return code;
+  const options = { variable: right };
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  const breakpointRight = new BreakpointNode(options);
+
+  breakpointRight._nodePath = _nodePath;
+  source.right = breakpointRight as any;
+
+  const code = source.toJS();
+  source.right = right;
+
+  return code;
 };
 
 const whileStatementGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { _nodePath, logic } = instance;
+  const { _nodePath, logic } = instance;
 
-    if (!logic) {
-        return;
-    }
+  if (!logic) {
+    return;
+  }
 
-    const source = logic as any;
-    const { concept, body = [] } = source;
+  const source = logic as any;
+  const { concept, body = [] } = source;
 
-    if (concept !== WHILE_STATEMENT_CONCEPT) {
-        return;
-    }
+  if (concept !== WHILE_STATEMENT_CONCEPT) {
+    return;
+  }
 
-    const item = new BreakpointNode();
-    item._nodePath = _nodePath;
-    source.body = body.concat(item);
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  const item = new BreakpointNode();
+  item._nodePath = _nodePath;
+  source.body = body.concat(item);
 
-    const code = source.toJS();
-    source.body = body;
+  const code = source.toJS();
+  source.body = body;
 
-    return `${breaker}\n${code}`;
+  return `${breaker}\n${code}`;
 };
 
-const matchCaseLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { _nodePath, logic } = instance;
+const matchCaseLogicGenerator = (instance: BreakpointNode) => () => {
+  const { _nodePath, logic } = instance;
 
-    if (!logic) {
-        return;
-    }
+  if (!logic) {
+    return;
+  }
 
-    const source = logic as any;
+  const source = logic as any;
 
-    const parentConcept = source?.parentNode?.concept;
-    const underMatch = parentConcept === MATCH_CASE_CONCEPT;
+  const parentConcept = source?.parentNode?.concept;
+  const underMatch = parentConcept === MATCH_CASE_CONCEPT;
 
-    const ancestor = source.getAncestor(MATCH_CONCEPT) || {};
-    const { isExpression } = ancestor;
+  const ancestor = source.getAncestor(MATCH_CONCEPT) || {};
+  const { isExpression } = ancestor;
 
-    if (!underMatch || !isExpression) {
-        return;
-    }
+  if (!underMatch || !isExpression) {
+    return;
+  }
 
-    const breakpoint = new BreakpointNode({ variable: source });
-    breakpoint._nodePath = _nodePath;
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  const breakpoint = new BreakpointNode({ variable: source });
+  breakpoint._nodePath = _nodePath;
 
-    return breakpoint.toJS();
+  return breakpoint.toJS();
 };
 
-const destinationLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { _nodePath, logic } = instance;
+const destinationLogicGenerator = (instance: BreakpointNode) => () => {
+  const { _nodePath, logic } = instance;
 
-    if (!logic) {
-        return;
-    }
+  if (!logic) {
+    return;
+  }
 
-    const source = logic as any;
-    const { anchor, concept } = source;
+  const source = logic as any;
+  const { anchor, concept } = source;
 
-    if (!DESTINATION_CONCPETS.includes(concept)) {
-        return;
-    }
+  if (!DESTINATION_CONCPETS.includes(concept)) {
+    return;
+  }
 
-    const breakpoint = new BreakpointNode({ variable: anchor });
-    breakpoint._nodePath = _nodePath;
-    source.anchor = breakpoint;
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  const breakpoint = new BreakpointNode({ variable: anchor });
+  breakpoint._nodePath = _nodePath;
+  source.anchor = breakpoint;
 
-    const code = source.toJS();
-    source.anchor = anchor;
+  const code = source.toJS();
+  source.anchor = anchor;
 
-    return code;
+  return code;
 };
 
 const logicGenerator = (instance: BreakpointNode) => (breaker: string) => {
-    const { logic } = instance;
+  const { logic } = instance;
 
-    if (!logic) {
-        return;
-    }
+  if (!logic) {
+    return;
+  }
 
-    const promise = (logic as any)?.toJS() || '';
-    const { concept } = logic as any;
+  const promise = (logic as any)?.toJS() || '';
+  const { concept } = logic as any;
 
-    const shouldSetBefore = BEFORE_LOGIC_CONCEPTS.includes(concept);
-    const code = shouldSetBefore ? [breaker, promise] : [promise, breaker];
+  const shouldSetBefore = BEFORE_LOGIC_CONCEPTS.includes(concept);
+  const code = shouldSetBefore ? [breaker, promise] : [promise, breaker];
 
-    return code.join('\n');
+  return code.join('\n');
 };
 
 // 不要更换顺序
 const generators = [
-    callLogicGenerator,
-    callFunctionGenerator,
-    variableGenerator,
-    assignmentGenerator,
-    whileStatementGenerator,
-    matchCaseLogicGenerator,
-    destinationLogicGenerator,
-    logicGenerator,
+  callLogicGenerator,
+  callFunctionGenerator,
+  callInterfaceGenerator,
+  variableGenerator,
+  assignmentGenerator,
+  whileStatementGenerator,
+  matchCaseLogicGenerator,
+  destinationLogicGenerator,
+  logicGenerator,
 ];
 
 const failsafes = [
-    variableGenerator,
-    logicGenerator,
+  variableGenerator,
+  logicGenerator,
 ];
 
 export default class BreakpointNode extends BaseNode {
-    _nodePath: string = '';
+  _nodePath: string = '';
 
-    variable: BaseNode = undefined;
-    logic: BaseNode = undefined;
+  variable: BaseNode = undefined;
 
-    constructor(options: Options = {}) {
-        super();
-        this.logic = options.logic;
-        this.variable = options.variable;
+  logic: BaseNode = undefined;
 
-        this.init();
-    }
+  constructor(options: Options = {}) {
+    super();
+    this.logic = options.logic;
+    this.variable = options.variable;
+
+    this.init();
+  }
 
-    init() {
-        const source = this.logic || this.variable;
-        const node = getRealNode(source);
+  get node() {
+    return this.logic || this.variable;
+  }
 
-        if (!node) {
-            return;
-        }
+  init() {
+    const source = this.logic || this.variable;
+    const node = getRealNode(source);
 
-        this._nodePath = getUniqueIdFromNode(node);
+    if (!node) {
+      return;
     }
 
-    toJS(): string {
-        const node = this.logic || this.variable;
-        const id = this._nodePath;
-        const keyword = `'${id}'`;
-        const breaker = id && `await $breaker.generateBreakpoint(${keyword}, ${parse})()`;
+    this._nodePath = getUniqueIdFromNode(node);
+  }
 
-        if (!node) {
-            return breaker;
-        }
+  toJS(): string {
+    const node = this.logic || this.variable;
+    const id = this._nodePath;
+    const keyword = `generateBreakpoint('${id}'`;
+    const breaker = id && `await $breaker.generateBreakpoint('${id}', ${parse})()`;
 
-        let result;
+    if (!node) {
+      return breaker;
+    }
 
-        result = generators.reduce((result, generator) => {
-            return result || generator(this)(breaker);
-        }, '');
+    let result;
 
-        result = failsafes.reduce((result, generator) => {
-            const useful = result && result.includes(keyword);
-            return useful ? result : generator(this)(breaker);
-        }, result);
+    result = generators.reduce(
+      (code, generator) => code || generator(this)(breaker),
+      '',
+    );
 
-        return result || breaker;
-    }
+    result = failsafes.reduce((code, generator) => {
+      const useful = code && code.includes(keyword);
+      return useful ? code : generator(this)(breaker);
+    }, result);
+
+    return result || breaker;
+  }
 }

package/src/breakpoint/generator/CallbackNode.ts

@@ -0,0 +1,20 @@
+import BreakpointNode from './BreakpointNode';
+
+export default class CallbackNode extends BreakpointNode {
+  toJS() {
+    const { logic, variable } = this;
+    const node = (logic || variable) as any;
+
+    if (!node) {
+      return '';
+    }
+
+    const code = node.toJS();
+
+    if (!code) {
+      return code;
+    }
+
+    return `$breaker.transfer(($breaker) => ${code})`;
+  }
+}

package/src/breakpoint/generator/FragmentNode.ts

@@ -0,0 +1,14 @@
+import BreakpointNode from './BreakpointNode';
+
+export default class FragmentNode extends BreakpointNode {
+  toJS() {
+    const { variable, _nodePath } = this;
+    const code = variable ? (variable as any).toJS() : '';
+
+    if (_nodePath) {
+      return `await $breaker.assembleFragment('${_nodePath}')(${code})`;
+    }
+
+    return code;
+  }
+}