4.0.8

README.md

@@ -3,7 +3,6 @@ make files easily accessible for processing in javascript.
 
 ## Status
 [![build status](https://gitlab.com/pushrocks/smartfile/badges/master/build.svg)](https://gitlab.com/pushrocks/smartfile/commits/master)
-[![Build status](https://ci.appveyor.com/api/projects/status/xefmtetv7bxupfby/branch/master?svg=true)](https://ci.appveyor.com/project/philkunz/smartfile/branch/master)
 [![Dependency Status](https://david-dm.org/pushrocks/smartfile.svg)](https://david-dm.org/pushrocks/smartfile)
 [![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smartfile/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smartfile/master/dependencies/npm)
 [![bitHound Code](https://www.bithound.io/github/pushrocks/smartfile/badges/code.svg)](https://www.bithound.io/github/pushrocks/smartfile)

dist/smartfile.fs.d.ts

@@ -1,4 +1,32 @@
 import "typings-global";
+/**
+ *
+ * @param filePath
+ * @returns {boolean}
+ */
+export declare let fileExistsSync: (filePath: any) => boolean;
+/**
+ *
+ * @param filePath
+ * @returns {any}
+ */
+export declare let fileExists: (filePath: any) => any;
+/**
+ * Checks if given path points to an existing directory
+ */
+export declare let isDirectory: (pathArg: any) => boolean;
+/**
+ * Checks if a given path points to an existing file
+ */
+export declare let isFile: (pathArg: any) => boolean;
+/**
+ * ensures that a directory is in place
+ */
+export declare let ensureDir: (dirPathArg: string) => any;
+/**
+ * ensures that a directory is in place
+ */
+export declare let ensureDirSync: (dirPathArg: string) => void;
 /**
  * copies a file from A to B on the local disk
  */
@@ -15,10 +43,6 @@ export declare let remove: (pathArg: string) => any;
  * removes a file SYNCHRONOUSLY from local disk
  */
 export declare let removeSync: (pathArg: string) => boolean;
-export declare let toFS: (options: {
-    from: string;
-    toPath: string;
-}, cb?: any) => void;
 /**
  *
  * @param filePathArg
@@ -54,23 +78,31 @@ export declare let toVinylSync: (filePathArg: any, options?: {}) => any;
 export declare let requireReload: (path: string) => any;
 /**
  * lists Folders in a directory on local disk
+ * @returns Promise
  */
-export declare let listFolders: (pathArg: string) => any;
+export declare let listFolders: (pathArg: string, regexFilter?: RegExp) => any;
 /**
  * lists Folders SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
  */
-export declare let listFoldersSync: (pathArg: any) => any;
+export declare let listFoldersSync: (pathArg: string, regexFilter?: RegExp) => string[];
 /**
- *
- * @param filePath
- * @returns {boolean}
+ * lists Files in a directory on local disk
+ * @returns Promise
  */
-export declare let fileExistsSync: (filePath: any) => boolean;
+export declare let listFiles: (pathArg: string, regexFilter?: RegExp) => any;
 /**
- *
- * @param filePath
- * @returns {any}
+ * lists Files SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
  */
-export declare let fileExists: (filePath: any) => any;
-export declare let isDirectory: (pathArg: any) => boolean;
-export declare let isFile: (pathArg: any) => boolean;
+export declare let listFilesSync: (pathArg: string, regexFilter?: RegExp) => string[];
+/**
+ * lists all items (folders AND files) in a directory on local disk
+ * @returns Promise
+ */
+export declare let listAllItems: (pathArg: string, regexFilter?: RegExp) => any;
+/**
+ * lists all items (folders AND files) SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export declare let listAllItemsSync: (pathArg: string, regexFilter?: RegExp) => string[];

dist/smartfile.memory.d.ts

@@ -45,11 +45,5 @@ export declare let toStringSync: (fileArg: plugins.vinyl) => string;
  * @param fileNameArg
  * @param fileBaseArg
  */
-export declare let toFs: (fileArg: any, optionsArg: {
-    fileName: string;
-    filePath: string;
-}) => any;
-export declare let toFsSync: (fileArg: any, optionsArg: {
-    fileName: string;
-    filePath: string;
-}) => void;
+export declare let toFs: (fileContentArg: string | plugins.vinyl, filePathArg: any) => any;
+export declare let toFsSync: (fileArg: any, filePathArg: string) => void;

npmts.json

@@ -1,5 +1,5 @@
 {
   "mode":"default",
   "codecov":true,
-  "coverageTreshold":80
+  "coverageTreshold":70
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartfile",
-  "version": "4.0.4",
+  "version": "4.0.8",
   "description": "offers smart ways to work with files in nodejs",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

test/test.ts

@@ -3,6 +3,7 @@ import * as smartfile from "../dist/index";
 let beautylog = require("beautylog");
 let gulp = require("gulp");
 let gFunction = require("gulp-function");
+import path = require("path");
 import should = require("should");
 let vinyl = require("vinyl");
 
@@ -39,6 +40,24 @@ describe("smartfile".yellow,function(){
                     });
             });
         });
+        describe(".listFilesSync()",function(){
+            it("should get the file type from a string",function(){
+                smartfile.fs.listFilesSync("./test/").should.containDeep([ "mytest.json"]);
+                smartfile.fs.listFilesSync("./test/").should.not.containDeep([ "notExistentFile"]);
+                smartfile.fs.listFilesSync("./test/",/mytest\.json/).should.containDeep([ "mytest.json"]);
+                smartfile.fs.listFilesSync("./test/",/mytests.json/).should.not.containDeep([ "mytest.json"]);
+            });
+        });
+        describe(".listFiles()",function(){
+            it("should get the file type from a string",function(done){
+                smartfile.fs.listFiles("./test/")
+                    .then(function(folderArrayArg){
+                        folderArrayArg.should.containDeep([ "mytest.json"]);
+                        folderArrayArg.should.not.containDeep([ "notExistentFile"]);
+                        done();
+                    });
+            });
+        });
         describe(".copy()".yellow,function(){
             it("should copy a directory",function(){
                 smartfile.fs.copy("./test/testfolder/","./test/temp/")
@@ -153,10 +172,7 @@ describe("smartfile".yellow,function(){
                 let localString = "myString";
                 smartfile.memory.toFs(
                     localString,
-                    {
-                        fileName:"./test/temp/testMemToFs.txt",
-                        filePath:process.cwd()
-                    }
+                    path.join(process.cwd(),"./test/temp/testMemToFs.txt")
                 ).then(done);
             });
         });
@@ -164,10 +180,8 @@ describe("smartfile".yellow,function(){
             it("should write a file to disk and return true if successfull",function(){
                 let localString = "myString";
                 smartfile.memory.toFsSync(
-                    localString,{
-                        fileName:"./test/temp/testMemToFsSync.txt",
-                        filePath:process.cwd()
-                    }
+                    localString,
+                    path.join(process.cwd(),"./test/temp/testMemToFsSync.txt")
                 );
             });
         });

ts/smartfile.fs.ts

@@ -3,10 +3,74 @@ import "typings-global";
 import plugins = require("./smartfile.plugins");
 import SmartfileInterpreter = require("./smartfile.interpreter");
 
+/*===============================================================
+============================ Checks =============================
+===============================================================*/
+
+/**
+ *
+ * @param filePath
+ * @returns {boolean}
+ */
+export let fileExistsSync = function(filePath):boolean {
+    let fileExistsBool:boolean = false;
+    try {
+        plugins.fs.readFileSync(filePath);
+        fileExistsBool = true
+    }
+    catch(err){
+        fileExistsBool = false;
+    }
+    return fileExistsBool;
+};
+
+/**
+ *
+ * @param filePath
+ * @returns {any}
+ */
+export let fileExists = function(filePath){
+    let done = plugins.q.defer();
+    plugins.fs.access(filePath, plugins.fs.R_OK, function (err) {
+        err ? done.reject() : done.resolve();
+    });
+    return done.promise;
+};
+
+/**
+ * Checks if given path points to an existing directory
+ */
+export let isDirectory = function(pathArg):boolean{
+    return plugins.fs.statSync(pathArg).isDirectory();
+};
+
+/**
+ * Checks if a given path points to an existing file
+ */
+export let isFile = function(pathArg):boolean{
+    return plugins.fs.statSync(pathArg).isFile();
+};
+
 /*===============================================================
 ============================ FS ACTIONS =========================
 ===============================================================*/
 
+/**
+ * ensures that a directory is in place
+ */
+export let ensureDir = (dirPathArg:string) => {
+    let done = plugins.q.defer();
+    plugins.fs.ensureDir(dirPathArg,done.resolve);
+    return done.promise;
+}
+
+/**
+ * ensures that a directory is in place
+ */
+export let ensureDirSync = (dirPathArg:string) => {
+    plugins.fs.ensureDirSync(dirPathArg);
+}
+
 /**
  * copies a file from A to B on the local disk
  */
@@ -50,11 +114,6 @@ export let removeSync = function(pathArg:string):boolean{
 ============================ Write/Read =========================
 ===============================================================*/
 
-
-export let toFS = function(options:{from:string,toPath:string}, cb=undefined){
-    
-};
-
 /**
  *
  * @param filePathArg
@@ -114,59 +173,103 @@ export let requireReload = function(path:string){
 
 /**
  * lists Folders in a directory on local disk
+ * @returns Promise
  */
-export let listFolders = function(pathArg:string){
+export let listFolders = function(pathArg:string,regexFilter?:RegExp){
     let done = plugins.q.defer();
     let folderArray = plugins.fs.readdirSync(pathArg).filter(function(file) {
         return plugins.fs.statSync(plugins.path.join(pathArg, file)).isDirectory();
     });
+    if(regexFilter){
+        folderArray = folderArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    }
     done.resolve(folderArray);
     return done.promise;
 };
 
 /**
  * lists Folders SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
  */
-export let listFoldersSync = function(pathArg){
-    return plugins.fs.readdirSync(pathArg).filter(function(file) {
+export let listFoldersSync = function(pathArg:string,regexFilter?:RegExp):string[]{
+    let folderArray = plugins.fs.readdirSync(pathArg).filter(function(file) {
         return plugins.fs.statSync(plugins.path.join(pathArg, file)).isDirectory();
     });
+    if(regexFilter){
+        folderArray = folderArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    return folderArray;
 };
 
-/**
- *
- * @param filePath
- * @returns {boolean}
- */
-export let fileExistsSync = function(filePath):boolean {
-    let fileExistsBool:boolean = false;
-    try {
-        plugins.fs.readFileSync(filePath);
-        fileExistsBool = true
-    }
-    catch(err){
-        fileExistsBool = false;
-    }
-    return fileExistsBool;
-};
 
 /**
- *
- * @param filePath
- * @returns {any}
+ * lists Files in a directory on local disk
+ * @returns Promise
  */
-export let fileExists = function(filePath){
+export let listFiles = function(pathArg:string, regexFilter?:RegExp){
     let done = plugins.q.defer();
-    plugins.fs.access(filePath, plugins.fs.R_OK, function (err) {
-        err ? done.reject() : done.resolve();
+    let fileArray = plugins.fs.readdirSync(pathArg).filter(function(file) {
+        return plugins.fs.statSync(plugins.path.join(pathArg, file)).isFile();
     });
+    if(regexFilter){
+        fileArray = fileArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    done.resolve(fileArray);
     return done.promise;
 };
 
-export let isDirectory = function(pathArg):boolean{
-    return plugins.fs.statSync(pathArg).isDirectory();
+/**
+ * lists Files SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export let listFilesSync = function(pathArg:string, regexFilter?:RegExp):string[]{
+    let fileArray = plugins.fs.readdirSync(pathArg).filter(function(file) {
+        return plugins.fs.statSync(plugins.path.join(pathArg, file)).isFile();
+    });
+    if(regexFilter){
+        fileArray = fileArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    return fileArray;
 };
 
-export let isFile = function(pathArg):boolean{
-    return plugins.fs.statSync(pathArg).isFile();
-};
+/**
+ * lists all items (folders AND files) in a directory on local disk
+ * @returns Promise
+ */
+export let listAllItems = function(pathArg:string, regexFilter?:RegExp){
+    let done = plugins.q.defer();
+    let allItmesArray = plugins.fs.readdirSync(pathArg);
+    if(regexFilter){
+        allItmesArray = allItmesArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    done.resolve(allItmesArray);
+    return done.promise;
+};
+
+/**
+ * lists all items (folders AND files) SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export let listAllItemsSync = function(pathArg:string, regexFilter?:RegExp):string[]{
+    let allItmesArray = plugins.fs.readdirSync(pathArg).filter(function(file) {
+        return plugins.fs.statSync(plugins.path.join(pathArg, file)).isFile();
+    });
+    if(regexFilter){
+        allItmesArray = allItmesArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    return allItmesArray;
+};
+
+

ts/smartfile.memory.ts

@@ -2,6 +2,7 @@ import "typings-global";
 
 import plugins = require("./smartfile.plugins");
 import SmartfileInterpreter = require("./smartfile.interpreter");
+import vinyl = require("vinyl");
 let Readable = require("stream").Readable;
 /**
  * allows you to create a gulp stream
@@ -96,33 +97,31 @@ export let toStringSync = function(fileArg:plugins.vinyl){
  * @param fileNameArg
  * @param fileBaseArg
  */
-export let toFs = function(fileArg,optionsArg:{fileName:string,filePath:string}){
+export let toFs = function(fileContentArg:string|vinyl,filePathArg){
     let done = plugins.q.defer();
 
     //function checks to abort if needed
-    if (!fileArg || !optionsArg || !(typeof optionsArg.fileName === "string"))
-        throw new Error("expected a valid arguments");
-    if (!(typeof optionsArg.filePath === "string")) optionsArg.filePath = "/";
+    if (!fileContentArg || !filePathArg) throw new Error("expected valid arguments");
 
-    let filePath:string = plugins.path.join(optionsArg.filePath,optionsArg.fileName);
+    // prepare actual write action
     let fileString:string;
-    if (fileArg instanceof plugins.vinyl){
-        fileString = toStringSync(fileArg);
-    } else if (typeof fileArg === "string") {
-        fileString = fileArg;
+    let filePath:string = filePathArg;
+    if (fileContentArg instanceof plugins.vinyl){
+        fileString = toStringSync(fileContentArg);
+    } else if (typeof fileContentArg === "string") {
+        fileString = fileContentArg;
     }
     plugins.fs.writeFile(filePath,fileString,"utf8",done.resolve);
     return done.promise;
 };
 
-export let toFsSync = function(fileArg,optionsArg:{fileName:string,filePath:string}){
+export let toFsSync = function(fileArg,filePathArg:string){
     //function checks to abort if needed
-    if (!fileArg || !optionsArg || !(typeof optionsArg.fileName === "string"))
-        throw new Error("expected a valid arguments");
-    if (!(typeof optionsArg.filePath === "string")) optionsArg.filePath = "/";
+    if (!fileArg || !filePathArg) throw new Error("expected a valid arguments");
 
-    let filePath = plugins.path.join(optionsArg.filePath,optionsArg.fileName);
+    // prepare actual write action
     let fileString:string;
+    let filePath:string = filePathArg;
 
     if (fileArg instanceof plugins.vinyl){
         fileString = toStringSync(fileArg);

ts/typings.json

@@ -1,8 +0,0 @@
-{
-  "globalDependencies": {
-    "colors": "github:DefinitelyTyped/DefinitelyTyped/colors/colors.d.ts",
-    "mocha": "github:Bartvds/tsd-deftools/typings/DefinitelyTyped/mocha/mocha.d.ts",
-    "node": "registry:dt/node",
-    "should": "registry:dt/should"
-  }
-}