proskomma-core 0.9.7 → 0.9.12

package/test/code/main/empty_blocks.cjs

@@ -0,0 +1,71 @@
+const test = require('tape');
+
+const { Proskomma } = require('../../../src/index.cjs');
+const {
+  pkWithDoc,
+  customPkWithDoc,
+} = require('../../lib/load.js');
+
+const testGroup = 'Empty Blocks';
+
+const pk = pkWithDoc('../test_data/usfm/en_ust_psa_1.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+const customProskomma = class extends Proskomma {
+  constructor() {
+    super();
+    this.filters = {};
+    this.customTags = {
+      heading: [],
+      paragraph: [],
+      char: [],
+      word: [],
+      intro: [],
+      introHeading: [],
+    };
+    this.emptyBlocks = ['blockTag/s5', 'blockTag/m'];
+  }
+};
+
+const customPk = customPkWithDoc(customProskomma, '../test_data/usfm/en_ust_psa_1.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+}, {})[0];
+
+const query = `{ documents { sequences { type blocks { bg { subType payload } bs { payload } text } } } }`;
+
+test(
+  `Without Custom (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = result.data.documents[0].sequences;
+      // t.equal(sequences.filter(s => s.type === 'heading').length, 0);
+      // BEHAVIOUR CHANGED WITH SUCCINCT FILTER. s5 sequences are empty but not deleted
+      t.equal(sequences.filter(s => s.type === 'main')[0].blocks[0].bs.payload, 'blockTag/q');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `With Custom (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const result = await customPk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequences = result.data.documents[0].sequences;
+      t.equal(sequences.filter(s => s.type === 'heading').length, 3);
+      t.equal(sequences.filter(s => s.type === 'heading' && s.blocks[0].bs.payload === 'blockTag/s5').length, 3);
+      t.equal(sequences.filter(s => s.type === 'main')[0].blocks[0].bs.payload, 'blockTag/m');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/entries.cjs

@@ -0,0 +1,402 @@
+/* eslint-disable no-return-assign */
+const path = require('path');
+const fse = require('fs-extra');
+const test = require('tape');
+
+const { Validator } = require('proskomma-json-tools');
+const { pkWithDoc } = require('../../lib/load.js');
+
+const { blocksSpec2Query } = require('../../../src/util/scriptlike/blocksSpec.cjs');
+
+const [pk, pkDoc] = pkWithDoc('../test_data/usfm/66-JUD-ust.usfm', {
+  lang: 'eng',
+  abbr: 'ust',
+});
+
+const cleanKV = entry => {
+  const fields = {};
+  entry.itemGroups.forEach(ig => fields[ig.scopeLabels[0].split('/')[1]] = ig.text);
+  const secondaryKeys = {};
+  entry.secondaryKeys.forEach(k => secondaryKeys[k.key] = k.value);
+  return {
+    key: entry.key,
+    secondaryKeys,
+    fields,
+  };
+};
+
+const testGroup = 'Entries';
+
+test(
+  `kv mutation (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      const kvQuery = blocksSpec2Query(
+        fse.readJSONSync(path.resolve(__dirname, '../../test_data/inputBlockSpec/kv.json')),
+      );
+
+      let query = `mutation { newSequence(` +
+        ` documentId: "${pkDoc.id}"` +
+        ` type: "kv"` +
+        ` blocksSpec: ${kvQuery}` +
+        ` graftToMain: true) }`;
+
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const newSeqId = result.data.newSequence;
+      query = `mutation { addSequenceTags(docSetId: "eng_ust", documentId: "${pkDoc.id}", sequenceId: "${newSeqId}", tags: ["kv"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Without args (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(8);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"kv") {
+              nEntries
+              entries {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const kv = document.kvSequences[0].entries.map(kv => cleanKV(kv));
+      t.equal(document.kvSequences[0].nEntries, 3);
+      t.equal(kv.length, 3);
+      t.equal(kv[0].key, 'a');
+      t.equal(Object.keys(kv[0].secondaryKeys).length, 2);
+      t.equal(kv[0].secondaryKeys['service'], 'dessert');
+      t.equal(Object.keys(kv[0].fields).length, 2);
+      t.equal(kv[0].fields['name'], 'apple');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `keyEquals (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"kv") {
+              entries(keyEquals: ["a", "c"]) {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const kv = document.kvSequences[0].entries.map(kv => cleanKV(kv));
+      t.equal(kv.length, 2);
+      t.equal(kv[0].key, 'a');
+      t.equal(kv[1].key, 'c');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `keyMatches (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"kv") {
+              entries(keyMatches: "[ab]") {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const kv = document.kvSequences[0].entries.map(kv => cleanKV(kv));
+      t.equal(kv.length, 2);
+      t.equal(kv[0].key, 'a');
+      t.equal(kv[1].key, 'b');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `secondaryEquals (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"kv") {
+              entries(secondaryEquals: [{key: "color", values: "green"}, {key: "service", values: "starter"}]) {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const kv = document.kvSequences[0].entries.map(kv => cleanKV(kv));
+      t.equal(kv.length, 1);
+      t.equal(kv[0].key, 'c');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `secondaryMatches (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"kv") {
+              entries(secondaryMatches: [{key: "color", matches: "ree"}, {key: "service", matches: "tar"}]) {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const kv = document.kvSequences[0].entries.map(kv => cleanKV(kv));
+      t.equal(kv.length, 1);
+      t.equal(kv[0].key, 'c');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `contentMatches (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"kv") {
+              entries(contentMatches: [{key: "name", matches: "pl|na"}, {key: "definition", matches: "obj"}]) {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const kv = document.kvSequences[0].entries.map(kv => cleanKV(kv));
+      t.equal(kv.length, 1);
+      t.equal(kv[0].key, 'b');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `contentEquals (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"kv") {
+              entries(contentEquals: [{key: "name", values: "apple"}, {key: "definition", values: "A tasty snack"}]) {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const kv = document.kvSequences[0].entries.map(kv => cleanKV(kv));
+      t.equal(kv.length, 1);
+      t.equal(kv[0].key, 'a');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Dodson lexicon mutation (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2);
+      const dodsonQuery = blocksSpec2Query(
+        fse.readJSONSync(path.resolve(__dirname, '../../test_data/inputBlockSpec/dodson.json')),
+      );
+
+      let query = `mutation { newSequence(` +
+        ` documentId: "${pkDoc.id}"` +
+        ` type: "kv"` +
+        ` blocksSpec: ${dodsonQuery}` +
+        ` graftToMain: true) }`;
+
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const newSeqId = result.data.newSequence;
+      query = `mutation { addSequenceTags(docSetId: "eng_ust", documentId: "${pkDoc.id}", sequenceId: "${newSeqId}", tags: ["dodson"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Dodson queries (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(13);
+
+      const query = `{
+        docSets {
+          document(bookCode:"JUD") {
+            kvSequences(withTags:"dodson") {
+              nEntries
+              allEntries: entries {
+                key
+                secondaryKeys { key value }
+                itemGroups {
+                  scopeLabels(startsWith:"kvField")
+                  text
+                }
+              }
+              byLemma: entries(keyEquals: ["ἀβαρής"]) { key }
+              byStrong: entries(secondaryEquals: [{key: "strong", values: "0007"}]) { key }
+              byContent: entries(contentMatches: [{key: "fullDef", matches: "son.+Amram"}]) { key itemGroups { text } }
+            }
+          }
+        }
+      }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const document = result.data.docSets[0].document;
+      const allEntries = document.kvSequences[0].allEntries.map(kv => cleanKV(kv));
+      t.equal(document.kvSequences[0].nEntries, 9);
+      t.equal(allEntries.length, 9);
+      t.equal(allEntries[0].key, 'ἄλφα');
+      t.equal(Object.keys(allEntries[0].secondaryKeys).length, 1);
+      t.equal(allEntries[0].secondaryKeys['strong'], '0001');
+      t.equal(Object.keys(allEntries[0].fields).length, 2);
+      t.ok(allEntries[0].fields['briefDef'].startsWith('the first letter'));
+      const lemmaEntries = document.kvSequences[0].byLemma;
+      t.equal(lemmaEntries.length, 1);
+      t.equal(lemmaEntries[0].key, 'ἀβαρής');
+      const strongEntries = document.kvSequences[0].byStrong;
+      t.equal(strongEntries.length, 1);
+      t.equal(strongEntries[0].key, 'Ἀβιά');
+      const sonEntries = document.kvSequences[0].byContent;
+      t.equal(sonEntries.length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Serialize (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query = '{ docSets { id } }';
+      const result = await pk.gqlQuery(query);
+      const docSetId = result.data.docSets[0].id;
+      const serialized = pk.serializeSuccinct(docSetId);
+      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/main/export_lexing_regexes.cjs

@@ -0,0 +1,19 @@
+const test = require('tape');
+
+const pkExports = require('../../../src/index.cjs');
+
+const testGroup = 'Export lexingRegexes';
+
+test(
+  `Smoke (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(3);
+      t.ok('Proskomma' in pkExports);
+      t.ok('lexingRegexes' in pkExports);
+      t.equal(pkExports.lexingRegexes.filter(r => r[0] === 'chapter').length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/fig.cjs

@@ -0,0 +1,67 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Fig';
+
+const pk = pkWithDoc('../test_data/usfm/fig.usfm', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+const pk2 = pkWithDoc('../test_data/usx/fig.usx', {
+  lang: 'fra',
+  abbr: 'hello',
+})[0];
+
+const query =
+  '{ documents { sequences { id type blocks { scopeLabels text items { type subType payload } } } } }';
+
+const checkResult = (t, result) => {
+  const sequences = result.data.documents[0].sequences;
+  t.equal(sequences.length, 2);
+  const figSequence = sequences.filter(s => s.type === 'fig')[0];
+  const firstFigItem = figSequence.blocks[0].items[0];
+  t.equal(firstFigItem.subType, 'start');
+  t.equal(firstFigItem.payload, 'spanWithAtts/fig');
+  const lastFigItem = figSequence.blocks[0].items[figSequence.blocks[0].items.length - 1];
+  t.equal(lastFigItem.subType, 'end');
+  t.equal(lastFigItem.payload, 'spanWithAtts/fig');
+  const attributeTypes = figSequence.blocks[0].scopeLabels.filter(sl => sl.startsWith('attribute')).map(sl => sl.split('/')[3]);
+
+  for (const att of ['src', 'size', 'ref']) {
+    t.ok(attributeTypes.includes(att));
+  }
+
+  const mainSequence = sequences.filter(s => s.type === 'main')[0];
+  const lastMainItem = mainSequence.blocks[0].items[mainSequence.blocks[0].items.length - 1];
+  t.equal(lastMainItem.type, 'graft');
+  t.equal(lastMainItem.subType, 'fig');
+};
+
+test(
+  `USFM (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(11);
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      checkResult(t, result);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `USX (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(11);
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      checkResult(t, result);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);