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

package/project/client/markup/markup-documentation/markup-documentation.js

@@ -0,0 +1,74 @@
+
+'use strict';
+
+const DataDocumentationNavigation = require('../../data/data-documentation/data-documentation-navigation');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+const MarkupDocumentationNavigation = require('./markup-documentation-navigation');
+const MarkupDocumentationPage = require('./markup-documentation-page');
+const DataDocumentation = require('../../data/data-documentation/data-documentation');
+
+
+class MarkupDocumentation {
+  stringify(documentation, currentPage) {
+    let results = [];
+    results.push(MarkupDocumentationNavigation.stringify(documentation.navigations));
+    results.push(MarkupDocumentationPage.stringify(documentation.page));
+    return `${results.join('\n\n')}\n`;
+  }
+  
+  parse(markup) {
+    let documentation = new DataDocumentation();
+    let foundParts = this._getparse(markup);
+    foundParts.forEach((part) => {
+      if(MarkupDocumentation.NAVIGATION_START === part.type) {
+       // documentation.addNavigation(MarkupDocumentationNavigation.parse(part.value));
+      }
+      else if(MarkupDocumentation.PAGE_START === part.type) {
+        documentation.setPage(MarkupDocumentationPage.parse(part.value).values);
+      }
+    });
+    return {
+      success: true,
+      result: documentation
+    };
+  }
+  
+  _getparse(markup, index = 0, foundParts = []) {    
+    let indexStart = markup.indexOf(MarkupDocumentation.PART_START, index);
+    let indexStop = markup.indexOf(MarkupDocumentation.PART_STOP, indexStart + MarkupDocumentation.PART_START_LENGTH);
+    if(-1 === indexStart || -1 === indexStop) {
+      return foundParts;
+    }
+    else {
+      if(markup.substr(indexStart, MarkupDocumentation.NAVIGATION_START_LENGTH).startsWith(MarkupDocumentation.NAVIGATION_START)) {
+        foundParts.push({
+          type: MarkupDocumentation.NAVIGATION_START,
+          value: markup.substring(indexStart + MarkupDocumentation.NAVIGATION_START_LENGTH, indexStop).trim()
+        });
+      }
+      else if(markup.substr(indexStart, MarkupDocumentation.PAGE_START_LENGTH).startsWith(MarkupDocumentation.PAGE_START)) {
+        foundParts.push({
+          type: MarkupDocumentation.PAGE_START,
+          value: markup.substring(indexStart + MarkupDocumentation.PAGE_START_LENGTH, indexStop).trim()
+        });
+      }
+     }
+    return this._getparse(markup, indexStop + MarkupDocumentation.PART_STOP_LENGTH, foundParts);
+  }
+}
+
+MarkupDocumentation.PART_START = '€[';
+MarkupDocumentation.PART_STOP = '}€[';
+MarkupDocumentation.PART_START_LENGTH = MarkupDocumentation.PART_START.length;
+MarkupDocumentation.PART_STOP_LENGTH = MarkupDocumentation.PART_STOP.length;
+
+MarkupDocumentation.NAVIGATION_START = '€[navigation]{';
+MarkupDocumentation.NAVIGATION_STOP = '}€[navigation]';
+MarkupDocumentation.NAVIGATION_START_LENGTH = MarkupDocumentation.NAVIGATION_START.length;
+
+MarkupDocumentation.PAGE_START = '€[page]{';
+MarkupDocumentation.PAGE_STOP = '}€[page]';
+MarkupDocumentation.PAGE_START_LENGTH = MarkupDocumentation.PAGE_START.length;
+
+module.exports = new MarkupDocumentation();

package/project/client/markup/markup-flowchart.js

@@ -0,0 +1,264 @@
+
+'use strict';
+
+const DataFlowchart = require('../data/data-flowchart/data-flowchart');
+const DataFlowchartBlock = require('../data/data-flowchart/data-flowchart-block');
+const DataFlowchartConnection = require('../data/data-flowchart/data-flowchart-connection');
+
+
+class MarkupFlowchart {
+  markupName() {
+    return 'flow';
+  }
+  
+  stringify(flowchart) {
+    let stringified = '';
+    if('' !== flowchart.title) {
+      stringified += `${MarkupFlowchart.TAG_TITLE} ${flowchart.title}\n`;
+    }
+    if(1 <= flowchart.blockRows.length) {
+      for(let i = 0; i < flowchart.blockRows.length; ++i) {
+        stringified += 'Blocks[';
+        const firstBlock = flowchart.blockRows[i][0];
+        stringified += firstBlock.name;
+        if('' !== firstBlock.name && (undefined !== firstBlock.type || undefined !== firstBlock.data || undefined !== firstBlock.css || undefined !== firstBlock.link)) {
+          stringified += `(${firstBlock.type ? firstBlock.type : ''}:${firstBlock.data ? firstBlock.data : ''}:${firstBlock.css ? firstBlock.css : ''}:${firstBlock.link ? firstBlock.link : ''})`;
+        }
+        for(let j = 1; j < flowchart.blockRows[i].length; ++j) {
+          const block = flowchart.blockRows[i][j];
+          stringified += `, ${block.name}`;
+          if('' !== block.name && (undefined !== block.type || undefined !== block.data || undefined !== block.css || undefined !== block.link)) {
+            stringified += `(${block.type ? block.type : ''}:${block.data ? block.data : ''}:${block.css ? block.css : ''}:${block.link ? block.link : ''})`;
+          }
+        }
+        stringified += ']\n';
+      }
+    }
+    else {
+      stringified += 'Blocks[]';
+    }
+    for(let i = 0; i < flowchart.connections.length; ++i) {
+      const connection = flowchart.connections[i];
+      if(-1 !== connection.fromXIndex && -1 !== connection.fromYIndex && -1 !== connection.toXIndex && -1 !== connection.toYIndex) {
+        const fromBlock = this._getBlockFromName(flowchart, connection.fromBlockName);
+        const toBlock = this._getBlockFromName(flowchart, connection.toBlockName);
+        if(null !== fromBlock && null !== toBlock) {
+          stringified += `\n${fromBlock.name} ${this._stringifyConnectionType(connection)} ${toBlock.name}[${connection.type}]: ${connection.data}`;
+          continue;
+        }
+      }
+      stringified += `\n${connection.data}`
+    }
+    return stringified;
+  }
+  
+
+  parse(markup) {
+    const rows = this._getRows(markup);
+    const dataFlowchart = new DataFlowchart();
+    rows.forEach((row) => {
+      this._parseRow(dataFlowchart, row);
+    });
+    return dataFlowchart;
+  }
+  
+  _parseRow(dataFlowchart, row) {
+    const trimRow = row.trim();
+    if(trimRow.startsWith(MarkupFlowchart.TAG_TITLE)) {
+      dataFlowchart.setTitle(trimRow.substr(MarkupFlowchart.TAG_TITLE_LENGTH).trim());
+    }
+    else if(trimRow.startsWith('Blocks')) {
+      let index = 0;
+      while(true) {
+        const start = trimRow.indexOf('[', index);
+        if(-1 === start) {
+          break;
+        }
+        const stop = trimRow.indexOf(']', start + 1);
+        const blockNames = trimRow.substring(start + 1, -1 !== stop ? stop : undefined).split(',');
+        if(null !== blockNames) {
+          dataFlowchart.addBlockRow();
+          blockNames.forEach((blockName) => {
+            let trimBlock = '';
+            if(blockName.startsWith(',') && blockName.endsWith(',')) {
+              trimBlock = blockName.substring(1, blockName.length - 1).trim();
+            }
+            else {
+              trimBlock = blockName.trim();
+            }
+            const startType = trimBlock.indexOf('(');
+            const stopType = trimBlock.indexOf(')', startType + 1);
+            if(-1 !== startType && -1 !==  stopType) {
+              const blockParameters = trimBlock.substring(startType + 1, -1 !== stopType ? stopType : undefined).split(':');
+              dataFlowchart.addBlock(new DataFlowchartBlock(trimBlock.substring(0, startType), ...blockParameters));
+            }
+            else {
+              dataFlowchart.addBlock(new DataFlowchartBlock(trimBlock));
+            }
+          });
+        }
+        if(-1 === stop) {
+          break;
+        }
+        else {
+          index = stop;
+        }
+      }
+    }
+    else {
+      let type = 'unknown';
+      let data = '';
+      let typeStartIndex = trimRow.indexOf('[');
+      let typeStopIndex = trimRow.indexOf(']');
+      if(-1 !== typeStartIndex && -1 !== typeStopIndex) {
+        const types = trimRow.slice(typeStartIndex + 1, typeStopIndex).match(/([^\s,]+)/g);
+        if(types && 1 === types.length) {
+          type = types[0];
+        }
+      }
+      const dataIndex = trimRow.indexOf(':');
+      if(-1 !== dataIndex) {
+        data = trimRow.substring(dataIndex + 1, trimRow.length).trim();
+      }
+      let connectionTypeIndex = this._parseConnectionTypeIndex(trimRow);
+      if(-1 !== connectionTypeIndex) {
+        const connectionType = this._parseConnectionType(trimRow, connectionTypeIndex);
+        const from = trimRow.substring(0, connectionTypeIndex).trim();
+        const to = trimRow.substring(connectionTypeIndex + connectionType.size, typeStartIndex).trim();
+        const fromBlock = this._getBlockFromName(dataFlowchart, from);
+        const toBlock = this._getBlockFromName(dataFlowchart, to);
+        if(null !== fromBlock && null !== toBlock) {
+          dataFlowchart.addConnection(new DataFlowchartConnection(data, type, connectionType.type, fromBlock, toBlock));
+        }
+        else {
+          dataFlowchart.addConnection(new DataFlowchartConnection(trimRow, type, connectionType.type, fromBlock, toBlock));
+        }
+      }
+    }
+  }
+  
+  _getRows(markup) {
+    let index = 0;
+    let nextIndex = 0;
+    let rows = [];
+    let 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;
+  }
+    
+  _stringifyConnectionType(connection) {
+    if('normal' === connection.connectionType) {
+      return '=>';
+    }
+    else if('normal-bi-directional' === connection.connectionType) {
+      return '<=>';
+    }
+    else if('part' === connection.connectionType) {
+      return '->';
+    }
+    else if('part-bi-directional' === connection.connectionType) {
+      return '<->';
+    }
+    else if('connect' === connection.connectionType) {
+      return '-o';
+    }
+    else if('disconnect' === connection.connectionType) {
+      return '-x';
+    }
+  }
+  
+  _parseConnectionTypeIndex(row) {
+    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;
+    }
+    return -1;
+  }
+  
+  _parseConnectionType(row, index) {
+    if('=>' === row.substr(index, 2)) {
+      return {
+        type: 'normal',
+        size: 2
+      };
+    }
+    else if('<=>' === row.substr(index, 3)) {
+      return {
+        type: 'normal-bi-directional',
+        size: 3
+      };
+    }
+    else if('->' === row.substr(index, 2)) {
+      return {
+        type: 'part',
+        size: 2
+      };
+    }
+    else if('<->' === row.substr(index, 3)) {
+      return {
+        type: 'part-bi-directional',
+        size: 3
+      };
+    }
+    else if('-o' === row.substr(index, 2)) {
+      return {
+        type: 'connect',
+        size: 2
+      };
+    }
+    else if('-x' === row.substr(index, 2)) {
+      return {
+        type: 'disconnect',
+        size: 2
+      };
+    }
+    return '';
+  }
+  
+  _getBlockFromName(dataFlowchart, blockName) {
+    for(let i = 0; i < dataFlowchart.blockRows.length; ++i) {
+      for(let j = 0; j < dataFlowchart.blockRows[i].length; ++j) {
+        if(dataFlowchart.blockRows[i][j].name === blockName) {
+          return dataFlowchart.blockRows[i][j];
+        }
+      }
+    }
+    return null;
+  }
+}
+
+MarkupFlowchart.TAG_TITLE = 'Title:';
+MarkupFlowchart.TAG_TITLE_LENGTH = MarkupFlowchart.TAG_TITLE.length;
+
+
+module.exports = new MarkupFlowchart();

package/project/client/markup/markup-lab.js

@@ -0,0 +1,116 @@
+
+'use strict';
+
+const DataLab = require('../data/data-lab/data-lab');
+const DataLabNetwork = require('../data/data-lab/data-lab-network');
+const DataLabInterfaceClient = require('../data/data-lab/data-lab-interface-client');
+const DataLabInterfaceSut = require('../data/data-lab/data-lab-interface-sut');
+const DataLabInterfaceServer = require('../data/data-lab/data-lab-interface-server');
+const MarkupPatternFunction = require('./markup-pattern-function');
+
+
+class MarkupLab {
+  markupName() {
+    return 'lab';
+  }
+  
+  stringify(networks) {
+    const dataLab = new DataLab(networks);
+    let stringified = '';
+    dataLab.networks.forEach((network) => {
+      stringified += 'Network(';
+      stringified += network.networkName + ', ';
+      stringified += network.family + ', ';
+      stringified += network.subnet + ', ';
+      stringified += network.description + ', ';
+      stringified += network.valid + ', ';
+      stringified += network.reduced + ')\n';
+      if(0 !== network.clients.length) {
+        network.clients.forEach((client) => {
+          stringified += MarkupPatternFunction.stringify('Client', client);
+        });
+      }
+      if(0 !== network.suts.length) {
+        network.suts.forEach((sut) => {
+          stringified += MarkupPatternFunction.stringify('Sut', sut);
+        });
+      }
+      if(0 !== network.servers.length) {
+        network.servers.forEach((server) => {
+          stringified += MarkupPatternFunction.stringify('Server', server);
+        });
+      }
+    });
+    return stringified;
+  }
+  
+  parse(markup) {
+    const rows = this._getRows(markup);
+    const dataLab = new DataLab();
+    rows.forEach((row) => {
+      this._parseRow(dataLab, row);
+    });
+    return dataLab.networks;
+  }
+  
+  _parseRow(dataLab, row) {
+    const trimRow = row.trim();
+    if(trimRow.startsWith('Network(')) {
+      const stop = trimRow.indexOf(')');
+      const parametersRaw = trimRow.substring('Network('.length, -1 !== stop ? stop : undefined).split(',');
+      const parameters = parametersRaw.map((parameter) => {
+        return parameter.trim();
+      });
+      dataLab.addNetwork(new DataLabNetwork(...parameters));
+    }
+    else if(trimRow.startsWith('Client')) {
+      MarkupPatternFunction.parse(trimRow, (...parameters) => {
+        const client = new DataLabInterfaceClient(...parameters);
+        const network = dataLab.getNetwork(client.network);
+        if(undefined !== network) {
+          network.addClient(client);
+        }
+      });
+    }
+    else if(trimRow.startsWith('Sut')) {
+      MarkupPatternFunction.parse(trimRow, (...parameters) => {
+        const sut = new DataLabInterfaceSut(...parameters);
+        const network = dataLab.getNetwork(sut.network);
+        if(undefined !== network) {
+          network.addSut(sut);
+        }
+      });
+    }
+    else if(trimRow.startsWith('Server')) {
+      MarkupPatternFunction.parse(trimRow, (...parameters) => {
+        const server = new DataLabInterfaceServer(...parameters);
+        const network = dataLab.getNetwork(server.network);
+        if(undefined !== network) {
+          network.addServer(server);
+        }
+      });
+    }
+  }
+  
+  _getRows(markup) {
+    let index = 0;
+    let nextIndex = 0;
+    let rows = [];
+    let 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;
+  }   
+}
+
+
+module.exports = new MarkupLab();

package/project/client/markup/markup-licenses/markup-licenses.js

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