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

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

@@ -0,0 +1,101 @@
+
+'use strict';
+
+const MarkupTablesParser = require('./markup-tables-parser');
+
+
+class MarkupTableNameValue {
+  stringify(tables) {
+    let markup = '';
+    tables.forEach((table, index) => {
+      let sizes = this._calculateSizes(table.rows);
+      markup += `${this._generateMarkup(table.name, table.rows, sizes)}${index === tables.length - 1 ? '' : '\n\n'}`;
+    });
+    return markup;
+  }
+
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(objectTables.success) {
+      let tables = objectTables.objects.map((tableRows) => {
+        let name = tableRows[0].columns[0]; 
+        tableRows.shift();
+        let rows = tableRows.map((tableRow) => {
+          return {
+            name: tableRow.columns[0],
+            value: tableRow.columns[1]
+          };
+        });
+        return {
+          name: name,
+          rows: rows
+        };
+      });
+      return {
+        success: true,
+        tables: tables
+      }; 
+    }
+    else {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+  }
+  
+  _calculateSizes(rows) {
+    let sizes = [0, 0];  
+    rows.forEach((row) => {
+      this._calculateSize(sizes, row);
+    });
+    return sizes;
+  }
+  
+  _calculateSize(sizes, row) {
+    if(undefined !== row.name) {
+      if(sizes[0] < row.name.length) {
+        sizes[0] = row.name.length;
+      }
+    }
+    if(undefined !== row.value) {
+      if(sizes[1] < row.value.length) {
+        sizes[1] = row.value.length;
+      }
+    }
+  }
+  
+  _generateMarkup(tableName, tableRows, sizes) {
+    let totalColumnSize = sizes.length - 1 + sizes.reduce((prev, curr) => prev + curr);
+    let formattedtableRows = [];
+    if(tableName.length <= totalColumnSize) {
+      tableName += ' '.repeat(totalColumnSize - tableName.length);
+      formattedtableRows = tableRows.map((row) => {
+        return this._generateMarkupRow(row, sizes);
+      });
+    }
+    let markup = `|${tableName}|`;
+    formattedtableRows.forEach((row, index) => {
+      markup += `\n|${row.name}|${row.value}|`;
+    });
+    return markup;
+  }
+  
+  _generateMarkupRow(row, sizes) {
+    return {
+      name: this._generateMarkupColumn(row.name, 0, sizes),
+      value: this._generateMarkupColumn(row.value, 1, sizes)
+    };
+  }
+  
+  _generateMarkupColumn(column, index, sizes) {
+    if(undefined !== column) {
+      return column +  ' '.repeat(sizes[index] - column.length);
+    }
+    else {
+       return ' '.repeat(sizes[index]);
+    }
+  }
+}
+
+module.exports = new MarkupTableNameValue();

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

@@ -0,0 +1,85 @@
+
+'use strict';
+
+const MarkupTablesParser = require('./markup-tables-parser');
+const MarkupPatternConfig = require('./markup-pattern-config');
+const DataTableConfig = require('../data/data-table/data-table-config');
+
+
+class MarkupTable {
+  markupName() {
+    return 'table';
+  }
+
+  stringify(data) {
+    let stringified = '';
+    stringified += MarkupPatternConfig.stringify(data.config);
+    data.objects.forEach((objects, index) => {
+      const sizes = this._calculateSizes(objects);
+      stringified += `${this._generateMarkup(objects, sizes)}`;
+    });
+    return stringified;
+  }
+  
+  parse(markup) {
+    const dataTableConfig = new DataTableConfig();
+    const table = MarkupTablesParser.parse(markup, (rows) => {
+      rows.forEach((row) => {
+        const trimRow = row.trim();
+        if(trimRow.startsWith('Config')) {
+          MarkupPatternConfig.parse(trimRow, dataTableConfig);
+        }
+      });
+      return rows;
+    });
+    table.config = dataTableConfig;
+    return table;
+  }
+  
+  _calculateSizes(objects) {
+    const sizes = [];  
+    for(let i = 1; i < objects.length; ++i) {
+      const object = objects[i];
+      const columns = object.columns.length;
+      for(let j = sizes.length; j < columns; ++j) {
+        sizes.push(0);
+      }
+      for(let j = 0; j < columns; ++j) {
+        if(sizes[j] < object.columns[j].length) {
+          sizes[j] = object.columns[j].length;
+        }
+      }
+    }
+    return sizes;
+  }
+  
+  _generateMarkup(objects, sizes) {
+    const totalColumnSize = sizes.length - 1 + sizes.reduce((prev, curr) => prev + curr);
+    let markupTableName = 1 <= objects.length ? (1 <= objects[0].columns.length ? objects[0].columns[0] : '') : '';
+    const markupTableHeadings = 2 <= objects.length ? objects[1].columns : [];
+    if(markupTableName.length <= totalColumnSize) {
+      markupTableName += ' '.repeat(totalColumnSize - markupTableName.length);
+    }
+    this._generateMarkupRow(markupTableHeadings, sizes);
+    let markup = `|${markupTableName}|\n|${markupTableHeadings.join('|')}|`;
+    for(let i = 2; i < objects.length; ++i) {
+      this._generateMarkupRow(objects[i].columns, sizes);
+      markup += `\n|${objects[i].columns.join('|')}|`;
+    }
+    return markup;
+  }
+  
+  _generateMarkupRow(row, sizes) {
+    row.forEach((value, index, array) => {
+      if(undefined !== value) {
+        array[index] = value +  ' '.repeat(sizes[index] - value.length);
+      }
+      else {
+         array[index] = ' '.repeat(sizes[index]);
+      }
+    });
+  }
+}
+
+
+module.exports = new MarkupTable();

package/project/client/markup/markup-tables-parser.js

@@ -0,0 +1,122 @@
+
+'use strict';
+
+
+class MarkupTablesParser {
+  parse(markup, cbRows) {
+    const rows = this._getRows(markup);
+    if(undefined !== cbRows) {
+      cbRows = cbRows(rows);
+    }
+    const formattedRows = this._formatRows(rows);
+    const objectTables = this._getObjectTables(formattedRows);
+    return {
+      success: objectTables.success,
+      rows: formattedRows,
+      objects: objectTables.objects,
+      config: undefined
+    };
+  }
+  
+  _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));
+        index = nextIndex + 1;
+      }
+      else {
+        rows.push(markup.substring(index, length));
+        index = length;
+      }
+    }
+    return rows;
+  }
+  
+  _formatRows(rows) {
+    const formattedRows = [];
+    rows.forEach((row, rowIndex) => {
+      let trimmedRow = row.trim();
+      const commentOut = trimmedRow.startsWith('#');
+      if(commentOut) {
+        trimmedRow = trimmedRow.substring(1).trim();
+      }
+      const columns = trimmedRow.split('|');
+      if(1 === columns.length) {
+        formattedRows.push({
+          object: false,
+          empty: true,
+          commentOut: commentOut,
+          row: rowIndex,
+          columns: [],
+          success: 0 === columns[0].length
+        });  
+      }
+      else if(columns.length >= 2) {
+        const success = 0 === columns[0].length && 0 === columns[columns.length - 1].length;
+        columns.splice(columns.length - 1, 1);
+        columns.splice(0, 1);
+        let empty = true;
+        columns.forEach((column, columnIndex, array) => {
+          const value = column.trim();
+          array[columnIndex] = value;
+          empty &&= 0 === value.length;
+        });
+        formattedRows.push({
+          object: true,
+          empty: empty,
+          commentOut: commentOut,
+          row: rowIndex,
+          columns: columns,
+          success: success
+        });
+      }
+    });
+    return formattedRows;
+  }
+  
+  _getObjectTables(rows) {
+    const objectTables = {
+      success: true,
+      objects: []
+    };
+    let objectRows = undefined;
+    let rowlength = 0;
+    rows.forEach((row) => {
+      if(row.object) {
+        if(undefined === objectRows) {
+          objectRows = [];
+          objectRows.push(row);
+          objectTables.objects.push(objectRows);
+          if(1 !== row.columns.length) {
+            row.success = false;
+            objectTables.success = false;
+          }
+        }
+        else {
+          if(!row.empty) {
+            objectRows.push(row);
+          }
+          if(0 === rowlength) {
+            rowlength = row.columns.length;
+          }
+          else if(row.columns.length != rowlength) {
+            row.success = false;
+            objectTables.success = false;
+          }
+        }
+      }
+      else {
+        objectRows = undefined;
+        rowlength = 0;
+      }
+    });
+    return objectTables;
+  }
+}
+
+module.exports = new MarkupTablesParser();

package/project/client/markup/markup-test-case/markup-test-case.js

@@ -0,0 +1,67 @@
+
+'use strict';
+
+const DataConstructor = require('../../data/data-constructor');
+const DataTestCase = require('../../data/data-test-case/data-test-case');
+const DataTestCaseSettings = require('../../data/data-test-case/data-test-case-settings');
+const DataActor = require('../../data/data-test-case/data-actor');
+const DataTestDataTestCase = require('../../data/data-test-case/data-test-data-test-case');
+const DataTestDataIteration = require('../../data/data-test-case/data-test-data-iteration');
+const DataVerificationTestCase = require('../../data/data-test-case/data-verification-test-case');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupTestCase {
+  markupName() {
+    return 'tc';
+  }
+    
+  stringify(dataTestCase, stringifyEmptyTables = true) {
+    const dataTestCaseTc = dataTestCase.tc;
+    let markup = '';
+    markup += this._stringifyMarkupPart(markup.length, MarkupTableKeyValue.stringify(new DataTestCaseSettings(), dataTestCaseTc.settings, stringifyEmptyTables));
+    markup += this._stringifyMarkupPart(markup.length, MarkupTableKeyValue.stringify(new DataActor(), dataTestCaseTc.actors, stringifyEmptyTables));
+    markup += this._stringifyMarkupPart(markup.length, MarkupTableKeyValue.stringify(new DataTestDataTestCase(), dataTestCaseTc.testDataTestCases, stringifyEmptyTables));
+    markup += this._stringifyMarkupPart(markup.length, MarkupTableKeyValue.stringify(new DataTestDataIteration(), dataTestCaseTc.testDataIteration, stringifyEmptyTables));
+    markup += this._stringifyMarkupPart(markup.length, MarkupTableKeyValue.stringify(new DataVerificationTestCase(), dataTestCaseTc.verificationTestCases, stringifyEmptyTables));
+    return markup;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    const settings = MarkupTableKeyValue.parse(DataTestCaseSettings, objectTables.objects);
+    const actors = MarkupTableKeyValue.parse(DataActor, objectTables.objects);
+    const testDataTestCases = MarkupTableKeyValue.parse(DataTestDataTestCase, objectTables.objects);
+    const testDataIteration = MarkupTableKeyValue.parse(DataTestDataIteration, objectTables.objects);
+    const verificationTestCases = MarkupTableKeyValue.parse(DataVerificationTestCase, objectTables.objects);
+    const dataTestCase = new DataTestCase(DataConstructor.create(settings), DataConstructor.create(actors), DataConstructor.create(testDataTestCases), DataConstructor.create(testDataIteration), DataConstructor.create(verificationTestCases));
+    return {
+      success: true,
+      tc: dataTestCase
+    };
+  }
+  
+  _stringifyMarkupPart(markupLength, markupPart) {
+    if(0 !== markupPart.length) {
+      if(0 !== markupLength) {
+        return `\n\n${markupPart}`;
+      }
+      else {
+        return `${markupPart}`;
+      }
+    }
+    else {
+      return '';
+    }
+  }
+}
+
+
+module.exports = new MarkupTestCase();

package/project/client/markup/markup-test-data/markup-test-data-environment.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataTestDataEnvironmentGlobal = require('../../data/data-test-data/data-test-data-environment-global');
+const DataTestDataEnvironmentLocal = require('../../data/data-test-data/data-test-data-environment-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupTestDataEnvironment {
+  stringify(dataTestDataGlobals, dataTestDataLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataTestDataEnvironmentLocal(), dataTestDataLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataTestDataEnvironmentGlobal(), dataTestDataGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataTestDataEnvironmentGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataTestDataEnvironmentLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupTestDataEnvironment();

package/project/client/markup/markup-test-data/markup-test-data-general.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataTestDataGeneralGlobal = require('../../data/data-test-data/data-test-data-general-global');
+const DataTestDataGeneralLocal = require('../../data/data-test-data/data-test-data-general-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupTestDataGeneral {
+  stringify(dataTestDataGlobals, dataTestDataLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataTestDataGeneralLocal(), dataTestDataLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataTestDataGeneralGlobal(), dataTestDataGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataTestDataGeneralGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataTestDataGeneralLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupTestDataGeneral();

package/project/client/markup/markup-test-data/markup-test-data-output.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataTestDataOutputGlobal = require('../../data/data-test-data/data-test-data-output-global');
+const DataTestDataOutputLocal = require('../../data/data-test-data/data-test-data-output-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupTestDataOutput {
+  stringify(dataTestDataGlobals, dataTestDataLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataTestDataOutputLocal(), dataTestDataLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataTestDataOutputGlobal(), dataTestDataGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataTestDataOutputGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataTestDataOutputLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupTestDataOutput();

package/project/client/markup/markup-test-data/markup-test-data-system.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataTestDataSystemGlobal = require('../../data/data-test-data/data-test-data-system-global');
+const DataTestDataSystemLocal = require('../../data/data-test-data/data-test-data-system-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupTestDataSystem {
+  stringify(dataTestDataGlobals, dataTestDataLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataTestDataSystemLocal(), dataTestDataLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataTestDataSystemGlobal(), dataTestDataGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataTestDataSystemGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataTestDataSystemLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupTestDataSystem();

package/project/client/markup/markup-test-suite/markup-test-suite.js

@@ -0,0 +1,40 @@
+
+'use strict';
+
+const DataConstructor = require('../../data/data-constructor');
+const DataTestSuite = require('../../data/data-test-suite/data-test-suite');
+const DataTestSuiteAbstraction = require('../../data/data-test-suite/data-test-suite-abstraction');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupTestSuite {
+  markupName() {
+    return 'ts';
+  }
+  
+  stringify(dataTestSuite, stringifyEmptyTables = true) {
+    const dataTestSuiteTs = dataTestSuite.ts;
+    const markup = MarkupTableKeyValue.stringify(new DataTestSuiteAbstraction(), dataTestSuiteTs.abstractions, stringifyEmptyTables);
+    return markup;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    const abstractions = MarkupTableKeyValue.parse(DataTestSuiteAbstraction, objectTables.objects);
+    const dataTestSuite = new DataTestSuite(DataConstructor.create(abstractions));
+    return {
+      success: true,
+      ts: dataTestSuite
+    };
+  }
+}
+
+
+module.exports = new MarkupTestSuite();

package/project/client/react-components/helper/line-data.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+
+class LineData {
+  constructor(line, lineObject = null) {
+    this.line = line;
+    this.objects = lineObject ? [lineObject] : [];
+  }
+  
+  addObject(lineObject) {
+    this.objects.push(lineObject);
+  }
+}
+
+module.exports = LineData;

package/project/client/react-components/helper/line-object.js

@@ -0,0 +1,22 @@
+
+'use strict';
+
+
+class LineObject {
+  constructor(id, type, start, stop, element, top, line, linePosition, delta, percent, previousRealObject, nextRealObject) {
+    this.id = id;
+    this.type = type;
+    this.start = start;
+    this.stop = stop;
+    this.element = element;
+    this.top = top;
+    this.line = line;
+    this.linePosition = linePosition;
+    this.delta = delta;
+    this.percent = percent;
+    this.previousRealObject = previousRealObject;
+    this.nextRealObject = nextRealObject;
+  }
+}
+
+module.exports = LineObject;

package/project/client/react-components/helper/scroll-data.js

@@ -0,0 +1,74 @@
+
+'use strict';
+
+
+class ScrollData {
+  constructor(line = 0, delta = 0.0, top = 0.0, length = Number.MAX_SAFE_INTEGER) {
+    this.line = line;
+    this.delta = delta;
+    this.top = top;
+    this.length = length;
+  }
+  
+  setLength(length) {
+    this.length = length + 2;
+    this.setLine(this.line, this.delta);
+  }
+  
+  setLineFirst() {
+    this.line = 0
+    this.delta = 0.0;
+  }
+  
+  setLineLast() {
+    this.line = this.length ;
+    this.delta = 0.0;
+  }
+  
+  setLine(line = 0, delta = 0.0) {
+    if(line < 0) {
+      this.line = 0;
+      this.delta = 0;
+    }
+    else if(line >= 0 && line < this.length) {
+      this.line = line;
+      this.delta = delta;  
+    }
+    else if(line >= this.length) {
+      this.line = this.length;
+      this.delta = 0;
+    }
+  }
+  
+  setScroll(top) {
+    this.top = top;
+  }
+  
+  increment(delta = 0.0) {
+    if(this.line < this.length) {
+      ++this.line;
+    }
+    this.delta = delta;
+  }
+  
+  stepLines(lines) {
+    if(this.line + lines > this.length) {
+      this.line = this.length;
+    }
+    else if(this.line + lines < 0) {
+      this.line = 0;
+    }
+    else {
+      this.line += lines;
+    }
+  }
+  
+  decrement(delta = 0.0) {
+    if(1 <= this.line) {
+      --this.line;
+    }
+    this.delta = delta;
+  }
+}
+
+module.exports = ScrollData;