proskomma-core 0.9.10 → 0.9.13

package/src/graph/lib/do_cv.cjs

@@ -0,0 +1,249 @@
+const xre = require('xregexp');
+const utils = require('../../util/index.cjs');
+
+const updatedOpenScopes = (openScopes, items) => {
+  let ret = openScopes;
+
+  for (const item of items) {
+    if (item[0] === 'scope') {
+      if (item[1] === 'start') {
+        const existingScopes = ret.filter(s => s === item[2]);
+
+        if (existingScopes.length === 0) {
+          ret.push(item[2]);
+        }
+      } else {
+        ret = ret.filter(s => s !== item[2]);
+      }
+    }
+  }
+  return ret;
+};
+
+const do_chapter_cv = (root, context, mainSequence, chapterN, includeContext) => {
+  const ci = root.chapterIndex(chapterN);
+
+  if (ci) {
+    const block = mainSequence.blocks[ci.startBlock];
+    return [[
+      updatedOpenScopes(
+        context.docSet.unsuccinctifyScopes(block.os).map(s => s[2]),
+        context.docSet.unsuccinctifyItems(block.c, {}, 0, [])
+          .slice(0, ci.startItem + 1)
+          .filter(i => i[0] === 'scope'),
+      ),
+      context.docSet.itemsByIndex(mainSequence, ci, includeContext || false)
+        .reduce((a, b) => a.concat([['token', 'lineSpace', ' ']].concat(b))),
+    ]];
+  } else {
+    return [];
+  }
+};
+
+const do_chapter_verse_array = (root, context, mainSequence, chapterN, verses, includeContext, doMap, mappedDocSetId) => {
+  let docSet = context.docSet;
+  let book = root.headers.bookCode;
+  let chapterVerses = verses.map(v => [parseInt(chapterN), parseInt(v)]);
+
+  if (doMap) {
+    const mappedDocSet = root.processor.docSets[mappedDocSetId];
+
+    if (mappedDocSet) {
+      docSet = mappedDocSet;
+    }
+
+    if ('forward' in mainSequence.verseMapping && chapterN in mainSequence.verseMapping.forward) {
+      let mappings = [];
+
+      for (const verse of verses) { // May handle multiple verses one day, but, eg, may map to multiple books
+        mappings.push(
+          utils.versification.mapVerse(
+            mainSequence.verseMapping.forward[chapterN],
+            root.headers.bookCode,
+            chapterN,
+            verse,
+          ),
+        );
+      }
+
+      const mapping = mappings[0];
+      book = mapping[0];
+      chapterVerses = mapping[1];
+    }
+
+    const mappedDocument = docSet.documentWithBook(book);
+
+    if (mappedDocument) {
+      const mappedMainSequence = mappedDocument.sequences[mappedDocument.mainId];
+
+      if (mappedMainSequence.verseMapping && 'reversed' in mappedMainSequence.verseMapping) {
+        const doubleMappings = [];
+
+        for (const [origC, origV] of chapterVerses) {
+          if (`${origC}` in mappedMainSequence.verseMapping.reversed) {
+            doubleMappings.push(
+              utils.versification.mapVerse(
+                mappedMainSequence.verseMapping.reversed[`${origC}`],
+                book,
+                origC,
+                origV,
+              ),
+            );
+          } else {
+            doubleMappings.push([book, [[origC, origV]]]);
+          }
+          book = doubleMappings[0][0];
+          chapterVerses = doubleMappings.map(bcv => bcv[1]).reduce((a, b) => a.concat(b));
+        }
+      }
+    }
+  }
+
+  const cvis = {};
+
+  const document = docSet.documentWithBook(book);
+
+  if (!document) {
+    return [];
+  }
+
+  const documentMainSequence = document.sequences[document.mainId];
+
+  for (const chapter of chapterVerses.map(cv => cv[0])) {
+    if (!(chapter in cvis)) {
+      cvis[chapter] = document.chapterVerseIndex(chapter);
+    }
+  }
+
+  const retItemGroups = [];
+
+  for (const [chapter, verse] of chapterVerses) {
+    if (cvis[chapter]) {
+      let retItems = [];
+      let firstStartBlock;
+      let firstStartItem;
+
+      if (cvis[chapter][verse]) {
+        for (const ve of cvis[chapter][verse]) {
+          if (!firstStartBlock) {
+            firstStartBlock = ve.startBlock;
+            firstStartItem = ve.startItem;
+          }
+          retItems = retItems.concat(docSet.itemsByIndex(documentMainSequence, ve, includeContext || null)
+            .reduce((a, b) => a.concat([['token', 'lineSpace', ' ']].concat(b))));
+        }
+
+        const block = documentMainSequence.blocks[firstStartBlock];
+
+        retItemGroups.push([
+          updatedOpenScopes(
+            docSet.unsuccinctifyScopes(block.os).map(s => s[2]),
+            docSet.unsuccinctifyItems(block.c, {}, 0, [])
+              .slice(0, firstStartItem + 1)
+              .filter(i => i[0] === 'scope'),
+          ),
+          retItems,
+        ]);
+      }
+    }
+  }
+  return retItemGroups;
+};
+
+const scopesMatchAChapterSpec = (scopes, chapterSpecs) => {
+  if (chapterSpecs.length === 0) {
+    return false;
+  } else if (
+    scopes.includes(`chapter/${chapterSpecs[0][0]}`) &&
+    (!chapterSpecs[0][1] || scopes.filter(s => s.startsWith('verse/') && parseInt(s.split('/')[1]) >= chapterSpecs[0][1]).length > 0) &&
+    (!chapterSpecs[0][2] || scopes.filter(s => s.startsWith('verse/') && parseInt(s.split('/')[1]) <= chapterSpecs[0][2]).length > 0)
+  ) {
+    return true;
+  } else {
+    return scopesMatchAChapterSpec(scopes, chapterSpecs.slice(1));
+  }
+};
+
+const do_chapterVerses = (root, context, mainSequence, fromCV, toCV, includeContext) => {
+  const [fromCInt, fromVInt] = fromCV.split(':').map(str => parseInt(str));
+  const [toCInt, toVInt] = toCV.split(':').map(str => parseInt(str));
+
+  if (toCInt < fromCInt) {
+    throw new Error(`cv chapterVerses requires fromChapter <= toChapter, not ${fromCInt} to ${toCInt}`);
+  }
+
+  const chapterSpecs = []; // [chN, minVN?, maxVN?]
+  let ch = fromCInt;
+
+  while (ch <= toCInt) {
+    chapterSpecs.push([
+      ch,
+      ch === fromCInt ? fromVInt : null,
+      ch === toCInt ? toVInt : null,
+    ]);
+    ch++;
+  }
+  return context.docSet.sequenceItemsByScopes(mainSequence.blocks, ['chapter/', 'verse/'], includeContext)
+    .filter(ig => scopesMatchAChapterSpec(ig[0], chapterSpecs));
+};
+
+const do_cv_separate_args = (root, args, context, mainSequence, doMap, mappedDocSetId) => {
+  if (args.chapter && !args.verses) { // whole chapter
+    return do_chapter_cv(root, context, mainSequence, args.chapter, args.includeContext);
+  } else if (args.verses) { // c:v, c:v-v one day, may be mapped
+    return do_chapter_verse_array(root, context, mainSequence, args.chapter, args.verses, args.includeContext, doMap, mappedDocSetId);
+  } else {
+    throw new Error('Unexpected args to do_cv_separate_args');
+  }
+};
+
+const do_cv_string_arg = (root, args, context, mainSequence) => {
+  if (xre.test(args.chapterVerses, xre('^[0-9]+:[0-9]+-[0-9]+:[0-9]+$'))) { // c:v-c:v
+    const [fromSpec, toSpec] = args.chapterVerses.split('-');
+    return do_chapterVerses(root, context, mainSequence, fromSpec, toSpec, args.includeContext);
+  } else if (xre.test(args.chapterVerses, xre('^[0-9]+:[0-9]+-[0-9]+$'))) { // c:v-v
+    const [ch, vRange] = args.chapterVerses.split(':');
+    const [fromV, toV] = vRange.split('-');
+    return do_chapterVerses(root, context, mainSequence, `${ch}:${fromV}`, `${ch}:${toV}`, args.includeContext);
+  } else if (xre.test(args.chapterVerses, xre('^[0-9]+:[0-9]+$'))) { // c:v
+    const [ch, v] = args.chapterVerses.split(':');
+    return do_chapterVerses(root, context, mainSequence, `${ch}:${v}`, `${ch}:${v}`, args.includeContext);
+  } else if (xre.test(args.chapterVerses, xre('^[0-9]+$'))) { // c
+    const ch = args.chapterVerses;
+    const cvi = root.chapterVerseIndex(ch);
+
+    if (!cvi) {
+      throw new Error(`No chapter ${ch} found`);
+    }
+
+    const verseNs = cvi.map((c, n) => [n, c]).filter(nc => nc[1].length > 0).map(nc => nc[0]);
+    return do_chapterVerses(root, context, mainSequence, `${ch}:${Math.min(verseNs)}`, `${ch}:${Math.max(verseNs)}`, args.includeContext);
+  } else {
+    throw new Error(`Could not parse chapterVerses string '${args.chapterVerses}'`);
+  }
+};
+
+const do_cv = (root, args, context, doMap, mappedDocSetId) => {
+  context.docSet = root.processor.docSets[root.docSetId];
+  const mainSequence = root.sequences[root.mainId];
+
+  if (!args.chapter && !args.chapterVerses) {
+    throw new Error('Must specify either chapter or chapterVerses for cv');
+  }
+
+  if (args.chapter && args.chapterVerses) {
+    throw new Error('Must not specify both chapter and chapterVerses for cv');
+  }
+
+  if (args.chapterVerses && args.verses) {
+    throw new Error('Must not specify both chapterVerses and verses for cv');
+  }
+
+  if (args.chapter) {
+    return do_cv_separate_args(root, args, context, mainSequence, doMap, mappedDocSetId);
+  } else {
+    return do_cv_string_arg(root, args, context, mainSequence);
+  }
+};
+
+module.exports = { do_cv };

package/src/graph/lib/dump.cjs

@@ -0,0 +1,40 @@
+const dumpItem = i => {
+  let wrapper;
+
+  switch (i[0]) {
+  case 'token':
+    return `|${i[2]}`;
+  case 'scope':
+    wrapper = i[1] === 'start' ? '+' : '-';
+    return `${wrapper}${i[2]}${wrapper}`;
+  case 'graft':
+    return `>${i[1]}<`;
+  }
+};
+
+const dumpItems = il => il.map(bci => dumpItem(bci)).join('');
+
+const dumpItemGroup = ig => {
+  const ret = ['ItemGroup:'];
+  ret.push(`   Open Scopes ${ig[0].join(', ')}`);
+  ret.push(`   ${dumpItems(ig[1])}`);
+  return ret.join('\n');
+};
+
+const dumpBlock = b => {
+  const ret = ['Block:'];
+
+  if (b.bg.length > 0) {
+    b.bg.forEach(bbg => ret.push(`   ${bbg[1]} graft to ${bbg[2]}`));
+  }
+  ret.push(`   Scope ${b.bs[2]}`);
+  ret.push(`   ${dumpItems(b.c)}`);
+  return ret.join('\n');
+};
+
+module.exports = {
+  dumpBlock,
+  dumpItemGroup,
+  dumpItems,
+  dumpItem,
+};

package/src/graph/lib/remake_blocks.cjs

@@ -0,0 +1,57 @@
+const remakeBlocks = (docSet, document, sequence, blocksSpec) => {
+  const nBlocks = sequence.blocks.length;
+
+  for (let blockN = 0; blockN < nBlocks; blockN++) {
+    document.deleteBlock(sequence.id, 0, false);
+  }
+
+  for (let blockN = 0; blockN < blocksSpec.length; blockN++) {
+    const block = blocksSpec[blockN];
+    document.newBlock(sequence.id, blockN, block.bs.payload, null, false);
+    const bgResult = docSet.updateBlockGrafts(
+      document.id,
+      sequence.id,
+      blockN,
+      block.bg,
+    );
+
+    if (!bgResult) {
+      return false;
+    }
+
+    const osResult = docSet.updateOpenScopes(
+      document.id,
+      sequence.id,
+      blockN,
+      block.os,
+    );
+
+    if (!osResult) {
+      return false;
+    }
+
+    const isResult = docSet.updateIncludedScopes(
+      document.id,
+      sequence.id,
+      blockN,
+      block.is,
+    );
+
+    if (!isResult) {
+      return false;
+    }
+
+    const itemsResult = docSet.updateItems(
+      document.id,
+      sequence.id,
+      blockN,
+      block.items,
+    );
+
+    if (!itemsResult) {
+      return false;
+    }
+  }
+};
+
+module.exports = { remakeBlocks };

package/src/graph/lib/sequence_chars.cjs

@@ -0,0 +1,84 @@
+const utils = require('../../util/index.cjs');
+
+const exactSearchTermIndexes = (docSet, chars, allChars) => {
+  let charsIndexesArray = [
+    chars
+      .map(
+        c => [utils.enums.enumStringIndex(docSet.enums.wordLike, c)],
+      ),
+  ];
+
+  if (allChars) {
+    charsIndexesArray = charsIndexesArray[0];
+  } else {
+    charsIndexesArray = charsIndexesArray.map(ci => ci.reduce((a, b) => a.concat(b)));
+  }
+  return charsIndexesArray;
+};
+
+const regexSearchTermIndexes = (docSet, chars, allChars) => {
+  let charsIndexesArray = [
+    chars
+      .map(
+        c =>
+          utils.enums.enumRegexIndexTuples(docSet.enums.wordLike, c)
+            .map(tup => tup[0]),
+      ),
+  ];
+
+  if (allChars) {
+    charsIndexesArray = charsIndexesArray[0];
+  } else {
+    charsIndexesArray = charsIndexesArray.map(ci => ci.reduce((a, b) => a.concat(b)));
+  }
+  return charsIndexesArray;
+};
+
+const sequenceMatchesSearchTerms = (seq, charsIndexesArray, allChars) => {
+  if (allChars && charsIndexesArray.filter(i => i.length === 0).length > 0) {
+    return false;
+  }
+
+  charsIndexesArray = charsIndexesArray.filter(i => i.length > 0);
+
+  if (charsIndexesArray.length === 0) {
+    return false;
+  }
+
+  for (const charsIndexes of charsIndexesArray) {
+    let found = false;
+
+    for (const charsIndex of charsIndexes) {
+      const isPresent = charsIndex >= 0 && seq.tokensPresent.get(charsIndex) > 0;
+
+      if (isPresent) {
+        found = true;
+        break;
+      }
+    }
+
+    if (allChars && !found) {
+      return false;
+    } else if (!allChars && found) {
+      return true;
+    }
+  }
+  return allChars;
+};
+
+const sequenceHasChars = (docSet, seq, chars, allChars) => {
+  let charsIndexesArray = exactSearchTermIndexes(docSet, chars, allChars);
+  return sequenceMatchesSearchTerms(seq, charsIndexesArray, allChars);
+};
+
+const sequenceHasMatchingChars = (docSet, seq, chars, allChars) => {
+  let charsIndexesArray = regexSearchTermIndexes(docSet, chars, allChars);
+  return sequenceMatchesSearchTerms(seq, charsIndexesArray, allChars);
+};
+
+module.exports = {
+  sequenceHasChars,
+  sequenceHasMatchingChars,
+  regexSearchTermIndexes,
+  exactSearchTermIndexes,
+};

package/src/graph/lib/sort.cjs

@@ -0,0 +1,39 @@
+const utils = require('../../util/index.cjs');
+
+const ptCompare = (a, b) => {
+  const bcA = a.headers.bookCode || 'GEN';
+  const bcB = b.headers.bookCode || 'GEN';
+  const posA = utils.canons.ptBooks[bcA] ? utils.canons.ptBooks[bcA].position : 999;
+  const posB = utils.canons.ptBooks[bcB] ? utils.canons.ptBooks[bcB].position : 999;
+  return posA - posB;
+};
+
+const alphaCompare = (a, b) => {
+  const bcA = a.headers.bookCode || 'GEN';
+  const bcB = b.headers.bookCode || 'GEN';
+  return bcA.localeCompare(bcB);
+};
+
+const alpha2Compare = (a, b) => {
+  const digits = [1, 2, 3, 4, 5, 6];
+  let bcA = a.headers.bookCode || 'GEN';
+
+  if (digits.includes(bcA[0])) {
+    bcA = bcA.substring(1) + bcA[0];
+  }
+
+  let bcB = b.headers.bookCode || 'GEN';
+
+  if (digits.includes(bcB[0])) {
+    bcB = bcB.substring(1) + bcB[0];
+  }
+  return bcA.localeCompare(bcB);
+};
+
+const bookCodeCompareFunctions = {
+  paratext: ptCompare,
+  alpha: alphaCompare,
+  alpha2: alpha2Compare,
+};
+
+module.exports = { bookCodeCompareFunctions };

package/src/graph/lib/tribos.cjs

@@ -0,0 +1,97 @@
+const xre = require('xregexp');
+
+const { expressions, doPredicate } = require('./tribos_expression.cjs');
+const { stepActions } = require('./tribos_step.cjs');
+
+class Tribos {
+  constructor() {
+    this.currentStepType = null;
+  }
+
+  doStep(docSet, allNodes, nodeLookup, result, queryStep) {
+    for (const stepAction of stepActions) {
+      const matches = xre.exec(queryStep, stepAction.regex);
+
+      if (matches && stepAction.inputType === this.currentStepType) {
+        let ret = stepAction.function(docSet, allNodes, nodeLookup, result, queryStep, matches);
+
+        if (matches[stepAction.predicateCapture]) {
+          ret = doPredicate(docSet, ret, matches[stepAction.predicateCapture]);
+        }
+        this.currentStepType = stepAction.outputType;
+        return ret;
+      }
+    }
+    return { errors: `Unable to match step ${queryStep}` };
+  }
+
+  parse1(docSet, allNodes, nodeLookup, result, queryArray) {
+    if (queryArray.length > 0) {
+      const stepResult = this.doStep(docSet, allNodes, nodeLookup, result, queryArray[0]);
+
+      if (stepResult.errors || stepResult.data.length === 0) {
+        return stepResult;
+      } else {
+        return this.parse1(docSet, allNodes, nodeLookup, stepResult, queryArray.slice(1));
+      }
+    } else {
+      return result;
+    }
+  }
+
+  queryArray(qs) {
+    const ret = [];
+
+    for (const s of qs.split('/')) {
+      ret.push(s);
+    }
+    return ret;
+  }
+
+  indexNodes(docSet, nodes) {
+    const ret = new Map();
+
+    for (const [n, node] of nodes.entries()) {
+      const nodeId = docSet.unsuccinctifyScopes(node.bs)[0][2].split('/')[1];
+      ret.set(nodeId, n);
+    }
+    return ret;
+  }
+
+  doc() {
+    return '** Steps **\n\n' +
+    stepActions
+      .map(sa => sa.doc)
+      .map(d => `* ${d.title} *\n${d.syntax}\n${d.description}`)
+      .join('\n\n') +
+      '** Predicate Operators **\n\n' +
+      Object.values(expressions)
+        .filter(e => e.doc)
+        .map(e => `${e.doc.operator}(${e.doc.args.map(a => '<' + a + '>').join(', ')}) => ${e.doc.result}\n${e.doc.description}`)
+        .join('\n\n');
+  }
+
+  parse(docSet, nodes, queryString) {
+    // console.log(`\n===> ${queryString}\n`);
+    const result = this.parse1(
+      docSet,
+      nodes,
+      this.indexNodes(docSet, nodes),
+      { data: nodes },
+      this.queryArray(queryString),
+    );
+
+    if (result.data) {
+      switch (this.currentStepType) {
+      case 'nodes':
+        result.data = result.data.map(n => ({ id: docSet.unsuccinctifyScopes(n.bs)[0][2].split('/')[1] }));
+      }
+    }
+
+    const ret = JSON.stringify(result, null, 2);
+    // console.log(`${ret}\n`);
+    return ret;
+  }
+}
+
+module.exports = Tribos;