monocart-coverage-reports 2.10.4 → 2.10.5

package/lib/converter/untested.js

@@ -0,0 +1,298 @@
+const fs = require('fs');
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const { pathToFileURL, fileURLToPath } = require('url');
+
+// const EC = require('eight-colors');
+const { minimatch, convertSourceMap } = require('../packages/monocart-coverage-vendor.js');
+
+// ========================================================================================================
+
+const resolveAllDirList = (input) => {
+    const dirs = Util.toList(input, ',');
+    if (!dirs.length) {
+        return;
+    }
+    const dirList = dirs.filter((it) => fs.existsSync(it));
+    if (!dirList.length) {
+        return;
+    }
+    return dirList;
+};
+
+const resolveAllFilter = (input) => {
+    // for function handler
+    if (typeof input === 'function') {
+        return input;
+    }
+
+    // for single minimatch pattern
+    if (input && typeof input === 'string') {
+        // string to multiple patterns "{...}"
+        const obj = Util.strToObj(input);
+        if (obj) {
+            input = obj;
+        } else {
+            return (filePath) => {
+                return minimatch(filePath, input);
+            };
+        }
+    }
+
+    // for patterns
+    if (input && typeof input === 'object') {
+        const patterns = Object.keys(input);
+        return (filePath) => {
+            for (const pattern of patterns) {
+                if (minimatch(filePath, pattern)) {
+                    return input[pattern];
+                }
+            }
+            // false if not matched
+        };
+    }
+
+    // default
+    return () => true;
+};
+
+const resolveAllOptions = (input) => {
+    if (!input) {
+        return;
+    }
+
+    let dir;
+    let filter;
+    let transformer;
+
+    if (typeof input === 'string') {
+        const obj = Util.strToObj(input);
+        if (obj) {
+            dir = obj.dir;
+            filter = obj.filter;
+            transformer = obj.transformer;
+        } else {
+            dir = input;
+        }
+    } else if (Array.isArray(input)) {
+        dir = input;
+    } else {
+        dir = input.dir;
+        filter = input.filter;
+        transformer = input.transformer;
+    }
+
+    const dirList = resolveAllDirList(dir);
+    if (!dirList) {
+        return;
+    }
+
+    const fileFilter = resolveAllFilter(filter);
+    const fileTransformer = typeof transformer === 'function' ? transformer : () => {};
+
+    return {
+        dirList,
+        fileFilter,
+        fileTransformer
+    };
+};
+
+const resolveFileType = (fileType, filePath) => {
+    if (fileType === 'js' || fileType === 'css') {
+        return fileType;
+    }
+    const extname = path.extname(filePath);
+    if (['.css', '.scss', '.sass', '.less'].includes(extname)) {
+        return 'css';
+    }
+    return 'js';
+};
+
+const saveUntestedFileSource = async (entryFile, options) => {
+    const {
+        id,
+        url,
+        source,
+        sourceMap
+    } = entryFile;
+    // console.log('-', entry.sourcePath);
+
+    const { cachePath } = Util.getCacheFileInfo('source', id, options.cacheDir);
+    if (fs.existsSync(cachePath)) {
+        return;
+    }
+
+    // save source and sourceMap to separated json file
+    const sourceData = {
+        id,
+        url,
+        source,
+        sourceMap
+    };
+
+    // remove comments if not debug
+    if (!Util.isDebug()) {
+        sourceData.source = convertSourceMap.removeComments(source);
+    }
+
+    // console.log('save untested file', id, url);
+
+    await Util.saveSourceCacheFile(sourceData, options);
+
+};
+
+const getUntestedCoverageData = async (emptyList, options, coverageType) => {
+
+    // save all empty coverage
+    const dataId = Util.uid();
+    const results = {
+        id: dataId
+    };
+
+    if (coverageType === 'istanbul') {
+        results.type = 'istanbul';
+        results.data = {};
+    } else {
+        results.type = 'v8';
+        results.data = [];
+    }
+
+    const emptyCoverageList = [];
+
+    // save all empty source and sourcemap
+    for (const entryFile of emptyList) {
+
+        // for raw report: source file
+        await saveUntestedFileSource(entryFile, options);
+
+        const { type, url } = entryFile;
+
+        if (coverageType === 'istanbul') {
+
+            // ===============================================
+            const item = {
+                path: fileURLToPath(url),
+                statementMap: {},
+                fnMap: {},
+                branchMap: {},
+                s: {},
+                f: {},
+                b: {}
+            };
+            // object
+            results.data[item.path] = item;
+            emptyCoverageList.push(item);
+
+        } else {
+
+            // ===============================================
+            if (type === 'js') {
+                // empty js
+                entryFile.functions = entryFile.functions || [{
+                    functionName: '',
+                    ranges: [{
+                        startOffset: 0,
+                        endOffset: entryFile.source.length,
+                        count: 0
+                    }]
+                }];
+            } else {
+                // empty css
+                entryFile.ranges = entryFile.ranges || [];
+            }
+
+            const item = {
+                ... entryFile
+            };
+            delete item.source;
+            delete item.sourceMap;
+
+            // array
+            results.data.push(item);
+            // will be parsed to AST and converted to V8 coverage
+            emptyCoverageList.push(entryFile);
+
+        }
+
+    }
+
+    // for raw report: coverage file
+    const { cachePath } = Util.getCacheFileInfo('coverage', dataId, options.cacheDir);
+    await Util.writeFile(cachePath, JSON.stringify(results));
+
+    return emptyCoverageList;
+};
+
+const getEmptyCoverages = async (fileList, options, coverageType, fileTransformer) => {
+
+    const emptyList = [];
+
+    for (const item of fileList) {
+        const {
+            filePath, fileType, sourcePath
+        } = item;
+        const type = resolveFileType(fileType, filePath);
+        const url = pathToFileURL(filePath).toString();
+        const source = Util.readFileSync(filePath);
+        const entryFile = {
+            empty: true,
+            type,
+            url,
+            sourcePath,
+            // for empty, css supports both source and text
+            source
+        };
+
+        await fileTransformer(entryFile, coverageType);
+
+        // after transformer
+        entryFile.id = Util.calculateSha1(entryFile.sourcePath + entryFile.source);
+
+        emptyList.push(entryFile);
+    }
+
+    // save empty coverage for merging raw reports
+    return getUntestedCoverageData(emptyList, options, coverageType);
+};
+
+const getUntestedList = (testedMap, options, coverageType = 'v8') => {
+    const allOptions = resolveAllOptions(options.all);
+    // console.log('allOptions', all, allOptions);
+    if (!allOptions) {
+        return;
+    }
+    const {
+        dirList, fileFilter, fileTransformer
+    } = allOptions;
+    const fileList = [];
+    dirList.forEach((dir) => {
+        Util.forEachFile(dir, [], (fileName, fileDir) => {
+            const filePath = path.resolve(fileDir, fileName);
+            // return file extname for file type
+            const fileType = fileFilter(filePath);
+            if (fileType) {
+                const sourcePath = Util.relativePath(filePath);
+                if (!testedMap.has(sourcePath)) {
+                    fileList.push({
+                        filePath,
+                        fileType,
+                        sourcePath
+                    });
+                }
+            }
+        });
+    });
+    // console.log('fileList', fileList);
+    if (!fileList.length) {
+        return;
+    }
+
+    return getEmptyCoverages(fileList, options, coverageType, fileTransformer);
+
+};
+
+
+module.exports = {
+    getUntestedList
+};

package/lib/default/options.js

@@ -67,7 +67,8 @@ module.exports = {
     // options for adding empty coverage for all files
     // all: {
     //     dir: ['src'],
-    //     filter: (sourcePath) => true
+    //     filter: (sourcePath) => true,
+    //     transformer: (entry) => {}
     // },
     all: null,
 

package/lib/generate.js

@@ -1,9 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { pathToFileURL, fileURLToPath } = require('url');
-
-const EC = require('eight-colors');
-const { minimatch } = require('./packages/monocart-coverage-vendor.js');
+const { fileURLToPath } = require('url');
 
 const Util = require('./utils/util.js');
 const { convertV8List } = require('./converter/converter.js');
@@ -178,7 +175,7 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
         // console.log('after merge', v8list.map((it) => it.url));
 
         const t2 = Date.now();
-        const results = convertV8List(v8list, options);
+        const results = await convertV8List(v8list, options);
         Util.logTime('┌ [generate] converted coverage data', t2);
 
         const {
@@ -189,7 +186,7 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
 
     // istanbul data
     const t3 = Date.now();
-    const istanbulData = mergeIstanbulCoverage(dataList);
+    const istanbulData = await mergeIstanbulCoverage(dataList, options);
     const { coverageData, fileSources } = initIstanbulData(istanbulData, options);
     Util.logTime('┌ [generate] prepared istanbul coverage data', t3);
     const results = await saveIstanbulReports(coverageData, fileSources, options);
@@ -219,187 +216,6 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
     return coverageResults;
 };
 
-// ========================================================================================================
-
-const resolveAllDirList = (input) => {
-    const dirs = Util.toList(input, ',');
-    if (!dirs.length) {
-        return;
-    }
-    const dirList = dirs.filter((it) => fs.existsSync(it));
-    if (!dirList.length) {
-        return;
-    }
-    return dirList;
-};
-
-const resolveAllFilter = (input) => {
-    // for function handler
-    if (typeof input === 'function') {
-        return input;
-    }
-
-    // for single minimatch pattern
-    if (input && typeof input === 'string') {
-        // string to multiple patterns "{...}"
-        const obj = Util.strToObj(input);
-        if (obj) {
-            input = obj;
-        } else {
-            return (filePath) => {
-                return minimatch(filePath, input);
-            };
-        }
-    }
-
-    // for patterns
-    if (input && typeof input === 'object') {
-        const patterns = Object.keys(input);
-        return (filePath) => {
-            for (const pattern of patterns) {
-                if (minimatch(filePath, pattern)) {
-                    return input[pattern];
-                }
-            }
-            // false if not matched
-        };
-    }
-
-    // default
-    return () => true;
-};
-
-const resolveAllDataType = (type, dataList) => {
-    if (!type && dataList.length) {
-        const firstData = dataList[0];
-        type = firstData.type;
-    }
-    const types = {
-        v8: 'v8',
-        istanbul: 'istanbul'
-    };
-    return types[type] || types.v8;
-};
-
-const resolveAllOptions = (input, dataList) => {
-    if (!input) {
-        return;
-    }
-
-    let type;
-    let dir;
-    let filter;
-
-    if (typeof input === 'string') {
-        const obj = Util.strToObj(input);
-        if (obj) {
-            type = obj.type;
-            dir = obj.dir;
-            filter = obj.filter;
-        } else {
-            dir = input;
-        }
-    } else if (Array.isArray(input)) {
-        dir = input;
-    } else {
-        type = input.type;
-        dir = input.dir;
-        filter = input.filter;
-    }
-
-    const dirList = resolveAllDirList(dir);
-    if (!dirList) {
-        return;
-    }
-
-    const dataType = resolveAllDataType(type, dataList);
-    const fileFilter = resolveAllFilter(filter);
-
-    return {
-        dirList,
-        dataType,
-        fileFilter
-    };
-};
-
-const resolveFileType = (fileType, filePath) => {
-    if (fileType === 'js' || fileType === 'css') {
-        return fileType;
-    }
-    const extname = path.extname(filePath);
-    if (['.css', '.scss', '.sass', '.less'].includes(extname)) {
-        return 'css';
-    }
-    return 'js';
-};
-
-const getV8EmptyData = (fileList) => {
-    const v8DataList = [];
-    fileList.forEach((item) => {
-        const { filePath, fileType } = item;
-        const type = resolveFileType(fileType, filePath);
-        const url = pathToFileURL(filePath).toString();
-        const source = Util.readFileSync(filePath);
-        const entryFile = {
-            empty: true,
-            type,
-            url,
-            // for empty, css supports both source and text
-            source
-        };
-        v8DataList.push(entryFile);
-    });
-    return v8DataList;
-};
-
-const getIstanbulEmptyData = (fileList) => {
-    const istanbulData = {};
-    fileList.forEach((item) => {
-        const { filePath } = item;
-        istanbulData[filePath] = {
-            path: filePath,
-            statementMap: {},
-            fnMap: {},
-            branchMap: {},
-            s: {},
-            f: {},
-            b: {}
-        };
-    });
-    return istanbulData;
-};
-
-const getEmptyData = (all, dataList) => {
-    const allOptions = resolveAllOptions(all, dataList);
-    // console.log('allOptions', all, allOptions);
-    if (!allOptions) {
-        return;
-    }
-    const {
-        dirList, dataType, fileFilter
-    } = allOptions;
-    const fileList = [];
-    dirList.forEach((dir) => {
-        Util.forEachFile(dir, [], (fileName, fileDir) => {
-            const filePath = path.resolve(fileDir, fileName);
-            const fileType = fileFilter(filePath);
-            if (fileType) {
-                fileList.push({
-                    filePath,
-                    fileType
-                });
-            }
-        });
-    });
-    // console.log('fileList', fileList);
-    if (!fileList.length) {
-        return;
-    }
-    if (dataType === 'v8') {
-        return getV8EmptyData(fileList);
-    }
-    return getIstanbulEmptyData(fileList);
-};
 
 // ========================================================================================================
 
@@ -448,55 +264,6 @@ const addJsonData = async (mcr, dataList, sourceCache, dir, filename) => {
     }
 };
 
-const addEmptyData = async (mcr, dataList, sourceCache) => {
-
-    const { all, cacheDir } = mcr.options;
-    // add empty coverage for all files
-    // dataList for data type, before `add` we don't which one is tested, because using hash id
-    const emptyData = getEmptyData(all, dataList);
-    if (!emptyData) {
-        return;
-    }
-
-    let files = 0;
-    if (Util.isList(emptyData)) {
-        files = emptyData.length;
-    } else {
-        files = Object.keys(emptyData).length;
-    }
-
-    Util.logDebug(`added all files with empty coverage: ${EC.yellow(files)}`);
-    const coverageResults = await mcr.add(emptyData);
-    // after `add`
-    if (!coverageResults) {
-        return;
-    }
-
-    dataList.push(coverageResults);
-
-    if (coverageResults.type === 'v8') {
-        // sourceCache
-        coverageResults.data.forEach((entry) => {
-            const { id } = entry;
-            if (sourceCache.has(id)) {
-                // console.log('+', entry.sourcePath);
-                return;
-            }
-            // console.log('-', entry.sourcePath);
-            const { cacheName, cachePath } = Util.getCacheFileInfo('source', id, cacheDir);
-            if (mcr.fileCache.has(cacheName)) {
-                const json = mcr.fileCache.get(cacheName);
-                sourceCache.set(json.id, json);
-            } else {
-                const content = Util.readFileSync(cachePath);
-                if (content) {
-                    const json = JSON.parse(content);
-                    sourceCache.set(json.id, json);
-                }
-            }
-        });
-    }
-};
 
 const getInputData = async (mcr) => {
 
@@ -520,8 +287,6 @@ const getInputData = async (mcr) => {
         }
     }
 
-    await addEmptyData(mcr, dataList, sourceCache);
-
     if (!dataList.length) {
         const dirs = inputList.map((dir) => Util.relativePath(dir));
         Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);

package/lib/index.d.ts

@@ -359,8 +359,7 @@ declare namespace MCR {
         all?: string | string[] | {
             /** the dir(s) of all files */
             dir: string | string[];
-            /** the coverage data type, v8 or istanbul */
-            type?: "v8" | "istanbul";
+
             /** 
              * the file filter, return the file type, if true, defaults to css if ".css" otherwise is js 
              * 
@@ -369,6 +368,14 @@ declare namespace MCR {
             filter?: string | {
                 [pattern: string]: "js" | "css" | boolean;
             } | ((filePath: string) => "js" | "css" | boolean);
+
+            /**
+             * the file transformer for source and sourceMap
+             * some of untested files like .ts/.jsx/.vue can not be parsed to AST directly by acorn
+             * so this is the function which can transform the original source to generated source and sourceMap
+             */
+            transformer?: (entry: any) => Promise<void>;
+
         };
 
         /** (V8 only) {boolean} Enable/Disable ignoring uncovered codes with the special comments: v8 ignore next/next N/start/stop */

package/lib/istanbul/istanbul.js

@@ -8,6 +8,7 @@ const Util = require('../utils/util.js');
 const IstanbulSummary = require('./istanbul-summary.js');
 
 const { initIstanbulSourcePath } = require('../utils/source-path.js');
+const { getUntestedList } = require('../converter/untested.js');
 
 const findHtmlPath = (outputDir) => {
     const defaultHtml = path.resolve(outputDir, 'index.html');
@@ -121,18 +122,42 @@ const saveIstanbulReports = (coverageData, fileSources, options) => {
     return coverageResults;
 };
 
-const mergeIstanbulCoverage = (dataList) => {
+const addUntestedFiles = async (istanbulData, options) => {
+    const testedMap = new Map();
+    Object.keys(istanbulData).forEach((filePath) => {
+        const sourcePath = Util.relativePath(filePath);
+        testedMap.set(sourcePath, true);
+    });
+
+    // untested files
+    const untestedList = await getUntestedList(testedMap, options, 'istanbul');
+    if (!untestedList) {
+        return;
+    }
+
+    // console.log('istanbul untestedList', untestedList);
+    untestedList.forEach((item) => {
+        if (!istanbulData[item.path]) {
+            istanbulData[item.path] = item;
+        }
+    });
+
+};
+
+const mergeIstanbulCoverage = async (dataList, options) => {
     const istanbulCoverageList = dataList.map((it) => it.data);
     const coverageMap = istanbulLibCoverage.createCoverageMap();
     istanbulCoverageList.forEach((coverage) => {
         coverageMap.merge(coverage);
     });
     const istanbulData = coverageMap.toJSON();
+
+    await addUntestedFiles(istanbulData, options);
+
     return istanbulData;
 };
 
 const initIstanbulData = (istanbulData, options) => {
-
     const fileSources = options.fileSources || {};
     const coverageData = initIstanbulSourcePath(istanbulData, fileSources, options);