6802050857

Committed 08 Nov 2023 05:46PM UTC coverage: 69.943% (-0.2%) from 70.111%

Build # 6802050857

Build Type

push

github

Committed by Evgeny Metelkin

Commit Message

remove _.omit where possible

Run Details

1724 of 2578 branches covered (0.0%)

Branch coverage included in aggregate %.

6 of 36 new or added lines in 5 files covered. (16.67%)

1 existing line in 1 file now uncovered.

2830 of 3933 relevant lines covered (71.96%)

55.82 hits per line

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

66.3

/src/table-export/index.js

const { AbstractExport } = require('../core/abstract-export');
const _ = require('lodash');
const _omit = require('lodash/omit');
const { ajv, uniqBy } = require('../utils');
const XLSX = require('xlsx');

// how to order columns in sheets
const propSequence = [
  'on', 'action', 'class', 'space', 'id', 
  'num', 'assignments.start_', 'assignments.ode_', 'units', 'boundary',
  'compartment', 'isAmount', 'actors', 'modifiers[]',
  'title', 'notes', 'tags[]'
];
// how to order sheets in file
const sheetSequence = [
  'Compartment', 'Species', 'Reaction', 'Record', 'Const',
  'Identification', 'UnitDef'
];

const schema = {
  type: 'object',
  properties: {
    omitRows: {type: 'number'},
    omit: {type: 'array', items: { type: 'string' }},
    splitByClass: {type: 'boolean'},
    bookType: {
      type: 'string',
      enum: ['xlsx', 'xlsm', 'xlsb', 'biff8', 'biff5', 'biff4', 
        'biff3', 'biff2', 'xlml', 'ods', 'fods', 
        'wk3', 'csv', 'txt', 'sylk', 'html', 
        'dif', 'dbf', 'wk1', 'rtf', 'prn', 
        'eth']
    }
  }
};

const bookTypes = {
  xlsx: {fileExt: '.xlsx', containerSheets: 'ZIP', description: 'multiExcel 2007+ XML Format'},
  xlsm: {fileExt: '.xlsm', containerSheets: 'ZIP', description: 'multiExcel 2007+ Macro XML Format'},
  xlsb: {fileExt: '.xlsb', containerSheets: 'ZIP', description: 'multiExcel 2007+ Binary Format'},
  biff8: {fileExt: '.xls', containerSheets: 'CFB', description: 'multiExcel 97-2004 Workbook Format'},
  biff5: {fileExt: '.xls', containerSheets: 'CFB', description: 'multiExcel 5.0/95 Workbook Format'},
  biff4: {fileExt: '.xls', containerSheets: 'none', description: 'singleExcel 4.0 Worksheet Format'},
  biff3: {fileExt: '.xls', containerSheets: 'none', description: 'singleExcel 3.0 Worksheet Format'},
  biff2: {fileExt: '.xls', containerSheets: 'none', description: 'singleExcel 2.0 Worksheet Format'},
  xlml: {fileExt: '.xls', containerSheets: 'none', description: 'multiExcel 2003-2004 (SpreadsheetML)'},
  ods: {fileExt: '.ods', containerSheets: 'ZIP', description: 'multiOpenDocument Spreadsheet'},
  fods: {fileExt: '.fods', containerSheets: 'none', description: 'multiFlat OpenDocument Spreadsheet'},
  wk3: {fileExt: '.wk3', containerSheets: 'none', description: 'singleLotus Workbook (WK3)'},
  csv: {fileExt: '.csv', containerSheets: 'none', description: 'singleComma Separated Values'},
  txt: {fileExt: '.txt', containerSheets: 'none', description: 'singleUTF-16 Unicode Text (TXT)'},
  sylk: {fileExt: '.sylk', containerSheets: 'none', description: 'singleSymbolic Link (SYLK)'},
  html: {fileExt: '.html', containerSheets: 'none', description: 'singleHTML Document'},
  dif: {fileExt: '.dif', containerSheets: 'none', description: 'singleData Interchange Format (DIF)'},
  dbf: {fileExt: '.dbf', containerSheets: 'none', description: 'singledBASE II + VFP Extensions (DBF)'},
  wk1: {fileExt: '.wk1', containerSheets: 'none', description: 'singleLotus Worksheet (WK1)'},
  rtf: {fileExt: '.rtf', containerSheets: 'none', description: 'singleRich Text Format (RTF)'},
  prn: {fileExt: '.prn', containerSheets: 'none', description: 'singleLotus Formatted Text'},
  eth: {fileExt: '.eth', containerSheets: 'none', description: 'singleEthercalc Record Format (ETH)'}
};

class TableExport extends AbstractExport {
  constructor(q = {}, isCore = false){
    super(q, isCore);

    // check arguments here
    let logger = this._container.logger;
    let valid = TableExport.isValid(q, logger);
    if (!valid) { this.errored = true; return; }

    if (q.omitRows!==undefined) this.omitRows = q.omitRows;
    if (q.spaceFilter) this.spaceFilter = q.spaceFilter;
    this.bookType = q.bookType ? q.bookType : 'csv';

    if (q.omit) this.omit = q.omit;
  }
  get className(){
    return 'TableExport';
  }
  get format(){
    return 'Table';
  }
  makeSheet(){
    // filtered namespaces
    let nsArray = [...this._container.namespaceStorage]
      .map((pair) => pair[1]);
    let nsArrayFiltered = typeof this.spaceFilter === 'undefined'
      ? nsArray
      : nsArray.filter((ns) => this.spaceFilter.indexOf(ns.spaceName) !== -1);
    
    // create array of flat
    let fArr_ns = nsArrayFiltered.reduce((accumulator, ns) => {
      let fArr_setns = ns.spaceName === 'nameless' ? [] : [ns.toFlat()];
      let fArr_components = ns.toArray().filter((x) => !x.isCore).map((x) => x.toFlat());
      return accumulator.concat(fArr_setns, fArr_components);
    }, []);
    let fArr_unitDef = [...this._container.unitDefStorage]
      .filter((x) => !x[1].isCore)
      .map((x) => x[1].toFlat());
    let fArr_functionDef = [...this._container.functionDefStorage]
      .filter((x) => !x[1].isCore)
      .map((x) => x[1].toFlat());
    let fArr_scenario = [...this._container.scenarioStorage]
      .filter((x) => !x[1].isCore)
      .map((x) => x[1].toFlat());
    let fArr_full = [].concat(fArr_ns, fArr_unitDef, fArr_functionDef, fArr_scenario).map((x) => {
      x.on = 1;
      return _.mapValues(x, (value) => typeof value === 'boolean' ? value.toString() : value);
    });

    if (this.omit) {
      var fArr = fArr_full.map((q) => {
        return _omit(q, this.omit);
      });
    } else {
      fArr = fArr_full;
    }

    // split qArr to several sheets
    if (this.splitByClass) {
      let splitted = _.chain(fArr)
        .groupBy((q) => q.class)
        .mapValues((value, prop) => {
          let keys = _.chain(value) // store unique keys
            .map((x) => Object.keys(x))
            .flatten()
            .value();
          let sequence_i = _.intersection(propSequence, uniqBy(keys));

          return {
            content:  value,
            pathSuffix: '',
            type: 'sheet',
            name: prop,
            headerSeq: sequence_i
          };
        })
        .toPairs()
        .sortBy((x) => { // sort in pre-defined order
          let order = sheetSequence.indexOf(x[0]);
          return order !== -1 ? order : 999;
        })
        .map(1)
        .value();
      return splitted;
    } else {
      let keys = _.chain(fArr) // store unique keys
        .map((x) => Object.keys(x))
        .flatten()
        .value();
      let sequence_out = _.intersection(propSequence, uniqBy(keys));

      return [{
        content: fArr,
        pathSuffix: '',
        type: 'sheet',
        name: this.space,
        headerSeq: sequence_out
      }];
    }
  }

  make(){  
    let out = this.makeSheet();
    
    let wb = XLSX.utils.book_new();
    out.forEach((x) => {
      let omitRows = x.omitRows!==undefined
        ? x.omitRows // use omitRows from out
        : this.omitRows;
      let ws = XLSX.utils.json_to_sheet(
        _.times(omitRows, {}).concat(x.content),
        { header: x.headerSeq, skipHeader: x.skipHeader } // XLSX tries to mutate header
      );
      XLSX.utils.book_append_sheet(wb, ws, x.name);
    });
  
    return [{
      content: XLSX.write(wb, { type: 'buffer', bookType: this.bookType}),
      type: 'buffer',
      pathSuffix: bookTypes[this.bookType].fileExt
    }];
  }

  static get validate(){
    return ajv.compile(schema);
  }
}

module.exports = TableExport;

1	const { AbstractExport } = require('../core/abstract-export');	1✔
2	const _ = require('lodash');	1✔
3	const _omit = require('lodash/omit');	1✔
4	const { ajv, uniqBy } = require('../utils');	1✔
5	const XLSX = require('xlsx');	1✔
6
7	// how to order columns in sheets
8	const propSequence = [	1✔
9	'on', 'action', 'class', 'space', 'id',
10	'num', 'assignments.start_', 'assignments.ode_', 'units', 'boundary',
11	'compartment', 'isAmount', 'actors', 'modifiers[]',
12	'title', 'notes', 'tags[]'
13	];
14	// how to order sheets in file
15	const sheetSequence = [	1✔
16	'Compartment', 'Species', 'Reaction', 'Record', 'Const',
17	'Identification', 'UnitDef'
18	];
19
20	const schema = {	1✔
21	type: 'object',
22	properties: {
23	omitRows: {type: 'number'},
24	omit: {type: 'array', items: { type: 'string' }},
25	splitByClass: {type: 'boolean'},
26	bookType: {
27	type: 'string',
28	enum: ['xlsx', 'xlsm', 'xlsb', 'biff8', 'biff5', 'biff4',
29	'biff3', 'biff2', 'xlml', 'ods', 'fods',
30	'wk3', 'csv', 'txt', 'sylk', 'html',
31	'dif', 'dbf', 'wk1', 'rtf', 'prn',
32	'eth']
33	}
34	}
35	};
36
37	const bookTypes = {	1✔
38	xlsx: {fileExt: '.xlsx', containerSheets: 'ZIP', description: 'multiExcel 2007+ XML Format'},
39	xlsm: {fileExt: '.xlsm', containerSheets: 'ZIP', description: 'multiExcel 2007+ Macro XML Format'},
40	xlsb: {fileExt: '.xlsb', containerSheets: 'ZIP', description: 'multiExcel 2007+ Binary Format'},
41	biff8: {fileExt: '.xls', containerSheets: 'CFB', description: 'multiExcel 97-2004 Workbook Format'},
42	biff5: {fileExt: '.xls', containerSheets: 'CFB', description: 'multiExcel 5.0/95 Workbook Format'},
43	biff4: {fileExt: '.xls', containerSheets: 'none', description: 'singleExcel 4.0 Worksheet Format'},
44	biff3: {fileExt: '.xls', containerSheets: 'none', description: 'singleExcel 3.0 Worksheet Format'},
45	biff2: {fileExt: '.xls', containerSheets: 'none', description: 'singleExcel 2.0 Worksheet Format'},
46	xlml: {fileExt: '.xls', containerSheets: 'none', description: 'multiExcel 2003-2004 (SpreadsheetML)'},
47	ods: {fileExt: '.ods', containerSheets: 'ZIP', description: 'multiOpenDocument Spreadsheet'},
48	fods: {fileExt: '.fods', containerSheets: 'none', description: 'multiFlat OpenDocument Spreadsheet'},
49	wk3: {fileExt: '.wk3', containerSheets: 'none', description: 'singleLotus Workbook (WK3)'},
50	csv: {fileExt: '.csv', containerSheets: 'none', description: 'singleComma Separated Values'},
51	txt: {fileExt: '.txt', containerSheets: 'none', description: 'singleUTF-16 Unicode Text (TXT)'},
52	sylk: {fileExt: '.sylk', containerSheets: 'none', description: 'singleSymbolic Link (SYLK)'},
53	html: {fileExt: '.html', containerSheets: 'none', description: 'singleHTML Document'},
54	dif: {fileExt: '.dif', containerSheets: 'none', description: 'singleData Interchange Format (DIF)'},
55	dbf: {fileExt: '.dbf', containerSheets: 'none', description: 'singledBASE II + VFP Extensions (DBF)'},
56	wk1: {fileExt: '.wk1', containerSheets: 'none', description: 'singleLotus Worksheet (WK1)'},
57	rtf: {fileExt: '.rtf', containerSheets: 'none', description: 'singleRich Text Format (RTF)'},
58	prn: {fileExt: '.prn', containerSheets: 'none', description: 'singleLotus Formatted Text'},
59	eth: {fileExt: '.eth', containerSheets: 'none', description: 'singleEthercalc Record Format (ETH)'}
60	};
61
62	class TableExport extends AbstractExport {
63	constructor(q = {}, isCore = false){	×
64	super(q, isCore);	2✔
65
66	// check arguments here
67	let logger = this._container.logger;	2✔
68	let valid = TableExport.isValid(q, logger);	2✔
69	if (!valid) { this.errored = true; return; }	2!
70
71	if (q.omitRows!==undefined) this.omitRows = q.omitRows;	2!
72	if (q.spaceFilter) this.spaceFilter = q.spaceFilter;	2!
73	this.bookType = q.bookType ? q.bookType : 'csv';	2✔
74
75	if (q.omit) this.omit = q.omit;	2!
76	}
77	get className(){
78	return 'TableExport';	×
79	}
80	get format(){
81	return 'Table';	×
82	}
83	makeSheet(){
84	// filtered namespaces
85	let nsArray = [...this._container.namespaceStorage]	1✔
86	.map((pair) => pair[1]);	2✔
87	let nsArrayFiltered = typeof this.spaceFilter === 'undefined'	1!
88	? nsArray
89	: nsArray.filter((ns) => this.spaceFilter.indexOf(ns.spaceName) !== -1);	2✔
90
91	// create array of flat
92	let fArr_ns = nsArrayFiltered.reduce((accumulator, ns) => {	1✔
93	let fArr_setns = ns.spaceName === 'nameless' ? [] : [ns.toFlat()];	1!
94	let fArr_components = ns.toArray().filter((x) => !x.isCore).map((x) => x.toFlat());	7✔
95	return accumulator.concat(fArr_setns, fArr_components);	1✔
96	}, []);
97	let fArr_unitDef = [...this._container.unitDefStorage]	1✔
98	.filter((x) => !x[1].isCore)	84✔
99	.map((x) => x[1].toFlat());	48✔
100	let fArr_functionDef = [...this._container.functionDefStorage]	1✔
101	.filter((x) => !x[1].isCore)	×
102	.map((x) => x[1].toFlat());	×
103	let fArr_scenario = [...this._container.scenarioStorage]	1✔
104	.filter((x) => !x[1].isCore)	×
105	.map((x) => x[1].toFlat());	×
106	let fArr_full = [].concat(fArr_ns, fArr_unitDef, fArr_functionDef, fArr_scenario).map((x) => {	1✔
107	x.on = 1;	56✔
108	return _.mapValues(x, (value) => typeof value === 'boolean' ? value.toString() : value);	248✔
109	});
110
111	if (this.omit) {	1!
112	var fArr = fArr_full.map((q) => {	×
NEW 113	return _omit(q, this.omit);	×
114	});
115	} else {
116	fArr = fArr_full;	1✔
117	}
118
119	// split qArr to several sheets
120	if (this.splitByClass) {	1!
121	let splitted = _.chain(fArr)	1✔
122	.groupBy((q) => q.class)	56✔
123	.mapValues((value, prop) => {
124	let keys = _.chain(value) // store unique keys	5✔
125	.map((x) => Object.keys(x))	56✔
126	.flatten()
127	.value();
128	let sequence_i = _.intersection(propSequence, uniqBy(keys));	5✔
129
130	return {	5✔
131	content: value,
132	pathSuffix: '',
133	type: 'sheet',
134	name: prop,
135	headerSeq: sequence_i
136	};
137	})
138	.toPairs()
139	.sortBy((x) => { // sort in pre-defined order
140	let order = sheetSequence.indexOf(x[0]);	5✔
141	return order !== -1 ? order : 999;	5✔
142	})
143	.map(1)
144	.value();
145	return splitted;	1✔
146	} else {
147	let keys = _.chain(fArr) // store unique keys	×
148	.map((x) => Object.keys(x))	×
149	.flatten()
150	.value();
151	let sequence_out = _.intersection(propSequence, uniqBy(keys));	×
152
153	return [{	×
154	content: fArr,
155	pathSuffix: '',
156	type: 'sheet',
157	name: this.space,
158	headerSeq: sequence_out
159	}];
160	}
161	}
162
163	make(){
164	let out = this.makeSheet();	×
165
166	let wb = XLSX.utils.book_new();	×
167	out.forEach((x) => {	×
168	let omitRows = x.omitRows!==undefined	×
169	? x.omitRows // use omitRows from out
170	: this.omitRows;
171	let ws = XLSX.utils.json_to_sheet(	×
172	_.times(omitRows, {}).concat(x.content),
173	{ header: x.headerSeq, skipHeader: x.skipHeader } // XLSX tries to mutate header
174	);
175	XLSX.utils.book_append_sheet(wb, ws, x.name);	×
176	});
177
178	return [{	×
179	content: XLSX.write(wb, { type: 'buffer', bookType: this.bookType}),
180	type: 'buffer',
181	pathSuffix: bookTypes[this.bookType].fileExt
182	}];
183	}
184
185	static get validate(){
186	return ajv.compile(schema);	2✔
187	}
188	}
189
190	module.exports = TableExport;	1✔

hetalang / heta-compiler / 6802050857

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