push.rocks/smartfile
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BREAKING CHANGE(Smartfile class): switch to a Buffer only approach

Browse Source
This commit is contained in:
Philipp Kunz
2020-08-10 20:58:22 +00:00
parent 7204607c8a
commit e3c46cdd2c
11 changed files with 9575 additions and 567 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
ts/smartfile.classes.smartfile.ts
View File

@ -4,7 +4,6 @@ import * as memory from './smartfile.memory';
export interface ISmartfileConstructorOptions {
path?: string;
contentString?: string;
contentBuffer?: Buffer;
base?: string;
}
@ -24,42 +23,64 @@ export class Smartfile {
*/
public static async fromFilePath(filePath: string) {
filePath = plugins.path.resolve(filePath);
const fileString = fs.toStringSync(filePath);
const fileBuffer = fs.toBufferSync(filePath);
const smartfile = new Smartfile({
path: filePath,
contentString: fileString
contentBuffer: fileBuffer,
});
return smartfile;
}
public static async fromBuffer(filePath: string, contentBufferArg: Buffer) {
const smartfile = new Smartfile({
contentBuffer: contentBufferArg,
path: filePath,
});
return smartfile;
}
public static async fromString(
filePath: string,
contentStringArg: string,
encodingArg: 'utf8' | 'binary'
) {
const smartfile = new Smartfile({
contentBuffer: Buffer.from(contentStringArg, encodingArg),
path: filePath,
});
return smartfile;
}
// ========
// INSTANCE
// ========
/**
* the full path of the file on disk
*/
path: string;
public path: string;
/**
*
*/
parsedPath: plugins.path.ParsedPath;
public parsedPath: plugins.path.ParsedPath;
/**
* the content of the file as Buffer
*/
contentBuffer: Buffer;
public contentBuffer: Buffer;
/**
* The current working directory of the file
* Note:this is similar to gulp and different from native node path base
*/
base: string;
public base: string;
/**
* sync the file with disk
*/
sync: boolean;
public sync: boolean;
/**
* the constructor of Smartfile
@ -69,8 +90,6 @@ export class Smartfile {
constructor(optionsArg: ISmartfileConstructorOptions) {
if (optionsArg.contentBuffer) {
this.contentBuffer = optionsArg.contentBuffer;
} else if (optionsArg.contentString) {
this.setContentsFromString(optionsArg.contentString);
} else {
console.log('created empty Smartfile?');
}
@ -83,8 +102,8 @@ export class Smartfile {
* set contents from string
* @param contentString
*/
setContentsFromString(contentString: string) {
this.contents = new Buffer(contentString);
public setContentsFromString(contentString: string, encodingArg: 'utf8' | 'binary' = 'utf8') {
this.contents = new Buffer(contentString, encodingArg);
}
/**
@ -92,7 +111,7 @@ export class Smartfile {
* Behaviours:
* - no argument write to exactly where the file was picked up
*/
async write(pathArg?: string) {
public async write(pathArg?: string) {
const stringToWrite = this.contentBuffer.toString();
await memory.toFs(stringToWrite, this.path);
}
@ -100,7 +119,7 @@ export class Smartfile {
/**
* read file from disk
*/
async read() {}
public async read() {}
// -----------------------------------------------
// vinyl compatibility
@ -118,21 +137,21 @@ export class Smartfile {
/**
* vinyl-compatibility
*/
get cwd() {
public get cwd() {
return process.cwd();
}
/**
* return relative path of file
*/
get relative(): string {
public get relative(): string {
return plugins.path.relative(this.base, this.path);
}
/**
* return truw when the file has content
*/
isNull(): boolean {
public isNull(): boolean {
if (!this.contentBuffer) {
return true;
}
@ -142,28 +161,28 @@ export class Smartfile {
/**
* return true if contents are Buffer
*/
isBuffer(): boolean {
public isBuffer(): boolean {
if (this.contents instanceof Buffer) {
return true;
}
return false;
}
isDirectory() {
public isDirectory() {
return false;
}
isStream() {
public isStream() {
return false;
}
isSymbolic() {
public isSymbolic() {
return false;
}
// update things
updateFileName(fileNameArg: string) {
let oldFileName = this.parsedPath.base;
public updateFileName(fileNameArg: string) {
const oldFileName = this.parsedPath.base;
this.path = this.path.replace(new RegExp(oldFileName + '$'), fileNameArg);
}
}

22
ts/smartfile.fs.ts
View File

@ -31,7 +31,7 @@ export const fileExistsSync = (filePath): boolean => {
*/
export const fileExists = async (filePath): Promise<boolean> => {
const done = plugins.smartpromise.defer<boolean>();
plugins.fs.access(filePath, 4, err => {
plugins.fs.access(filePath, 4, (err) => {
err ? done.resolve(false) : done.resolve(true);
});
return done.promise;
@ -64,7 +64,7 @@ export const isFile = (pathArg): boolean => {
*/
export const copy = async (fromArg: string, toArg: string): Promise<boolean> => {
const done = plugins.smartpromise.defer<boolean>();
plugins.fsExtra.copy(fromArg, toArg, {}, err => {
plugins.fsExtra.copy(fromArg, toArg, {}, (err) => {
if (err) {
throw new Error(`Could not copy from ${fromArg} to ${toArg}: ${err}`);
}
@ -244,7 +244,7 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
new Smartfile({
contentBuffer: Buffer.from(fileContentString),
base: dirPath,
path: filePath
path: filePath,
})
);
}
@ -264,11 +264,11 @@ export const listFolders = async (pathArg: string, regexFilter?: RegExp): Promis
* @returns an array with the folder names as strings
*/
export const listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] => {
let folderArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
let folderArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
});
if (regexFilter) {
folderArray = folderArray.filter(fileItem => {
folderArray = folderArray.filter((fileItem) => {
return regexFilter.test(fileItem);
});
}
@ -288,11 +288,11 @@ export const listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<
* @returns an array with the folder names as strings
*/
export const listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] => {
let fileArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
let fileArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
});
if (regexFilter) {
fileArray = fileArray.filter(fileItem => {
fileArray = fileArray.filter((fileItem) => {
return regexFilter.test(fileItem);
});
}
@ -313,11 +313,11 @@ export const listAllItems = async (pathArg: string, regexFilter?: RegExp): Promi
* @executes SYNC
*/
export const listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[] => {
let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
});
if (regexFilter) {
allItmesArray = allItmesArray.filter(fileItem => {
allItmesArray = allItmesArray.filter((fileItem) => {
return regexFilter.test(fileItem);
});
}
@ -347,7 +347,7 @@ export const listFileTree = async (
const options = {
cwd: dirPath,
nodir: true,
dot: true
dot: true,
};
plugins.glob(miniMatchFilter, options, (err, files: string[]) => {
if (err) {
@ -359,7 +359,7 @@ export const listFileTree = async (
let fileList = await done.promise;
if (absolutePathsBool) {
fileList = fileList.map(filePath => {
fileList = fileList.map((filePath) => {
return plugins.path.resolve(plugins.path.join(dirPath, filePath));
});
}

22
ts/smartfile.memory.ts
View File

@ -10,7 +10,7 @@ import SmartfileInterpreter = require('./smartfile.interpreter');
* @param fileTypeArg
* @returns {any|any}
*/
export let toObject = function(fileStringArg: string, fileTypeArg: string) {
export let toObject = function (fileStringArg: string, fileTypeArg: string) {
return SmartfileInterpreter.objectFile(fileStringArg, fileTypeArg);
};
@ -37,27 +37,27 @@ export let toFs = async (
}
// prepare actual write action
let fileString: string;
let fileEncoding: string = 'utf8';
let fileContent: string | Buffer;
let fileEncoding: 'utf8' | 'binary' = 'utf8';
let filePath: string = filePathArg;
// handle Smartfile
if (fileContentArg instanceof Smartfile) {
fileString = fileContentArg.contentBuffer.toString();
fileContent = fileContentArg.contentBuffer;
// handle options
if (optionsArg.respectRelative) {
filePath = plugins.path.join(filePath, fileContentArg.path);
}
} else if (Buffer.isBuffer(fileContentArg)) {
fileString = fileContentArg.toString('binary');
fileContent = fileContentArg;
fileEncoding = 'binary';
} else if (typeof fileContentArg === 'string') {
fileString = fileContentArg;
fileContent = fileContentArg;
} else {
throw new Error('fileContent is neither string nor Smartfile');
}
await smartfileFs.ensureDir(plugins.path.parse(filePath).dir);
plugins.fsExtra.writeFile(filePath, fileString, { encoding: fileEncoding }, done.resolve);
plugins.fsExtra.writeFile(filePath, fileContent, { encoding: fileEncoding }, done.resolve);
return await done.promise;
};
@ -66,7 +66,7 @@ export let toFs = async (
* @param fileArg
* @param filePathArg
*/
export let toFsSync = function(fileArg: string, filePathArg: string) {
export const toFsSync = (fileArg: string, filePathArg: string) => {
// function checks to abort if needed
if (!fileArg || !filePathArg) {
throw new Error('expected a valid arguments');
@ -74,7 +74,7 @@ export let toFsSync = function(fileArg: string, filePathArg: string) {
// prepare actual write action
let fileString: string;
let filePath: string = filePathArg;
const filePath: string = filePathArg;
if (typeof fileArg !== 'string') {
throw new Error('fileArg is not of type String.');
@ -86,9 +86,9 @@ export let toFsSync = function(fileArg: string, filePathArg: string) {
export let smartfileArrayToFs = async (smartfileArrayArg: Smartfile[], dirArg: string) => {
await smartfileFs.ensureDir(dirArg);
for (let smartfile of smartfileArrayArg) {
for (const smartfile of smartfileArrayArg) {
await toFs(smartfile, dirArg, {
respectRelative: true
respectRelative: true,
});
}
};

2
ts/smartfile.remote.ts
View File

@ -19,7 +19,7 @@ export let toObject = (fromArg: string) => {
const done = plugins.smartpromise.defer();
plugins.smartrequest
.request(fromArg, {
method: 'get'
method: 'get',
})
.then((res: any) => {
if (res.statusCode === 200) {