@aj-shadow/z-abs-complayer-markup-client 0.0.0-aj-beta.221

package/project/client/markup/markup-sequence-diagram.js

@@ -0,0 +1,466 @@
+
+'use strict';
+
+const DataSequenceDiagram = require('../data/data-sequence-diagram/data-sequence-diagram');
+const DataSequenceDiagramNode = require('../data/data-sequence-diagram/data-sequence-diagram-node');
+const DataSequenceDiagramMessage = require('../data/data-sequence-diagram/data-sequence-diagram-message');
+const DataSequenceDiagramConfig = require('../data/data-sequence-diagram/data-sequence-diagram-config');
+
+
+class MarkupSequenceDiagram {
+  markupName() {
+    return 'seq';
+  }
+  
+  stringify(sequenceDiagram) {
+    let stringified = '';
+    if('' !== sequenceDiagram.title) {
+      stringified += `${MarkupSequenceDiagram.TAG_TITLE} ${sequenceDiagram.title}\n`;
+    }
+    const dataSequenceDiagramConfig = sequenceDiagram.dataSequenceDiagramConfig;
+    const keys = Object.keys(dataSequenceDiagramConfig);
+    stringified += 'Config(';
+    if(1 <= keys.length) {
+      stringified += `${keys[0]}: ${dataSequenceDiagramConfig[keys[0]]}`;
+      for(let i = 1; i < keys.length; ++i) {
+        stringified += `, ${keys[i]}: ${dataSequenceDiagramConfig[keys[i]]}`;
+      }
+    }
+    stringified += ')\n\n';
+    if(1 <= sequenceDiagram.nodes.length) {
+      stringified += 'Nodes[';
+      stringified += sequenceDiagram.nodes[0].name;
+      for(let i = 1; i < sequenceDiagram.nodes.length; ++i) {
+        stringified += `, ${sequenceDiagram.nodes[i].name}`;
+      }
+      stringified += ']';
+    }
+    else {
+      stringified += 'Nodes[]\n';
+    }
+    for(let i = 0; i < sequenceDiagram.messages.length; ++i) {
+      const message = sequenceDiagram.messages[i];
+      if(2 === message.nodes) {
+        if(-1 !== message.fromIndex && -1 !== message.toIndex) {
+          stringified += `\n${sequenceDiagram.nodes[message.fromIndex].name} ${this._stringifyMessageType(message)} ${sequenceDiagram.nodes[message.toIndex].name}[${message.type}]: ${message.data}`;
+        }
+      }
+      else if(1 === message.nodes) {
+        if(-1 !== message.fromIndex) {
+          stringified += `\n${sequenceDiagram.nodes[message.fromIndex].name} ${this._stringifyMessageType(message)} [${message.type}]: ${message.data}`;
+        }
+      }
+      else {
+        stringified += `\n${message.data}`
+      }
+    }
+    return stringified;
+  }
+  
+  parse(markup) {
+    const rows = this._getRows(markup);
+    const dataSequenceDiagram = new DataSequenceDiagram();
+    rows.forEach((row) => {
+      this._parseRow(dataSequenceDiagram, row);
+    });
+    return dataSequenceDiagram;
+  }
+  
+  _parseRow(dataSequenceDiagram, row) {
+    const trimRow = row.trim();
+    if(trimRow.startsWith(MarkupSequenceDiagram.TAG_TITLE)) {
+      dataSequenceDiagram.setTitle(trimRow.substr(MarkupSequenceDiagram.TAG_TITLE_LENGTH));
+    }
+    else if(trimRow.startsWith('Nodes')) {
+      const nodeNames = trimRow.slice(trimRow.indexOf('[') + 1, trimRow.indexOf(']')).match(/([^\s,]+)/g);
+      if(null !== nodeNames) {
+        nodeNames.forEach((nodeName) => {
+          dataSequenceDiagram.addNode(new DataSequenceDiagramNode(nodeName));
+        });
+      }
+    }
+    else if(trimRow.startsWith('Config')) {
+      const start = trimRow.indexOf('(', 0);
+      if(-1 === start) {
+        return;
+      }
+      const stop = trimRow.indexOf(')', start + 1);
+      const configParameters = trimRow.substring(start + 1, -1 !== stop ? stop : undefined).split(',');
+      if(null !== configParameters) {
+        const config = {};
+        configParameters.forEach((configParameter) => {
+          const parameters = configParameter.split(':');
+          if(2 === parameters.length) {
+            const parameterName = parameters[0].trim();
+            const parameterValue = parameters[1].trim();
+            const numberValue = Number.parseInt(parameterValue);
+            if(!Number.isNaN(numberValue)) {
+              dataSequenceDiagram.addConfig(parameterName, numberValue);
+            }
+            else if('true' === parameterValue) {
+              dataSequenceDiagram.addConfig(parameterName, true);
+            }
+            else if('false' === parameterValue) {
+              dataSequenceDiagram.addConfig(parameterName, false);
+            }
+            else {
+              dataSequenceDiagram.addConfig(parameterName, parameterValue);
+            }
+          }
+        });
+      }
+    }
+    else {
+      let type = 'unknown';
+      let data = '';
+      const typeStartIndex = trimRow.indexOf('[');
+      const typeStopIndex = trimRow.indexOf(']');
+      if(-1 !== typeStartIndex && -1 !== typeStopIndex) {
+        let types = trimRow.slice(typeStartIndex + 1, typeStopIndex).match(/([^\s,]+)/g);
+        if(types && 1 === types.length) {
+          type = types[0];
+        }
+      }
+      let dataIndex = trimRow.indexOf(':');
+      if(-1 !== dataIndex) {
+        data = trimRow.substring(dataIndex + 1, trimRow.length).trim();
+      }
+      const messageTypeIndex = this._parseMessageTypeIndex(trimRow);
+      if(-1 !== messageTypeIndex) {
+        const messageType = this._parseMessageType(trimRow, messageTypeIndex);
+        if(2 === messageType.nodes) {
+          const from = trimRow.substring(0, messageTypeIndex).trim();
+          const to = trimRow.substring(messageTypeIndex + messageType.size, typeStartIndex).trim();
+          const fromIndex = this._getNodeIndex(dataSequenceDiagram, from);
+          const toIndex = this._getNodeIndex(dataSequenceDiagram, to);
+          if(-1 !== fromIndex && -1 !== toIndex) {
+            dataSequenceDiagram.addMessage(new DataSequenceDiagramMessage(data, type, messageType.nodes, messageType.type, messageType.height, fromIndex, toIndex));
+          }
+        }
+        else {
+          const from = trimRow.substring(0, messageTypeIndex).trim();
+          const fromIndex = this._getNodeIndex(dataSequenceDiagram, from);
+          if(-1 !== fromIndex) {
+            dataSequenceDiagram.addMessage(new DataSequenceDiagramMessage(data, type, messageType.nodes, messageType.type, messageType.height, fromIndex, -1));
+          }
+        }
+      }
+    }
+  }
+  
+  _getRows(markup) {
+    let index = 0;
+    let nextIndex = 0;
+    const rows = [];
+    const length = markup.length;
+    while(index < length) {
+      nextIndex = markup.indexOf('\n', index);
+      if(-1 !== nextIndex) {
+        rows.push(markup.substring(index, nextIndex).trim());
+        index = nextIndex + 1;
+      }
+      else {
+        rows.push(markup.substring(index, length).trim());
+        index = length;
+      }
+    }
+    return rows;
+  }
+    
+  _stringifyMessageType(message) {
+    if('normal' === message.messageType) {
+      return '=>';
+    }
+    else if('normal-bi-directional' === message.messageType) {
+      return '<=>';
+    }
+    else if('part' === message.messageType) {
+      return '->';
+    }
+    else if('part-bi-directional' === message.messageType) {
+      return '<->';
+    }
+    else if('connect' === message.messageType) {
+      return '-o';
+    }
+    else if('disconnect' === message.messageType) {
+      return '-x';
+    }
+    else if('start' === message.messageType) {
+      return '>';
+    }
+    else if('stop' === message.messageType) {
+      return '#';
+    }
+    else if('pause' === message.messageType) {
+      return '||';
+    }
+    else if('comment' === message.messageType) {
+      return '//';
+    }
+    else if('long-comment' === message.messageType) {
+      return '/**/';
+    }
+    else if('verify' === message.messageType) {
+      return '==';
+    }
+    else if('new' === message.messageType) {
+      return '=';
+    }
+    else if('delete' === message.messageType) {
+      return '!';
+    }
+    else if('browser' === message.messageType) {
+      return 'browser';
+    }
+    else if('page' === message.messageType) {
+      return 'page';
+    }
+    else if('click' === message.messageType) {
+      return 'click';
+    }
+    else if('type' === message.messageType) {
+      return 'type';
+    }
+  }
+  
+  _parseMessageTypeIndex(row) {
+    let colonIndex = row.indexOf(':');
+    if(-1 !== colonIndex) {
+      row = row.substring(0, colonIndex);
+    }
+    let index = row.indexOf('<=>');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('=>');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('<->');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('->');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('-o');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('-x');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('>');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('#');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('||');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('//');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('/**/');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('==');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('=');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('!');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('browser');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('page');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('click');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('type');
+    if(-1 !== index) {
+      return index;
+    }
+    return -1;
+  }
+  
+  _parseMessageType(row, index) {
+    if('=>' === row.substr(index, 2)) {
+      return {
+        type: 'normal',
+        size: 2,
+        nodes: 2,
+        height: 'msg'
+      };
+    }
+    else if('<=>' === row.substr(index, 3)) {
+      return {
+        type: 'normal-bi-directional',
+        size: 3,
+        nodes: 2,
+        height: 'msg'
+      };
+    }
+    else if('->' === row.substr(index, 2)) {
+      return {
+        type: 'part',
+        size: 2,
+        nodes: 2,
+        height: 'msg'
+      };
+    }
+    else if('<->' === row.substr(index, 3)) {
+      return {
+        type: 'part-bi-directional',
+        size: 3,
+        nodes: 2,
+        height: 'msg'
+      };
+    }
+    else if('-o' === row.substr(index, 2)) {
+      return {
+        type: 'connect',
+        size: 2,
+        nodes: 2,
+        height: 'msg'
+      };
+    }
+    else if('-x' === row.substr(index, 2)) {
+      return {
+        type: 'disconnect',
+        size: 2,
+        nodes: 2,
+        height: 'msg'
+      };
+    }
+    else if('>' === row.substr(index, 1)) {
+      return {
+        type: 'start',
+        size: 1,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('#' === row.substr(index, 1)) {
+      return {
+        type: 'stop',
+        size: 1,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('||' === row.substr(index, 2)) {
+      return {
+        type: 'pause',
+        size: 2,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('//' === row.substr(index, 2)) {
+      return {
+        type: 'comment',
+        size: 2,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('/**/' === row.substr(index, 4)) {
+      return {
+        type: 'long-comment',
+        size: 4,
+        nodes: 2,
+        height: 'comment'
+      };
+    }
+    else if('==' === row.substr(index, 2)) {
+      return {
+        type: 'verify',
+        size: 2,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('=' === row.substr(index, 1)) {
+      return {
+        type: 'new',
+        size: 1,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('!' === row.substr(index, 1)) {
+      return {
+        type: 'delete',
+        size: 1,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('browser' === row.substr(index, 7)) {
+      return {
+        type: 'browser',
+        size: 2,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('page' === row.substr(index, 4)) {
+      return {
+        type: 'page',
+        size: 2,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('click' === row.substr(index, 5)) {
+      return {
+        type: 'click',
+        size: 2,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    else if('type' === row.substr(index, 4)) {
+      return {
+        type: 'type',
+        size: 2,
+        nodes: 1,
+        height: 'event'
+      };
+    }
+    return '';
+  }
+  
+  _getNodeIndex(dataSequenceDiagram, nodeName) {
+    return dataSequenceDiagram.nodes.findIndex((node) => {
+      return node.name === nodeName;
+    });
+  }
+}
+
+MarkupSequenceDiagram.TAG_TITLE = 'Title: ';
+MarkupSequenceDiagram.TAG_TITLE_LENGTH = MarkupSequenceDiagram.TAG_TITLE.length;
+
+
+module.exports = new MarkupSequenceDiagram();

package/project/client/markup/markup-system-under-test/markup-system-under-test-instances.js

@@ -0,0 +1,29 @@
+
+'use strict';
+
+const DataSystemUnderTestInstances = require('../../data/data-system-under-test/data-system-under-test-instances');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupSystemUnderTestInstances {
+  stringify(dataSystemUnderTestInstances) {
+    return `\n${MarkupTableKeyValue.stringify(new DataSystemUnderTestInstances(), dataSystemUnderTestInstances, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      instances: MarkupTableKeyValue.parse(DataSystemUnderTestInstances, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupSystemUnderTestInstances();

package/project/client/markup/markup-system-under-test/markup-system-under-test-nodes.js

@@ -0,0 +1,30 @@
+
+'use strict';
+
+const DataSystemUnderTestNodes = require('../../data/data-system-under-test/data-system-under-test-nodes');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupSystemUnderTestNodes {
+  stringify(dataSystemUnderTestNodes) {
+    return `\n${MarkupTableKeyValue.stringify(new DataSystemUnderTestNodes(), dataSystemUnderTestNodes, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      nodes: MarkupTableKeyValue.parse(DataSystemUnderTestNodes, objectTables.objects)
+    };
+  }
+}
+
+
+module.exports = new MarkupSystemUnderTestNodes();

package/project/client/markup/markup-table-key-value-parse.js

@@ -0,0 +1,25 @@
+
+'use strict';
+
+
+class MarkupTableKeyValueParse {
+  parse(dataObject, objectTables) {
+    const objectTable = objectTables.find((objectTable) => {
+      return dataObject.name.substr(4) === objectTable[0].columns[0];
+    });
+    const objects = [];
+    if(undefined !== objectTable && 2 <= objectTable.length) {
+      const parameterNames = objectTable[1].columns;
+      for(let i = 2; i < objectTable.length; ++i) {
+        const dataObjectInstance = new dataObject(...objectTable[i].columns);
+        if(objectTable[i].commentOut && dataObjectInstance.commentOut) {
+          dataObjectInstance.commentOut();
+        }
+        objects.push(dataObjectInstance);
+      }
+    }
+    return objects;
+  }
+}
+
+module.exports = new MarkupTableKeyValueParse();

package/project/client/markup/markup-table-key-value-stringify.js

@@ -0,0 +1,91 @@
+
+'use strict';
+
+
+class MarkupTableKeyValueStringify {
+  stringify(dataObject, dataValues, stringifyEmptyTables) {
+    const markupTableName = dataObject.getName();
+    const markupTableHeadings = dataObject.getHeadings();
+    const markupTableRows = this._getMarkupTableRows(markupTableHeadings, dataValues);
+    if(0 === markupTableRows.length && !stringifyEmptyTables) {
+      return '';
+    }
+    const sizes = this._calculateSizes(markupTableName, markupTableHeadings, markupTableRows);
+    return this._generateMarkup(markupTableName, markupTableHeadings, markupTableRows, sizes);
+  }
+  
+  _getMarkupTableRows(markupTableHeadings, dataValues) {
+    const markupTableRows = [];
+    if(undefined !== dataValues) {
+      dataValues.forEach((dataValue) => {
+        const markupTableRow = {
+          row: [],
+          commentOut: false
+        };
+        markupTableRows.push(markupTableRow);
+        markupTableHeadings.forEach((key) => {
+          markupTableRow.row.push(dataValue[key]);
+        });
+        markupTableRow.commentOut = dataValue['_commentOut_'];
+      });
+    }
+    return markupTableRows;
+  }
+  
+  _calculateSizes(markupTableName, markupTableHeadings, markupTableRows) {
+    const sizes = Array(markupTableHeadings.length).fill(0);  
+    this._calculateSize(sizes, markupTableHeadings, false);
+    markupTableRows.forEach((markupTableRow) => {
+      this._calculateSize(sizes, markupTableRow.row, markupTableRow.commentOut);
+    });
+    return sizes;
+  }
+  
+  _calculateSize(sizes, array, commentOut) {
+    array.forEach((value, index) => {
+      if(undefined !== value) {
+        if(sizes[index] < value.length) {
+          sizes[index] = value.length + (0 === index && commentOut ? 1 : 0);
+        }
+      }
+    });
+  }
+  
+  _generateMarkup(markupTableName, markupTableHeadings, markupTableRows, sizes) {
+    const totalColumnSize = sizes.length - 1 + sizes.reduce((prev, curr) => prev + curr);
+    if(markupTableName.length <= totalColumnSize) {
+      markupTableName += ' '.repeat(totalColumnSize - markupTableName.length);
+      this._generateMarkupRow(markupTableHeadings, false, sizes);
+      markupTableRows.forEach((markupTableRows) => {
+        this._generateMarkupRow(markupTableRows.row, markupTableRows.commentOut, sizes);
+      });
+      markupTableRows.push({
+        row: new Array(sizes.length),
+        commentOut: false
+      });
+      const lastMarkupTableRows = markupTableRows[markupTableRows.length - 1];
+      this._generateMarkupRow(lastMarkupTableRows.row, lastMarkupTableRows.commentOut, sizes);
+    }
+    let markup = `|${markupTableName}|\n|${markupTableHeadings.join('|')}|`;
+    markupTableRows.forEach((markupTableRows) => {
+      markup += `\n${markupTableRows.commentOut ? '#' : ''}|${markupTableRows.row.join('|')}|`;
+    });
+    return markup;
+  }
+  
+  _generateMarkupRow(row, commentOut, sizes) {
+    for(let index = 0; index < row.length; ++index) {
+      if(undefined !== row[index]) {
+        const repeateSize = sizes[index] - row[index].length - (commentOut && 0 === index ? 1 : 0);
+        if(repeateSize > 0) {
+          row[index] = row[index] +  ' '.repeat(sizes[index] - row[index].length - (commentOut && 0 === index ? 1 : 0));
+        }
+      }
+      else {
+         row[index] = ' '.repeat(sizes[index]);
+      }
+    };
+  }
+}
+
+module.exports = new MarkupTableKeyValueStringify();

package/project/client/markup/markup-table-key-value.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const MarkupTableKeyValueStringify = require('./markup-table-key-value-stringify');
+const MarkupTableKeyValueParse = require('./markup-table-key-value-parse');
+
+
+class MarkupTableKeyValue {
+  stringify(dataObject, dataValues, stringifyEmptyTables) {
+    return MarkupTableKeyValueStringify.stringify(dataObject, dataValues, stringifyEmptyTables);
+  }
+
+  parse(dataObjects, markup) {
+    return MarkupTableKeyValueParse.parse(dataObjects, markup);
+  }
+}
+
+module.exports = new MarkupTableKeyValue();