proskomma-core 0.9.7 → 0.9.12

package/test/code/main/hello.cjs

@@ -0,0 +1,105 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Hello USFM';
+
+const pk = pkWithDoc('../test_data/usfm/hello.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+test(
+  `Headers (${testGroup})`,
+  async function (t) {
+    try {
+      const expectedHeaders = [
+        ['bookCode', 'MRK'],
+        ['id', 'MRK Mark\'s Gospel, translated by Mark'],
+        ['toc', 'The Gospel of Mark'],
+        ['toc2', 'Mark'],
+        ['toc3', 'Mk'],
+      ];
+      t.plan(6 + (2 * expectedHeaders.length));
+      const query = '{ documents { headers { key value } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const queryHeaders = result.data.documents[0].headers;
+      t.equal(queryHeaders.length, expectedHeaders.length);
+
+      for (const [expectedKey, expectedValue] of expectedHeaders) {
+        const queryTuple = queryHeaders.filter(kv => kv.key === expectedKey);
+        t.ok(queryTuple.length === 1);
+        t.ok(queryTuple[0].value === expectedValue);
+      }
+
+      const query2 = '{documents { toc: header(id:"toc") toc3: header(id:"toc3") banana: header(id:"banana")} }';
+      const result2 = await pk.gqlQuery(query2);
+      t.equal(result2.errors, undefined);
+      t.equal(result2.data.documents[0].toc, 'The Gospel of Mark');
+      t.equal(result2.data.documents[0].toc3, 'Mk');
+      t.equal(result2.data.documents[0].banana, null);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+test(
+  `One-Block Sequence (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      const query =
+        '{ documents { sequences { type blocks { bs { payload } text } } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = result.data.documents[0].sequences;
+      t.equal(sequences.length, 1);
+      t.equal(sequences[0].type, 'main');
+      t.equal(sequences[0].blocks.length, 1);
+      t.equal(sequences[0].blocks[0].bs.payload, 'blockTag/p');
+      const expectedText = 'This is how the Good News of JC began...';
+      t.equal(sequences[0].blocks[0].text, expectedText);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `One Chapter and Verse (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      const query =
+        '{ documents { sequences { type blocks { os { payload } is { payload } } } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const block = result.data.documents[0].sequences[0].blocks[0];
+      t.equal(block.os.length, 0);
+      t.equal(block.is.length, 3);
+      t.equal(block.is[0].payload, 'chapter/1');
+      t.equal(block.is[1].payload, 'verse/1');
+      t.equal(block.is[2].payload, 'verses/1');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Query callback (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(1);
+      let callbackValue = 2;
+      const callback = () => callbackValue++;
+      const query =
+        '{ nDocuments }';
+      await pk.gqlQuery(query, callback);
+      t.equal(callbackValue, 3);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/import_document.cjs

@@ -0,0 +1,22 @@
+const test = require('tape');
+
+const { Proskomma } = require('../../../src/index.cjs');
+
+const testGroup = 'Document';
+
+test(
+  `Unknown Content Format (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(1);
+      const pk = new Proskomma();
+
+      t.throws(() => pk.importDocument({
+        lang: 'deu',
+        abbr: 'xyz',
+      }, 'mov', 'abc', {}));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/import_usfm_int.cjs

@@ -0,0 +1,48 @@
+const path = require('path');
+const test = require('tape');
+const fse = require('fs-extra');
+const { Proskomma } = require('../../../src/index.cjs');
+
+const testGroup = 'importUsfmInt';
+
+test(
+  `Import (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(8);
+      const pk = new Proskomma();
+      let fp = '../../test_data/usfm/cp_vp.usfm';
+      let content = fse.readFileSync(path.resolve(__dirname, fp));
+
+      t.throws(() =>
+        pk.importUsfmPeriph(
+          { lang: 'eng', abbr: 'abc' },
+          content,
+          {},
+        ),
+      /INT.+ESG/);
+      fp = '../../test_data/usfm/int.usfm';
+      content = fse.readFileSync(path.resolve(__dirname, fp));
+
+      t.doesNotThrow(() =>
+        pk.importUsfmPeriph(
+          { lang: 'eng', abbr: 'abc' },
+          content,
+          {},
+        ));
+      t.equal(pk.nDocuments(), 2);
+      const query = '{documents { headers { key value } sequences { type text } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const firstDoc = result.data.documents[0];
+      const headerKeys = firstDoc.headers.map(h => h.key);
+      t.ok(headerKeys.includes('id'));
+      t.ok(headerKeys.includes('bookCode'));
+      t.equal(firstDoc.headers.filter(h => h.key === 'bookCode')[0].value, 'P00');
+      const introSequence = firstDoc.sequences.filter(s => s.type === 'introduction')[0];
+      t.equal(introSequence.text, 'The Bible is a book of books.');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/item_groups.cjs

@@ -0,0 +1,133 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graph Item Groups';
+
+const pk = pkWithDoc('../test_data/usfm/verse_breaks_in_blocks.usfm', {
+  lang: 'eng',
+  abbr: 'ust',
+})[0];
+const pk2 = pkWithDoc('../test_data/usfm/ust_psa_with_ts.usfm', {
+  lang: 'eng',
+  abbr: 'ust',
+})[0];
+const pk3 = pkWithDoc('../test_data/usfm/add_test.usfm', {
+  lang: 'eng',
+  abbr: 'ust',
+})[0];
+
+test(
+  `Text by scopes (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(14);
+      const query = '{ documents { mainSequence { itemGroups(byScopes:["chapter/", "verse/"]) {' +
+        'scopeLabels chapterScope: scopeLabels(startsWith:"chapter/") text dump' +
+        '} } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      // console.log(JSON.stringify(result.data.documents[0].mainSequence.itemGroups[1], null, 2))
+      const itemGroups = result.data.documents[0].mainSequence.itemGroups;
+      t.equal(itemGroups.length, 3);
+      t.equal(itemGroups[1].scopeLabels.length, 4);
+      t.ok(itemGroups[1].scopeLabels.includes('chapter/1'));
+      t.ok(itemGroups[1].scopeLabels.includes('verse/2'));
+      t.ok(itemGroups[1].scopeLabels.includes('verses/2'));
+      t.ok(itemGroups[1].scopeLabels.includes('blockTag/q'));
+      t.equal(itemGroups[1].chapterScope.length, 1);
+      t.equal(itemGroups[1].chapterScope[0], 'chapter/1');
+      t.ok(itemGroups[1].text.startsWith('Instead'));
+      t.ok(itemGroups[1].text.trim().endsWith('Yahweh teaches.')); // trim cos trailing newline before next \v
+      const dumped = itemGroups[1].dump.split('\n').map(l => l.trim());
+      t.ok(dumped[0].startsWith('ItemGroup'));
+      t.ok(dumped[1].includes('verse/2'));
+      t.ok(dumped[4].endsWith('-verse/2-'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Text by scopes with multiple hits per block (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainSequence { itemGroups(byScopes:"span/add") {' +
+        'scopeLabels(startsWith:["chapter/", "verses/"]) text' +
+        '} } } }';
+      let result = await pk3.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].mainSequence.itemGroups.length, 2);
+      t.equal(
+        result.data.documents[0].mainSequence.itemGroups[0].text,
+        'Actually, one was Yahweh, and the other two were angels',
+      );
+      t.equal(
+        result.data.documents[0].mainSequence.itemGroups[1].text,
+        'to one of them',
+      );
+      // console.log(JSON.stringify(result.data.documents[0].mainSequence.itemGroups, null, 2))
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Items & tokens by scopes (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(12);
+      const query = '{ documents { mainSequence { itemGroups(byScopes:["chapter/", "verse/"]) {' +
+        'scopeLabels ' +
+        `items {type subType payload position scopes } ` +
+        'tokens { payload }' +
+        'wordLikes: tokens(withSubTypes:"wordLike") { payload }' +
+        '} } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const itemGroups = result.data.documents[0].mainSequence.itemGroups;
+      t.equal(itemGroups.length, 3);
+      t.equal(itemGroups[1].tokens.length, 57);
+      t.equal(itemGroups[1].wordLikes.length, 27);
+      t.equal(itemGroups[1].scopeLabels.length, 4);
+      t.equal(itemGroups[1].items.filter(i => i.type === 'token')[0].payload, 'Instead');
+      t.equal(itemGroups[1].items.filter(i => i.type === 'token').reverse()[1].payload, '.'); // Trailing newline before next \v
+      t.equal(itemGroups[1].tokens[0].payload, 'Instead');
+      t.equal([...itemGroups[1].tokens].reverse()[1].payload, '.'); // Leading newline (before reversal)
+      t.equal(itemGroups[0].items.filter(i => i.type === 'graft').length, 1);
+      t.equal(itemGroups[1].items.filter(i => i.subType === 'start' && i.payload === 'blockTag/q2').length, 0);
+      t.equal(itemGroups[2].items.filter(i => i.subType === 'start' && i.payload === 'blockTag/q2').length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Text by milestones (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      const query = '{ documents { mainSequence { itemGroups(byMilestones:["milestone/ts"]) {' +
+        'scopeLabels text normalized: text(normalizeSpace:true)' +
+        '} } } }';
+      let result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const itemGroups = result.data.documents[0].mainSequence.itemGroups;
+      t.equal(itemGroups.length, 3);
+      t.ok(itemGroups[0].scopeLabels.includes('chapter/150'));
+      t.ok(itemGroups[0].scopeLabels.includes('verse/1'));
+      t.ok(!itemGroups[1].scopeLabels.includes('verse/1'));
+      t.ok(itemGroups[1].text.trim().startsWith('Praise'));
+      t.ok(itemGroups[1].text.trim().endsWith('cymbals!'));
+      t.equal(itemGroups[0].text.split('\n').length, 5);
+      t.equal(itemGroups[0].normalized.split('\n').length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+

package/test/code/main/items_with_cv.cjs

@@ -0,0 +1,311 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Items with CV';
+
+const pk = pkWithDoc('../test_data/usx/web_rut.usx', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+const pk2 = pkWithDoc('../test_data/usx/web_psa_40_60.usx', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+test(
+  `Bad cv (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"2") { items(withScriptureCV:"x=y") {type subType payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors.length, 1);
+      t.equal(result.errors.filter(e => e.message.includes('Bad cv reference')).length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `withScopes + cv (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"2") { items(withScriptureCV:"2" withScopes:[]) {type, subType, payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors.length, 1);
+      t.equal(result.errors.filter(e => e.message.includes('Cannot specify both withScopes and withScriptureCV')).length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `One Chapter (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"2") { items(withScriptureCV:"2") {type, subType, payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'Naomi');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'law');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Chapter Range (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"1-3") { items(withScriptureCV:"1-3") {type, subType, payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'In');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'today');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Reverse Chapter Range (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"1-3") { items(withScriptureCV:"3-1") {type, subType, payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors.length, 1);
+      t.equal(result.errors.filter(e => e.message.includes('Chapter range must be from min to max')).length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `One verse (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"1:15") { items(withScriptureCV:"1:15") {type, subType, payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'She');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'law');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Verse zero (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"PSA") {
+                     mainSequence { blocks(withScriptureCV:"51:0") { items(withScriptureCV:"51:0") {type, subType, payload} } } } }
+                }`;
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'For');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'Bathsheba');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Verse range (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"1:10-13") { items(withScriptureCV:"1:10-13") {type, subType, payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'They');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'me');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Verse range from zero (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"PSA") {
+                     mainSequence { blocks(withScriptureCV:"51:0-1") { items(withScriptureCV:"51:0-1") {type, subType, payload} } } } }
+                }`;
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'For');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'transgressions');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Chapter/verse range (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"1:22-3:3") { items(withScriptureCV:"1:22-3:3") {type, subType, payload} } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'So');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'drinking');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Chapter/verse range to zero (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"PSA") {
+                     mainSequence { blocks(withScriptureCV:"50:23-51:0") { items(withScriptureCV:"50:23-51:0") {type, subType, payload} } } } }
+                }`;
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'Whoever');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'Bathsheba');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Chapter/verse range from zero (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"PSA") {
+                     mainSequence { blocks(withScriptureCV:"51:0-52:1") { items(withScriptureCV:"51:0-52:1") {type, subType, payload} } } } }
+                }`;
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].items;
+      const lastBlockItems = blocks[blocks.length - 1].items;
+      t.equal(firstBlockItems.filter(i => i.subType === 'wordLike')[0].payload, 'For');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'continually');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Chapter/verse range tokens (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"1:22-3:3") { tokens(withScriptureCV:"1:22-3:3") { subType payload } } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockItems = blocks[0].tokens;
+      const lastBlockItems = blocks[blocks.length - 1].tokens;
+      t.equal(firstBlockItems[0].payload, 'So');
+      t.equal(lastBlockItems.filter(i => i.subType === 'wordLike').reverse()[0].payload, 'drinking');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Chapter/verse range text (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query =
+        `{ docSets { document(bookCode:"RUT") {
+                     mainSequence { blocks(withScriptureCV:"1:22-3:3") { text(withScriptureCV:"1:22-3:3") } } } }
+                }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const blocks = result.data.docSets[0].document.mainSequence.blocks;
+      const firstBlockText = blocks[0].text;
+      const lastBlockText = blocks[blocks.length - 1].text;
+      t.ok(firstBlockText.startsWith('So'));
+      t.ok(lastBlockText.endsWith('drinking.'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);