os-file-handler
v1.4.1
Published
This module contains fundamental files manipulation functions to implement in an npm project.
Downloads
12
Readme
Introduction
This module contains fundamental fileHandler scripts to implement in every npm project, to make life easier instead of just remember everything :)
Installation
Install via npm:
npm i os-file-handlerUsage
Require tools:
/**
* Will recursively create a directory, and all of the directories to it's path, if needed
*/
createDir: function (dirPath) {
fs.mkdirSync(dirPath, {recursive: true});
},
/**
* Will return the path to the parent of a file
*/
getParentDirPath: function (filePath) {
return path.dirname(filePath);
},
/**
* Will check if a file is a directory
*/
isDir: function (filePath) {
return new Promise(async function (resolve, reject) {
fs.lstat(filePath, (err, stats) => {
let dir = stats.isDirectory()
resolve(dir)
});
}.bind())
},
/**
* Will return the inner dirs of a current dir
*/
getDirs: async function (filePath) {
let dirContent = self.getDirContent(filePath)
let dirsList = [];
for (let i = 0; i < dirContent.length; i++) {
let pathh = self.joinPath(filePath, dirContent[i])
if (await self.isDir(pathh)) {
dirsList.push(dirContent[i])
}
}
return dirsList
},
/**
* Will check if file (or directory) exists
*/
isFileOrDirExists: function (path) {
try {
return fs.existsSync(path);
} catch (err) {
return false
}
},
/**
* Will remove a file from a directory
*/
removeFile: function (filePath) {
try {
fs.unlinkSync(filePath);
} catch (e) {
//if no file exist, no problem
}
},
/**
* Will remove a list of files
*/
removeFiles: function (filePaths) {
for (let i = 0; i < filePaths.length; i++) {
self.removeFile(filePaths[i])
}
},
/**
* Will copy a directory
*/
copyDir: function (src, dst) {
const fs = require('fs-extra')
fs.copySync(src, dst)
},
/**
* Will return the content of a directory (only immediate children).
*/
getDirContent: function (dirPath, ignoreFiles = ['.DS_Store']) {
let files = fs.readdirSync(dirPath);
return files.filter(file => {
for (let i = 0; i < ignoreFiles.length; i++) {
if (file === ignoreFiles[i]) {
return false
}
}
return true
})
},
/**
* Will return the full paths of files and/or dirs in a directory.
*
* @param dirPath -> the path to the directory
* @param recursive -> set to true if you want to look in inner directories as well
* @param collectFiles -> set to true if you want files in the output list
* @param collectDirs -> set to true if you want dirs in the output list
* @param ignoreFiles -> set the list of files you wish to ignore
*/
getDirContentFullPaths: function (dirPath, recursive = false, collectFiles = true, collectDirs = true, ignoreFiles = ['.DS_Store']) {
return new Promise(async function (resolve, reject) {
let files = [];
if (recursive) {
files = await self.findFilesInPath(dirPath, '*', '.*', collectFiles, collectDirs, ignoreFiles)
} else {
fs.readdirSync(dirPath).forEach(file => {
let fullPath = path.join(dirPath, file);
files.push(fullPath);
}
);
files = await filterFiles(files, collectFiles, collectDirs, ignoreFiles)
}
resolve(files)
}.bind())
},
/**
* Will search for files in a given path
*/
findFilesInPath: function (dirPath, fileName = '*', fileExtension = '.*', collectFiles = true, collectDirs = true, ignoreFiles = ['.DS_Store']) {
return new Promise(function (resolve) {
const glob = require('glob');
let searchQuery = dirPath + '/**/' + fileName + fileExtension;
glob(searchQuery, {}, async function (err, files) {
resolve(await filterFiles(files, collectFiles, collectDirs, ignoreFiles))
})
}.bind())
},
/**
* Will remove a directory (and all of it's content)
*/
removeDir: function (path) {
return new Promise(async function (resolve, reject) {
let deleteFolderRecursive = function (path) {
if (fs.existsSync(path)) {
fs.readdirSync(path).forEach(function (file, index) {
var curPath = self.joinPath(path, file);
if (fs.lstatSync(curPath).isDirectory()) { // recurse
deleteFolderRecursive(curPath);
} else { // delete file
fs.unlinkSync(curPath);
}
});
fs.rmdirSync(path);
}
};
deleteFolderRecursive(path)
resolve()
}.bind())
},
/**
* Will remove a bunch of directories (and all of their content)
*/
removeDirs: function (dirList) {
return new Promise(async function (resolve, reject) {
for (let i = 0; i < dirList.length; i++) {
await self.removeDir(dirList[i])
}
resolve()
}.bind())
},
/**
* Will copy a file to a given destination.
*/
copyFile: async function (src, dest) {
return new Promise(async function (resolve, reject) {
let parentDir = self.getParentDirPath(dest);
if (!self.isDirExists(parentDir)) {
self.createDir(parentDir)
}
await mCopyFile(src, dest)
resolve()
}.bind());
},
/**
* Will copy a list of files to a given destination.
*/
copyFiles: async function (filePathsList = [], destDir) {
return new Promise(async function (resolve, reject) {
let parentDir = self.getParentDirPath(destDir);
if (!self.isDirExists(parentDir)) {
self.createDir(parentDir)
}
for (let i = 0; i < filePathsList.length; i++) {
let fileName = await self.getFileNameFromPath(filePathsList[i])
let destPath = self.joinPath(destDir, fileName)
await mCopyFile(filePathsList[i], destPath)
}
resolve()
}.bind());
},
/**
* Will check if dir exists
*/
isDirExists: function (path) {
return fs.existsSync(path)
},
/**
* Will turn a list of file paths to file names
*/
filesPathListToFileNamesList: function (filePathList) {
let fileNamesList = [];
for (let i = 0; i < filePathList.length; i++) {
fileNamesList[i] = self.getFileNameFromPath(filePathList[i])
}
return fileNamesList
},
/**
* Will return the file name from a given path
*/
getFileNameFromPath: function (path, withExtension = true) {
let fName = path.replace(/^.*[\\\/]/, '');
if (!withExtension) {
return self.stripExtension(fName)
} else {
return fName
}
},
/**
* Will return the dir name from a given path
*/
getDirNameFromPath: function (dirPath) {
return path.basename(dirPath)
},
/**
* Will strip the extension from a file
*/
stripExtension: function (file) {
return file.split('.').slice(0, -1).join('.')
},
/**
* Will join the paths of dirs
*/
joinPath: function (...paths) {
return path.join(...paths)
},
/**
* Will rename a file
*/
renameFile: function (filePath, newFileNameWithPath) {
return new Promise(async function (resolve, reject) {
fs.rename(filePath, newFileNameWithPath, function (err) {
if (err) {
console.log('ERROR: ' + err);
}
resolve()
});
}.bind())
},
/**
* Will return the size of a file
*/
getFileSize: function (filePath, inMB = false, inKB = false, inBytes = false) {
const stats = fs.statSync(filePath);
const fileSizeInBytes = stats.size;
//Convert the file size to megabytes (optional)
if (inMB) return fileSizeInBytes / 1000000.0;
if (inKB) return fileSizeInBytes / 1000.0;
if (inBytes) return fileSizeInBytes;
return fileSizeInBytes
},
/**
* Will filter a list of files by size.
*
* @param filePathsArr -> the files list
* @param checkInMB -> set true to check in mb
* @param checkInKb -> set true to check in kb
* @param checkInBytes -> set true to check in bytes
* @param biggerThanSize -> set an int here if you want to check for bigger than
* @param smallerThanSize -> set an int here if you want to check for snmalle than
* @return {Array} -> a list of all of the file paths which correspond to the characteristics set
*/
filterFilesBySize: function (filePathsArr,
checkInMB = false,
checkInKb = false,
checkInBytes = false,
biggerThanSize = -1,
smallerThanSize = -1) {
let resLst = [];
for (let i = 0; i < filePathsArr.length; i++) {
let fileSize = self.getFileSize(filePathsArr[i], checkInMB, checkInKb, checkInBytes);
if (biggerThanSize !== -1) {
if (fileSize > biggerThanSize) {
if (smallerThanSize !== -1) {
if (fileSize < smallerThanSize) {
resLst.push(filePathsArr[i]);
continue
}
} else {
resLst.push(filePathsArr[i]);
continue
}
}
}
if (smallerThanSize !== -1) {
if (fileSize < smallerThanSize) {
if (biggerThanSize !== -1) {
if (fileSize > biggerThanSize) {
resLst.push(filePathsArr[i]);
}
} else {
resLst.push(filePathsArr[i]);
}
}
}
}
return resLst
},
/**
* Will run a file
*/
runFile: function (filePath) {
let platform = '';
switch (process.platform) {
case 'darwin' :
platform = 'open';
break
case 'win32' :
platform = 'start';
break;
case 'win64' :
platform = 'start';
break;
default :
platform = 'xdg-open';
break;
}
const sys = require('sys');
let exec = require('child_process').exec;
exec(platform + ' ' + filePath);
},
/**
* Will return the relative file path of a file from an absolute path.
*
* To get the absolute path of a file: __filename
*/
relativeFilePathFromAbsolutePath: function (absolutePath) {
return path.relative(process.cwd(), absolutePath)
}
};
// Will do a filtration for a list of files by properties
async function filterFiles(filesArr, collectFiles = true, collectDirs = true, ignoreFiles = ['.DS_Store']) {
for (let i = filesArr.length - 1; i >= 0; i--) {
// remove ignored
for (let j = 0; j < ignoreFiles.length; j++) {
if (await self.getFileNameFromPath(filesArr[i]) === ignoreFiles[j]) {
filesArr.splice(i, 1)
}
}
// remove dirs
if (await self.isDir(filesArr[i])) {
if (!collectDirs) {
filesArr.splice(i, 1)
}
} else {
// remove files
if (!collectFiles) {
filesArr.splice(i, 1)
}
}
}
return filesArr
}
// Will copy a file
async function mCopyFile(src, dest) {
return new Promise(async function (resolve, reject) {
fs.copyFile(src, dest, (err) => {
if (err) {
throw err;
} else {
resolve()
}
});
}.bind());
}And more...
Links -> see more tools
- os-tools-npm -> This module contains fundamental functions to implement in an npm project
- os-file-handler-npm -> This module contains fundamental files manipulation functions to implement in an npm project
- os-file-stream-handler-npm -> This module contains read/write and more advanced operations on files
- os-xml-handler-npm -> This module will build, read and manipulate an xml file. Other handy stuff is also available, like search for specific nodes
Licence
ISC