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

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

View File

@ -19,6 +19,8 @@ mirror:
stage: security stage: security
script: script:
- npmci git mirror - npmci git mirror
only:
- tags
tags: tags:
- lossless - lossless
- docker - docker
@ -33,9 +35,7 @@ audit:
- npmci command npm config set registry https://registry.npmjs.org - npmci command npm config set registry https://registry.npmjs.org
- npmci command npm audit --audit-level=high - npmci command npm audit --audit-level=high
tags: tags:
- lossless
- docker - docker
- notpriv
# ==================== # ====================
# test stage # test stage
@ -50,9 +50,7 @@ testStable:
- npmci npm test - npmci npm test
coverage: /\d+.?\d+?\%\s*coverage/ coverage: /\d+.?\d+?\%\s*coverage/
tags: tags:
- lossless
- docker - docker
- priv
testBuild: testBuild:
stage: test stage: test
@ -63,9 +61,7 @@ testBuild:
- npmci command npm run build - npmci command npm run build
coverage: /\d+.?\d+?\%\s*coverage/ coverage: /\d+.?\d+?\%\s*coverage/
tags: tags:
- lossless
- docker - docker
- notpriv
release: release:
stage: release stage: release
@ -85,6 +81,8 @@ release:
codequality: codequality:
stage: metadata stage: metadata
allow_failure: true allow_failure: true
only:
- tags
script: script:
- npmci command npm install -g tslint typescript - npmci command npm install -g tslint typescript
- npmci npm prepare - npmci npm prepare

View File

@ -15,7 +15,7 @@
"properties": { "properties": {
"projectType": { "projectType": {
"type": "string", "type": "string",
"enum": ["website", "element", "service", "npm"] "enum": ["website", "element", "service", "npm", "wcc"]
} }
} }
} }

9896
package-lock.json generated

File diff suppressed because it is too large Load Diff

View File

@ -7,11 +7,7 @@
"typings": "dist_ts/index.d.ts", "typings": "dist_ts/index.d.ts",
"scripts": { "scripts": {
"test": "(tstest test/)", "test": "(tstest test/)",
"reinstall": "(rm -r node_modules && npm install)", "build": "(tsbuild --web)"
"release": "(git pull origin master && npm version patch && git push origin master && git checkout release && git merge master && git push origin release && git checkout master)",
"update": "(git checkout master && git pull origin master && npm install)",
"upgrade": "(npm run update) && (ncu upgradeAll && npm install)",
"build": "(tsbuild)"
}, },
"repository": { "repository": {
"type": "git", "type": "git",
@ -21,7 +17,7 @@
"filesystem", "filesystem",
"json" "json"
], ],
"author": "Smart Coordination GmbH <office@push.rocks> (https://push.rocks)", "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
"license": "MIT", "license": "MIT",
"bugs": { "bugs": {
"url": "https://gitlab.com/pushrocks/smartfile/issues" "url": "https://gitlab.com/pushrocks/smartfile/issues"
@ -30,22 +26,22 @@
"dependencies": { "dependencies": {
"@pushrocks/smarthash": "^2.1.6", "@pushrocks/smarthash": "^2.1.6",
"@pushrocks/smartmime": "^1.0.3", "@pushrocks/smartmime": "^1.0.3",
"@pushrocks/smartpath": "^4.0.1", "@pushrocks/smartpath": "^4.0.3",
"@pushrocks/smartpromise": "^3.0.6", "@pushrocks/smartpromise": "^3.0.6",
"@pushrocks/smartrequest": "^1.1.47", "@pushrocks/smartrequest": "^1.1.47",
"@types/fs-extra": "^8.1.0", "@types/fs-extra": "^9.0.1",
"fs-extra": "^8.1.0", "fs-extra": "^9.0.1",
"glob": "^7.1.6", "glob": "^7.1.6",
"js-yaml": "^3.13.1" "js-yaml": "^3.14.0"
}, },
"devDependencies": { "devDependencies": {
"@gitzone/tsbuild": "^2.1.22", "@gitzone/tsbuild": "^2.1.24",
"@gitzone/tsrun": "^1.2.8", "@gitzone/tsrun": "^1.2.12",
"@gitzone/tstest": "^1.0.28", "@gitzone/tstest": "^1.0.43",
"@pushrocks/tapbundle": "^3.2.1", "@pushrocks/tapbundle": "^3.2.9",
"@types/node": "^13.9.1", "@types/node": "^14.0.27",
"gulp-function": "^2.2.14", "gulp-function": "^2.2.14",
"tslint": "^6.1.0", "tslint": "^6.1.3",
"tslint-config-prettier": "^1.18.0" "tslint-config-prettier": "^1.18.0"
}, },
"files": [ "files": [
@ -59,5 +55,8 @@
"cli.js", "cli.js",
"npmextra.json", "npmextra.json",
"readme.md" "readme.md"
],
"browserslist": [
"last 1 chrome versions"
] ]
} }

View File

@ -8,13 +8,20 @@ smart ways to work with files in nodejs
* [docs (typedoc)](https://pushrocks.gitlab.io/smartfile/) * [docs (typedoc)](https://pushrocks.gitlab.io/smartfile/)
## Status for master ## Status for master
[![pipeline status](https://gitlab.com/pushrocks/smartfile/badges/master/pipeline.svg)](https://gitlab.com/pushrocks/smartfile/commits/master)
[![coverage report](https://gitlab.com/pushrocks/smartfile/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartfile/commits/master) Status Category | Status Badge
[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartfile.svg)](https://www.npmjs.com/package/@pushrocks/smartfile) -- | --
[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartfile/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartfile) GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartfile/badges/master/pipeline.svg)](https://lossless.cloud)
[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/) GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartfile/badges/master/coverage.svg)](https://lossless.cloud)
[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/) npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartfile)](https://lossless.cloud)
[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/) Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartfile)](https://lossless.cloud)
TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartfile)](https://lossless.cloud)
PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartfile)](https://lossless.cloud)
BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartfile)](https://lossless.cloud)
Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
## Usage ## Usage

View File

@ -15,7 +15,7 @@ tap.test('.fs.fileExistsSync -> should return an accurate boolean', async () =>
tap.test('.fs.fileExists -> should resolve or reject a promise', async () => { tap.test('.fs.fileExists -> should resolve or reject a promise', async () => {
expect(smartfile.fs.fileExists('./test/testassets/mytest.json')).to.be.instanceof(Promise); expect(smartfile.fs.fileExists('./test/testassets/mytest.json')).to.be.instanceof(Promise);
await smartfile.fs.fileExists('./test/testassets/mytest.json'); await smartfile.fs.fileExists('./test/testassets/mytest.json');
await smartfile.fs.fileExists('./test/testassets/notthere.json').catch(err => { await smartfile.fs.fileExists('./test/testassets/notthere.json').catch((err) => {
return expect(err.message).to.equal( return expect(err.message).to.equal(
"ENOENT: no such file or directory, access './test/testassets/notthere.json'" "ENOENT: no such file or directory, access './test/testassets/notthere.json'"
); );
@ -28,7 +28,7 @@ tap.test('.fs.listFoldersSync() -> should get the file type from a string', asyn
}); });
tap.test('.fs.listFolders() -> should get the file type from a string', async () => { tap.test('.fs.listFolders() -> should get the file type from a string', async () => {
let folderArrayArg = await smartfile.fs.listFolders('./test/testassets/'); const folderArrayArg = await smartfile.fs.listFolders('./test/testassets/');
expect(folderArrayArg).to.include('testfolder'); expect(folderArrayArg).to.include('testfolder');
expect(folderArrayArg).to.not.include('notExistentFolder'); expect(folderArrayArg).to.not.include('notExistentFolder');
}); });
@ -45,13 +45,13 @@ tap.test('.fs.listFilesSync() -> should get the file type from a string', async
}); });
tap.test('.fs.listFiles() -> should get the file type from a string', async () => { tap.test('.fs.listFiles() -> should get the file type from a string', async () => {
let folderArrayArg = await smartfile.fs.listFiles('./test/testassets/'); const folderArrayArg = await smartfile.fs.listFiles('./test/testassets/');
expect(folderArrayArg).to.include('mytest.json'); expect(folderArrayArg).to.include('mytest.json');
expect(folderArrayArg).to.not.include('notExistentFile'); expect(folderArrayArg).to.not.include('notExistentFile');
}); });
tap.test('.fs.listFileTree() -> should get a file tree', async () => { tap.test('.fs.listFileTree() -> should get a file tree', async () => {
let folderArrayArg = await smartfile.fs.listFileTree( const folderArrayArg = await smartfile.fs.listFileTree(
path.resolve('./test/testassets/'), path.resolve('./test/testassets/'),
'**/*.txt' '**/*.txt'
); );
@ -60,7 +60,7 @@ tap.test('.fs.listFileTree() -> should get a file tree', async () => {
}); });
tap.test('.fs.fileTreeToObject -> should read a file tree into an Object', async () => { tap.test('.fs.fileTreeToObject -> should read a file tree into an Object', async () => {
let fileArrayArg = await smartfile.fs.fileTreeToObject( const fileArrayArg = await smartfile.fs.fileTreeToObject(
path.resolve('./test/testassets/'), path.resolve('./test/testassets/'),
'**/*.txt' '**/*.txt'
); );
@ -106,26 +106,26 @@ tap.test('.fs.removeMany -> should remove and array of files', async () => {
tap.test('.fs.removeManySync -> should remove and array of single files synchronouly', async () => { tap.test('.fs.removeManySync -> should remove and array of single files synchronouly', async () => {
smartfile.fs.removeManySync([ smartfile.fs.removeManySync([
'./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile1.txt',
'./test/testassets/temp/testfile2.txt' './test/testassets/temp/testfile2.txt',
]); ]);
expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).to.be.false; expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).to.be.false;
expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).to.be.false; expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).to.be.false;
}); });
tap.test('.fs.toObjectSync() -> should read an ' + '.yaml' + ' file to an object', async () => { tap.test('.fs.toObjectSync() -> should read an ' + '.yaml' + ' file to an object', async () => {
let testData = smartfile.fs.toObjectSync('./test/testassets/mytest.yaml'); const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.yaml');
expect(testData).to.include({ key1: 'this works' }); expect(testData).to.include({ key1: 'this works' });
expect(testData).to.include({ key2: 'this works too' }); expect(testData).to.include({ key2: 'this works too' });
}); });
tap.test( tap.test(
'.fs.toObjectSync() -> should state unknown file type for unknown file types', '.fs.toObjectSync() -> should state unknown file type for unknown file types',
async () => { async () => {
let testData = smartfile.fs.toObjectSync('./test/testassets/mytest.txt'); const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.txt');
} }
); );
tap.test('.fs.toObjectSync() -> should read an ' + '.json' + ' file to an object', async () => { tap.test('.fs.toObjectSync() -> should read an ' + '.json' + ' file to an object', async () => {
let testData = smartfile.fs.toObjectSync('./test/testassets/mytest.json'); const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.json');
expect(testData).to.include({ key1: 'this works' }); expect(testData).to.include({ key1: 'this works' });
expect(testData).to.include({ key2: 'this works too' }); expect(testData).to.include({ key2: 'this works too' });
}); });
@ -149,7 +149,7 @@ tap.test('.interpreter.filetype() -> should get the file type from a string', as
// --------------------------- // ---------------------------
tap.test('.memory.toFs() -> should write a file to disk and return a promise', async () => { tap.test('.memory.toFs() -> should write a file to disk and return a promise', async () => {
let localString = 'myString'; const localString = 'myString';
await smartfile.memory.toFs( await smartfile.memory.toFs(
localString, localString,
path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt') path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt')
@ -159,7 +159,7 @@ tap.test('.memory.toFs() -> should write a file to disk and return a promise', a
tap.test( tap.test(
'.memory.toFsSync() -> should write a file to disk and return true if successfull', '.memory.toFsSync() -> should write a file to disk and return true if successfull',
async () => { async () => {
let localString = 'myString'; const localString = 'myString';
smartfile.memory.toFsSync( smartfile.memory.toFsSync(
localString, localString,
path.join(process.cwd(), './test/testassets/temp/testMemToFsSync.txt') path.join(process.cwd(), './test/testassets/temp/testMemToFsSync.txt')
@ -174,8 +174,8 @@ tap.test('.remote.toString() -> should load a remote file to a variable', async
expect(responseString).to.equal('Some TestString &&%$'); expect(responseString).to.equal('Some TestString &&%$');
}); });
tap.test('.remote.toString() -> should reject a Promise when the link is false', async tools => { tap.test('.remote.toString() -> should reject a Promise when the link is false', async (tools) => {
await smartfile.remote.toString('https://push.rocks/doesnotexist.txt').catch(err => { await smartfile.remote.toString('https://push.rocks/doesnotexist.txt').catch((err) => {
return expect(err.message).to.equal( return expect(err.message).to.equal(
'could not get remote file from https://push.rocks/doesnotexist.txt' 'could not get remote file from https://push.rocks/doesnotexist.txt'
); );
@ -187,11 +187,11 @@ tap.test('.remote.toString() -> should reject a Promise when the link is false',
// --------------------------- // ---------------------------
tap.test('.Smartfile -> should produce vinyl compatible files', async () => { tap.test('.Smartfile -> should produce vinyl compatible files', async () => {
let smartfileArray = await smartfile.fs.fileTreeToObject( const smartfileArray = await smartfile.fs.fileTreeToObject(
process.cwd(), process.cwd(),
'./test/testassets/testfolder/**/*' './test/testassets/testfolder/**/*'
); );
let localSmartfile = smartfileArray[0]; const localSmartfile = smartfileArray[0];
expect(localSmartfile).to.be.instanceof(smartfile.Smartfile); expect(localSmartfile).to.be.instanceof(smartfile.Smartfile);
expect(localSmartfile.contents).to.be.instanceof(Buffer); expect(localSmartfile.contents).to.be.instanceof(Buffer);
// tslint:disable-next-line:no-unused-expression // tslint:disable-next-line:no-unused-expression
@ -203,12 +203,12 @@ tap.test('.Smartfile -> should produce vinyl compatible files', async () => {
}); });
tap.test('should output a smartfile array to disk', async () => { tap.test('should output a smartfile array to disk', async () => {
let smartfileArray = await smartfile.fs.fileTreeToObject('./test/testassets/testfolder/', '*'); const smartfileArray = await smartfile.fs.fileTreeToObject('./test/testassets/testfolder/', '*');
for (let smartfile of smartfileArray) { for (const smartfileInstance of smartfileArray) {
console.log(smartfile.relative); console.log(smartfileInstance.relative);
console.log(smartfile.path); console.log(smartfileInstance.path);
console.log(smartfile.base); console.log(smartfileInstance.base);
console.log(smartfile.parsedPath); console.log(smartfileInstance.parsedPath);
} }
await smartfile.memory.smartfileArrayToFs( await smartfile.memory.smartfileArrayToFs(
smartfileArray, smartfileArray,
@ -216,4 +216,14 @@ tap.test('should output a smartfile array to disk', async () => {
); );
}); });
tap.test('should create, store and retrieve valid smartfiles', async () => {
const fileString = 'hi there';
const filePath = './test/testassets/utf8.txt';
const smartfileInstance = await smartfile.Smartfile.fromString(filePath, fileString, 'utf8');
smartfileInstance.write();
const smartfileInstance2 = await smartfile.Smartfile.fromFilePath(filePath);
const retrievedString = smartfileInstance.contents.toString();
expect(retrievedString).to.equal(fileString);
});
tap.start(); tap.start();

1
test/testassets/utf8.txt Normal file
View File

@ -0,0 +1 @@
hi there

View File

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

View File

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

View File

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

View File

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