fix(core): update

.gitlab-ci.yml

@@ -38,22 +38,34 @@ snyk:
 # test stage
 # ====================
 
-testLTS:
+testStable:
   stage: test
   script:
   - npmci npm prepare
-  - npmci node install lts
+  - npmci node install stable
   - npmci npm install
   - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
   - docker
+  - priv
+
+testBuild:
+  stage: test
+  script:
+  - npmci npm prepare
+  - npmci node install stable
+  - npmci npm install
+  - npmci command npm run build
+  coverage: /\d+.?\d+?\%\s*coverage/
+  tags:
+  - docker
   - notpriv
 
 release:
   stage: release
   script:
-  - npmci node install lts
+  - npmci node install stable
   - npmci npm publish
   only:
   - tags
@@ -69,6 +81,7 @@ codequality:
   allow_failure: true
   script:
     - npmci command npm install -g tslint typescript
+    - npmci npm prepare
     - npmci npm install
     - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
@@ -86,7 +99,9 @@ trigger:
   - notpriv
 
 pages:
-  image: hosttoday/ht-docker-node:npmci
+  image: hosttoday/ht-docker-dbase:npmci
+  services:
+   - docker:stable-dind
   stage: metadata
   script:
     - npmci command npm install -g @gitzone/tsdoc

README.md

@@ -35,6 +35,6 @@ smartfile thinks in sections:
 For further information read the linked docs at the top of this readme.
 
 > MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
 
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

package.json

@@ -28,24 +28,23 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartfile",
   "dependencies": {
+    "@pushrocks/smarthash": "^2.0.6",
     "@pushrocks/smartpath": "^4.0.1",
-    "@pushrocks/smartpromise": "^3.0.2",
+    "@pushrocks/smartpromise": "^3.0.5",
-    "@pushrocks/smartrequest": "^1.1.14",
+    "@pushrocks/smartrequest": "^1.1.27",
-    "@types/fs-extra": "^5.0.5",
+    "@types/fs-extra": "^8.0.0",
-    "@types/vinyl": "^2.0.2",
+    "fs-extra": "^8.1.0",
-    "fs-extra": "^7.0.1",
+    "glob": "^7.1.4",
-    "glob": "^7.1.3",
+    "js-yaml": "^3.13.1"
-    "js-yaml": "^3.13.1",
-    "vinyl-file": "^3.0.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.8",
+    "@gitzone/tsbuild": "^2.1.17",
-    "@gitzone/tsrun": "^1.2.1",
+    "@gitzone/tsrun": "^1.2.8",
-    "@gitzone/tstest": "^1.0.18",
+    "@gitzone/tstest": "^1.0.24",
-    "@pushrocks/tapbundle": "^3.0.7",
+    "@pushrocks/tapbundle": "^3.0.13",
-    "@types/node": "^11.13.0",
+    "@types/node": "^12.7.8",
     "gulp-function": "^2.2.14",
-    "tslint": "^5.15.0",
+    "tslint": "^5.20.0",
     "tslint-config-prettier": "^1.18.0"
   },
   "files": [
@@ -53,6 +52,7 @@
     "ts_web/*",
     "dist/*",
     "dist_web/*",
+    "dist_ts_web/*",
     "assets/*",
     "cli.js",
     "npmextra.json",

test/test.ts

@@ -36,8 +36,12 @@ tap.test('.fs.listFolders() -> should get the file type from a string', async ()
 tap.test('.fs.listFilesSync() -> should get the file type from a string', async () => {
   expect(smartfile.fs.listFilesSync('./test/testassets/')).to.include('mytest.json');
   expect(smartfile.fs.listFilesSync('./test/testassets/')).to.not.include('notExistentFile');
-  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytest\.json/)).to.include('mytest.json');
+  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytest\.json/)).to.include(
-  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytests.json/)).to.not.include('mytest.json');
+    'mytest.json'
+  );
+  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytests.json/)).to.not.include(
+    'mytest.json'
+  );
 });
 
 tap.test('.fs.listFiles() -> should get the file type from a string', async () => {
@@ -47,13 +51,19 @@ tap.test('.fs.listFiles() -> should get the file type from a string', async () =
 });
 
 tap.test('.fs.listFileTree() -> should get a file tree', async () => {
-  let folderArrayArg = await smartfile.fs.listFileTree(path.resolve('./test/testassets/'), '**/*.txt');
+  let folderArrayArg = await smartfile.fs.listFileTree(
+    path.resolve('./test/testassets/'),
+    '**/*.txt'
+  );
   expect(folderArrayArg).to.include('testfolder/testfile1.txt');
   expect(folderArrayArg).to.not.include('mytest.json');
 });
 
 tap.test('.fs.fileTreeToObject -> should read a file tree into an Object', async () => {
-  let fileArrayArg = await smartfile.fs.fileTreeToObject(path.resolve('./test/testassets/'), '**/*.txt');
+  let fileArrayArg = await smartfile.fs.fileTreeToObject(
+    path.resolve('./test/testassets/'),
+    '**/*.txt'
+  );
   expect(fileArrayArg[0]).to.be.instanceof(smartfile.Smartfile);
   expect(fileArrayArg[0].contents.toString()).to.equal(fileArrayArg[0].contentBuffer.toString());
 });
@@ -67,7 +77,10 @@ tap.test('.fs.copy() -> should copy a file', async () => {
 });
 
 tap.test('.fs.copy() -> should copy a file and rename it', async () => {
-  await smartfile.fs.copy('./test/testassets/mytest.yaml', './test/testassets/temp/mytestRenamed.yaml');
+  await smartfile.fs.copy(
+    './test/testassets/mytest.yaml',
+    './test/testassets/temp/mytestRenamed.yaml'
+  );
 });
 
 tap.test('.fs.remove() -> should remove an entire directory', async () => {});
@@ -82,14 +95,19 @@ tap.test('.fs.removeSync -> should remove single files synchronouly', async () =
 });
 
 tap.test('.fs.removeMany -> should remove and array of files', async () => {
-  smartfile.fs.removeMany(['./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile2.txt']).then(() => {
+  smartfile.fs
-    expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).to.be.false;
+    .removeMany(['./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile2.txt'])
-    expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).to.be.false;
+    .then(() => {
-  });
+      expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).to.be.false;
+      expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).to.be.false;
+    });
 });
 
 tap.test('.fs.removeManySync -> should remove and array of single files synchronouly', async () => {
-  smartfile.fs.removeManySync(['./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile2.txt']);
+  smartfile.fs.removeManySync([
+    './test/testassets/temp/testfile1.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/testfile2.txt')).to.be.false;
 });
@@ -113,7 +131,9 @@ tap.test('.fs.toObjectSync() -> should read an ' + '.json' + ' file to an object
 });
 
 tap.test('.fs.toStringSync() -> should read a file to a string', async () => {
-  expect(smartfile.fs.toStringSync('./test/testassets/mytest.txt')).to.equal('Some TestString &&%$');
+  expect(smartfile.fs.toStringSync('./test/testassets/mytest.txt')).to.equal(
+    'Some TestString &&%$'
+  );
 });
 
 // ---------------------------
@@ -130,7 +150,10 @@ 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 () => {
   let localString = 'myString';
-  await smartfile.memory.toFs(localString, path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt'));
+  await smartfile.memory.toFs(
+    localString,
+    path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt')
+  );
 });
 
 tap.test(
@@ -164,7 +187,10 @@ tap.test('.remote.toString() -> should reject a Promise when the link is false',
 // ---------------------------
 
 tap.test('.Smartfile -> should produce vinyl compatible files', async () => {
-  let smartfileArray = await smartfile.fs.fileTreeToObject(process.cwd(), './test/testassets/testfolder/**/*');
+  let smartfileArray = await smartfile.fs.fileTreeToObject(
+    process.cwd(),
+    './test/testassets/testfolder/**/*'
+  );
   let localSmartfile = smartfileArray[0];
   expect(localSmartfile).to.be.instanceof(smartfile.Smartfile);
   expect(localSmartfile.contents).to.be.instanceof(Buffer);

ts/smartfile.fs.ts

@@ -29,7 +29,7 @@ export const fileExistsSync = (filePath): boolean => {
  * @param filePath
  * @returns {any}
  */
-export let fileExists = async (filePath): Promise<boolean> => {
+export const fileExists = async (filePath): Promise<boolean> => {
   const done = plugins.smartpromise.defer<boolean>();
   plugins.fs.access(filePath, 4, err => {
     err ? done.resolve(false) : done.resolve(true);
@@ -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}`);
     }
@@ -84,16 +84,14 @@ export const copySync = (fromArg: string, toArg: string): boolean => {
 /**
  * ensures that a directory is in place
  */
-export let ensureDir = (dirPathArg: string) => {
+export const ensureDir = async (dirPathArg: string) => {
-  let done = plugins.smartpromise.defer();
+  await plugins.fsExtra.ensureDir(dirPathArg);
-  plugins.fsExtra.ensureDir(dirPathArg, done.resolve);
-  return done.promise;
 };
 
 /**
  * ensures that a directory is in place
  */
-export let ensureDirSync = (dirPathArg: string) => {
+export const ensureDirSync = (dirPathArg: string) => {
   plugins.fsExtra.ensureDirSync(dirPathArg);
 };
 
@@ -101,19 +99,16 @@ export let ensureDirSync = (dirPathArg: string) => {
  * ensure an empty directory
  * @executes ASYNC
  */
-export let ensureEmptyDir = (dirPathArg: string) => {
+export const ensureEmptyDir = async (dirPathArg: string) => {
-  let done = plugins.smartpromise.defer();
+  await plugins.fsExtra.ensureDir(dirPathArg);
-  plugins.fsExtra.ensureDir(dirPathArg, () => {
+  await plugins.fsExtra.emptyDir(dirPathArg);
-    plugins.fsExtra.emptyDir(dirPathArg, done.resolve);
-  });
-  return done.promise;
 };
 
 /**
  * ensure an empty directory
  * @executes SYNC
  */
-export let ensureEmptyDirSync = (dirPathArg: string) => {
+export const ensureEmptyDirSync = (dirPathArg: string) => {
   plugins.fsExtra.ensureDirSync(dirPathArg);
   plugins.fsExtra.emptyDirSync(dirPathArg);
 };
@@ -125,11 +120,8 @@ export let ensureEmptyDirSync = (dirPathArg: string) => {
  * @returns Promise<void>
  * @exec ASYNC
  */
-export let ensureFile = (filePathArg, initFileStringArg): Promise<void> => {
+export const ensureFile = async (filePathArg, initFileStringArg): Promise<void> => {
-  let done = plugins.smartpromise.defer<void>();
   ensureFileSync(filePathArg, initFileStringArg);
-  done.resolve();
-  return done.promise;
 };
 
 /**
@@ -139,7 +131,7 @@ export let ensureFile = (filePathArg, initFileStringArg): Promise<void> => {
  * @returns Promise<void>
  * @exec SYNC
  */
-export let ensureFileSync = (filePathArg: string, initFileStringArg: string): void => {
+export const ensureFileSync = (filePathArg: string, initFileStringArg: string): void => {
   if (fileExistsSync(filePathArg)) {
     return null;
   } else {
@@ -150,38 +142,33 @@ export let ensureFileSync = (filePathArg: string, initFileStringArg: string): vo
 /**
  * removes a file or folder from local disk
  */
-export let remove = function(pathArg: string): Promise<void> {
+export const remove = async (pathArg: string): Promise<void> => {
-  let done = plugins.smartpromise.defer<void>();
+  await plugins.fsExtra.remove(pathArg);
-  plugins.fsExtra.remove(pathArg, function() {
-    done.resolve();
-  });
-  return done.promise;
 };
 
 /**
  * removes a file SYNCHRONOUSLY from local disk
  */
-export let removeSync = function(pathArg: string): boolean {
+export const removeSync = (pathArg: string): void => {
   plugins.fsExtra.removeSync(pathArg);
-  return true;
 };
 
 /**
  * removes an array of filePaths from disk
  */
-export let removeMany = function(filePathArrayArg: string[]) {
+export const removeMany = async (filePathArrayArg: string[]) => {
-  let promiseArray: Promise<void>[] = [];
+  const promiseArray: Array<Promise<void>> = [];
-  for (let filePath of filePathArrayArg) {
+  for (const filePath of filePathArrayArg) {
     promiseArray.push(remove(filePath));
   }
-  return Promise.all(promiseArray);
+  await Promise.all(promiseArray);
 };
 
 /**
  * like removeFilePathArray but SYNCHRONOUSLY
  */
-export let removeManySync = function(filePathArrayArg: string[]): void {
+export const removeManySync = (filePathArrayArg: string[]): void => {
-  for (let filePath of filePathArrayArg) {
+  for (const filePath of filePathArrayArg) {
     removeSync(filePath);
   }
 };
@@ -196,7 +183,7 @@ export let removeManySync = function(filePathArrayArg: string[]): void {
  * @param fileTypeArg
  * @returns {any}
  */
-export let toObjectSync = function(filePathArg, fileTypeArg?) {
+export const toObjectSync = (filePathArg, fileTypeArg?) => {
   const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
   let fileType;
   fileTypeArg ? (fileType = fileTypeArg) : (fileType = SmartfileInterpreter.filetype(filePathArg));
@@ -213,6 +200,21 @@ export const toStringSync = (filePath: string): string => {
   return fileString;
 };
 
+export const fileTreeToHash = async (dirPathArg: string, miniMatchFilter: string) => {
+  const fileTreeObject = await fileTreeToObject(dirPathArg, miniMatchFilter);
+  let combinedString = '';
+  for (const smartfile of fileTreeObject) {
+    combinedString += smartfile.contentBuffer.toString();
+  }
+  const hash = await plugins.smarthash.sha256FromString(combinedString);
+  return hash;
+};
+
+/**
+ * creates a smartfile array from a directory
+ * @param dirPathArg the directory to start from
+ * @param miniMatchFilter a minimatch filter of what files to include
+ */
 export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: string) => {
   // handle absolute miniMatchFilter
   let dirPath: string;
@@ -224,15 +226,15 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
 
   const fileTree = await listFileTree(dirPath, miniMatchFilter);
   const smartfileArray: Smartfile[] = [];
-  for (let filePath of fileTree) {
+  for (const filePath of fileTree) {
-    let readPath = ((): string => {
+    const readPath = ((): string => {
       if (!plugins.path.isAbsolute(filePath)) {
         return plugins.path.join(dirPath, filePath);
       } else {
         return filePath;
       }
     })();
-    let fileContentString = toStringSync(readPath);
+    const fileContentString = toStringSync(readPath);
 
     // push a read file as Smartfile
     smartfileArray.push(
@@ -246,21 +248,11 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
   return smartfileArray;
 };
 
-/**
- *
- * @param filePathArg
- * @param options
- * @returns {number}
- */
-export let toVinylSync = function(filePathArg, options = {}) {
-  return plugins.vinylFile.readSync(filePathArg, options);
-};
-
 /**
  * lists Folders in a directory on local disk
  * @returns Promise with an array that contains the folder names
  */
-export let listFolders = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
+export const listFolders = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
   return listFoldersSync(pathArg, regexFilter);
 };
 
@@ -268,7 +260,7 @@ export let listFolders = async (pathArg: string, regexFilter?: RegExp): Promise<
  * lists Folders SYNCHRONOUSLY in a directory on local disk
  * @returns an array with the folder names as strings
  */
-export let listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] => {
+export const listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] => {
   let folderArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
     return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
   });
@@ -284,7 +276,7 @@ export let listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] =
  * lists Files in a directory on local disk
  * @returns Promise
  */
-export let listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
+export const listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
   return listFilesSync(pathArg, regexFilter);
 };
 
@@ -292,7 +284,7 @@ export let listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<st
  * lists Files SYNCHRONOUSLY in a directory on local disk
  * @returns an array with the folder names as strings
  */
-export let listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] => {
+export const listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] => {
   let fileArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
     return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
   });
@@ -308,7 +300,7 @@ export let listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] =>
  * lists all items (folders AND files) in a directory on local disk
  * @returns Promise<string[]>
  */
-export let listAllItems = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
+export const listAllItems = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
   return listAllItemsSync(pathArg, regexFilter);
 };
 
@@ -317,8 +309,8 @@ export let listAllItems = async (pathArg: string, regexFilter?: RegExp): Promise
  * @returns an array with the folder names as strings
  * @executes SYNC
  */
-export let listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[] => {
+export const listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[] => {
-  let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
+  let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
     return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
   });
   if (regexFilter) {
@@ -334,7 +326,11 @@ export let listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[]
  * note: if the miniMatch Filter is an absolute path, the cwdArg will be omitted
  * @returns Promise<string[]> string array with the absolute paths of all matching files
  */
-export const listFileTree = async (dirPathArg: string, miniMatchFilter: string, absolutePathsBool: boolean = false): Promise<string[]> => {
+export const listFileTree = async (
+  dirPathArg: string,
+  miniMatchFilter: string,
+  absolutePathsBool: boolean = false
+): Promise<string[]> => {
   const done = plugins.smartpromise.defer<string[]>();
 
   // handle absolute miniMatchFilter
@@ -357,7 +353,7 @@ export const listFileTree = async (dirPathArg: string, miniMatchFilter: string,
     }
     done.resolve(files);
   });
-  
+
   let fileList = await done.promise;
   if (absolutePathsBool) {
     fileList = fileList.map(filePath => {

ts/smartfile.interpreter.ts

@@ -1,8 +1,8 @@
 import plugins = require('./smartfile.plugins');
 
 export let filetype = (pathArg: string): string => {
-  let extName = plugins.path.extname(pathArg);
+  const extName = plugins.path.extname(pathArg);
-  let fileType = extName.replace(/\.([a-z]*)/, '$1'); // remove . form fileType
+  const fileType = extName.replace(/\.([a-z]*)/, '$1'); // remove . form fileType
   return fileType;
 };
 

ts/smartfile.plugins.ts

@@ -1,9 +1,32 @@
-export import fs = require('fs');
+// node native scope
-export import fsExtra = require('fs-extra');
+import * as fs from 'fs';
-export let glob = require('glob');
+import * as path from 'path';
-export import path = require('path');
+
-export import smartpromise = require('@pushrocks/smartpromise');
+export {
-export import smartrequest = require('@pushrocks/smartrequest');
+  fs,
-export import smartpath = require('@pushrocks/smartpath');
+  path
-export let vinylFile = require('vinyl-file');
+};
-export let yaml = require('js-yaml');
+
+// @pushrocks scope
+import * as smarthash from '@pushrocks/smarthash';
+import * as smartpath from '@pushrocks/smartpath';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrequest from '@pushrocks/smartrequest';
+
+export {
+  smarthash,
+  smartpath,
+  smartpromise,
+  smartrequest,
+};
+
+// third party scope
+import * as fsExtra from 'fs-extra';
+import glob from 'glob';
+import yaml from 'js-yaml';
+
+export {
+  fsExtra,
+  glob,
+  yaml
+};