9.0.4

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pushrocks/smartfile",
   "private": false,
-  "version": "8.0.7",
+  "version": "9.0.4",
   "description": "offers smart ways to work with files in nodejs",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
@@ -24,26 +24,28 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartfile",
   "dependencies": {
+    "@pushrocks/lik": "^5.0.0",
+    "@pushrocks/smartdelay": "^2.0.13",
     "@pushrocks/smartfile-interfaces": "^1.0.7",
-    "@pushrocks/smarthash": "^2.1.6",
+    "@pushrocks/smarthash": "^2.1.10",
-    "@pushrocks/smartjson": "^4.0.3",
+    "@pushrocks/smartjson": "^4.0.6",
-    "@pushrocks/smartmime": "^1.0.3",
+    "@pushrocks/smartmime": "^1.0.5",
     "@pushrocks/smartpath": "^4.0.3",
-    "@pushrocks/smartpromise": "^3.0.6",
+    "@pushrocks/smartpromise": "^3.1.6",
-    "@pushrocks/smartrequest": "^1.1.51",
+    "@pushrocks/smartrequest": "^1.1.52",
-    "@types/fs-extra": "^9.0.1",
+    "@types/fs-extra": "^9.0.13",
-    "@types/glob": "^7.1.3",
+    "@types/glob": "^7.2.0",
-    "@types/js-yaml": "^3.12.5",
+    "@types/js-yaml": "^4.0.5",
-    "fs-extra": "^9.0.1",
+    "fs-extra": "^10.0.0",
-    "glob": "^7.1.6",
+    "glob": "^7.2.0",
-    "js-yaml": "^3.14.0"
+    "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
+    "@gitzone/tsbuild": "^2.1.28",
-    "@gitzone/tsrun": "^1.2.12",
+    "@gitzone/tsrun": "^1.2.18",
-    "@gitzone/tstest": "^1.0.52",
+    "@gitzone/tstest": "^1.0.60",
-    "@pushrocks/tapbundle": "^3.2.9",
+    "@pushrocks/tapbundle": "^3.2.14",
-    "@types/node": "^14.11.2",
+    "@types/node": "^16.11.11",
     "gulp-function": "^2.2.14",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"

test/test.ts

@@ -1,5 +1,5 @@
 import * as smartfile from '../ts/index';
-import path = require('path');
+import * as path from 'path';
 
 import { expect, tap } from '@pushrocks/tapbundle';
 
@@ -8,7 +8,9 @@ import { expect, tap } from '@pushrocks/tapbundle';
 // ---------------------------
 
 tap.test('.fs.fileExistsSync -> should return an accurate boolean', async () => {
+  // tslint:disable-next-line: no-unused-expression
   expect(smartfile.fs.fileExistsSync('./test/testassets/mytest.json')).to.be.true;
+  // tslint:disable-next-line: no-unused-expression
   expect(smartfile.fs.fileExistsSync('./test/testassets/notthere.json')).be.false;
 });
 
@@ -167,21 +169,6 @@ tap.test(
   }
 );
 
-tap.test('.remote.toString() -> should load a remote file to a variable', async () => {
-  const responseString = await smartfile.remote.toString(
-    'https://raw.githubusercontent.com/pushrocks/smartfile/master/test/testassets/mytest.txt'
-  );
-  expect(responseString).to.equal('Some TestString &&%$');
-});
-
-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) => {
-    return expect(err.message).to.equal(
-      'could not get remote file from https://push.rocks/doesnotexist.txt'
-    );
-  });
-});
-
 // ---------------------------
 // smartfile.Smartfile
 // ---------------------------

test/test.virtualdirectory.ts

@@ -0,0 +1,15 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import * as smartfile from '../ts';
+
+tap.test('should create a virtualdirectory', async () => {
+  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath('./test/testassets/testfolder');
+  expect(virtualDir.smartfileArray.length).to.equal(4);
+});
+
+tap.test('should write to a directory', async () => {
+  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath('./test/testassets/testfolder');
+  virtualDir.saveToDisk('./test/testassets/test');
+});
+
+tap.start();

test/testassets/test/subfolder/deepsubfolder/deepsubtestfile.txt

@@ -0,0 +1 @@
+okidoks

test/testassets/test/subfolder/subtestfile.txt

@@ -0,0 +1 @@
+hi

ts/index.ts

@@ -1,13 +1,12 @@
 import * as plugins from './smartfile.plugins';
-import * as SmartfileFs from './smartfile.fs';
+import * as fsMod from './smartfile.fs';
-import * as SmartfileInterpreter from './smartfile.interpreter';
+import * as interpreterMod from './smartfile.interpreter';
-import * as SmartfileMemory from './smartfile.memory';
+import * as memoryMod from './smartfile.memory';
-import * as SmartfileRemote from './smartfile.remote';
 
-export { Smartfile } from './smartfile.classes.smartfile';
+export { Smartfile, ISmartfileConstructorOptions } from './smartfile.classes.smartfile';
 export { VirtualDirectory } from './smartfile.classes.virtualdirectory';
 
-export let fs = SmartfileFs;
+
-export let interpreter = SmartfileInterpreter;
+export let fs = fsMod;
-export let memory = SmartfileMemory;
+export let interpreter = interpreterMod;
-export let remote = SmartfileRemote;
+export let memory = memoryMod;

ts/smartfile.classes.smartfile.ts

@@ -3,9 +3,9 @@ import * as fs from './smartfile.fs';
 import * as memory from './smartfile.memory';
 
 export interface ISmartfileConstructorOptions {
-  path?: string;
+  path: string;
-  contentBuffer?: Buffer;
+  contentBuffer: Buffer;
-  base?: string;
+  base: string;
 }
 
 /**
@@ -21,20 +21,26 @@ export class Smartfile extends plugins.smartjson.Smartjson {
    * creates a Smartfile from a filePath
    * @param filePath
    */
-  public static async fromFilePath(filePath: string) {
+  public static async fromFilePath(filePath: string, baseArg: string = process.cwd()) {
     filePath = plugins.path.resolve(filePath);
     const fileBuffer = fs.toBufferSync(filePath);
     const smartfile = new Smartfile({
-      path: filePath,
       contentBuffer: fileBuffer,
+      base: baseArg,
+      path: plugins.path.relative(baseArg, filePath),
     });
     return smartfile;
   }
 
-  public static async fromBuffer(filePath: string, contentBufferArg: Buffer) {
+  public static async fromBuffer(
+    filePath: string,
+    contentBufferArg: Buffer,
+    baseArg: string = process.cwd()
+  ) {
     const smartfile = new Smartfile({
       contentBuffer: contentBufferArg,
-      path: filePath,
+      base: baseArg,
+      path: plugins.path.relative(baseArg, filePath),
     });
 
     return smartfile;
@@ -43,21 +49,27 @@ export class Smartfile extends plugins.smartjson.Smartjson {
   public static async fromString(
     filePath: string,
     contentStringArg: string,
-    encodingArg: 'utf8' | 'binary'
+    encodingArg: 'utf8' | 'binary',
+    baseArg = process.cwd()
   ) {
     const smartfile = new Smartfile({
       contentBuffer: Buffer.from(contentStringArg, encodingArg),
-      path: filePath,
+      base: baseArg,
+      path: plugins.path.relative(baseArg, filePath),
     });
 
     return smartfile;
   }
 
+  public static async fromFoldedJson(foldedJsonArg: string) {
+    return new Smartfile(plugins.smartjson.parse(foldedJsonArg));
+  }
+
   // ========
   // INSTANCE
   // ========
   /**
-   * the full path of the file on disk
+   * the relative path of the file
    */
   @plugins.smartjson.foldDec()
   public path: string;
@@ -65,8 +77,16 @@ export class Smartfile extends plugins.smartjson.Smartjson {
   /**
    * a parsed path
    */
-  @plugins.smartjson.foldDec()
+  public get parsedPath (): plugins.path.ParsedPath {
-  public parsedPath: plugins.path.ParsedPath;
+    return plugins.path.parse(this.path);
+  };
+  public get absolutePath () {
+    return plugins.path.join(this.base, this.path);
+  }
+
+  public get absoluteParsedPath() {
+    return plugins.path.parse(this.absolutePath);
+  }
 
   /**
    * the content of the file as Buffer
@@ -100,7 +120,6 @@ export class Smartfile extends plugins.smartjson.Smartjson {
       console.log('created empty Smartfile?');
     }
     this.path = optionsArg.path;
-    this.parsedPath = plugins.path.parse(this.path);
     this.base = optionsArg.base;
   }
 
@@ -118,11 +137,12 @@ export class Smartfile extends plugins.smartjson.Smartjson {
    * - no argument write to exactly where the file was picked up
    */
   public async write() {
-    await memory.toFs(this.contentBuffer, this.path);
+    await memory.toFs(this.contentBuffer, plugins.path.join(this.base, this.path));
   }
 
   /**
    * writes the file to path given as argument
+   * note: if the path is not absolute, takes process.cwd() as base
    * @param filePathArg
    */
   public async writeToDiskAtPath(filePathArg: string) {
@@ -132,19 +152,31 @@ export class Smartfile extends plugins.smartjson.Smartjson {
     await memory.toFs(this.contentBuffer, filePathArg);
   }
 
+  /**
+   * writes the file to a directory combined with the relative path portion
+   * @param dirPathArg
+   * @returns
+   */
   public async writeToDir(dirPathArg: string) {
-    if (!plugins.path.isAbsolute(dirPathArg)) {
+    dirPathArg = plugins.smartpath.transform.toAbsolute(dirPathArg);
-      dirPathArg = plugins.path.join(process.cwd(), dirPathArg);
+    const filePath = plugins.path.join(dirPathArg, this.path);
-    }
-    const relativePath = this.relative;
-    const filePath = plugins.path.join(dirPathArg, relativePath);
     await memory.toFs(this.contentBuffer, filePath);
+    return filePath;
   }
 
   /**
    * read file from disk
    */
-  public async read() {}
+  public async read() {
+    this.contentBuffer = await fs.toBuffer(plugins.path.join(this.base, this.path));
+  }
+
+  /**
+   * deletes the file from disk at its original location
+   */
+  public async delete() {
+    await fs.remove(plugins.path.join(this.base, this.path));
+  }
 
   // -----------------------------------------------
   // vinyl compatibility
@@ -170,7 +202,7 @@ export class Smartfile extends plugins.smartjson.Smartjson {
    * return relative path of file
    */
   public get relative(): string {
-    return plugins.path.relative(this.base, this.path);
+    return this.path;
   }
 
   /**

ts/smartfile.classes.virtualdirectory.ts

@@ -24,16 +24,16 @@ export class VirtualDirectory {
   }
 
   // INSTANCE
-  private fileArray: Smartfile[] = [];
+  public smartfileArray: Smartfile[] = [];
 
   constructor() {}
 
   public addSmartfiles(smartfileArrayArg: Smartfile[]) {
-    this.fileArray = this.fileArray.concat(smartfileArrayArg);
+    this.smartfileArray = this.smartfileArray.concat(smartfileArrayArg);
   }
 
   public async getFileByPath(pathArg: string) {
-    for (const smartfile of this.fileArray) {
+    for (const smartfile of this.smartfileArray) {
       if (smartfile.path === pathArg) {
         return smartfile;
       }
@@ -42,13 +42,17 @@ export class VirtualDirectory {
 
   public async toVirtualDirTransferableObject(): Promise<plugins.smartfileInterfaces.VirtualDirTransferableObject> {
     return {
-      files: this.fileArray.map(smartfileArg => smartfileArg.foldToJson())
+      files: this.smartfileArray.map(smartfileArg => smartfileArg.foldToJson())
     };
   }
 
-  public async saveToDisk() {
+  public async saveToDisk(dirArg: string) {
-    for (const smartfileArg of this.fileArray) {
+    console.log(`writing VirtualDirectory with ${this.smartfileArray.length} to directory:
-      
+    --> ${dirArg}`);
+    for (const smartfileArg of this.smartfileArray) {
+      const filePath = await smartfileArg.writeToDir(dirArg);
+      console.log(`wrote ${smartfileArg.relative} to
+        --> ${filePath}`);
     }
   }
 

ts/smartfile.fs.ts

@@ -202,6 +202,10 @@ export const toStringSync = (filePath: string): string => {
   return fileString;
 };
 
+export const toBuffer = async (filePath: string): Promise<Buffer> => {
+  return plugins.fsExtra.readFile(filePath);
+};
+
 export const toBufferSync = (filePath: string): Buffer => {
   return plugins.fsExtra.readFileSync(filePath);
 };
@@ -227,7 +231,7 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
   if (plugins.path.isAbsolute(miniMatchFilter)) {
     dirPath = '/';
   } else {
-    dirPath = dirPathArg;
+    dirPath = plugins.smartpath.transform.toAbsolute(dirPathArg);
   }
 
   const fileTree = await listFileTree(dirPath, miniMatchFilter);
@@ -369,3 +373,26 @@ export const listFileTree = async (
 
   return fileList;
 };
+
+/**
+ * checks wether a file is ready for processing
+ */
+export const waitForFileToBeReady = async (filePathArg: string): Promise<void> => {
+  if (!plugins.path.isAbsolute(filePathArg)) {
+    filePathArg = plugins.path.resolve(filePathArg);
+  }
+  const limitedArray = new plugins.lik.LimitedArray<number>(3);
+  let fileReady = false;
+  while (!fileReady) {
+    const stats = await plugins.fsExtra.stat(filePathArg);
+    limitedArray.addOne(stats.size);
+    if (
+      limitedArray.array.length < 3 ||
+      !(limitedArray.array[0] === limitedArray[1] && limitedArray.array[1] === limitedArray[2])
+    ) {
+      await plugins.smartdelay.delayFor(5000);
+    } else {
+      fileReady = true;
+    }
+  }
+};

ts/smartfile.interpreter.ts

@@ -10,7 +10,7 @@ export let objectFile = (fileStringArg: string, fileTypeArg) => {
   switch (fileTypeArg) {
     case 'yml':
     case 'yaml':
-      return plugins.yaml.safeLoad(fileStringArg);
+      return plugins.yaml.load(fileStringArg);
     case 'json':
       return JSON.parse(fileStringArg);
     default:

ts/smartfile.plugins.ts

@@ -5,7 +5,9 @@ import * as path from 'path';
 export { fs, path };
 
 // @pushrocks scope
+import * as lik from '@pushrocks/lik';
 import * as smartfileInterfaces from '@pushrocks/smartfile-interfaces';
+import * as smartdelay from '@pushrocks/smartdelay';
 import * as smarthash from '@pushrocks/smarthash';
 import * as smartjson from '@pushrocks/smartjson';
 import * as smartmime from '@pushrocks/smartmime';
@@ -13,7 +15,7 @@ import * as smartpath from '@pushrocks/smartpath';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as smartrequest from '@pushrocks/smartrequest';
 
-export { smartfileInterfaces, smarthash, smartjson, smartmime, smartpath, smartpromise, smartrequest };
+export { lik, smartfileInterfaces, smartdelay, smarthash, smartjson, smartmime, smartpath, smartpromise, smartrequest };
 
 // third party scope
 import * as fsExtra from 'fs-extra';

ts/smartfile.remote.ts

@@ -1,51 +0,0 @@
-import plugins = require('./smartfile.plugins');
-import SmartfileInterpreter = require('./smartfile.interpreter');
-
-/* export let toFs = function (from: string, toPath: string) {
-  let done = plugins.q.defer()
-  let stream = plugins.smartrequest(from).pipe(plugins.fsExtra.createWriteStream(toPath))
-  stream.on('finish', function () {
-    done.resolve(toPath)
-  })
-  return done.promise
-} */
-
-/**
- *
- * @param fromArg
- * @returns {any}
- */
-export let toObject = (fromArg: string) => {
-  const done = plugins.smartpromise.defer();
-  plugins.smartrequest
-    .request(fromArg, {
-      method: 'get',
-    })
-    .then((res: any) => {
-      if (res.statusCode === 200) {
-        done.resolve(res.body);
-      } else {
-        console.log('could not get remote file from ' + fromArg);
-        done.reject(new Error('could not get remote file from ' + fromArg));
-      }
-    });
-  return done.promise;
-};
-
-/**
- *
- * @param fromArg
- * @returns {any}
- */
-export let toString = (fromArg: string): Promise<string> => {
-  const done = plugins.smartpromise.defer<string>();
-  plugins.smartrequest.getBinary(fromArg).then((res: any) => {
-    if (res.statusCode === 200) {
-      const encoding = plugins.smartmime.getEncoding(fromArg);
-      done.resolve(res.body.toString(encoding));
-    } else {
-      done.reject(new Error('could not get remote file from ' + fromArg));
-    }
-  });
-  return done.promise;
-};