10724279977

Committed 05 Sep 2024 04:21PM UTC coverage: 69.517% (-0.02%) from 69.536%

Build # 10724279977

Build Type

push

github

Committed by

metelkin

Commit Message

use builder to store export

Run Details

1814 of 2726 branches covered (66.54%)

Branch coverage included in aggregate %.

29 of 37 new or added lines in 15 files covered. (78.38%)

1 existing line in 1 file now uncovered.

3007 of 4209 relevant lines covered (71.44%)

75.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.21

/src/builder/index.js

const path = require('path');
const fs = require('fs-extra');
const declarationSchema = require('./declaration-schema');
const Ajv = require('ajv');
const ajv = new Ajv({ useDefaults: true }); //.addSchema(declarationSchema);
const Container = require('../container');
const HetaLevelError = require('../heta-level-error');
const ModuleSystem = require('../module-system');
const { StdoutTransport } = require('../logger');

/**
 * Auxiliary class for performing compilation and storing a platform's options. 
 * The main purpose is a support of Heta compiler's CLI mode.
 *
 * The main method of the class is {@link Builder#run} which  
 * runs a sequence of compilation steps.
 * 
 * @class Builder
 *
 * @param {Object} declaration - Object representing options for builder,
 *  see [CLI references]{@link https://hetalang.github.io/#/heta-compiler/cli-references}
 *  for more information about the structure.
 * @param {string} coreDirname="." - Path of working directory of a Heta platform. Default: working directory of a shell.
 *
 * @property {Container} container This is the reference to the main platform storage. 
 * @property {Logger} logger Reference to logger object of platform. This object can also be called with `this.container.logger`
 * @property {string} _coreDirname Absolute path of the core directory. Calculated from `coreDirname` parameter.
 * @property {string} _distDirname Absolute path of the directory for exporting files.
 *    Calculated from `declaration.options.distDir` property.
 * @property {string} _metaDirname Absolute path of the directory for storing meta files.
 *    Calculated from `declaration.options.metaDir`.
 * @property {string} _logPath Absolute path of log file.
 *    Calculated from `declaration.options.logPath`.
 * @property ... Other properties inherit from `declaration` object, see 
 *   [CLI references]{@link https://hetalang.github.io/#/heta-compiler/cli-references?id=declaration-file-format}
 * @property {object} _exportClasses map-like structure for storing all available constructors describing `_Export`s.
 * @property {object[]} export Storage for `_Export` instances.
 */
class Builder {
  constructor(declaration, coreDirname = '.'){
    // create container
    this.container = new Container();
    this.container._builder = this; // back reference to parent builder
    this.export = []; // storing Export objects
    this.exportClasses = {}; // storing Export classes bound to builder (XXX: maybe it must be static)

    // set transport and logger
    this.logger = this.container.logger;
    let minLogLevel = declaration?.options?.logLevel || 'info';
    this.logger.addTransport(new StdoutTransport(minLogLevel));

    // check based on schema 
    // XXX: move to heta-build.js ?
    let validate = ajv.compile(declarationSchema);
    let valid = validate(declaration);
    if (!valid) {
      // convert validation errors to heta errors
      validate.errors.forEach((x) => {
        this.logger.error(`${x.dataPath} ${x.message}`, {type: 'BuilderError'});
      });
      throw new HetaLevelError('Wrong structure of platform file.');
    }

    // file paths
    Object.assign(this, declaration);
    this._coreDirname = path.resolve(coreDirname);
    this._distDirname = path.resolve(coreDirname, declaration.options.distDir);
    this._metaDirname = path.resolve(coreDirname, declaration.options.metaDir);
    this._logPath = path.resolve(coreDirname, declaration.options.logPath);

    this.logger.info(`Builder initialized in directory "${this._coreDirname}".`);
    if (this.id) this.logger.info(`Platform id: "${this.id}"`);
    
    // create "export" classes bound to this container
    Builder._exportClasses && Object.entries(Builder._exportClasses).forEach(([key, _Class]) => {
      this.exportClasses[key] = class extends _Class {};
      this.exportClasses[key].prototype._builder = this;
    });
    
    this.exportArray = [];
    // create "export" instances
    declaration.export && declaration.export.forEach((exportItem) => {
      let ExportClass = this.exportClasses.hasOwnProperty(exportItem.format) 
        && this.exportClasses[exportItem.format];
      if (ExportClass) {
        this.exportArray.push(new ExportClass(exportItem));
      } else {
        this.logger.error(`Export format "${exportItem.format}" is not supported.`, {type: 'BuilderError'});
      }
    });
  }

  static _exportClasses = {}; // storing abstract Export classes

  /**
   * The method runs building of a platform declared with `Builder` object.
   * If the execution throws an error platform building will stop.
   * 
   * The sequence of operations is following:
   * 
   * 1. Read and parse platform modules (files).
   * 2. Modules integration. Creation meta files if required.
   * 3. Loading integrated structures into `Platform`.
   * 4. Setting cross-references in platform's elements.
   * 5. Checking circular references in mathematical expressions.
   * 6. Checking circular unitDef references. Checking circular functionDef rferences.
   * 7. Checking left and right side units compatibility for mathematical expressions.
   * 8. Checking unit\'s terms.
   * 9. Export of a platform to series of formats. 
   *    Depending on the declaration file it runs {@link Builder#exportMany} or {@link Builder#exportJuliaOnly}.
   * 10. Saving logs if required
   * 
   * @method Builder#run
   * 
   */
  run(){
    this.logger.info(`Compilation of module "${this.importModule.source}" of type "${this.importModule.type}"...`);
    
    // 1. Parsing
    let fileHandler = (filename) => fs.readFileSync(filename);
    let ms = new ModuleSystem(this.container.logger, fileHandler);
    let absFilename = path.join(this._coreDirname, this.importModule.source);
    ms.addModuleDeep(absFilename, this.importModule.type, this.importModule);

    // 2. Modules integration
    if (this.options.debug) {
      Object.getOwnPropertyNames(ms.moduleCollection).forEach((name) => {
        let relPath = path.relative(this._coreDirname, name + '.json');
        let absPath = path.join(this._metaDirname, relPath);
        let str = JSON.stringify(ms.moduleCollection[name], null, 2);
        fs.outputFileSync(absPath, str);
        this.logger.info(`Meta file was saved to ${absPath}`);
      });
    }
    let qArr = ms.integrate();

    // 3. Translation
    this.container.loadMany(qArr, false);

    // 4. Binding
    this.logger.info('Setting references in elements, total length ' + this.container.length);
    this.container.knitMany();

    // 5. Circular start_ and ode_
    this.logger.info('Checking for circular references in Records.');
    this.container.checkCircRecord();

    // 6. check circ UnitDef & FunctionDef
    this.container.checkCircUnitDef();
    this.container.checkCircFunctionDef();

    // === STOP if errors ===
    if (!this.logger.hasErrors) {

      // 7. Units checking
      if (this.options.unitsCheck) {
        this.logger.info('Checking unit\'s consistency.');
        this.container.checkUnits();
      } else {
        this.logger.warn('Units checking skipped. To turn it on set "unitsCheck: true" in declaration.');
      }

      // 8. Terms checking
      this.logger.info('Checking unit\'s terms.');
      this.container.checkTerms();

      // 9. Exports
      if (this.options.skipExport) {
        this.logger.warn('Exporting skipped as stated in declaration.');
      } else if (this.options.juliaOnly) {
        this.logger.warn('"Julia only" mode');
        this.exportJuliaOnly();
      } else {
        this.exportMany();
      }
    } else {
      this.logger.warn('Units checking and export were skipped because of errors in compilation.');
    }

    // 10. save logs if required
    let hetaErrors = this.container.hetaErrors();
    let createLog = this.options.logMode === 'always' 
      || (this.options.logMode === 'error' && hetaErrors.length > 0);
    if (createLog) {
      switch (this.options.logFormat) {
      case 'json':
        var logs = JSON.stringify(this.container.defaultLogs, null, 2);
        break;
      default: 
        logs = this.container.defaultLogs
          .map(x => `[${x.level}]\t${x.msg}`)
          .join('\n');  
      }

      fs.outputFileSync(this._logPath, logs);
      this.logger.info(`All logs was saved to file: "${this._logPath}"`);
    }
    return;
  }

  /**
   * Run exporting of files based on components of `this.container.exportArray`.
   * 
   * @method Builder#exportMany
   */
  exportMany() {
    this.logger.info(`Start exporting to files, total: ${this.exportArray.length}.`);

    this.exportArray.forEach((exportItem) => _makeAndSave(exportItem, this._distDirname));
  }

  /**
   * Run exporting of files for Julia only.
   * It was created to support HetaSimulator.jl package.
   * 
   * @method Builder#exportJuliaOnly
   */
  exportJuliaOnly(){
    // create export without putting it to exportArray
    let Julia = this.exportClasses['Julia'];
    let exportItem = new Julia({
      format: 'Julia',
      filepath: '_julia'
    });

    _makeAndSave(exportItem, this._distDirname);
  }
}

function _makeAndSave(exportItem, pathPrefix) {
  let { logger } = exportItem._builder;
  let absPath = path.resolve(pathPrefix, exportItem.filepath);
  let msg = `Exporting to "${absPath}" of format "${exportItem.format}"...`;
  logger.info(msg);

  exportItem.make().forEach((out) => {
    let filePath = [absPath, out.pathSuffix].join('');
    try {
      fs.outputFileSync(filePath, out.content);
    } catch (err) {
      let msg =`Heta compiler cannot export to file: "${err.path}": ${err.message}`;
      logger.error(msg, {type: 'ExportError'});
    }
  });
}

module.exports = {
  Builder
};

1	const path = require('path');	1✔
2	const fs = require('fs-extra');	1✔
3	const declarationSchema = require('./declaration-schema');	1✔
4	const Ajv = require('ajv');	1✔
5	const ajv = new Ajv({ useDefaults: true }); //.addSchema(declarationSchema);	1✔
6	const Container = require('../container');	1✔
7	const HetaLevelError = require('../heta-level-error');	1✔
8	const ModuleSystem = require('../module-system');	1✔
9	const { StdoutTransport } = require('../logger');	1✔
10
11	/**
12	* Auxiliary class for performing compilation and storing a platform's options.
13	* The main purpose is a support of Heta compiler's CLI mode.
14	*
15	* The main method of the class is {@link Builder#run} which
16	* runs a sequence of compilation steps.
17	*
18	* @class Builder
19	*
20	* @param {Object} declaration - Object representing options for builder,
21	* see [CLI references]{@link https://hetalang.github.io/#/heta-compiler/cli-references}
22	* for more information about the structure.
23	* @param {string} coreDirname="." - Path of working directory of a Heta platform. Default: working directory of a shell.
24	*
25	* @property {Container} container This is the reference to the main platform storage.
26	* @property {Logger} logger Reference to logger object of platform. This object can also be called with `this.container.logger`
27	* @property {string} _coreDirname Absolute path of the core directory. Calculated from `coreDirname` parameter.
28	* @property {string} _distDirname Absolute path of the directory for exporting files.
29	* Calculated from `declaration.options.distDir` property.
30	* @property {string} _metaDirname Absolute path of the directory for storing meta files.
31	* Calculated from `declaration.options.metaDir`.
32	* @property {string} _logPath Absolute path of log file.
33	* Calculated from `declaration.options.logPath`.
34	* @property ... Other properties inherit from `declaration` object, see
35	* [CLI references]{@link https://hetalang.github.io/#/heta-compiler/cli-references?id=declaration-file-format}
36	* @property {object} _exportClasses map-like structure for storing all available constructors describing `_Export`s.
37	* @property {object[]} export Storage for `_Export` instances.
38	*/
39	class Builder {
40	constructor(declaration, coreDirname = '.'){	4✔
41	// create container
42	this.container = new Container();	12✔
43	this.container._builder = this; // back reference to parent builder	12✔
44	this.export = []; // storing Export objects	12✔
45	this.exportClasses = {}; // storing Export classes bound to builder (XXX: maybe it must be static)	12✔
46
47	// set transport and logger
48	this.logger = this.container.logger;	12✔
49	let minLogLevel = declaration?.options?.logLevel \|\| 'info';	12✔
50	this.logger.addTransport(new StdoutTransport(minLogLevel));	12✔
51
52	// check based on schema
53	// XXX: move to heta-build.js ?
54	let validate = ajv.compile(declarationSchema);	12✔
55	let valid = validate(declaration);	12✔
56	if (!valid) {	12✔
57	// convert validation errors to heta errors
58	validate.errors.forEach((x) => {	3✔
59	this.logger.error(`${x.dataPath} ${x.message}`, {type: 'BuilderError'});	3✔
60	});
61	throw new HetaLevelError('Wrong structure of platform file.');	3✔
62	}
63
64	// file paths
65	Object.assign(this, declaration);	9✔
66	this._coreDirname = path.resolve(coreDirname);	9✔
67	this._distDirname = path.resolve(coreDirname, declaration.options.distDir);	9✔
68	this._metaDirname = path.resolve(coreDirname, declaration.options.metaDir);	9✔
69	this._logPath = path.resolve(coreDirname, declaration.options.logPath);	9✔
70
71	this.logger.info(`Builder initialized in directory "${this._coreDirname}".`);	9✔
72	if (this.id) this.logger.info(`Platform id: "${this.id}"`);	9✔
73
74	// create "export" classes bound to this container
75	Builder._exportClasses && Object.entries(Builder._exportClasses).forEach(([key, _Class]) => {	9✔
76	this.exportClasses[key] = class extends _Class {};	135✔
77	this.exportClasses[key].prototype._builder = this;	135✔
78	});
79
80	this.exportArray = [];	9✔
81	// create "export" instances
82	declaration.export && declaration.export.forEach((exportItem) => {	9!
83	let ExportClass = this.exportClasses.hasOwnProperty(exportItem.format)	×
84	&& this.exportClasses[exportItem.format];
85	if (ExportClass) {	×
86	this.exportArray.push(new ExportClass(exportItem));	×
87	} else {
88	this.logger.error(`Export format "${exportItem.format}" is not supported.`, {type: 'BuilderError'});	×
89	}
90	});
91	}
92
93	static _exportClasses = {}; // storing abstract Export classes	1✔
94
95	/**
96	* The method runs building of a platform declared with `Builder` object.
97	* If the execution throws an error platform building will stop.
98	*
99	* The sequence of operations is following:
100	*
101	* 1. Read and parse platform modules (files).
102	* 2. Modules integration. Creation meta files if required.
103	* 3. Loading integrated structures into `Platform`.
104	* 4. Setting cross-references in platform's elements.
105	* 5. Checking circular references in mathematical expressions.
106	* 6. Checking circular unitDef references. Checking circular functionDef rferences.
107	* 7. Checking left and right side units compatibility for mathematical expressions.
108	* 8. Checking unit\'s terms.
109	* 9. Export of a platform to series of formats.
110	* Depending on the declaration file it runs {@link Builder#exportMany} or {@link Builder#exportJuliaOnly}.
111	* 10. Saving logs if required
112	*
113	* @method Builder#run
114	*
115	*/
116	run(){
117	this.logger.info(`Compilation of module "${this.importModule.source}" of type "${this.importModule.type}"...`);	8✔
118
119	// 1. Parsing
120	let fileHandler = (filename) => fs.readFileSync(filename);	13✔
121	let ms = new ModuleSystem(this.container.logger, fileHandler);	8✔
122	let absFilename = path.join(this._coreDirname, this.importModule.source);	8✔
123	ms.addModuleDeep(absFilename, this.importModule.type, this.importModule);	8✔
124
125	// 2. Modules integration
126	if (this.options.debug) {	8!
127	Object.getOwnPropertyNames(ms.moduleCollection).forEach((name) => {	×
128	let relPath = path.relative(this._coreDirname, name + '.json');	×
129	let absPath = path.join(this._metaDirname, relPath);	×
130	let str = JSON.stringify(ms.moduleCollection[name], null, 2);	×
131	fs.outputFileSync(absPath, str);	×
132	this.logger.info(`Meta file was saved to ${absPath}`);	×
133	});
134	}
135	let qArr = ms.integrate();	8✔
136
137	// 3. Translation
138	this.container.loadMany(qArr, false);	8✔
139
140	// 4. Binding
141	this.logger.info('Setting references in elements, total length ' + this.container.length);	8✔
142	this.container.knitMany();	8✔
143
144	// 5. Circular start_ and ode_
145	this.logger.info('Checking for circular references in Records.');	8✔
146	this.container.checkCircRecord();	8✔
147
148	// 6. check circ UnitDef & FunctionDef
149	this.container.checkCircUnitDef();	8✔
150	this.container.checkCircFunctionDef();	8✔
151
152	// === STOP if errors ===
153	if (!this.logger.hasErrors) {	8✔
154
155	// 7. Units checking
156	if (this.options.unitsCheck) {	6!
157	this.logger.info('Checking unit\'s consistency.');	×
158	this.container.checkUnits();	×
159	} else {
160	this.logger.warn('Units checking skipped. To turn it on set "unitsCheck: true" in declaration.');	6✔
161	}
162
163	// 8. Terms checking
164	this.logger.info('Checking unit\'s terms.');	6✔
165	this.container.checkTerms();	6✔
166
167	// 9. Exports
168	if (this.options.skipExport) {	6✔
169	this.logger.warn('Exporting skipped as stated in declaration.');	3✔
170	} else if (this.options.juliaOnly) {	3!
171	this.logger.warn('"Julia only" mode');	×
172	this.exportJuliaOnly();	×
173	} else {
174	this.exportMany();	3✔
175	}
176	} else {
177	this.logger.warn('Units checking and export were skipped because of errors in compilation.');	2✔
178	}
179
180	// 10. save logs if required
181	let hetaErrors = this.container.hetaErrors();	8✔
182	let createLog = this.options.logMode === 'always'	8✔
183	\|\| (this.options.logMode === 'error' && hetaErrors.length > 0);
184	if (createLog) {	8✔
185	switch (this.options.logFormat) {	2!
186	case 'json':
187	var logs = JSON.stringify(this.container.defaultLogs, null, 2);	×
188	break;	×
189	default:
190	logs = this.container.defaultLogs	2✔
191	.map(x => `[${x.level}]\t${x.msg}`)	21✔
192	.join('\n');
193	}
194
195	fs.outputFileSync(this._logPath, logs);	2✔
196	this.logger.info(`All logs was saved to file: "${this._logPath}"`);	2✔
197	}
198	return;	8✔
199	}
200
201	/**
202	* Run exporting of files based on components of `this.container.exportArray`.
203	*
204	* @method Builder#exportMany
205	*/
206	exportMany() {
207	this.logger.info(`Start exporting to files, total: ${this.exportArray.length}.`);	3✔
208
209	this.exportArray.forEach((exportItem) => _makeAndSave(exportItem, this._distDirname));	3✔
210	}
211
212	/**
213	* Run exporting of files for Julia only.
214	* It was created to support HetaSimulator.jl package.
215	*
216	* @method Builder#exportJuliaOnly
217	*/
218	exportJuliaOnly(){
219	// create export without putting it to exportArray
220	let Julia = this.exportClasses['Julia'];	×
221	let exportItem = new Julia({	×
222	format: 'Julia',
223	filepath: '_julia'
224	});
225
226	_makeAndSave(exportItem, this._distDirname);	×
227	}
228	}
229
230	function _makeAndSave(exportItem, pathPrefix) {
NEW 231	let { logger } = exportItem._builder;	×
232	let absPath = path.resolve(pathPrefix, exportItem.filepath);	×
233	let msg = `Exporting to "${absPath}" of format "${exportItem.format}"...`;	×
234	logger.info(msg);	×
235
236	exportItem.make().forEach((out) => {	×
237	let filePath = [absPath, out.pathSuffix].join('');	×
238	try {	×
239	fs.outputFileSync(filePath, out.content);	×
240	} catch (err) {
241	let msg =`Heta compiler cannot export to file: "${err.path}": ${err.message}`;	×
242	logger.error(msg, {type: 'ExportError'});	×
243	}
244	});
245	}
246
247	module.exports = {	1✔
248	Builder
249	};

hetalang / heta-compiler / 10724279977

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous