NodeFileStorage: Initial commit

- Added NodeFileStorage
- Added DevDependency: mock-fs (https://github.com/tschaub/mock-fs)
- Modified InMemoryStorage specs to work for both kinds of storage implementations

Author: frankebersoll

package.json

@@ -41,6 +41,7 @@
     "gulp-wrap-umd": "0.2.1",
     "rimraf": "2.5.1",
     "source-map-support": "0.4.0",
+    "mock-fs": "3.6.0",
     "tracekit": "0.3.1",
     "tslint": "3.3.0",
     "tsproject": "1.2.0-rc.4",

src/storage/InMemoryStorage-spec.ts

@@ -0,0 +1,160 @@
+import { IStorage } from './IStorage';
+import { IStorageItem } from './IStorageItem';
+
+import * as Fs from 'fs';
+import * as Path from 'path';
+
+interface IndexEntry {
+  name: string;
+  timestamp: number;
+}
+
+export class NodeFileStorage implements IStorage {
+  private directory: string;
+  private maxItems: number;
+  private timestamp: number;
+  private index: IndexEntry[];
+  private fs: any;
+
+  constructor(folder: string, maxItems: number = 20, fs?: any) {
+    this.directory = Path.resolve(folder);
+    this.maxItems = maxItems;
+    this.fs = fs ? fs : Fs;
+
+    mkdirParent(this.directory);
+    this.index = this.createIndex(this.directory);
+    this.timestamp = this.index.length > 0
+      ? this.index[this.index.length - 1].timestamp
+      : 0;
+  }
+
+  save(path: string, value: any): boolean {
+    if (!path || !value) {
+      return false;
+    }
+
+    this.remove(path);
+    let entry = { name: path, timestamp: ++this.timestamp };
+    this.index.push(entry);
+    let fullPath = this.getFullPath(entry);
+    let json = JSON.stringify(value);
+    this.fs.writeFileSync(fullPath, json);
+
+    return true;
+  }
+
+  get(path: string): any {
+    try {
+      let entry = this.findEntry(path);
+      if (!entry) {
+        return null;
+      }
+
+      let fullPath = this.getFullPath(entry);
+      let json = this.fs.readFileSync(fullPath, 'utf8');
+      return JSON.parse(json, parseDate);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  getList(searchPattern?: string, limit?: number): IStorageItem[] {
+    let entries = this.index;
+
+    if (searchPattern) {
+      let regex = new RegExp(searchPattern);
+      entries = entries.filter(entry => regex.test(entry.name));
+    }
+
+    if (entries.length > this.maxItems) {
+      entries = entries.slice(entries.length - this.maxItems);
+    }
+
+    if (entries.length > limit) {
+      entries = entries.slice(0, limit);
+    }
+
+    let items = entries.map(e => this.loadEntry(e));
+    return items;
+  }
+
+  remove(path: string): void {
+    try {
+      let entry = this.findEntry(path);
+      if (!entry) {
+        return null;
+      }
+
+      let fullPath = this.getFullPath(entry);
+      this.fs.unlinkSync(fullPath);
+      this.removeEntry(entry);
+    } catch (e) { }
+  }
+
+  private loadEntry(entry: IndexEntry) {
+    let fullPath = this.getFullPath(entry);
+    let created = this.fs.statSync(fullPath).birthtime.getTime();
+    let json = this.fs.readFileSync(fullPath, 'utf8');
+    let value = JSON.parse(json, parseDate);
+    return {
+      created: created,
+      path: entry.name,
+      value
+    };
+  }
+
+  private findEntry(path: string) {
+    for (let i = this.index.length - 1; i >= 0; i--) {
+      if (this.index[i].name === path) {
+        return this.index[i];
+      }
+    }
+    return null;
+  }
+
+  private removeEntry(entry: IndexEntry) {
+    let i = this.index.indexOf(entry);
+    if (i > -1) {
+      this.index.splice(i, 1);
+    }
+  }
+
+  private getFullPath(entry: IndexEntry) {
+    let filename = entry.name + '__' + entry.timestamp;
+    return Path.join(this.directory, filename);
+  }
+
+  private createIndex(path: string) {
+    let files = this.fs.readdirSync(path);
+    return files
+      .map(file => {
+        let parts = file.split('__');
+        return {
+          name: parts[0],
+          timestamp: parseInt(parts[1], 10)
+        };
+      }).sort((a, b) => a.timestamp - b.timestamp);
+  }
+}
+
+function parseDate(key, value) {
+  let dateRegx = /\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)/g;
+  if (typeof value === 'string') {
+    let a = dateRegx.exec(value);
+    if (a) {
+      return new Date(value);
+    }
+  }
+  return value;
+};
+
+function mkdirParent(dirPath) {
+  try {
+    this.fs.mkdirSync(dirPath);
+  } catch (e) {
+    if (e.errno === 34) {
+      mkdirParent(Path.dirname(dirPath));
+      mkdirParent(dirPath);
+    }
+  }
+}