From a43976110a1cafefbfddc4b172e6005e66249892 Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Fri, 24 Jun 2016 02:49:55 +0200 Subject: [PATCH] update structure --- dist/smartssh.classes.sshdir.d.ts | 4 +- dist/smartssh.classes.sshdir.js | 6 +-- dist/smartssh.classes.sshinstance.d.ts | 24 ++++++++-- dist/smartssh.classes.sshinstance.js | 58 ++++++++++++++++------- package.json | 6 +-- ts/smartssh.classes.sshdir.ts | 4 +- ts/smartssh.classes.sshinstance.ts | 65 ++++++++++++++++++-------- 7 files changed, 117 insertions(+), 50 deletions(-) diff --git a/dist/smartssh.classes.sshdir.d.ts b/dist/smartssh.classes.sshdir.d.ts index 131efb7..7902ad7 100644 --- a/dist/smartssh.classes.sshdir.d.ts +++ b/dist/smartssh.classes.sshdir.d.ts @@ -5,7 +5,7 @@ export declare class SshDir { path: string; sshInstance: SshInstance; constructor(sshInstanceArg: SshInstance, sshDirPathArg?: string); - syncToDir(): void; - syncFromDir(): void; + writeToDir(): void; + readFromDir(): void; getKeys(): SshKey[]; } diff --git a/dist/smartssh.classes.sshdir.js b/dist/smartssh.classes.sshdir.js index de6b5ee..2254763 100644 --- a/dist/smartssh.classes.sshdir.js +++ b/dist/smartssh.classes.sshdir.js @@ -13,10 +13,10 @@ var SshDir = (function () { } this.path = sshDirPath; } - SshDir.prototype.syncToDir = function () { + SshDir.prototype.writeToDir = function () { }; ; - SshDir.prototype.syncFromDir = function () { + SshDir.prototype.readFromDir = function () { }; SshDir.prototype.getKeys = function () { return helpers.sshKeyArrayFromDir(this.path); @@ -25,4 +25,4 @@ var SshDir = (function () { }()); exports.SshDir = SshDir; -//# sourceMappingURL=data:application/json;charset=utf8;base64,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 +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/dist/smartssh.classes.sshinstance.d.ts b/dist/smartssh.classes.sshinstance.d.ts index 4f72db2..989614f 100644 --- a/dist/smartssh.classes.sshinstance.d.ts +++ b/dist/smartssh.classes.sshinstance.d.ts @@ -1,10 +1,11 @@ import "typings-global"; +import { SshDir } from "./smartssh.classes.sshdir"; import { SshKey } from "./smartssh.classes.sshkey"; export declare class SshInstance { - private sshConfig; - private sshDir; + private _sshConfig; + sshDir: SshDir; protected sshKeyArray: SshKey[]; - private sshSync; + private _sshSync; constructor(optionsArg?: { sshDirPath?: string; sshSync?: boolean; @@ -14,5 +15,20 @@ export declare class SshInstance { replaceKey(sshKeyOldArg: SshKey, sshKeyNewArg: SshKey): void; getKey(hostArg: string): SshKey; sshKeys: SshKey[]; - sync(directionArg: string): void; + /** + * write SshInstance to disk + */ + writeToDisk(): void; + /** + * read ab SshInstance from disk + */ + readFromDisk(): void; + /** + * method to invoke SshInstance _sync automatically when sshSync is true + */ + private _syncAuto(directionArg); + /** + * private method to sync SshInstance + */ + private _sync(directionArg); } diff --git a/dist/smartssh.classes.sshinstance.js b/dist/smartssh.classes.sshinstance.js index e6cee42..2eec503 100644 --- a/dist/smartssh.classes.sshinstance.js +++ b/dist/smartssh.classes.sshinstance.js @@ -5,37 +5,37 @@ var SshInstance = (function () { function SshInstance(optionsArg) { if (optionsArg === void 0) { optionsArg = {}; } optionsArg ? void (0) : optionsArg = {}; - this.sshDir = new smartssh_classes_sshdir_1.SshDir(this, optionsArg.sshDirPath); this.sshKeyArray = []; - this.sshSync = optionsArg.sshSync; + this._sshSync = optionsArg.sshSync; + this.sshDir = new smartssh_classes_sshdir_1.SshDir(this, optionsArg.sshDirPath); } ; //altering methods SshInstance.prototype.addKey = function (sshKeyArg) { - this.sync("from"); + this._syncAuto("from"); this.sshKeyArray.push(sshKeyArg); - this.sync("to"); + this._syncAuto("to"); }; ; SshInstance.prototype.removeKey = function (sshKeyArg) { - this.sync("from"); + this._syncAuto("from"); var filteredArray = this.sshKeyArray.filter(function (sshKeyArg2) { return (sshKeyArg != sshKeyArg2); }); this.sshKeyArray = filteredArray; - this.sync("to"); + this._syncAuto("to"); }; ; SshInstance.prototype.replaceKey = function (sshKeyOldArg, sshKeyNewArg) { - this.sync("from"); + this._syncAuto("from"); this.removeKey(sshKeyOldArg); this.addKey(sshKeyNewArg); - this.sync("to"); + this._syncAuto("to"); }; ; // SshInstance.prototype.getKey = function (hostArg) { - this.sync("from"); + this._syncAuto("from"); var filteredArray = this.sshKeyArray.filter(function (keyArg) { return (keyArg.host == hostArg); }); @@ -49,20 +49,44 @@ var SshInstance = (function () { ; Object.defineProperty(SshInstance.prototype, "sshKeys", { get: function () { - this.sync("from"); + this._syncAuto("from"); return this.sshKeyArray; }, enumerable: true, configurable: true }); - SshInstance.prototype.sync = function (directionArg) { - if (this.sshSync && directionArg == "from") { - this.sshDir.syncFromDir(); // call sync method of sshDir class; + ; + //FS methods + /** + * write SshInstance to disk + */ + SshInstance.prototype.writeToDisk = function () { + this._sync("to"); + }; + /** + * read ab SshInstance from disk + */ + SshInstance.prototype.readFromDisk = function () { + this._sync("from"); + }; + /** + * method to invoke SshInstance _sync automatically when sshSync is true + */ + SshInstance.prototype._syncAuto = function (directionArg) { + if (this._sshSync) + this._sync(directionArg); + }; + /** + * private method to sync SshInstance + */ + SshInstance.prototype._sync = function (directionArg) { + if (directionArg == "from") { + this.sshDir.readFromDir(); // call sync method of sshDir class; } - else if (this.sshSync && directionArg == "to") { - this.sshDir.syncToDir(); + else if (directionArg == "to") { + this.sshDir.writeToDir(); } - else if (this.sshSync) { + else { throw new Error("directionArg not recognised. Must be 'to' or 'from'"); } }; @@ -71,4 +95,4 @@ var SshInstance = (function () { }()); exports.SshInstance = SshInstance; -//# sourceMappingURL=data:application/json;charset=utf8;base64,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 +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/package.json b/package.json index ab53c58..a168b01 100644 --- a/package.json +++ b/package.json @@ -23,11 +23,11 @@ }, "homepage": "https://gitlab.com/pushrocks/smartssh#readme", "dependencies": { - "beautylog": "^5.0.10", + "beautylog": "^5.0.12", "fs-extra": "^0.30.0", "js-base64": "^2.1.9", - "minimatch": "^3.0.0", - "smartfile": "^3.0.10", + "minimatch": "^3.0.2", + "smartfile": "^4.0.4", "smartpath": "^3.2.2", "typings-global": "^1.0.3", "typings-test": "^1.0.1" diff --git a/ts/smartssh.classes.sshdir.ts b/ts/smartssh.classes.sshdir.ts index 08aa83c..fefe4ef 100644 --- a/ts/smartssh.classes.sshdir.ts +++ b/ts/smartssh.classes.sshdir.ts @@ -16,10 +16,10 @@ export class SshDir { // sshDir class -> NOT EXPORTED, ONLY FOR INTERNAL USE } this.path = sshDirPath; } - syncToDir(){ // syncs sshInstance to directory + writeToDir(){ // syncs sshInstance to directory }; - syncFromDir(){ // syncs sshInstance from directory + readFromDir(){ // syncs sshInstance from directory } getKeys(){ diff --git a/ts/smartssh.classes.sshinstance.ts b/ts/smartssh.classes.sshinstance.ts index efba01a..9a56b53 100644 --- a/ts/smartssh.classes.sshinstance.ts +++ b/ts/smartssh.classes.sshinstance.ts @@ -7,41 +7,41 @@ import {SshConfig} from "./smartssh.classes.sshconfig"; import {SshKey} from "./smartssh.classes.sshkey"; export class SshInstance { - private sshConfig:SshConfig; // sshConfig (e.g. represents ~/.ssh/config) - private sshDir:SshDir; // points to sshDir class instance. + private _sshConfig:SshConfig; // sshConfig (e.g. represents ~/.ssh/config) + sshDir:SshDir; // points to sshDir class instance. protected sshKeyArray:SshKey[]; //holds all ssh keys - private sshSync:boolean; // if set to true, the ssh dir will be kept in sync automatically + private _sshSync:boolean; // if set to true, the ssh dir will be kept in sync automatically constructor(optionsArg:{sshDirPath?:string,sshSync?:boolean}={}){ optionsArg ? void(0) : optionsArg = {}; - this.sshDir = new SshDir(this,optionsArg.sshDirPath); this.sshKeyArray = []; - this.sshSync = optionsArg.sshSync; + this._sshSync = optionsArg.sshSync; + this.sshDir = new SshDir(this,optionsArg.sshDirPath); }; //altering methods addKey(sshKeyArg:SshKey){ - this.sync("from"); + this._syncAuto("from"); this.sshKeyArray.push(sshKeyArg); - this.sync("to"); + this._syncAuto("to"); }; removeKey(sshKeyArg:SshKey){ - this.sync("from"); + this._syncAuto("from"); let filteredArray = this.sshKeyArray.filter((sshKeyArg2:SshKey) => { return (sshKeyArg != sshKeyArg2); }); this.sshKeyArray = filteredArray; - this.sync("to"); + this._syncAuto("to"); }; replaceKey(sshKeyOldArg:SshKey,sshKeyNewArg:SshKey){ - this.sync("from"); + this._syncAuto("from"); this.removeKey(sshKeyOldArg); this.addKey(sshKeyNewArg); - this.sync("to"); + this._syncAuto("to"); }; // getKey(hostArg:string):SshKey{ - this.sync("from"); + this._syncAuto("from"); let filteredArray = this.sshKeyArray.filter(function(keyArg){ return (keyArg.host == hostArg); }); @@ -52,15 +52,42 @@ export class SshInstance { } }; get sshKeys():SshKey[] { - this.sync("from"); + this._syncAuto("from"); return this.sshKeyArray; + }; + + //FS methods + + /** + * write SshInstance to disk + */ + writeToDisk(){ + this._sync("to"); } - sync(directionArg:string){ - if(this.sshSync && directionArg == "from"){ - this.sshDir.syncFromDir(); // call sync method of sshDir class; - } else if(this.sshSync && directionArg == "to") { - this.sshDir.syncToDir(); - } else if(this.sshSync) { + + /** + * read ab SshInstance from disk + */ + readFromDisk(){ + this._sync("from"); + } + + /** + * method to invoke SshInstance _sync automatically when sshSync is true + */ + private _syncAuto(directionArg){ + if(this._sshSync) this._sync(directionArg); + } + + /** + * private method to sync SshInstance + */ + private _sync(directionArg:string){ + if(directionArg == "from"){ + this.sshDir.readFromDir(); // call sync method of sshDir class; + } else if(directionArg == "to") { + this.sshDir.writeToDir(); + } else { throw new Error("directionArg not recognised. Must be 'to' or 'from'"); } };