proskomma-core 0.9.7 → 0.9.12

package/test/code/utils/inspect.cjs

@@ -0,0 +1,130 @@
+const path = require('path');
+const test = require('tape');
+const fs = require('fs-extra');
+const { utils } = require('../../../src/index.cjs');
+const ByteArray = utils.ByteArray;
+const { unpackEnum } = utils.succinct;
+const { inspectEnum, inspectSuccinct } = utils.inspect;
+const { enumStringIndex, enumRegexIndexTuples } = utils.enums;
+
+const testGroup = 'Inspect';
+
+const serialized = fs.readJsonSync(path.resolve(__dirname, '../../test_data/utils/serialize_example.json'));
+
+test(
+  `enum array (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(Object.keys(serialized.enums).length);
+
+      for (const enumString of Object.values(serialized.enums)) {
+        const ba = new ByteArray();
+        ba.fromBase64(enumString);
+        const enumArray = unpackEnum(ba);
+        t.ok(enumArray);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `enum entries (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(Object.keys(serialized.enums).length);
+
+      for (const [category, enumString] of Object.entries(serialized.enums)) {
+        const ba = new ByteArray();
+        ba.fromBase64(enumString);
+        const enumStrings = unpackEnum(ba);
+        const inspected = inspectEnum(enumString);
+        // console.log("***", category, "***");
+        // console.log(inspected);
+        t.ok(inspected);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `succinct (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(12);
+      const doc = Object.values(serialized.docs)[0];
+      const mainSequence = doc.sequences[doc.mainId];
+
+      for (const block of mainSequence.blocks) {
+        for (const [category, succinct] of Object.entries(block)) {
+          const inspected = inspectSuccinct(succinct, serialized.enums);
+          // console.log("***", category, "***");
+          // console.log(inspected);
+          t.ok(inspected);
+        }
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `enum index (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(Object.entries(serialized.enums).length);
+
+      for (const [category, enumString] of Object.entries(serialized.enums)) {
+        const ba = new ByteArray();
+        ba.fromBase64(enumString);
+        const enumValues = unpackEnum(ba);
+        let allGood = true;
+        let count = 0;
+
+        for (const enumValue of enumValues) {
+          const enumIndex = enumStringIndex(ba, enumValue);
+
+          if (enumIndex < 0) {
+            allGood = false;
+            break;
+          }
+
+          if (enumIndex !== count) {
+            allGood = false;
+            break;
+          }
+          count += 1;
+        }
+        t.ok(allGood);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `enum regex indexes (${testGroup})`,
+  function (t) {
+    try {
+      const expectedTokens = ['you', 'your', 'young', 'yourself', 'You', 'Your'];
+      t.plan(1 + expectedTokens.length);
+      const enumString = serialized.enums.wordLike;
+      const ba = new ByteArray();
+      ba.fromBase64(enumString);
+      const enumIndexes = enumRegexIndexTuples(ba, 'You');
+      const foundTokens = enumIndexes.map(ei => ei[1]);
+      t.equal(foundTokens.length, expectedTokens.length);
+
+      for (const expectedToken of expectedTokens) {
+        t.ok(foundTokens.includes(expectedToken));
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/utils/items.cjs

@@ -0,0 +1,56 @@
+const test = require('tape');
+const deepEqual = require('deep-equal');
+
+const { utils } = require('../../../src/index.cjs');
+const { itemObjects2Arrays, itemArrays2Objects } = utils.itemDefs;
+
+const itemObjects = [
+  {
+    type: 'token',
+    subType: 'wordLike',
+    payload: 'Hello',
+  },
+  {
+    type: 'scope',
+    subType: 'start',
+    payload: 'blockTag/p',
+  },
+  {
+    type: 'graft',
+    subType: 'footnote',
+    payload: 'abcdefg',
+  },
+];
+
+const itemArrays = [
+  ['token', 'wordLike', 'Hello'],
+  ['scope', 'start', 'blockTag/p'],
+  ['graft', 'footnote', 'abcdefg'],
+];
+
+const testGroup = 'item arrays and objects';
+
+test(
+  `Arrays to Objects (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(1);
+      const newObjects = itemArrays2Objects(itemArrays);
+      t.ok(deepEqual(itemObjects, newObjects));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Objects to Arrays (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(1);
+      t.ok(deepEqual(itemArrays, itemObjects2Arrays(itemObjects)));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/utils/push_succinct.cjs

@@ -0,0 +1,69 @@
+const test = require('tape');
+
+const { utils } = require('../../../src/index.cjs');
+const ByteArray = utils.ByteArray;
+const {
+  pushSuccinctTokenBytes, pushSuccinctGraftBytes, pushSuccinctScopeBytes,
+} = utils.succinct;
+
+const testGroup = 'Push Succinct';
+
+test(
+  `Token (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(2);
+      const ba = new ByteArray(1);
+      pushSuccinctTokenBytes(ba, 2, 299);
+      t.equal(ba.byte(1), 2);
+      t.equal(ba.nByte(2), 299);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Graft (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(2);
+      const ba = new ByteArray(1);
+      pushSuccinctGraftBytes(ba, 10, 299);
+      t.equal(ba.byte(1), 10);
+      t.equal(ba.nByte(2), 299);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Scope (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(2);
+      const ba = new ByteArray(1);
+      pushSuccinctScopeBytes(ba, 3, 2, [567]);
+      t.equal(ba.byte(1), 2);
+      t.equal(ba.nByte(2), 567);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Scope missing args (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(3);
+      const ba = new ByteArray(1);
+      t.throws(() => pushSuccinctScopeBytes(ba, undefined, 2, [567]));
+      t.throws(() => pushSuccinctScopeBytes(ba, 3, undefined, [567]));
+      t.throws(() => pushSuccinctScopeBytes(ba, 3, 2, undefined));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/utils/scope_defs.cjs

@@ -0,0 +1,79 @@
+/* eslint-disable require-await */
+const test = require('tape');
+const { utils } = require('../../../src/index.cjs');
+const {
+  scopeEnum, scopeEnumLabels, labelForScope, nComponentsForScope,
+} = utils.scopeDefs;
+
+const testGroup = 'Scope Def';
+
+test(
+  `scopeEnum (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(1);
+      t.equal(scopeEnum['chapter'], 2);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `scopeEnumLabels (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(1);
+      t.equal(scopeEnumLabels[2], 'chapter');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `labelForScope (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(19);
+      t.equal(labelForScope('blockTag', ['p']), 'blockTag/p');
+      t.equal(labelForScope('inline', ['f']), 'inline/f');
+      t.equal(labelForScope('chapter', ['1']), 'chapter/1');
+      t.equal(labelForScope('verses', ['1-3']), 'verses/1-3');
+      t.equal(labelForScope('verse', ['2']), 'verse/2');
+      t.equal(labelForScope('span', ['nd']), 'span/nd');
+      t.equal(labelForScope('table', []), 'table');
+      t.equal(labelForScope('cell', ['thr2-3']), 'cell/colHeading/right/2');
+      t.equal(labelForScope('milestone', ['zaln']), 'milestone/zaln');
+      t.equal(labelForScope('spanWithAtts', ['w']), 'spanWithAtts/w');
+      t.equal(labelForScope('attribute', ['milestone', 'zaln', 'x-content', '0']), 'attribute/milestone/zaln/x-content/0');
+      t.equal(labelForScope('orphanTokens'), 'orphanTokens');
+      t.equal(labelForScope('hangingGraft'), 'hangingGraft');
+      t.equal(labelForScope('pubChapter', ['1']), 'pubChapter/1');
+      t.equal(labelForScope('pubVerse', ['1']), 'pubVerse/1');
+      t.equal(labelForScope('altChapter', ['1']), 'altChapter/1');
+      t.equal(labelForScope('altVerse', ['1']), 'altVerse/1');
+      t.equal(labelForScope('esbCat', ['x']), 'esbCat/x');
+      t.throws(() => labelForScope('banana'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `nComponentsForScope (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(5);
+      t.equal(nComponentsForScope('table'), 1);
+      t.equal(nComponentsForScope('blockTag'), 2);
+      t.equal(nComponentsForScope('cell'), 4);
+      t.equal(nComponentsForScope('attribute'), 6);
+      t.throws(() => nComponentsForScope('banana'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+

package/test/code/utils/serialize.cjs

@@ -0,0 +1,28 @@
+const path = require('path');
+const test = require('tape');
+const fs = require('fs-extra');
+const { Validator } = require('proskomma-json-tools');
+
+const { utils } = require('../../../src/index.cjs');
+
+const testGroup = 'Validate Schema';
+
+test(
+  `Validate valid document (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(3);
+      const serialized = fs.readJsonSync(path.resolve(__dirname, '..', '..', 'test_data', 'utils', 'serialize_example.json'));
+      t.ok(serialized);
+      const validationReport = new Validator().validate('proskomma',
+        'succinct',
+        '0.2.0',
+        serialized
+      );
+      t.ok(validationReport.isValid);
+      t.equal(validationReport.errors, null);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/utils/splice.cjs

@@ -0,0 +1,67 @@
+const test = require('tape');
+
+const { utils } = require('../../../src/index.cjs');
+const ByteArray = utils.ByteArray;
+const {
+  pushSuccinctTokenBytes, pushSuccinctGraftBytes, pushSuccinctScopeBytes,
+} = utils.succinct;
+
+const testGroup = 'Splice';
+
+test(
+  `Delete Item (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(4);
+      const ba = new ByteArray(1);
+      pushSuccinctTokenBytes(ba, 1, 299);
+      pushSuccinctGraftBytes(ba, 10, 143);
+      pushSuccinctScopeBytes(ba, 3, 2, [567]);
+      const firstLength = ba.byte(0) & 0x0000003F;
+      const secondLength = ba.byte(firstLength) & 0x0000003F;
+      const thirdLength = ba.byte(firstLength + secondLength) & 0x0000003F;
+      t.equal(firstLength + secondLength + thirdLength, ba.length);
+      ba.deleteItem(firstLength);
+      const newFirstLength = ba.byte(0) & 0x0000003F;
+      const newSecondLength = ba.byte(newFirstLength) & 0x0000003F;
+      t.equal(firstLength, newFirstLength);
+      t.equal(thirdLength, newSecondLength);
+      t.equal(newFirstLength + newSecondLength, ba.length);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Insert (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(7);
+      const ba = new ByteArray(8);
+      pushSuccinctTokenBytes(ba, 1, 299);
+      pushSuccinctScopeBytes(ba, 3, 2, [567]);
+      const tokenLength = ba.byte(0) & 0x0000003F;
+      const scopeLength = ba.byte(tokenLength) & 0x0000003F;
+      t.equal(tokenLength + scopeLength, ba.length);
+      const iba = new ByteArray(1);
+      pushSuccinctGraftBytes(iba, 10, 143);
+      ba.insert(tokenLength, iba);
+      const firstLength = ba.byte(0) & 0x0000003F;
+      const secondLength = ba.byte(firstLength) & 0x0000003F;
+      const thirdLength = ba.byte(firstLength + secondLength) & 0x0000003F;
+      t.equal(firstLength, tokenLength);
+      t.equal(secondLength, iba.length);
+      t.equal(thirdLength, scopeLength);
+      t.equal(firstLength + secondLength + thirdLength, ba.length);
+      const iba2 = new ByteArray(1);
+      pushSuccinctGraftBytes(iba2, 5, 47);
+      ba.insert(firstLength + secondLength + thirdLength, iba2);
+      const fourthLength = ba.byte(firstLength + secondLength + thirdLength) & 0x0000003F;
+      t.equal(fourthLength, iba2.length);
+      t.equal(firstLength + secondLength + thirdLength + fourthLength, ba.length);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/utils/tags.cjs

@@ -0,0 +1,69 @@
+/* eslint-disable require-await */
+const test = require('tape');
+const { utils } = require('../../../src/index.cjs');
+const {
+  validateTags, validateTag, addTag, removeTag,
+} = utils.tags;
+
+const testGroup = 'Tags';
+
+test(
+  `Validate Tag (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      t.doesNotThrow(() => validateTag('foo'));
+      t.throws(() => validateTag('foo!'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Validate Tags (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      t.doesNotThrow(() => validateTags(['foo', 'baa']));
+      t.throws(() => validateTags(['foo', 'baa!']));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Add Tag (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(5);
+      let tags = new Set(['foo', 'baa']);
+      t.doesNotThrow(() => addTag(tags,'frob'));
+      t.equal(tags.size, 3);
+      t.ok(tags.has('frob'));
+      t.throws(() => addTag(tags, 'fooie!'));
+      t.equal(tags.size, 3);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Remove Tag (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let tags = new Set(['foo', 'baa']);
+      t.doesNotThrow(() => removeTag(tags,'frob'));
+      t.equal(tags.size, 2);
+      t.doesNotThrow(() => removeTag(tags,'foo'));
+      t.equal(tags.size, 1);
+      t.throws(() => removeTag(tags, 'fooie!'));
+      t.equal(tags.size, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);