proskomma-core 0.9.7 → 0.9.12

package/test/code/main/selectors.cjs

@@ -0,0 +1,289 @@
+const path = require('path');
+const test = require('tape');
+const fse = require('fs-extra');
+
+const { Proskomma } = require('../../../src/index.cjs');
+const {
+  customPkWithDoc,
+  customPkWithDocs,
+} = require('../../lib/load.js');
+
+const testGroup = 'Graph Selectors';
+
+test(
+  `selectors for root (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      const query = '{ selectors { name type regex min max enum } }';
+      const pk = new Proskomma();
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('selectors' in result.data);
+      const selectors = result.data.selectors;
+      t.equal(selectors.length, 2);
+      t.equal(selectors[0].name, 'lang');
+      t.equal(selectors[0].type, 'string');
+      t.equal(selectors[0].regex, '[a-z]{3}');
+      t.equal(selectors[1].name, 'abbr');
+      t.equal(selectors[1].type, 'string');
+      t.equal(selectors[1].regex, null);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Throw on bad spec (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(15);
+      let selectors = [];
+      const customProskomma = class extends Proskomma {
+        constructor() {
+          super();
+          this.selectors = selectors;
+          this.validateSelectors();
+        }
+      };
+      t.throws(() => new customProskomma(), /No selectors found/);
+      selectors = [{}];
+      t.throws(() => new customProskomma(), /Selector.+has no name/);
+      selectors = [{ name: 'foo' }];
+      t.throws(() => new customProskomma(), /Selector.+has no type/);
+      selectors = [{
+        name: 'foo',
+        type: 'banana',
+      }];
+      t.throws(() => new customProskomma(), /Type for selector/);
+      selectors = [{
+        name: 'foo',
+        type: 'string',
+        banana: 'split',
+      }];
+      t.throws(() => new customProskomma(), /Unexpected key/);
+      selectors = [{
+        name: 'foo',
+        type: 'string',
+        min: 23,
+      }];
+      t.throws(() => new customProskomma(), /should not include 'min'/);
+      selectors = [{
+        name: 'foo',
+        type: 'string',
+        max: 23,
+      }];
+      t.throws(() => new customProskomma(), /should not include 'max'/);
+      selectors = [{
+        name: 'foo',
+        type: 'string',
+        regex: '[',
+      }];
+      t.throws(() => new customProskomma(), /is not valid/);
+      selectors = [{
+        name: 'foo',
+        type: 'string',
+        enum: ['a', 'b', 23],
+      }];
+      t.throws(() => new customProskomma(), /should be strings/);
+      selectors = [{
+        name: 'foo',
+        type: 'integer',
+        regex: '[a]',
+      }];
+      t.throws(() => new customProskomma(), /should not include 'regex'/);
+      selectors = [{
+        name: 'foo',
+        type: 'integer',
+        min: '23',
+      }];
+      t.throws(() => new customProskomma(), /'min' must be a number/);
+      selectors = [{
+        name: 'foo',
+        type: 'integer',
+        max: '23',
+      }];
+      t.throws(() => new customProskomma(), /'max' must be a number/);
+      selectors = [{
+        name: 'foo',
+        type: 'integer',
+        min: 23,
+        max: 22,
+      }];
+      t.throws(() => new customProskomma(), /'min' cannot be greater than 'max'/);
+      selectors = [{
+        name: 'foo',
+        type: 'integer',
+        enum: [1, 2, '3'],
+      }];
+      t.throws(() => new customProskomma(), /should be numbers/);
+      selectors = [
+        {
+          name: 'foo',
+          type: 'string',
+          regex: '.*',
+          enum: ['a', 'b', 'c'],
+        },
+        {
+          name: 'baa',
+          type: 'integer',
+          min: 1,
+          max: 9,
+          enum: [2, 4, 6],
+        },
+      ];
+      t.doesNotThrow(() => new customProskomma());
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Throw on bad selector name and type (${testGroup})`,
+  function (t) {
+    try {
+      t.plan(8);
+      const customProskomma = class extends Proskomma {
+        constructor() {
+          super();
+          this.selectors = [
+            {
+              name: 'foo',
+              type: 'string',
+              regex: '[a-z]+',
+              enum: ['banana', 'mango', 'apple'],
+            },
+            {
+              name: 'baa',
+              type: 'integer',
+              min: 1,
+              max: 9,
+              enum: [2, 4, 6, 8],
+            },
+          ];
+          this.validateSelectors();
+        }
+      };
+      const pk = new customProskomma();
+      const content = fse.readFileSync(path.resolve(__dirname, '../../test_data/usx/web_rut.usx'));
+      let selectors = {};
+      const importFn = () => pk.importDocument(
+        selectors,
+        'usx',
+        content,
+      );
+      t.throws(importFn, /Expected selector 'foo' not found/);
+      selectors = { banana: 23 };
+      t.throws(importFn, /Unexpected selector/);
+      selectors = {
+        foo: 23,
+        baa: 24,
+      };
+      t.throws(importFn, /is of type number \(expected string\)/);
+      selectors = {
+        foo: 'banana',
+        baa: 24.5,
+      };
+      t.throws(importFn, /is not an integer/);
+      selectors = {
+        foo: 'banana',
+        baa: 7,
+      };
+      t.throws(importFn, /is not in enum/);
+      selectors = {
+        foo: 'orange',
+        baa: 8,
+      };
+      t.throws(importFn, /is not in enum/);
+      selectors = {
+        foo: '123',
+        baa: 8,
+      };
+      t.throws(importFn, /does not match regex/);
+      selectors = {
+        foo: 'banana',
+        baa: 6,
+      };
+      t.doesNotThrow(importFn);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `selectors in graph for docSet (${testGroup})`,
+  async function (t) {
+    try {
+      const customProskomma = class extends Proskomma {
+        constructor() {
+          super();
+          this.selectors = [
+            {
+              name: 'foo',
+              type: 'string',
+            },
+            {
+              name: 'baa',
+              type: 'integer',
+            },
+          ];
+          this.validateSelectors();
+        }
+      };
+      let cpk = customPkWithDoc(customProskomma, '../test_data/usx/web_rut.usx', {
+        foo: 'banana',
+        baa: 23,
+      })[0];
+      t.plan(17);
+      let query = '{ docSets { id selectors { key value } } }';
+      let result = await cpk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('selectors' in result.data.docSets[0]);
+      const selectors = result.data.docSets[0].selectors;
+      t.equal(selectors[0].key, 'foo');
+      t.equal(selectors[0].value, 'banana');
+      t.equal(selectors[1].key, 'baa');
+      t.equal(selectors[1].value, '23');
+      t.equal(result.data.docSets[0].id, 'banana_23');
+      cpk = customPkWithDocs(customProskomma, [
+        ['../test_data/usx/web_rut.usx', {
+          foo: 'banana',
+          baa: 23,
+        }],
+        ['../test_data/usx/web_psa150.usx', {
+          foo: 'banana',
+          baa: 48,
+        }],
+        ['../test_data/usx/fig.usx', {
+          foo: 'mango',
+          baa: 48,
+        }],
+      ]);
+      query = '{ docSets { foo: selector(id:"foo") baa: selector(id:"baa") } }';
+      result = await cpk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 3);
+      query = '{ docSets(withSelectors:[{key:"foo", value:"banana"}]) { foo: selector(id:"foo") baa: selector(id:"baa") } }';
+      result = await cpk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 2);
+      query = '{ docSets(withSelectors:[{key:"baa", value:"48"}]) { foo: selector(id:"foo") baa: selector(id:"baa") } }';
+      result = await cpk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 2);
+      query = '{ docSets(withSelectors:[{key: "foo", value:"banana"}, {key:"baa", value:"48"}]) { foo: selector(id:"foo") baa: selector(id:"baa") } }';
+      result = await cpk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 1);
+      query = '{ docSets(withSelectors:[{key:"foo", value:"durian"}]) { foo: selector(id:"foo") baa: selector(id:"baa") } }';
+      result = await cpk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/sequence.cjs

@@ -0,0 +1,361 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graph Sequence';
+
+const [pk] = pkWithDoc('../test_data/usfm/hello.usfm', {
+  lang: 'eng',
+  abbr: 'ust',
+});
+const pk2 = pkWithDoc('../test_data/usx/web_rut.usx', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+test(
+  `Scalars (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(5);
+      const query = '{ documents { mainSequence { id type nBlocks } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('mainSequence' in result.data.documents[0]);
+      t.ok('id' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.type, 'main');
+      t.equal(result.data.documents[0].mainSequence.nBlocks, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Blocks (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainSequence { blocks { text } } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      t.ok('text' in result.data.documents[0].mainSequence.blocks[0]);
+      t.equal(result.data.documents[0].mainSequence.blocks[0].text, 'This is how the Good News of JC began...');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `position (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(8);
+      let query = '{ documents { mainSequence { blocks(positions: [0]) { text } } } }';
+      let result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.blocks.length, 1);
+      t.ok(result.data.documents[0].mainSequence.blocks[0].text.startsWith('In the days when the judges judged'));
+      query = '{ documents { mainSequence { blocks(positions: []) { text } } } }';
+      result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.blocks.length, 0);
+      query = '{ documents { mainSequence { blocks(positions: [1, 3, 1]) { text } } } }';
+      result = await pk2.gqlQuery(query);
+      t.equal(result.data.documents[0].mainSequence.blocks.length, 2);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `withScopes (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(7);
+      let query = '{ documents { mainSequence { blocks(withScopes:["chapter/1", "verse/1"]) { text } } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.blocks.length, 1);
+      t.equal(result.data.documents[0].mainSequence.blocks[0].text, 'This is how the Good News of JC began...');
+      query = '{ documents { mainSequence { blocks(withScopes:["chapter/1", "verse/2"]) { text } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.blocks.length, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `withBlockScope (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let query = '{ documents { mainSequence { blocks(withBlockScope:"blockTag/p") { text } } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.blocks.length, 1);
+      query = '{ documents { mainSequence { blocks(withBlockScope:"blockTag/q") { text } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.blocks.length, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `withChars 'or' (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(27);
+      let query = '{ documents { mainSequence { blocks(withChars:["Boaz" "Naomi"]) { text } } } }';
+      let result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      const blocks = result.data.documents[0].mainSequence.blocks;
+      t.equal(blocks.length, 24);
+
+      for (const block of blocks) {
+        t.ok(block.text.includes('Boaz') || block.text.includes('Naomi'));
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `withChars 'and' (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(11);
+      let query = '{ documents { mainSequence { blocks(withChars:["Boaz" "Naomi"] allChars: true) { text } } } }';
+      let result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      const blocks = result.data.documents[0].mainSequence.blocks;
+      t.equal(blocks.length, 8);
+
+      for (const block of blocks) {
+        t.ok(block.text.includes('Boaz') && block.text.includes('Naomi'));
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `withMatchingChars 'or' (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      let query = '{ documents { mainSequence { blocks(withMatchingChars:["judge", "amminadab"]) { text } } } }';
+      let result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      const blocks = result.data.documents[0].mainSequence.blocks;
+      t.equal(blocks.length, 2);
+      // console.log(JSON.stringify(blocks, null, 2));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `withMatchingChars 'and' (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      let query = '{ documents { mainSequence { blocks(withMatchingChars:["naomi", "ruth", "boaz", "field"] allChars:true) { text } } } }';
+      let result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('blocks' in result.data.documents[0].mainSequence);
+      const blocks = result.data.documents[0].mainSequence.blocks;
+      t.equal(blocks.length, 3);
+      // console.log(JSON.stringify(blocks, null, 2));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `wordLikes (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let query = '{ documents { mainSequence { wordLikes } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok(result.data.documents[0].mainSequence.wordLikes.includes('Good'));
+      query = '{ documents { mainSequence { wordLikes(coerceCase:"toLower") } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok(result.data.documents[0].mainSequence.wordLikes.includes('good'));
+      query = '{ documents { mainSequence { wordLikes(coerceCase:"toUpper") } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok(result.data.documents[0].mainSequence.wordLikes.includes('GOOD'));
+    } catch
+    (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `hasChars (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '' +
+        '{' +
+        '  documents {' +
+        '    mainSequence {' +
+        '      orLogic: hasChars(chars:["Ruth", "Boaz", "banana"])' +
+        '      andLogic: hasChars(chars:["Ruth", "Boaz", "banana"] allChars:true)' +
+        '      allMiss: hasChars(chars: ["banana", "grapefruit"])' +
+        '    }' +
+        '  }' +
+        '}';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequence = result.data.documents[0].mainSequence;
+      t.ok(sequence.orLogic);
+      t.ok(!sequence.andLogic);
+      t.ok(!sequence.allMiss);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `hasMatchingChars (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query = '' +
+        '{' +
+        '  documents {' +
+        '    mainSequence {' +
+        '      orLogic: hasMatchingChars(chars:["Rut", "oaz", "banana"])' +
+        '      andLogic: hasMatchingChars(chars:["Rut", "oaz", "banana"] allChars:true)' +
+        '    }' +
+        '  }' +
+        '}';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const sequence = result.data.documents[0].mainSequence;
+      t.ok(sequence.orLogic);
+      t.ok(!sequence.andLogic);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `blocksItems (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(7);
+      const query = '{ documents { mainSequence { blocksItems { type subType payload } } } }';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('blocksItems' in result.data.documents[0].mainSequence);
+      const blocksItems = result.data.documents[0].mainSequence.blocksItems;
+      t.equal(blocksItems[0][0].payload, 'chapter/1');
+      t.equal(blocksItems[0][1].payload, 'verse/1');
+      t.equal(blocksItems[0][2].payload, 'verses/1');
+      t.equal(blocksItems[0][3].payload, 'In');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `blocksTokens (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainSequence { blocksTokens { type subType payload } } } }';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('blocksTokens' in result.data.documents[0].mainSequence);
+      t.equal(result.data.documents[0].mainSequence.blocksTokens[0][0].payload, 'In');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `blocksText (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(5);
+      const query = '{ documents { mainSequence { blocksText normalized: blocksText(normalizeSpace:true) } } }';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('blocksText' in result.data.documents[0].mainSequence);
+      t.ok(result.data.documents[0].mainSequence.blocksText[0].startsWith('In the days when'));
+      t.ok(result.data.documents[0].mainSequence.normalized[0].startsWith('In the days when'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `text (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainSequence { text } } }';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('text' in result.data.documents[0].mainSequence);
+      t.ok(result.data.documents[0].mainSequence.text.startsWith('In the days when'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `text with normalized space (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainSequence { text(normalizeSpace:true) } } }';
+      const result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('text' in result.data.documents[0].mainSequence);
+      t.ok(result.data.documents[0].mainSequence.text.startsWith('In the days when'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);