8.0.8

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartfile",
-  "version": "8.0.5",
+  "version": "8.0.8",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pushrocks/smartfile",
   "private": false,
-  "version": "8.0.5",
+  "version": "8.0.8",
   "description": "offers smart ways to work with files in nodejs",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",

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;
 });
 

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();

ts/smartfile.classes.smartfile.ts

@@ -63,24 +63,28 @@ export class Smartfile extends plugins.smartjson.Smartjson {
   public path: string;
 
   /**
-   *
+   * a parsed path
    */
+  @plugins.smartjson.foldDec()
   public parsedPath: plugins.path.ParsedPath;
 
   /**
    * the content of the file as Buffer
    */
+  @plugins.smartjson.foldDec()
   public contentBuffer: Buffer;
 
   /**
    * The current working directory of the file
    * Note:this is similar to gulp and different from native node path base
    */
+  @plugins.smartjson.foldDec()
   public base: string;
 
   /**
    * sync the file with disk
    */
+  @plugins.smartjson.foldDec()
   public sync: boolean;
 
   /**
@@ -109,13 +113,30 @@ export class Smartfile extends plugins.smartjson.Smartjson {
   }
 
   /**
-   * write file to disk
+   * write file to disk at its original location
    * Behaviours:
    * - no argument write to exactly where the file was picked up
    */
-  public async write(pathArg?: string) {
-    const stringToWrite = this.contentBuffer.toString();
-    await memory.toFs(stringToWrite, this.path);
+  public async write() {
+    await memory.toFs(this.contentBuffer, this.path);
+  }
+
+  /**
+   * writes the file to path given as argument
+   * @param filePathArg
+   */
+  public async writeToDiskAtPath(filePathArg: string) {
+    if (!plugins.path.isAbsolute(filePathArg)) {
+      filePathArg = plugins.path.join(process.cwd(), filePathArg);
+    }
+    await memory.toFs(this.contentBuffer, filePathArg);
+  }
+
+  public async writeToDir(dirPathArg: string) {
+    dirPathArg = plugins.smartpath.transform.toAbsolute(dirPathArg);
+    const filePath = plugins.path.join(dirPathArg, this.path);
+    await memory.toFs(this.contentBuffer, filePath);
+    return filePath;
   }
 
   /**

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,10 +42,20 @@ 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(dirArg: string) {
+    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}`);
+    }
+  }
+
   // TODO implement root shifting to get subdirectories as new virtual directories
   // TODO implement root shifting to combine VirtualDirecotries in a parent virtual directory
 }

ts/smartfile.fs.ts

@@ -227,7 +227,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);

ts/smartfile.memory.ts

@@ -1,8 +1,7 @@
-import plugins = require('./smartfile.plugins');
+import * as plugins from './smartfile.plugins';
 import { Smartfile } from './smartfile.classes.smartfile';
 import * as smartfileFs from './smartfile.fs';
-
-import SmartfileInterpreter = require('./smartfile.interpreter');
+import * as interpreter from './smartfile.interpreter';
 
 /**
  * converts file to Object
@@ -10,8 +9,8 @@ import SmartfileInterpreter = require('./smartfile.interpreter');
  * @param fileTypeArg
  * @returns {any|any}
  */
-export let toObject = function (fileStringArg: string, fileTypeArg: string) {
-  return SmartfileInterpreter.objectFile(fileStringArg, fileTypeArg);
+export let toObject = (fileStringArg: string, fileTypeArg: string) => {
+  return interpreter.objectFile(fileStringArg, fileTypeArg);
 };
 
 export interface IToFsOptions {