proskomma-core 0.9.7 → 0.9.12

package/test/code/main/filter.cjs

@@ -0,0 +1,222 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Filter on Parse';
+
+const queryToBlock = async (t, filter) => {
+  const pk = pkWithDoc('../test_data/usfm/filter.usfm', {
+    lang: 'fra',
+    abbr: 'hello',
+  }, filter)[0];
+  const query = `{ documents { mainSequence { blocks { bg { subType } bs { payload } scopeLabels items {type subType payload} } } } }`;
+  const result = await pk.gqlQuery(query);
+  t.equal(result.errors, undefined);
+  return result.data.documents[0].mainSequence.blocks[0];
+};
+
+const inlineGrafts = block => block.items.filter(i => i.type === 'graft');
+
+test(
+  `No Filter (${testGroup})`,
+  async function (t) {
+    try {
+      const scopeLabels = [
+        'chapter/1',
+        'verse/1',
+        'verses/1',
+        'span/nd',
+        'span/it',
+        'span/bd',
+        'blockTag/p',
+      ];
+      t.plan(6 + scopeLabels.length);
+      const block = await queryToBlock(t, {});
+      t.equal(block.bg.length, 2);
+      t.equal(block.bg[0].subType, 'title');
+      t.equal(block.bg[1].subType, 'heading');
+      t.equal(block.scopeLabels.length, 7);
+
+      for (const scopeLabel of scopeLabels) {
+        t.ok(block.scopeLabels.includes(scopeLabel));
+      }
+
+      const inlines = inlineGrafts(block);
+      t.equal(inlines.length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Exclude All Scopes (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const block = await queryToBlock(t, { includeScopes: [] });
+      t.equal(block.bg.length, 2);
+      t.equal(block.scopeLabels.length, 1);
+      const inlines = inlineGrafts(block);
+      t.equal(inlines.length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Exclude All Grafts (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const block = await queryToBlock(t, { includeGrafts: [] });
+      t.equal(block.bg.length, 0);
+      t.equal(block.scopeLabels.length, 7);
+      const inlines = inlineGrafts(block);
+      t.equal(inlines.length, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Exclude Everything (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const block = await queryToBlock(t, {
+        includeGrafts: [],
+        includeScopes: [],
+      });
+      t.equal(block.bg.length, 0);
+      t.equal(block.scopeLabels.length, 1);
+      const inlines = inlineGrafts(block);
+      t.equal(inlines.length, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Exclude Nothing (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const block = await queryToBlock(t, {
+        excludeGrafts: [],
+        excludeScopes: [],
+      });
+      t.equal(block.bg.length, 2);
+      t.equal(block.scopeLabels.length, 7);
+      const inlines = inlineGrafts(block);
+      t.equal(inlines.length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Include chapter/verse (${testGroup})`,
+  async function (t) {
+    try {
+      const scopeLabels = [
+        'chapter/1',
+        'verse/1',
+      ];
+      t.plan(2 + scopeLabels.length);
+      const block = await queryToBlock(t, { includeScopes: ['chapter', 'verse/'] });
+      t.equal(block.scopeLabels.length, 3);
+
+      for (const scopeLabel of scopeLabels) {
+        t.ok(block.scopeLabels.includes(scopeLabel));
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Exclude chapter/verse (${testGroup})`,
+  async function (t) {
+    try {
+      const scopeLabels = [
+        'verses/1',
+        'span/nd',
+        'span/it',
+        'span/bd',
+      ];
+      t.plan(2 + scopeLabels.length);
+      const block = await queryToBlock(t, { excludeScopes: ['chapter', 'verse/'] });
+      t.equal(block.scopeLabels.length, 5);
+
+      for (const scopeLabel of scopeLabels) {
+        t.ok(block.scopeLabels.includes(scopeLabel));
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Include Title (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const block = await queryToBlock(t, { includeGrafts: ['title'] });
+      t.equal(block.bg.length, 1);
+      t.equal(block.bg[0].subType, 'title');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Exclude Title (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const block = await queryToBlock(t, { excludeGrafts: ['title'] });
+      t.equal(block.bg.length, 1);
+      t.equal(block.bg[0].subType, 'heading');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Include Inline (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const block = await queryToBlock(t, { includeGrafts: ['footnote'] });
+      t.equal(block.bg.length, 0);
+      const inlines = inlineGrafts(block);
+      t.equal(inlines.length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Exclude Inline (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const block = await queryToBlock(t, { excludeGrafts: ['footnote'] });
+      t.equal(block.bg.length, 2);
+      const inlines = inlineGrafts(block);
+      t.equal(inlines.length, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/glossary.cjs

@@ -0,0 +1,36 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'PT GLO';
+
+const pk = pkWithDoc('../test_data/usx/not_nfc18_glo.usx', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+test(
+  `Headers (${testGroup})`,
+  async function (t) {
+    try {
+      const expectedHeaders = [
+        ['bookCode', 'GLO'],
+        ['id', 'GLO'],
+      ];
+      t.plan(2 + (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);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/graft_headings.cjs

@@ -0,0 +1,36 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graft Headings';
+
+const pk = pkWithDoc('../test_data/usfm/headings.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+test(
+  `Headings (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      const query = '{ documents { sequences { id type blocks { bg { subType, payload } text } } mainSequence { id } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = {};
+
+      for (const seq of result.data.documents[0].sequences) {
+        sequences[seq.id] = seq;
+      }
+
+      const mainSequence = sequences[result.data.documents[0].mainSequence.id];
+      t.equal(mainSequence.blocks[0].bg.length, 2);
+      t.equal(mainSequence.blocks[0].bg[0].subType, 'title');
+      t.equal(sequences[mainSequence.blocks[0].bg[0].payload].blocks[0].text, 'ACTS');
+      t.equal(mainSequence.blocks[0].bg[1].subType, 'heading');
+      t.equal(sequences[mainSequence.blocks[0].bg[1].payload].blocks[0].text, 'Prologue');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/graft_introduction.cjs

@@ -0,0 +1,96 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graft Introduction';
+
+const pk = pkWithDoc('../test_data/usx/not_nfc18_phm.usx', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+const pk2 = pkWithDoc('../test_data/usfm/section_intros.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+test(
+  `Main Intro (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(23);
+      const query = '{ documents { sequences { id type blocks { bg { subType, payload } bs { payload } text } } mainSequence { id } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = {};
+
+      for (const seq of result.data.documents[0].sequences) {
+        sequences[seq.id] = seq;
+      }
+
+      const mainSequence = sequences[result.data.documents[0].mainSequence.id];
+      t.equal(Object.keys(sequences).length, 8);
+      t.equal(mainSequence.blocks[0].bg.length, 3);
+      t.equal(mainSequence.blocks[0].bg[0].subType, 'title');
+      t.equal(mainSequence.blocks[0].bg[1].subType, 'introduction');
+      t.equal(mainSequence.blocks[0].bg[2].subType, 'heading');
+      const introSequence = sequences[mainSequence.blocks[0].bg[1].payload];
+      t.equal(introSequence.blocks.length, 3);
+      t.equal(introSequence.blocks[0].bs.payload.split('/')[1], 'ip');
+      const titleGraft = introSequence.blocks[0].bg[0];
+      t.equal(titleGraft.subType, 'title');
+      const titleSequence = sequences[titleGraft.payload];
+      t.equal(titleSequence.blocks.length, 3);
+      t.equal(titleSequence.blocks[0].bs.payload, 'blockTag/imt2');
+      t.equal(titleSequence.blocks[1].bs.payload, 'blockTag/imt3');
+      t.equal(titleSequence.blocks[2].bs.payload, 'blockTag/imt');
+      t.equal(introSequence.blocks[1].bs.payload.split('/')[1], 'ip');
+      const headingGraft = introSequence.blocks[1].bg[0];
+      t.equal(headingGraft.subType, 'heading');
+      const headingSequence = sequences[headingGraft.payload];
+      t.equal(headingSequence.blocks.length, 1);
+      t.equal(headingSequence.blocks[0].bs.payload, 'blockTag/is');
+      t.equal(introSequence.blocks[2].bs.payload.split('/')[1], 'hangingGraft');
+      const endTitleGraft = introSequence.blocks[2].bg[0];
+      t.equal(endTitleGraft.subType, 'endTitle');
+      const endTitleSequence = sequences[endTitleGraft.payload];
+      t.equal(endTitleSequence.blocks.length, 3);
+      t.equal(endTitleSequence.blocks[0].bs.payload, 'blockTag/imte2');
+      t.equal(endTitleSequence.blocks[1].bs.payload, 'blockTag/imte3');
+      t.equal(endTitleSequence.blocks[2].bs.payload, 'blockTag/imte');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Section Intro (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(12);
+      const query = '{ documents { sequences { id type blocks { bg { subType, payload } bs { payload } text } } mainSequence { id } } }';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = {};
+
+      for (const seq of result.data.documents[0].sequences) {
+        sequences[seq.id] = seq;
+      }
+
+      const mainSequence = sequences[result.data.documents[0].mainSequence.id];
+      t.equal(Object.keys(sequences).length, 8);
+      t.equal(mainSequence.blocks.length, 2);
+      t.equal(mainSequence.blocks[0].bg.length, 1);
+      t.equal(mainSequence.blocks[0].bg[0].subType, 'title');
+      t.equal(mainSequence.blocks[1].bg.length, 6);
+      t.equal(mainSequence.blocks[1].bg[2].subType, 'introduction');
+      t.equal(sequences[mainSequence.blocks[1].bg[2].payload].blocks.length, 2);
+      t.equal(sequences[mainSequence.blocks[1].bg[2].payload].blocks[0].bs.payload, 'blockTag/ip');
+      t.equal(mainSequence.blocks[1].bg[5].subType, 'introduction');
+      t.equal(sequences[mainSequence.blocks[1].bg[5].payload].blocks.length, 1);
+      t.equal(sequences[mainSequence.blocks[1].bg[5].payload].blocks[0].bs.payload, 'blockTag/ip');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/graft_note.cjs

@@ -0,0 +1,104 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graft Notes';
+
+const pk = pkWithDoc('../test_data/usfm/footnote.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+const pk2 = pkWithDoc('../test_data/usfm/xref.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+test(
+  `Footnote (${testGroup})`,
+  async function (t) {
+    try {
+      const expectedScopes = [
+        ['s', 'inline/f'],
+        ['s', 'span/ft'],
+        ['e', 'span/ft'],
+        ['s', 'span/fqa'],
+        ['e', 'span/fqa'],
+        ['s', 'span/ft'],
+        ['e', 'span/ft'],
+        ['s', 'span/fqa'],
+        ['e', 'span/fqa'],
+        ['s', 'span/ft'],
+        ['e', 'span/ft'],
+        ['e', 'inline/f'],
+      ];
+      t.plan(3 + (2 * expectedScopes.length));
+      const query = `{ documents { sequences { id type blocks { dump items {type subType payload} } } mainSequence { id } } }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = {};
+
+      for (const seq of result.data.documents[0].sequences) {
+        sequences[seq.id] = seq;
+      }
+
+      const mainSequence = sequences[result.data.documents[0].mainSequence.id];
+      t.equal(mainSequence.blocks.length, 5);
+      const footnoteCallerBlock = mainSequence.blocks[2];
+      const footnoteGrafts = footnoteCallerBlock.items.filter(i => i.subType === 'footnote');
+      t.equal(footnoteGrafts.length, 1);
+      const footnoteItems = sequences[footnoteGrafts[0].payload].blocks[0].items;
+      const scopes = footnoteItems.filter(i => i.type === 'scope');
+      let count = 0;
+
+      for (const [sOrE, expectedLabel] of expectedScopes) {
+        t.equal(scopes[count].subType, sOrE === 's' ? 'start' : 'end');
+        t.equal(scopes[count].payload, expectedLabel);
+        count++;
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `XRef (${testGroup})`,
+  async function (t) {
+    try {
+      const expectedScopes = [
+        ['s', 'inline/x'],
+        ['s', 'span/xo'],
+        ['e', 'span/xo'],
+        ['s', 'span/xt'],
+        ['e', 'span/xt'],
+        ['e', 'inline/x'],
+      ];
+      t.plan(3 + (2 * expectedScopes.length));
+      const query = `{ documents { sequences { id type blocks { items {type subType payload} } } mainSequence { id } } }`;
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = {};
+
+      for (const seq of result.data.documents[0].sequences) {
+        sequences[seq.id] = seq;
+      }
+
+      const mainSequence = sequences[result.data.documents[0].mainSequence.id];
+      t.equal(mainSequence.blocks.length, 1);
+      const xrefCallerBlock = mainSequence.blocks[0];
+      const xrefGrafts = xrefCallerBlock.items.filter(i => i.subType === 'xref');
+      t.equal(xrefGrafts.length, 1);
+      const xrefItems = sequences[xrefGrafts[0].payload].blocks[0].items;
+      const scopes = xrefItems.filter(i => i.type === 'scope');
+      let count = 0;
+
+      for (const [sOrE, expectedLabel] of expectedScopes) {
+        t.equal(scopes[count].subType, sOrE === 's' ? 'start' : 'end');
+        t.equal(scopes[count].payload, expectedLabel);
+        count++;
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/graft_rems.cjs

@@ -0,0 +1,34 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graft Headings';
+
+const pk = pkWithDoc('../test_data/usfm/rems.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+test(
+  `REMs (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { sequences { id type blocks { bg { subType, payload } text } } mainSequence { id } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = {};
+
+      for (const seq of result.data.documents[0].sequences) {
+        sequences[seq.id] = seq;
+      }
+
+      const mainSequence = sequences[result.data.documents[0].mainSequence.id];
+      t.equal(mainSequence.blocks[0].bg.length, 1);
+      t.equal(mainSequence.blocks[0].bg[0].subType, 'remark');
+      t.equal(sequences[mainSequence.blocks[0].bg[0].payload].blocks[0].text, 'Need to finish this sentence');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/graft_sidebars.cjs

@@ -0,0 +1,62 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graft Sidebars';
+
+const pkWithUSX = pkWithDoc('../test_data/usx/sidebars.usx', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+const pkWithUSFM = pkWithDoc('../test_data/usfm/sidebars.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+const doTest = async (t, pk) => {
+  t.plan(12);
+  const query = `{ documents { sequences { id blocks { scopeLabels bg { subType, payload } } } mainSequence { id } } }`;
+  const result = await pk.gqlQuery(query);
+  t.equal(result.errors, undefined);
+  const sequences = {};
+
+  for (const seq of result.data.documents[0].sequences) {
+    sequences[seq.id] = seq;
+  }
+
+  const mainSequence = sequences[result.data.documents[0].mainSequence.id];
+  t.equal(mainSequence.blocks.length, 2);
+  t.equal(mainSequence.blocks[0].bg.length, 4);
+  t.equal(mainSequence.blocks[0].bg[0].subType, 'title');
+  t.equal(mainSequence.blocks[0].bg[1].subType, 'introduction');
+  t.equal(mainSequence.blocks[0].bg[2].subType, 'sidebar');
+  t.equal(mainSequence.blocks[0].bg[3].subType, 'heading');
+  t.equal(mainSequence.blocks[1].bg.length, 1);
+  t.equal(mainSequence.blocks[1].bg[0].subType, 'sidebar');
+  const sb1Sequence = sequences[mainSequence.blocks[0].bg[2].payload];
+  t.equal(sb1Sequence.blocks.length, 1);
+  t.equal(sb1Sequence.blocks[0].bg.length, 2);
+  t.ok(sb1Sequence.blocks[0].scopeLabels.includes('esbCat/Theme'));
+};
+
+test(
+  `USX (${testGroup})`,
+  async function (t) {
+    try {
+      await doTest(t, pkWithUSX);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `USFM (${testGroup})`,
+  async function (t) {
+    try {
+      await doTest(t, pkWithUSFM);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/graft_title.cjs

@@ -0,0 +1,36 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graft Title';
+
+const pk = pkWithDoc('../test_data/usx/not_nfc18_phm.usx', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+test(
+  `Title (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      const query = '{ documents { sequences { id type blocks { bg { subType, payload } bs { payload } text } } mainSequence { id } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = result.data.documents[0].sequences;
+      const mainSequence = sequences.filter(s => s.id === result.data.documents[0].mainSequence.id)[0];
+      t.equal(mainSequence.blocks[0].bg[0].subType, 'title');
+      const titleSequence = sequences.filter(s => s.id === mainSequence.blocks[0].bg[0].payload)[0];
+      t.equal(titleSequence.blocks.length, 2);
+      t.equal(titleSequence.blocks[0].bs.payload.split('/')[1], 'mt2');
+      t.equal(titleSequence.blocks[1].bs.payload.split('/')[1], 'mt');
+      t.equal(mainSequence.blocks[1].bg[0].subType, 'endTitle');
+      const endTitleSequence = sequences.filter(s => s.id === mainSequence.blocks[1].bg[0].payload)[0];
+      t.equal(endTitleSequence.blocks.length, 2);
+      t.equal(endTitleSequence.blocks[0].bs.payload.split('/')[1], 'mte2');
+      t.equal(endTitleSequence.blocks[1].bs.payload.split('/')[1], 'mte');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);