Stryker

fileUtils.js - Stryker report

Summary

File
Mutation score
# Killed
# Survived
# Timeout
# No coverage
# Errors
Total detected
Total undetected
Total mutants
fileUtils.js
5%
4/76 3 11 1 61 0 4 72 76

Code

'use strict';
var _ = require('lodash');
var fs = require('fs');
var path = require('path');
var nodeGlob = require('glob');
var mkdirp = require('mkdirp');
/**
 * Checks if a file or folder exists.
 * @function
 * @param path - The path to the file or folder.
 * @returns True if the file exists.
 */
function fileOrFolderExistsSync(path) 0{
    try 1{
        fs.lstatSync(path);
        return true;
    }
    catch (error) 2{
        return false;
    }
}
exports.fileOrFolderExistsSync = fileOrFolderExistsSync;
;
function fileOrFolderExists(path) 3{
    return new Promise(function (resolve) 4{
        fs.lstat(path, function (error, stats) 5{
            resolve(!error);
        });
    });
}
exports.fileOrFolderExists = fileOrFolderExists;
/**
 * Reads a file.
 * @function
 * @param filename - The name of the file.
 * @returns The content of the file.
 */
function readFile(filename) 6{
    return fs.readFileSync(filename, 'utf8');
}
exports.readFile = readFile;
;
/**
   * Normalizes the paths of a list of filenames.
   * @param files - The list of filenames which have to be normalized.
   */
function normalize(files) 7{
    _.forEach(files, function (file, key) 8{
        files[key] = path.resolve(path.normalize(file));
    });
}
exports.normalize = normalize;
;
function glob(expression) 9{
    return new Promise(function (resolve, reject) 10{
        nodeGlob(expression, function (error, matches) 11{
            if (1213error) 14{
                reject(error);
            }
            else 15{
                resolve(matches);
            }
        });
    });
}
exports.glob = glob;
function readdir(path) 16{
    return new Promise(function (resolve, reject) 17{
        fs.readdir(path, function (error, files) 18{
            if (1920error) 21{
                reject(error);
            }
            else 22{
                resolve(files);
            }
        });
    });
}
exports.readdir = readdir;
function stats(path) 23{
    return new Promise(function (resolve, reject) 24{
        fs.stat(path, function (error, stats) 25{
            if (2627error) 28{
                reject(error);
            }
            else 29{
                resolve(stats);
            }
        });
    });
}
function rmFile(path) 30{
    return new Promise(function (fileResolve, fileReject) 31{
        fs.unlink(path, function (error) 32{
            if (3334error) 35{
                fileReject(error);
            }
            else 36{
                fileResolve();
            }
        });
    });
}
function rmdir(dirToDelete) 37{
    return new Promise(function (resolve, reject) 38{
        fs.rmdir(dirToDelete, function (error) 39{
            if (4041error) 42{
                reject(error);
            }
            else 43{
                resolve();
            }
        });
    });
}
/**
 * Deletes a directory recursively
 */
function deleteDir(dirToDelete) 44{
    return fileOrFolderExists(dirToDelete).then(function (exists) 45{
        if (4647exists) 48{
            return readdir(dirToDelete).then(function (files) 49{
                var promisses = files.map(function (file) 50{
                    var currentPath = path.join(dirToDelete, file);
                    return stats(currentPath).then(function (stats) 51{
                        if (5253stats.isDirectory()) 54{
                            // recursive
                            return deleteDir(currentPath);
                        }
                        else 55{
                            // delete file
                            return rmFile(currentPath);
                        }
                    });
                });
                // delete dir
                return Promise.all(promisses).then(function () 56{ return rmdir(dirToDelete); });
            });
        }
    });
}
exports.deleteDir = deleteDir;
function cleanFolder(folderName) 57{
    return fileOrFolderExists(folderName)
        .then(function (exists) 58{
        if (5960exists) 61{
            return deleteDir(folderName)
                .then(function () 62{ return mkdirRecursive(folderName); });
        }
        else 63{
            return mkdirRecursive(folderName);
        }
    });
}
exports.cleanFolder = cleanFolder;
function writeFile(fileName, content) 64{
    return new Promise(function (resolve, reject) 65{
        fs.writeFile(fileName, content, function (err) 66{
            if (6768err) 69{
                reject(err);
            }
            else 70{
                resolve();
            }
        });
    });
}
exports.writeFile = writeFile;
function mkdirRecursive(folderName) 71{
    if (7273!fileOrFolderExistsSync(folderName)) 74{
        mkdirp.sync(folderName);
    }
}
exports.mkdirRecursive = mkdirRecursive;
/**
 * Wrapper around the 'require' function (for testability)
 */
function importModule(moduleName) 75{
    require(moduleName);
}
exports.importModule = importModule;
//# sourceMappingURL=fileUtils.js.map