From 09d96fd94c86518d5fe4d1745d11d707e5429a7b Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Wed, 1 Jun 2016 03:57:17 +0200 Subject: [PATCH] update directory sync --- dist/smartssh.classes.sshdir.d.ts | 5 +- dist/smartssh.classes.sshdir.js | 6 +-- dist/smartssh.classes.sshinstance.d.ts | 10 ++-- dist/smartssh.classes.sshinstance.js | 64 ++++++++++++++++---------- test/test.js | 6 ++- test/test.ts | 4 +- ts/smartssh.classes.sshdir.ts | 5 +- ts/smartssh.classes.sshinstance.ts | 59 ++++++++++++++---------- 8 files changed, 96 insertions(+), 63 deletions(-) diff --git a/dist/smartssh.classes.sshdir.d.ts b/dist/smartssh.classes.sshdir.d.ts index 5a6b91a..131efb7 100644 --- a/dist/smartssh.classes.sshdir.d.ts +++ b/dist/smartssh.classes.sshdir.d.ts @@ -3,8 +3,9 @@ import { SshInstance } from "./smartssh.classes.sshinstance"; import { SshKey } from "./smartssh.classes.sshkey"; export declare class SshDir { path: string; - constructor(sshDirPathArg: string); - syncToDir(sshInstanceArg: SshInstance): void; + sshInstance: SshInstance; + constructor(sshInstanceArg: SshInstance, sshDirPathArg?: string); + syncToDir(): void; syncFromDir(): void; getKeys(): SshKey[]; } diff --git a/dist/smartssh.classes.sshdir.js b/dist/smartssh.classes.sshdir.js index 1a52fe1..d6f8933 100644 --- a/dist/smartssh.classes.sshdir.js +++ b/dist/smartssh.classes.sshdir.js @@ -3,7 +3,7 @@ require("typings-global"); var plugins = require("./smartssh.plugins"); var helpers = require("./smartssh.classes.helpers"); var SshDir = (function () { - function SshDir(sshDirPathArg) { + function SshDir(sshInstanceArg, sshDirPathArg) { var sshDirPath; if (sshDirPathArg) { sshDirPath = sshDirPathArg; @@ -13,7 +13,7 @@ var SshDir = (function () { } this.path = sshDirPath; } - SshDir.prototype.syncToDir = function (sshInstanceArg) { + SshDir.prototype.syncToDir = function () { }; ; SshDir.prototype.syncFromDir = function () { @@ -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 eb4b2d7..59f5f60 100644 --- a/dist/smartssh.classes.sshinstance.d.ts +++ b/dist/smartssh.classes.sshinstance.d.ts @@ -3,16 +3,16 @@ import { SshKey } from "./smartssh.classes.sshkey"; export declare class SshInstance { private sshConfig; private sshDir; - private sshKeys; + private sshKeysVar; private sshSync; constructor(optionsArg?: { - sshDir?: string; + sshDirPath?: string; sshSync?: boolean; }); addKey(sshKeyArg: SshKey): void; - getKey(hostArg: string): SshKey; - getKeys(): SshKey[]; removeKey(sshKeyArg: SshKey): void; replaceKey(sshKeyOldArg: SshKey, sshKeyNewArg: SshKey): void; - sync(): void; + getKey(hostArg: string): SshKey; + sshKeys: SshKey[]; + sync(directionArg: string): void; } diff --git a/dist/smartssh.classes.sshinstance.js b/dist/smartssh.classes.sshinstance.js index 2c2a8e0..28d3593 100644 --- a/dist/smartssh.classes.sshinstance.js +++ b/dist/smartssh.classes.sshinstance.js @@ -6,18 +6,36 @@ var SshInstance = (function () { function SshInstance(optionsArg) { if (optionsArg === void 0) { optionsArg = {}; } optionsArg ? void (0) : optionsArg = {}; - this.sshDir = new smartssh_classes_sshdir_1.SshDir(optionsArg.sshDir); - this.sshKeys = this.sshDir.getKeys(); + this.sshDir = new smartssh_classes_sshdir_1.SshDir(this, optionsArg.sshDirPath); + this.sshKeysVar = this.sshDir.getKeys(); this.sshSync = optionsArg.sshSync; } ; + //altering methods SshInstance.prototype.addKey = function (sshKeyArg) { - this.sshKeys.push(sshKeyArg); - this.sync(); + this.sync("from"); + this.sshKeysVar.push(sshKeyArg); + this.sync("to"); }; ; + SshInstance.prototype.removeKey = function (sshKeyArg) { + this.sync("from"); + var keyIndex = helpers.getKeyIndex(sshKeyArg.host); + this.sshKeysVar.splice(keyIndex, 1); + this.sync("to"); + }; + ; + SshInstance.prototype.replaceKey = function (sshKeyOldArg, sshKeyNewArg) { + this.sync("from"); + var keyIndex = helpers.getKeyIndex(sshKeyOldArg.host); + this.sshKeysVar.splice(keyIndex, 1, sshKeyNewArg); + this.sync("to"); + }; + ; + // SshInstance.prototype.getKey = function (hostArg) { - var filteredArray = this.sshKeys.filter(function (keyArg) { + this.sync("from"); + var filteredArray = this.sshKeysVar.filter(function (keyArg) { return (keyArg.host == hostArg); }); if (filteredArray.length > 0) { @@ -28,24 +46,22 @@ var SshInstance = (function () { } }; ; - SshInstance.prototype.getKeys = function () { - return this.sshKeys; - }; - SshInstance.prototype.removeKey = function (sshKeyArg) { - var keyIndex = helpers.getKeyIndex(sshKeyArg.host); - this.sshKeys.splice(keyIndex, 1); - this.sync(); - }; - ; - SshInstance.prototype.replaceKey = function (sshKeyOldArg, sshKeyNewArg) { - var keyIndex = helpers.getKeyIndex(sshKeyOldArg.host); - this.sshKeys.splice(keyIndex, 1, sshKeyNewArg); - this.sync(); - }; - ; - SshInstance.prototype.sync = function () { - if (this.sshSync) { - this.sshDir.sync(this.sshConfig, this.sshKeys); // call sync method of sshDir class; + Object.defineProperty(SshInstance.prototype, "sshKeys", { + get: function () { + return this.sshKeysVar; + }, + enumerable: true, + configurable: true + }); + SshInstance.prototype.sync = function (directionArg) { + if (this.sshSync && directionArg == "to") { + this.sshDir.syncToDir(); // call sync method of sshDir class; + } + else if (this.sshSync && directionArg == "from") { + this.sshDir.syncFromDir(); + } + else { + throw new Error("directionArg not recognised. Must be 'to' or 'from'"); } }; ; @@ -53,4 +69,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/test/test.js b/test/test.js index 24d91d9..9070e0f 100644 --- a/test/test.js +++ b/test/test.js @@ -28,9 +28,11 @@ describe("smartssh", function () { })); }); it("should return an array of sshKeys", function () { - testSshInstance.getKeys(); + var sshKeyArray = testSshInstance.sshKeys; + sshKeyArray.should.be.Array(); + sshKeyArray[0].host.should.equal("gitlab.com"); }); }); }); -//# 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/test/test.ts b/test/test.ts index fc2b99c..9a522cf 100644 --- a/test/test.ts +++ b/test/test.ts @@ -27,7 +27,9 @@ describe("smartssh",function(){ })); }); it("should return an array of sshKeys",function(){ - testSshInstance.getKeys(); + let sshKeyArray = testSshInstance.sshKeys; + sshKeyArray.should.be.Array(); + sshKeyArray[0].host.should.equal("gitlab.com"); }); }) }) \ No newline at end of file diff --git a/ts/smartssh.classes.sshdir.ts b/ts/smartssh.classes.sshdir.ts index e519dbd..6b0e762 100644 --- a/ts/smartssh.classes.sshdir.ts +++ b/ts/smartssh.classes.sshdir.ts @@ -6,7 +6,8 @@ import {SshKey} from "./smartssh.classes.sshkey"; import {SshConfig} from "./smartssh.classes.sshconfig"; export class SshDir { // sshDir class -> NOT EXPORTED, ONLY FOR INTERNAL USE path:string; // the path of the ssh directory - constructor(sshDirPathArg:string){ + sshInstance:SshInstance; + constructor(sshInstanceArg:SshInstance,sshDirPathArg?:string){ let sshDirPath:string; if(sshDirPathArg){ sshDirPath = sshDirPathArg; @@ -15,7 +16,7 @@ export class SshDir { // sshDir class -> NOT EXPORTED, ONLY FOR INTERNAL USE } this.path = sshDirPath; } - syncToDir(sshInstanceArg:SshInstance){ //syncs + syncToDir(){ //syncs }; syncFromDir(){ diff --git a/ts/smartssh.classes.sshinstance.ts b/ts/smartssh.classes.sshinstance.ts index 0d37b64..dfb6dbf 100644 --- a/ts/smartssh.classes.sshinstance.ts +++ b/ts/smartssh.classes.sshinstance.ts @@ -9,20 +9,39 @@ 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 sshKeys:SshKey[]; //holds all ssh keys + private sshKeyArray:SshKey[]; //holds all ssh keys private sshSync:boolean; // if set to true, the ssh dir will be kept in sync automatically - constructor(optionsArg:{sshDir?:string,sshSync?:boolean}={}){ + constructor(optionsArg:{sshDirPath?:string,sshSync?:boolean}={}){ optionsArg ? void(0) : optionsArg = {}; - this.sshDir = new SshDir(optionsArg.sshDir); - this.sshKeys = this.sshDir.getKeys(); + + this.sshDir = new SshDir(this,optionsArg.sshDirPath); + this.sshKeyArray = this.sshDir.getKeys(); this.sshSync = optionsArg.sshSync; }; + + //altering methods addKey(sshKeyArg:SshKey){ - this.sshKeys.push(sshKeyArg); - this.sync(); + this.sync("from"); + this.sshKeyArray.push(sshKeyArg); + this.sync("to"); }; + removeKey(sshKeyArg:SshKey){ + this.sync("from"); + let keyIndex = helpers.getKeyIndex(sshKeyArg.host); + this.sshKeyArray.splice(keyIndex,1); + this.sync("to"); + }; + replaceKey(sshKeyOldArg:SshKey,sshKeyNewArg:SshKey){ + this.sync("from"); + let keyIndex = helpers.getKeyIndex(sshKeyOldArg.host); + this.sshKeyArray.splice(keyIndex,1,sshKeyNewArg); + this.sync("to"); + }; + + // getKey(hostArg:string){ - let filteredArray = this.sshKeys.filter(function(keyArg){ + this.sync("from"); + let filteredArray = this.sshKeyArray.filter(function(keyArg){ return (keyArg.host == hostArg); }); if(filteredArray.length > 0){ @@ -31,24 +50,16 @@ export class SshInstance { return undefined; } }; - - getKeys(){ - return this.sshKeys; + get sshKeys():SshKey[] { + return this.sshKeyArray; } - - removeKey(sshKeyArg:SshKey){ - let keyIndex = helpers.getKeyIndex(sshKeyArg.host); - this.sshKeys.splice(keyIndex,1); - this.sync(); - }; - replaceKey(sshKeyOldArg:SshKey,sshKeyNewArg:SshKey){ - let keyIndex = helpers.getKeyIndex(sshKeyOldArg.host); - this.sshKeys.splice(keyIndex,1,sshKeyNewArg); - this.sync(); - }; - sync(){ - if(this.sshSync){ - this.sshDir.sync(this.sshConfig,this.sshKeys); // call sync method of sshDir class; + 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 { + throw new Error("directionArg not recognised. Must be 'to' or 'from'"); } }; }