proskomma-core 0.9.12 → 0.9.13

package/test/code/main/empty_blocks.cjs

@@ -1,71 +0,0 @@
-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

@@ -1,402 +0,0 @@
-/* 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

@@ -1,19 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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);
-    }
-  },
-);