Home Reference Source Repository

resolvers/resolveContextualizations/index.js

/**
 * Resolver dedicated to resolve  contextualization statements
 * @module resolvers/resolveContextualizations
 */

import {getMetaValue} from './../../utils/sectionUtils';
import {getResourceModel, getContextualizerModel, resolvePropAgainstType} from './../../utils/modelUtils';
import * as contextualizers from './../../../contextualizers/';

/**
 * Transforms 1, 2, 3 ordinally used number into a, b, c ordinally used letters
 * @param {number} num - the number to transform
 * @return {string} letter - the output letter
 */
export const numbersToLetters = (num) =>{
  const mod = num % 26;
  let pow = num / 26 | 0;
  const out = mod ? String.fromCharCode(64 + mod) : (--pow, 'Z');
  return pow ? numbersToLetters(pow) + out : out.toLowerCase();
};

/**
 * Resolves a contextualizer object against its model and context, and records errors
 * @param {object} contextualizer - the contextualizer to resolve
 * @param {object} contextualization - the contextualization to use as a clue-giver if the contextualizer is implicit
 * @param {object} section - the section to which the contextualizer belongs
 * @param {object} models - the models to parse the contextualizer against
 * @return {{err: error, contextualizer: Object}} result - parsing errors and final contextualizer
 */
const resolveContextualizer = (contextualizer, contextualization, section, models) =>{
  const err = [];
  let newContextualizer = Object.assign({}, contextualizer);
  // if overloading, first fetch the existing contextualizer
  if (newContextualizer.overloading) {
    const overload = newContextualizer.overloading.replace(/^@/, '');
    // find original
    const original = section.contextualizers.find((cont) =>{
      return cont.citeKey === overload;
    });
    // resolve original first
    if (original) {
      const originalFormatted = resolveContextualizer(original, contextualization, section, models).finalContextualizer;
      newContextualizer = Object.assign(originalFormatted, newContextualizer);
    } else {
      // no original found ==> overloading reference error
      err.push({
        type: 'error',
        preciseType: 'invalidContextualizer',
        sectionCiteKey: getMetaValue(section.metadata, 'general', 'citeKey'),
        message: 'overloading reference error: contextualizer ' + newContextualizer.citeKey + ' should overload ' + overload + ' but the original contextualizer does not exist'
      });
    }
  }
  // guess contextualizer type if needed
  if (!newContextualizer.type) {
    if (contextualization.resources.length > 0) {
      const source = contextualization.resources[0];
      if (source === undefined) {
        err.push({
          type: 'error',
          preciseType: 'invalidContextualizer',
          sectionCiteKey: getMetaValue(section.metadata, 'general', 'citeKey'),
          message: 'contextualizer ' + newContextualizer.citeKey + ' (' + newContextualizer.type + ') does not provide a valid resource'
        });
        return {err, undefined};
      }
      const sourceModel = getResourceModel(source.bibType, models.resourceModels);
      newContextualizer.type = sourceModel.defaultContextualizer;
    }
  }
  // resolve contextualizer object against its model
  const contextualizerModel = getContextualizerModel(newContextualizer.type, models.contextualizerModels);
  const finalContextualizer = contextualizerModel.properties.reduce((obj, thatModel) =>{
    obj[thatModel.key] = resolvePropAgainstType(newContextualizer[thatModel.key], thatModel.valueType, thatModel);
    // record error if required field is undefined
    if (obj[thatModel.key] === undefined && thatModel.required === true) {
      err.push({
        type: 'error',
        preciseType: 'invalidContextualizer',
        sectionCiteKey: getMetaValue(section.metadata, 'general', 'citeKey'),
        message: 'contextualizer ' + newContextualizer.citeKey + ' (' + newContextualizer.type + ') does not provide required type ' + thatModel.key
      });
    }
    return obj;
  }, {});
  return {err, finalContextualizer};
};

/**
 * Resolves contextualizations' contextualizer and resource, verifying that contextualization will be possible
 * @param {object} contextualizer - the contextualizer to resolve
 * @param {object} section - the section to resolve
 * @param {object} models - the models to use to validate data
 * @param {function(err: error, results: {errors: array, newSection: Object})} callback - callbacks updated section and possible errors as an array
 */
export const resolveBindings = ({section, models}, cb) =>{
  let errors = [];
  // find implicit contextualizers types
  section.contextualizations = section.contextualizations.map(contextualization =>{
    // populate contextualizers against their models
    const {err, finalContextualizer} = resolveContextualizer(contextualization.contextualizer, contextualization, section, models);
    if (err.length) {
      errors = errors.concat(err);
    } else {
      contextualization.contextualizer = finalContextualizer;
    }
    return contextualization;
  // verify that all required resources exist
  }).filter((contextualization) =>{
    let ok = true;
    if (contextualization.contextualizer === undefined) {
      errors.push({
        type: 'error',
        preciseType: 'invalidContextualization',
        sectionCiteKey: getMetaValue(section.metadata, 'general', 'citeKey'),
        message: 'contextualizer was not found for contextualization ' + contextualization
      });
      return cb(null, {errors, section});
    }
    const acceptedResourceTypes = getContextualizerModel(contextualization.contextualizer.type, models.contextualizerModels).acceptedResourceTypes;
    // resources compatibility and existence check
    contextualization.resources.some((res) =>{
      // resource exists, check if it is accepted for the contextualizerType
      if (res !== undefined) {
        let accepted = false;
        acceptedResourceTypes.some((type) => {
          if (type === '*' || type === res.bibType) {
            accepted = true;
            return true;
          }
        });
        if (!accepted) {
          ok = false;
          errors.push({
            type: 'error',
            preciseType: 'invalidContextualization',
            sectionCiteKey: getMetaValue(section.metadata, 'general', 'citeKey'),
            message: 'resource ' + res + ' was asked in a contextualization but is not handled by the contextualizer ' + contextualization.contextualizer
          });
        }
      } else {
        ok = false;
        errors.push({
          type: 'error',
          preciseType: 'invalidContextualization',
          sectionCiteKey: getMetaValue(section.metadata, 'general', 'citeKey'),
          message: 'resource ' + res + ' was asked in a contextualization but was not found'
        });
      }
      return ok;
    });
    return ok;
  });
  cb(null, {errors, section});
};

/**
 * Resolves relations of recurrence, order, and similarity between contextualizations in a section
 * @param {array} sections - the sections array to resolve
 * @param {object} settings - the rendering settings to apply
 * @return {array} newSections - the udpated sections
 */
export const resolveContextualizationsRelations = (sections, settings) =>{
  let opCitIndex;
  let sameResPrint;
  return sections.reduce((inputSections, sectio, index)=> {
    sectio.contextualizations = sectio.contextualizations.reduce((conts, contextualization, contIndex) => {
      contextualization.resPrint = contextualization.resources.map(res =>{
        return res.citeKey;
      }).join('-');
      // opcit section
      sameResPrint = conts.find((cont2, cont2Index)=> {
        if (cont2.resPrint === contextualization.resPrint) {
          opCitIndex = cont2Index;
          contextualization.precursorCiteKey = cont2.citeKey;
          return true;
        }
      });

      if (sameResPrint !== undefined) {
        contextualization.sectionOpCit = true;
      }
      // todo opcit document

      // ibid section
      if (opCitIndex) {
        const substrate = conts.slice(opCitIndex, contIndex).filter(oCont=> {
          return oCont.contextualizer.type === contextualization.contextualizer.type;
        });
        if (substrate.length === 2) {
          contextualization.sectionIbid = true;
        }
      }

      // todo ibid document

      if (contextualization.contextualizer.type === 'citation') {
        // same authors but different work in year - section scale
        contextualization.authorsPrint = contextualization.resources[0].author.reduce((str, author)=> {
          return str + author.lastName + '-' + author.firstName;
        }, '');

        conts.find((cont2)=> {
          if (cont2.authorsPrint === contextualization.authorsPrint && cont2.resPrint !== contextualization.resPrint && (cont2.year === contextualization.year || cont2.date === contextualization.date)) {
            cont2.sameAuthorInYear = cont2.sameAuthorInYear !== undefined ? cont2.sameAuthorInYear ++ : 1;
            contextualization.sameAuthorInYear = cont2.sameAuthorInYear + 1;
            contextualization.yearSuffix = numbersToLetters(contextualization.sameAuthorInYear);
            cont2.yearSuffix = numbersToLetters(cont2.sameAuthorInYear);
            return true;
          }
        });
        // todo same authors in year but different work - at document scale
      }

      opCitIndex = undefined;
      return conts.concat(contextualization);
    }, []);

    return inputSections.concat(sectio);
  }, []);
};

/**
 * Resolves all the contextualizations of a section by updating its contents pseudo-DOM representation
 * @param {object} section - the section to resolve
 * @param {string} renderingMode - whether rendering is static or dynamic
 * @param {object} settings - the rendering settings to take into account when resolving contextualizations
 * @return {Object} newSection - the updated section
 */
export const resolveContextualizationsImplementation = (section, renderingMode, settings) =>{
  let contextualizer;
  const sectio = section.contextualizations.reduce((inputSection, contextualization) => {
    // rebind resources
    contextualization.resources = contextualization.resources.map(res1 =>{
      return inputSection.resources.find(res2 =>{
        return res1.citeKey === res2.citeKey;
      });
    });
    contextualizer = contextualizers[contextualization.contextualizer.type];
    if (contextualizer === undefined) {
      console.log('no contextualizer function was found for type ', contextualization.contextualizer.type);
      return Object.assign({}, inputSection);
    }
    switch (renderingMode) {
    case 'static':
      switch (contextualization.type) {
      case 'inline':
        return contextualizer.contextualizeInlineStatic(inputSection, contextualization, settings);
      case 'block':
        return contextualizer.contextualizeBlockStatic(inputSection, contextualization, settings);
      default:
        break;
      }
      break;
    case 'dynamic':
      switch (contextualization.type) {
      case 'inline':
        return contextualizer.contextualizeInlineDynamic(inputSection, contextualization, settings);
      case 'block':
        return contextualizer.contextualizeBlockDynamic(inputSection, contextualization, settings);
      default:
        break;
      }
      break;
    default:
      break;
    }
    return Object.assign({}, inputSection);
  }, Object.assign({}, section));

  return sectio;
};