@accordproject/cicero-core/lib/templateloader.js

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
'use strict';

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

const fs = require('fs');

const fsPath = require('path');

const slash = require('slash');

const JSZip = require('jszip');

const xregexp = require('xregexp');

const languageTagRegex = require('ietf-language-tag-regex');

const DefaultArchiveLoader = require('./loaders/defaultarchiveloader');

const FileLoader = require('@accordproject/ergo-compiler').FileLoader;

const Logger = require('@accordproject/concerto-core').Logger; // Matches 'sample.md' or 'sample_TAG.md' where TAG is an IETF language tag (BCP 47)


const IETF_REGEXP = languageTagRegex({
  exact: false
}).toString().slice(1, -2);
const SAMPLE_FILE_REGEXP = xregexp('text[/\\\\]sample(_(' + IETF_REGEXP + '))?.md$');
/**
 * A utility class to create templates from data sources.
 * @class
 * @private
 * @abstract
 */

class TemplateLoader extends FileLoader {
  /**
   * Create a template from an archive.
   * @param {*} Template - the type to construct
   * @param {Buffer} buffer  - the buffer to a Cicero Template Archive (cta) file
   * @param {object} options - additional options
   * @return {Promise<Template>} a Promise to the template
   */
  static fromArchive(Template, buffer, options) {
    return _asyncToGenerator(function* () {
      const method = 'fromArchive';
      const zip = yield JSZip.loadAsync(buffer); // const allFiles = await TemplateLoader.loadZipFilesContents(zip, /.*/);
      // console.log(allFiles);

      const ctoModelFiles = [];
      const ctoModelFileNames = [];
      const sampleTextFiles = {};
      const readmeContents = yield TemplateLoader.loadZipFileContents(zip, 'README.md');
      let sampleFiles = yield TemplateLoader.loadZipFilesContents(zip, SAMPLE_FILE_REGEXP);
      sampleFiles.forEach(
      /*#__PURE__*/
      function () {
        var _ref = _asyncToGenerator(function* (sampleFile) {
          let matches = sampleFile.name.match(SAMPLE_FILE_REGEXP);
          let locale = 'default'; // Locale match found

          if (matches !== null && matches[2]) {
            locale = matches[2];
          }

          sampleTextFiles[locale] = sampleFile.contents;
        });

        return function (_x) {
          return _ref.apply(this, arguments);
        };
      }());
      const requestContents = yield TemplateLoader.loadZipFileContents(zip, 'request.json', true);
      const packageJsonObject = yield TemplateLoader.loadZipFileContents(zip, 'package.json', true, true);
      const templatizedGrammar = yield TemplateLoader.loadZipFileContents(zip, 'text/grammar.tem.md', false, false);
      Logger.debug(method, 'Looking for model files');
      let ctoFiles = yield TemplateLoader.loadZipFilesContents(zip, /model[/\\].*\.cto$/);
      ctoFiles.forEach(
      /*#__PURE__*/
      function () {
        var _ref2 = _asyncToGenerator(function* (file) {
          ctoModelFileNames.push(file.name);
          ctoModelFiles.push(file.contents);
        });

        return function (_x2) {
          return _ref2.apply(this, arguments);
        };
      }()); // create the template

      const template = new (Function.prototype.bind.call(Template, null, packageJsonObject, readmeContents, sampleTextFiles, requestContents, options))(); // add model files

      Logger.debug(method, 'Adding model files to model manager');
      template.getModelManager().addModelFiles(ctoModelFiles, ctoModelFileNames, true); // validation is disabled

      Logger.debug(method, 'Setting grammar');

      if (!templatizedGrammar) {
        throw new Error('A template must contain a grammar.tem.md file.');
      } else {
        template.parserManager.buildGrammar(templatizedGrammar);
      } // load and add the ergo files


      if (template.getMetadata().getRuntime() === 'ergo') {
        template.getLogicManager().addTemplateFile(templatizedGrammar, 'text/grammar.tem.md');
        Logger.debug(method, 'Adding Ergo files to script manager');
        const scriptFiles = yield TemplateLoader.loadZipFilesContents(zip, /logic[/\\].*\.ergo$/);
        scriptFiles.forEach(function (obj) {
          template.getLogicManager().addLogicFile(obj.contents, obj.name);
        });
      } else {
        // load and add compiled JS files - we assume all runtimes are JS based (review!)
        Logger.debug(method, 'Adding JS files to script manager');
        const scriptFiles = yield TemplateLoader.loadZipFilesContents(zip, /logic[/\\].*\.js$/);
        scriptFiles.forEach(function (obj) {
          template.getLogicManager().addLogicFile(obj.contents, obj.name);
        });
      } // check the integrity of the model and logic of the template


      template.validate();
      return template; // Returns template
    })();
  }
  /**
   * Create a template from an URL.
   * @param {*} Template - the type to construct
   * @param {String} url  - the URL to a Cicero Template Archive (cta) file
   * @param {object} options - additional options
   * @return {Promise} a Promise to the template
   */


  static fromUrl(Template, url, options) {
    return _asyncToGenerator(function* () {
      const loader = new DefaultArchiveLoader();
      const buffer = yield loader.load(url, options);
      return TemplateLoader.fromArchive(Template, buffer, options);
    })();
  }
  /**
   * Builds a Template from the contents of a directory.
   * The directory must include a package.json in the root (used to specify
   * the name, version and description of the template).
   *
   * @param {*} Template - the type to construct
   * @param {String} path to a local directory
   * @param {Object} [options] - an optional set of options to configure the instance.
   * @return {Promise<Template>} a Promise to the instantiated template
   */


  static fromDirectory(Template, path, options) {
    return _asyncToGenerator(function* () {
      if (!options) {
        options = {};
      }

      const method = 'fromDirectory'; // grab the README.md

      const readmeContents = yield TemplateLoader.loadFileContents(path, 'README.md'); // grab the request.json

      const requestJsonObject = yield TemplateLoader.loadFileContents(path, 'request.json', true); // grab the package.json

      const packageJsonObject = yield TemplateLoader.loadFileContents(path, 'package.json', true, true); // grab the sample files

      Logger.debug(method, 'Looking for sample files');
      const sampleFiles = yield TemplateLoader.loadFilesContents(path, SAMPLE_FILE_REGEXP);
      const sampleTextFiles = {};
      sampleFiles.forEach(file => {
        const matches = file.name.match(SAMPLE_FILE_REGEXP);
        let locale = 'default'; // Match found

        if (matches !== null && matches[2]) {
          locale = matches[2];
        }

        Logger.debug(method, 'Using sample file locale', locale);
        sampleTextFiles[locale] = file.contents;
      }); // create the template

      const template = new (Function.prototype.bind.call(Template, null, packageJsonObject, readmeContents, sampleTextFiles, requestJsonObject, options))();
      const modelFiles = [];
      const modelFileNames = [];
      const ctoFiles = yield TemplateLoader.loadFilesContents(path, /model[/\\].*\.cto$/);
      ctoFiles.forEach(file => {
        modelFileNames.push(slash(file.name));
        modelFiles.push(file.contents);
      });
      template.getModelManager().addModelFiles(modelFiles, modelFileNames, true);

      if (!options.skipUpdateExternalModels) {
        yield template.getModelManager().updateExternalModels();
        Logger.debug(method, 'Added model files', modelFiles.length);
        const externalModelFiles = template.getModelManager().getModels();
        externalModelFiles.forEach(function (file) {
          fs.writeFileSync(path + '/model/' + file.name, file.content);
        });
      } // load and add the template


      let templatizedGrammar = yield TemplateLoader.loadFileContents(path, 'text/grammar.tem.md', false, false);

      if (!templatizedGrammar) {
        throw new Error('A template must either contain a grammar.tem.md file.');
      } else {
        template.parserManager.buildGrammar(templatizedGrammar);
        Logger.debug(method, 'Loaded grammar.tem.md', templatizedGrammar);
      }

      Logger.debug(method, 'Loaded grammar.tem.md'); // load and add the ergo files

      if (template.getMetadata().getRuntime() === 'ergo') {
        // If Ergo then also register the template
        template.getLogicManager().addTemplateFile(templatizedGrammar, 'text/grammar.tem.md');
        const ergoFiles = yield TemplateLoader.loadFilesContents(path, /logic[/\\].*\.ergo$/);
        ergoFiles.forEach(file => {
          const resolvedPath = slash(fsPath.resolve(path));
          const resolvedFilePath = slash(fsPath.resolve(file.name));
          const truncatedPath = resolvedFilePath.replace(resolvedPath + '/', '');
          template.getLogicManager().addLogicFile(file.contents, truncatedPath);
        });
      } else {
        // load and add compiled JS files - we assume all runtimes are JS based (review!)
        const jsFiles = yield TemplateLoader.loadFilesContents(path, /logic[/\\].*\.js$/);
        jsFiles.forEach(file => {
          const resolvedPath = slash(fsPath.resolve(path));
          const resolvedFilePath = slash(fsPath.resolve(file.name));
          const truncatedPath = resolvedFilePath.replace(resolvedPath + '/', '');
          template.getLogicManager().addLogicFile(file.contents, truncatedPath);
        });
      } // check the template


      template.validate();
      return template;
    })();
  }
  /**
   * Prepare the text for parsing (normalizes new lines, etc)
   * @param {string} input - the text for the clause
   * @return {string} - the normalized text for the clause
   */


  static normalizeText(input) {
    // we replace all \r and \n with \n
    let text = input.replace(/\r/gm, '');
    return text;
  }

}

module.exports = TemplateLoader;