From 27237f14c75b0df854ab04a606c925e53463365b Mon Sep 17 00:00:00 2001 From: PhilKunz Date: Wed, 23 Nov 2016 12:38:38 +0100 Subject: [PATCH] update to latest standards --- .gitignore | 9 +- .gitlab-ci.yml | 41 ++++-- README.md | 2 + dist/index.d.ts | 10 +- dist/index.js | 3 +- dist/smartssh.classes.helpers.d.ts | 4 +- dist/smartssh.classes.helpers.js | 5 +- dist/smartssh.classes.sshconfig.d.ts | 9 +- dist/smartssh.classes.sshconfig.js | 52 ++++---- dist/smartssh.classes.sshdir.d.ts | 6 +- dist/smartssh.classes.sshdir.js | 38 +++--- dist/smartssh.classes.sshinstance.d.ts | 6 +- dist/smartssh.classes.sshinstance.js | 95 +++++++------- dist/smartssh.classes.sshkey.d.ts | 5 +- dist/smartssh.classes.sshkey.js | 169 ++++++++++--------------- dist/smartssh.plugins.d.ts | 21 +-- dist/smartssh.plugins.js | 30 +++-- package.json | 28 ++-- test/test.d.ts | 3 +- test/test.js | 93 +++++++------- test/test.ts | 138 ++++++++++---------- ts/index.ts | 12 +- ts/smartssh.classes.helpers.ts | 14 +- ts/smartssh.classes.sshconfig.ts | 66 +++++----- ts/smartssh.classes.sshdir.ts | 58 ++++----- ts/smartssh.classes.sshinstance.ts | 136 ++++++++++---------- ts/smartssh.classes.sshkey.ts | 111 ++++++++-------- ts/smartssh.plugins.ts | 32 +++-- tslint.json | 3 + 29 files changed, 606 insertions(+), 593 deletions(-) create mode 100644 tslint.json diff --git a/.gitignore b/.gitignore index a589969..d212640 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,5 @@ -.idea/ node_modules/ coverage/ -docs/ -ts/typings/ -ts/*.js -ts/*.js.map -test/temp/ \ No newline at end of file +pages/ +public/ +test/temp/ diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e663acf..f2d2ff7 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -3,7 +3,16 @@ image: hosttoday/ht-docker-node:npmts stages: - test - release -- page +- trigger +- pages + +testLEGACY: + stage: test + script: + - npmci test legacy + tags: + - docker + allow_failure: true testLTS: stage: test @@ -11,7 +20,6 @@ testLTS: - npmci test lts tags: - docker - - lossless testSTABLE: stage: test @@ -19,13 +27,6 @@ testSTABLE: - npmci test stable tags: - docker - - lossless - -testLEGACY: - stage: test - script: - - npmci test legacy - allow_failure: true release: stage: release @@ -35,4 +36,24 @@ release: - tags tags: - docker - - lossless + +trigger: + stage: trigger + script: + - npmci trigger + only: + - tags + tags: + - docker + +pages: + image: hosttoday/ht-docker-node:npmpage + stage: pages + script: + - npmci command npmpage --host gitlab + only: + - tags + artifacts: + expire_in: 1 week + paths: + - public diff --git a/README.md b/README.md index ed8ca05..de9cb2b 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,8 @@ setups SSH quickly and in a painless manner > Attention: This is still alpha, so some things won't work, not all things are inplemented. + + ## Usage ```javascript diff --git a/dist/index.d.ts b/dist/index.d.ts index 915e183..4f97b05 100644 --- a/dist/index.d.ts +++ b/dist/index.d.ts @@ -1,5 +1,5 @@ -import "typings-global"; -export { SshInstance } from "./smartssh.classes.sshinstance"; -export { SshKey } from "./smartssh.classes.sshkey"; -export { SshDir } from "./smartssh.classes.sshdir"; -export { SshConfig } from "./smartssh.classes.sshconfig"; +import 'typings-global'; +export { SshInstance } from './smartssh.classes.sshinstance'; +export { SshKey } from './smartssh.classes.sshkey'; +export { SshDir } from './smartssh.classes.sshdir'; +export { SshConfig } from './smartssh.classes.sshconfig'; diff --git a/dist/index.js b/dist/index.js index 0962dcd..44c1d17 100644 --- a/dist/index.js +++ b/dist/index.js @@ -8,5 +8,4 @@ var smartssh_classes_sshdir_1 = require("./smartssh.classes.sshdir"); exports.SshDir = smartssh_classes_sshdir_1.SshDir; var smartssh_classes_sshconfig_1 = require("./smartssh.classes.sshconfig"); exports.SshConfig = smartssh_classes_sshconfig_1.SshConfig; - -//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxRQUFPLGdCQUNQLENBQUMsQ0FEc0I7QUFHdkIsNkNBQTBCLGdDQUFnQyxDQUFDO0FBQW5ELGlFQUFtRDtBQUMzRCx3Q0FBcUIsMkJBQTJCLENBQUM7QUFBekMsa0RBQXlDO0FBQ2pELHdDQUFxQiwyQkFBMkIsQ0FBQztBQUF6QyxrREFBeUM7QUFDakQsMkNBQXdCLDhCQUE4QixDQUFDO0FBQS9DLDJEQUErQyIsImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBcInR5cGluZ3MtZ2xvYmFsXCJcbmltcG9ydCAqIGFzIHBsdWdpbnMgZnJvbSBcIi4vc21hcnRzc2gucGx1Z2luc1wiO1xuXG5leHBvcnQge1NzaEluc3RhbmNlfSBmcm9tIFwiLi9zbWFydHNzaC5jbGFzc2VzLnNzaGluc3RhbmNlXCI7XG5leHBvcnQge1NzaEtleX0gZnJvbSBcIi4vc21hcnRzc2guY2xhc3Nlcy5zc2hrZXlcIjtcbmV4cG9ydCB7U3NoRGlyfSBmcm9tIFwiLi9zbWFydHNzaC5jbGFzc2VzLnNzaGRpclwiO1xuZXhwb3J0IHtTc2hDb25maWd9IGZyb20gXCIuL3NtYXJ0c3NoLmNsYXNzZXMuc3NoY29uZmlnXCI7Il19 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBR3ZCLCtFQUEwRDtBQUFsRCxxREFBQSxXQUFXLENBQUE7QUFDbkIscUVBQWdEO0FBQXhDLDJDQUFBLE1BQU0sQ0FBQTtBQUNkLHFFQUFnRDtBQUF4QywyQ0FBQSxNQUFNLENBQUE7QUFDZCwyRUFBc0Q7QUFBOUMsaURBQUEsU0FBUyxDQUFBIn0= \ No newline at end of file diff --git a/dist/smartssh.classes.helpers.d.ts b/dist/smartssh.classes.helpers.d.ts index b76f0c3..f415cfa 100644 --- a/dist/smartssh.classes.helpers.d.ts +++ b/dist/smartssh.classes.helpers.d.ts @@ -1,3 +1,3 @@ -import "typings-global"; -import { SshKey } from "./smartssh.classes.sshkey"; +import 'typings-global'; +import { SshKey } from './smartssh.classes.sshkey'; export declare let sshKeyArrayFromDir: (dirArg: string) => SshKey[]; diff --git a/dist/smartssh.classes.helpers.js b/dist/smartssh.classes.helpers.js index 35a5ddc..f429133 100644 --- a/dist/smartssh.classes.helpers.js +++ b/dist/smartssh.classes.helpers.js @@ -1,8 +1,7 @@ "use strict"; require("typings-global"); exports.sshKeyArrayFromDir = function (dirArg) { - var sshKeyArray = []; //TODO + let sshKeyArray = []; // TODO return sshKeyArray; }; - -//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNtYXJ0c3NoLmNsYXNzZXMuaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsUUFBTyxnQkFDUCxDQUFDLENBRHNCO0FBSVosMEJBQWtCLEdBQUcsVUFBUyxNQUFhO0lBQ2xELElBQUksV0FBVyxHQUFHLEVBQUUsQ0FBQyxDQUFDLE1BQU07SUFDNUIsTUFBTSxDQUFDLFdBQVcsQ0FBQztBQUN2QixDQUFDLENBQUEiLCJmaWxlIjoic21hcnRzc2guY2xhc3Nlcy5oZWxwZXJzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFwidHlwaW5ncy1nbG9iYWxcIlxuaW1wb3J0ICogYXMgcGx1Z2lucyBmcm9tIFwiLi9zbWFydHNzaC5wbHVnaW5zXCI7XG5pbXBvcnQge1NzaEtleX0gZnJvbSBcIi4vc21hcnRzc2guY2xhc3Nlcy5zc2hrZXlcIjtcblxuZXhwb3J0IGxldCBzc2hLZXlBcnJheUZyb21EaXIgPSBmdW5jdGlvbihkaXJBcmc6c3RyaW5nKTpTc2hLZXlbXXtcbiAgICBsZXQgc3NoS2V5QXJyYXkgPSBbXTsgLy9UT0RPXG4gICAgcmV0dXJuIHNzaEtleUFycmF5O1xufSJdfQ== +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzc2guY2xhc3Nlcy5oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzc2guY2xhc3Nlcy5oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwwQkFBdUI7QUFJWixRQUFBLGtCQUFrQixHQUFHLFVBQVMsTUFBYztJQUNuRCxJQUFJLFdBQVcsR0FBRyxFQUFFLENBQUEsQ0FBQyxPQUFPO0lBQzVCLE1BQU0sQ0FBQyxXQUFXLENBQUE7QUFDdEIsQ0FBQyxDQUFBIn0= \ No newline at end of file diff --git a/dist/smartssh.classes.sshconfig.d.ts b/dist/smartssh.classes.sshconfig.d.ts index 656bde6..ec01f78 100644 --- a/dist/smartssh.classes.sshconfig.d.ts +++ b/dist/smartssh.classes.sshconfig.d.ts @@ -1,13 +1,14 @@ -import "typings-global"; -import { SshKey } from "./smartssh.classes.sshkey"; +/// +import 'typings-global'; +import { SshKey } from './smartssh.classes.sshkey'; export declare class SshConfig { private _sshKeyArray; constructor(sshKeyArrayArg: SshKey[]); /** * stores a config file */ - store(dirPathArg: string): any; - read(dirPathArg: any): any; + store(dirPathArg: string): Q.Promise<{}>; + read(dirPathArg: any): Q.Promise<{}>; } export interface configObject { configString: string; diff --git a/dist/smartssh.classes.sshconfig.js b/dist/smartssh.classes.sshconfig.js index f3e105b..87170fe 100644 --- a/dist/smartssh.classes.sshconfig.js +++ b/dist/smartssh.classes.sshconfig.js @@ -1,24 +1,24 @@ "use strict"; require("typings-global"); -var plugins = require("./smartssh.plugins"); -var SshConfig = (function () { - function SshConfig(sshKeyArrayArg) { +const plugins = require("./smartssh.plugins"); +class SshConfig { + constructor(sshKeyArrayArg) { this._sshKeyArray = sshKeyArrayArg; } /** * stores a config file */ - SshConfig.prototype.store = function (dirPathArg) { - var done = plugins.q.defer(); - var configArray = []; - var configString; - for (var key in this._sshKeyArray) { - var sshKey = this._sshKeyArray[key]; + store(dirPathArg) { + let done = plugins.q.defer(); + let configArray = []; + let configString; + for (let key in this._sshKeyArray) { + let sshKey = this._sshKeyArray[key]; if (sshKey.host) { - configString = "Host " + sshKey.host + "\n" + - " HostName " + sshKey.host + "\n" + - " IdentityFile ~/.ssh/" + sshKey.host + "\n" + - " StrictHostKeyChecking no" + "\n"; + configString = 'Host ' + sshKey.host + '\n' + + ' HostName ' + sshKey.host + '\n' + + ' IdentityFile ~/.ssh/' + sshKey.host + '\n' + + ' StrictHostKeyChecking no' + '\n'; } configArray.push({ configString: configString, @@ -26,24 +26,22 @@ var SshConfig = (function () { sshKey: sshKey }); } - var configFile = ""; - for (var key in configArray) { - configFile = configFile + configArray[key].configString + "\n"; + let configFile = ''; + for (let key in configArray) { + configFile = configFile + configArray[key].configString + '\n'; } ; - plugins.smartfile.memory.toFsSync(configFile, plugins.path.join(dirPathArg, "config")); + plugins.smartfile.memory.toFsSync(configFile, plugins.path.join(dirPathArg, 'config')); return done.promise; - }; - SshConfig.prototype.read = function (dirPathArg) { - var done = plugins.q.defer(); - var configArray; - plugins.smartfile.fs.toStringSync(plugins.path.join(dirPathArg, "config")); + } + read(dirPathArg) { + let done = plugins.q.defer(); + let configArray; + plugins.smartfile.fs.toStringSync(plugins.path.join(dirPathArg, 'config')); return done.promise; - }; - return SshConfig; -}()); + } +} exports.SshConfig = SshConfig; ; ; - -//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNtYXJ0c3NoLmNsYXNzZXMuc3NoY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxRQUFPLGdCQUFnQixDQUFDLENBQUE7QUFDeEIsSUFBWSxPQUFPLFdBQU0sb0JBQW9CLENBQUMsQ0FBQTtBQUk5QztJQUVJLG1CQUFZLGNBQXVCO1FBQy9CLElBQUksQ0FBQyxZQUFZLEdBQUcsY0FBYyxDQUFDO0lBQ3ZDLENBQUM7SUFFRDs7T0FFRztJQUNILHlCQUFLLEdBQUwsVUFBTSxVQUFpQjtRQUNuQixJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzdCLElBQUksV0FBVyxHQUFrQixFQUFFLENBQUM7UUFDcEMsSUFBSSxZQUFZLENBQUM7UUFDakIsR0FBRyxDQUFBLENBQUMsSUFBSSxHQUFHLElBQUksSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFBLENBQUM7WUFDOUIsSUFBSSxNQUFNLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNwQyxFQUFFLENBQUEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUEsQ0FBQztnQkFDWixZQUFZLEdBQUcsT0FBTyxHQUFHLE1BQU0sQ0FBQyxJQUFJLEdBQUcsSUFBSTtvQkFDeEIsYUFBYSxHQUFHLE1BQU0sQ0FBQyxJQUFJLEdBQUcsSUFBSTtvQkFDbEMsd0JBQXdCLEdBQUcsTUFBTSxDQUFDLElBQUksR0FBRyxJQUFJO29CQUM3Qyw0QkFBNEIsR0FBRyxJQUFJLENBQUE7WUFDMUQsQ0FBQztZQUNELFdBQVcsQ0FBQyxJQUFJLENBQUM7Z0JBQ2IsWUFBWSxFQUFDLFlBQVk7Z0JBQ3pCLFVBQVUsRUFBRSxNQUFNLENBQUMsVUFBVTtnQkFDN0IsTUFBTSxFQUFFLE1BQU07YUFDakIsQ0FBQyxDQUFDO1FBQ1AsQ0FBQztRQUNELElBQUksVUFBVSxHQUFVLEVBQUUsQ0FBQztRQUMzQixHQUFHLENBQUEsQ0FBQyxJQUFJLEdBQUcsSUFBSSxXQUFXLENBQUMsQ0FBQSxDQUFDO1lBQ3hCLFVBQVUsR0FBRyxVQUFVLEdBQUcsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7UUFDbkUsQ0FBQztRQUFBLENBQUM7UUFDRixPQUFPLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1FBQ3JGLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3hCLENBQUM7SUFDRCx3QkFBSSxHQUFKLFVBQUssVUFBVTtRQUNYLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDN0IsSUFBSSxXQUEwQixDQUFDO1FBQy9CLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUUxRSxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN4QixDQUFDO0lBQ0wsZ0JBQUM7QUFBRCxDQXpDQSxBQXlDQyxJQUFBO0FBekNZLGlCQUFTLFlBeUNyQixDQUFBO0FBQUEsQ0FBQztBQU1ELENBQUMiLCJmaWxlIjoic21hcnRzc2guY2xhc3Nlcy5zc2hjb25maWcuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgXCJ0eXBpbmdzLWdsb2JhbFwiO1xuaW1wb3J0ICogYXMgcGx1Z2lucyBmcm9tIFwiLi9zbWFydHNzaC5wbHVnaW5zXCI7XG5pbXBvcnQgKiBhcyBoZWxwZXJzIGZyb20gXCIuL3NtYXJ0c3NoLmNsYXNzZXMuaGVscGVyc1wiO1xuaW1wb3J0IHtTc2hLZXl9IGZyb20gXCIuL3NtYXJ0c3NoLmNsYXNzZXMuc3Noa2V5XCJcblxuZXhwb3J0IGNsYXNzIFNzaENvbmZpZyB7XG4gICAgcHJpdmF0ZSBfc3NoS2V5QXJyYXk6U3NoS2V5W107XG4gICAgY29uc3RydWN0b3Ioc3NoS2V5QXJyYXlBcmc6U3NoS2V5W10pe1xuICAgICAgICB0aGlzLl9zc2hLZXlBcnJheSA9IHNzaEtleUFycmF5QXJnO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIHN0b3JlcyBhIGNvbmZpZyBmaWxlXG4gICAgICovXG4gICAgc3RvcmUoZGlyUGF0aEFyZzpzdHJpbmcpe1xuICAgICAgICBsZXQgZG9uZSA9IHBsdWdpbnMucS5kZWZlcigpO1xuICAgICAgICBsZXQgY29uZmlnQXJyYXk6Y29uZmlnT2JqZWN0W10gPSBbXTtcbiAgICAgICAgbGV0IGNvbmZpZ1N0cmluZztcbiAgICAgICAgZm9yKGxldCBrZXkgaW4gdGhpcy5fc3NoS2V5QXJyYXkpe1xuICAgICAgICAgICAgbGV0IHNzaEtleSA9IHRoaXMuX3NzaEtleUFycmF5W2tleV07XG4gICAgICAgICAgICBpZihzc2hLZXkuaG9zdCl7XG4gICAgICAgICAgICAgICAgY29uZmlnU3RyaW5nID0gXCJIb3N0IFwiICsgc3NoS2V5Lmhvc3QgKyBcIlxcblwiICtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXCIgIEhvc3ROYW1lIFwiICsgc3NoS2V5Lmhvc3QgKyBcIlxcblwiICtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXCIgIElkZW50aXR5RmlsZSB+Ly5zc2gvXCIgKyBzc2hLZXkuaG9zdCArIFwiXFxuXCIgK1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcIiAgU3RyaWN0SG9zdEtleUNoZWNraW5nIG5vXCIgKyBcIlxcblwiXG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBjb25maWdBcnJheS5wdXNoKHtcbiAgICAgICAgICAgICAgICBjb25maWdTdHJpbmc6Y29uZmlnU3RyaW5nLFxuICAgICAgICAgICAgICAgIGF1dGhvcml6ZWQ6IHNzaEtleS5hdXRob3JpemVkLFxuICAgICAgICAgICAgICAgIHNzaEtleTogc3NoS2V5XG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfVxuICAgICAgICBsZXQgY29uZmlnRmlsZTpzdHJpbmcgPSBcIlwiO1xuICAgICAgICBmb3IobGV0IGtleSBpbiBjb25maWdBcnJheSl7XG4gICAgICAgICAgICBjb25maWdGaWxlID0gY29uZmlnRmlsZSArIGNvbmZpZ0FycmF5W2tleV0uY29uZmlnU3RyaW5nICsgXCJcXG5cIjtcbiAgICAgICAgfTtcbiAgICAgICAgcGx1Z2lucy5zbWFydGZpbGUubWVtb3J5LnRvRnNTeW5jKGNvbmZpZ0ZpbGUscGx1Z2lucy5wYXRoLmpvaW4oZGlyUGF0aEFyZyxcImNvbmZpZ1wiKSk7XG4gICAgICAgIHJldHVybiBkb25lLnByb21pc2U7XG4gICAgfVxuICAgIHJlYWQoZGlyUGF0aEFyZyl7XG4gICAgICAgIGxldCBkb25lID0gcGx1Z2lucy5xLmRlZmVyKCk7XG4gICAgICAgIGxldCBjb25maWdBcnJheTpjb25maWdPYmplY3RbXTtcbiAgICAgICAgcGx1Z2lucy5zbWFydGZpbGUuZnMudG9TdHJpbmdTeW5jKHBsdWdpbnMucGF0aC5qb2luKGRpclBhdGhBcmcsXCJjb25maWdcIikpO1xuXG4gICAgICAgIHJldHVybiBkb25lLnByb21pc2U7XG4gICAgfVxufTtcblxuZXhwb3J0IGludGVyZmFjZSBjb25maWdPYmplY3Qge1xuICAgIGNvbmZpZ1N0cmluZzpzdHJpbmc7XG4gICAgYXV0aG9yaXplZDpib29sZWFuO1xuICAgIHNzaEtleTpTc2hLZXk7XG59O1xuXG4iXX0= +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzc2guY2xhc3Nlcy5zc2hjb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHNzaC5jbGFzc2VzLnNzaGNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLDhDQUE2QztBQUk3QztJQUVJLFlBQVksY0FBd0I7UUFDaEMsSUFBSSxDQUFDLFlBQVksR0FBRyxjQUFjLENBQUE7SUFDdEMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSyxDQUFDLFVBQWtCO1FBQ3BCLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDNUIsSUFBSSxXQUFXLEdBQW1CLEVBQUUsQ0FBQTtRQUNwQyxJQUFJLFlBQVksQ0FBQTtRQUNoQixHQUFHLENBQUMsQ0FBQyxJQUFJLEdBQUcsSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQztZQUNoQyxJQUFJLE1BQU0sR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ25DLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUNkLFlBQVksR0FBRyxPQUFPLEdBQUcsTUFBTSxDQUFDLElBQUksR0FBRyxJQUFJO29CQUN4QixhQUFhLEdBQUcsTUFBTSxDQUFDLElBQUksR0FBRyxJQUFJO29CQUNsQyx3QkFBd0IsR0FBRyxNQUFNLENBQUMsSUFBSSxHQUFHLElBQUk7b0JBQzdDLDRCQUE0QixHQUFHLElBQUksQ0FBQTtZQUMxRCxDQUFDO1lBQ0QsV0FBVyxDQUFDLElBQUksQ0FBQztnQkFDYixZQUFZLEVBQUUsWUFBWTtnQkFDMUIsVUFBVSxFQUFFLE1BQU0sQ0FBQyxVQUFVO2dCQUM3QixNQUFNLEVBQUUsTUFBTTthQUNqQixDQUFDLENBQUE7UUFDTixDQUFDO1FBQ0QsSUFBSSxVQUFVLEdBQVcsRUFBRSxDQUFBO1FBQzNCLEdBQUcsQ0FBQyxDQUFDLElBQUksR0FBRyxJQUFJLFdBQVcsQ0FBQyxDQUFDLENBQUM7WUFDMUIsVUFBVSxHQUFHLFVBQVUsR0FBRyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQTtRQUNsRSxDQUFDO1FBQUEsQ0FBQztRQUNGLE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUE7UUFDcEYsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUE7SUFDdkIsQ0FBQztJQUNELElBQUksQ0FBQyxVQUFVO1FBQ1gsSUFBSSxJQUFJLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtRQUM1QixJQUFJLFdBQTJCLENBQUE7UUFDL0IsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBQyxRQUFRLENBQUMsQ0FBQyxDQUFBO1FBRXpFLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFBO0lBQ3ZCLENBQUM7Q0FDSjtBQXpDRCw4QkF5Q0M7QUFBQSxDQUFDO0FBTUQsQ0FBQyJ9 \ No newline at end of file diff --git a/dist/smartssh.classes.sshdir.d.ts b/dist/smartssh.classes.sshdir.d.ts index a1b4902..4a48fec 100644 --- a/dist/smartssh.classes.sshdir.d.ts +++ b/dist/smartssh.classes.sshdir.d.ts @@ -1,6 +1,6 @@ -import "typings-global"; -import { SshKey } from "./smartssh.classes.sshkey"; -import { SshConfig } from "./smartssh.classes.sshconfig"; +import 'typings-global'; +import { SshKey } from './smartssh.classes.sshkey'; +import { SshConfig } from './smartssh.classes.sshconfig'; export declare class SshDir { private _path; private _sshKeyArray; diff --git a/dist/smartssh.classes.sshdir.js b/dist/smartssh.classes.sshdir.js index 7bb2768..b481273 100644 --- a/dist/smartssh.classes.sshdir.js +++ b/dist/smartssh.classes.sshdir.js @@ -1,43 +1,41 @@ "use strict"; require("typings-global"); -var plugins = require("./smartssh.plugins"); -var helpers = require("./smartssh.classes.helpers"); -var SshDir = (function () { - function SshDir(sshKeyArray, sshConfig, sshDirPathArg) { +const plugins = require("./smartssh.plugins"); +const helpers = require("./smartssh.classes.helpers"); +class SshDir { + constructor(sshKeyArray, sshConfig, sshDirPathArg) { this._sshKeyArray = sshKeyArray; this._sshConfig = sshConfig; if (sshDirPathArg) { this._path = sshDirPathArg; } else { - this._path = plugins.path.join(plugins.smartpath.get.home(), ".ssh/"); + this._path = plugins.path.join(plugins.smartpath.get.home(), '.ssh/'); } ; } - SshDir.prototype.writeToDir = function (dirPathArg) { - var path = this._path; + writeToDir(dirPathArg) { + let path = this._path; if (dirPathArg) path = dirPathArg; - this._sshKeyArray.forEach(function (sshKeyArg) { + this._sshKeyArray.forEach((sshKeyArg) => { sshKeyArg.store(path); }); this._sshConfig.store(path); - }; + } ; - SshDir.prototype.readFromDir = function (dirPathArg) { - var path = this._path; + readFromDir(dirPathArg) { + let path = this._path; if (dirPathArg) path = dirPathArg; - }; - SshDir.prototype.updateDirPath = function (dirPathArg) { + } + updateDirPath(dirPathArg) { this._path = dirPathArg; - }; + } ; - SshDir.prototype.getKeys = function () { + getKeys() { return helpers.sshKeyArrayFromDir(this._path); - }; - return SshDir; -}()); + } +} exports.SshDir = SshDir; - -//# sourceMappingURL=data:application/json;charset=utf8;base64,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 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzc2guY2xhc3Nlcy5zc2hkaXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHNzaC5jbGFzc2VzLnNzaGRpci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLDhDQUE2QztBQUM3QyxzREFBcUQ7QUFJckQ7SUFJSSxZQUFZLFdBQXFCLEVBQUMsU0FBb0IsRUFBQyxhQUFzQjtRQUN6RSxJQUFJLENBQUMsWUFBWSxHQUFHLFdBQVcsQ0FBQTtRQUMvQixJQUFJLENBQUMsVUFBVSxHQUFHLFNBQVMsQ0FBQTtRQUMzQixFQUFFLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO1lBQ2hCLElBQUksQ0FBQyxLQUFLLEdBQUcsYUFBYSxDQUFBO1FBQzlCLENBQUM7UUFBQyxJQUFJLENBQUMsQ0FBQztZQUNKLElBQUksQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLEVBQUMsT0FBTyxDQUFDLENBQUE7UUFDeEUsQ0FBQztRQUFBLENBQUM7SUFDTixDQUFDO0lBQ0QsVUFBVSxDQUFDLFVBQW1CO1FBQzFCLElBQUksSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUE7UUFDckIsRUFBRSxDQUFDLENBQUMsVUFBVSxDQUFDO1lBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQTtRQUNqQyxJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUFDLFNBQVM7WUFDaEMsU0FBUyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUN6QixDQUFDLENBQUMsQ0FBQTtRQUNGLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFBO0lBQy9CLENBQUM7SUFBQSxDQUFDO0lBQ0YsV0FBVyxDQUFDLFVBQW1CO1FBQzNCLElBQUksSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUE7UUFDckIsRUFBRSxDQUFDLENBQUMsVUFBVSxDQUFDO1lBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQTtJQUNyQyxDQUFDO0lBQ0QsYUFBYSxDQUFDLFVBQWtCO1FBQzVCLElBQUksQ0FBQyxLQUFLLEdBQUcsVUFBVSxDQUFBO0lBQzNCLENBQUM7SUFBQSxDQUFDO0lBQ0YsT0FBTztRQUNILE1BQU0sQ0FBQyxPQUFPLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQ2pELENBQUM7Q0FDSjtBQS9CRCx3QkErQkMifQ== \ No newline at end of file diff --git a/dist/smartssh.classes.sshinstance.d.ts b/dist/smartssh.classes.sshinstance.d.ts index 5be8e78..82fed46 100644 --- a/dist/smartssh.classes.sshinstance.d.ts +++ b/dist/smartssh.classes.sshinstance.d.ts @@ -1,5 +1,5 @@ -import "typings-global"; -import { SshKey } from "./smartssh.classes.sshkey"; +import 'typings-global'; +import { SshKey } from './smartssh.classes.sshkey'; export declare class SshInstance { private _sshKeyArray; private _sshConfig; @@ -13,7 +13,7 @@ export declare class SshInstance { removeKey(sshKeyArg: SshKey): void; replaceKey(sshKeyOldArg: SshKey, sshKeyNewArg: SshKey): void; getKey(hostArg: string): SshKey; - sshKeys: SshKey[]; + readonly sshKeys: SshKey[]; /** * write SshInstance to disk */ diff --git a/dist/smartssh.classes.sshinstance.js b/dist/smartssh.classes.sshinstance.js index f0f6834..2ff547e 100644 --- a/dist/smartssh.classes.sshinstance.js +++ b/dist/smartssh.classes.sshinstance.js @@ -1,10 +1,9 @@ "use strict"; require("typings-global"); -var smartssh_classes_sshdir_1 = require("./smartssh.classes.sshdir"); -var smartssh_classes_sshconfig_1 = require("./smartssh.classes.sshconfig"); -var SshInstance = (function () { - function SshInstance(optionsArg) { - if (optionsArg === void 0) { optionsArg = {}; } +const smartssh_classes_sshdir_1 = require("./smartssh.classes.sshdir"); +const smartssh_classes_sshconfig_1 = require("./smartssh.classes.sshconfig"); +class SshInstance { + constructor(optionsArg = {}) { optionsArg ? void (0) : optionsArg = {}; this._sshKeyArray = []; this._sshConfig = new smartssh_classes_sshconfig_1.SshConfig(this._sshKeyArray); @@ -12,34 +11,34 @@ var SshInstance = (function () { this._sshSync = optionsArg.sshSync; } ; - //altering methods - SshInstance.prototype.addKey = function (sshKeyArg) { - this._syncAuto("from"); + // altering methods + addKey(sshKeyArg) { + this._syncAuto('from'); this._sshKeyArray.push(sshKeyArg); - this._syncAuto("to"); - }; + this._syncAuto('to'); + } ; - SshInstance.prototype.removeKey = function (sshKeyArg) { - this._syncAuto("from"); - var filteredArray = this._sshKeyArray.filter(function (sshKeyArg2) { + removeKey(sshKeyArg) { + this._syncAuto('from'); + let filteredArray = this._sshKeyArray.filter((sshKeyArg2) => { return (sshKeyArg != sshKeyArg2); }); this._sshKeyArray = filteredArray; - this._syncAuto("to"); - }; + this._syncAuto('to'); + } ; - SshInstance.prototype.replaceKey = function (sshKeyOldArg, sshKeyNewArg) { - this._syncAuto("from"); + replaceKey(sshKeyOldArg, sshKeyNewArg) { + this._syncAuto('from'); this.removeKey(sshKeyOldArg); this.addKey(sshKeyNewArg); - this._syncAuto("to"); - }; + this._syncAuto('to'); + } ; // - SshInstance.prototype.getKey = function (hostArg) { - this._syncAuto("from"); - var filteredArray = this._sshKeyArray.filter(function (keyArg) { - return (keyArg.host == hostArg); + getKey(hostArg) { + this._syncAuto('from'); + let filteredArray = this._sshKeyArray.filter(function (keyArg) { + return (keyArg.host === hostArg); }); if (filteredArray.length > 0) { return filteredArray[0]; @@ -47,59 +46,53 @@ var SshInstance = (function () { else { return undefined; } - }; + } ; - Object.defineProperty(SshInstance.prototype, "sshKeys", { - get: function () { - this._syncAuto("from"); - return this._sshKeyArray; - }, - enumerable: true, - configurable: true - }); + get sshKeys() { + this._syncAuto('from'); + return this._sshKeyArray; + } ; - //FS methods + // FS methods /** * write SshInstance to disk */ - SshInstance.prototype.writeToDisk = function (dirPathArg) { - this._sync("to", dirPathArg); - }; + writeToDisk(dirPathArg) { + this._sync('to', dirPathArg); + } /** * read ab SshInstance from disk */ - SshInstance.prototype.readFromDisk = function (dirPathArg) { - this._sync("from", dirPathArg); - }; + readFromDisk(dirPathArg) { + this._sync('from', dirPathArg); + } /* =============================================================== ========================= Private Methods ======================== ================================================================*/ - SshInstance.prototype._makeConfig = function () { - }; + _makeConfig() { + } /** * method to invoke SshInstance _sync automatically when sshSync is true */ - SshInstance.prototype._syncAuto = function (directionArg) { + _syncAuto(directionArg) { if (this._sshSync) this._sync(directionArg); - }; + } /** * private method to sync SshInstance */ - SshInstance.prototype._sync = function (directionArg, dirPathArg) { - if (directionArg == "from") { + _sync(directionArg, dirPathArg) { + if (directionArg === 'from') { this._sshDir.readFromDir(dirPathArg); // call sync method of sshDir class; } - else if (directionArg == "to") { + else if (directionArg === 'to') { this._sshDir.writeToDir(dirPathArg); } else { throw new Error("directionArg not recognised. Must be 'to' or 'from'"); } - }; + } ; - return SshInstance; -}()); +} exports.SshInstance = SshInstance; - -//# sourceMappingURL=data:application/json;charset=utf8;base64,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 +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/smartssh.classes.sshkey.d.ts b/dist/smartssh.classes.sshkey.d.ts index db30be9..9d49558 100644 --- a/dist/smartssh.classes.sshkey.d.ts +++ b/dist/smartssh.classes.sshkey.d.ts @@ -1,9 +1,12 @@ -import "typings-global"; +import 'typings-global'; export declare class SshKey { private _privKey; private _pubKey; private _hostVar; private _authorized; + /** + * the constructor for class SshKey + */ constructor(optionsArg?: { private?: string; public?: string; diff --git a/dist/smartssh.classes.sshkey.js b/dist/smartssh.classes.sshkey.js index 7e687eb..f6ddbac 100644 --- a/dist/smartssh.classes.sshkey.js +++ b/dist/smartssh.classes.sshkey.js @@ -1,125 +1,96 @@ "use strict"; require("typings-global"); -var plugins = require("./smartssh.plugins"); -var SshKey = (function () { - function SshKey(optionsArg) { - if (optionsArg === void 0) { optionsArg = {}; } +const plugins = require("./smartssh.plugins"); +class SshKey { + /** + * the constructor for class SshKey + */ + constructor(optionsArg = {}) { this._privKey = optionsArg.private; this._pubKey = optionsArg.public; this._hostVar = optionsArg.host; this._authorized = optionsArg.authorized; } ; - Object.defineProperty(SshKey.prototype, "host", { - // this.host - get: function () { - return this._hostVar; - }, - set: function (hostArg) { - this._hostVar = hostArg; - }, - enumerable: true, - configurable: true - }); + // this.host + get host() { + return this._hostVar; + } ; + set host(hostArg) { + this._hostVar = hostArg; + } ; - Object.defineProperty(SshKey.prototype, "privKey", { - // this.privKey - get: function () { - return this._privKey; - }, - set: function (privateKeyArg) { - this._privKey = privateKeyArg; - }, - enumerable: true, - configurable: true - }); + // this.privKey + get privKey() { + return this._privKey; + } ; + set privKey(privateKeyArg) { + this._privKey = privateKeyArg; + } ; - Object.defineProperty(SshKey.prototype, "privKeyBase64", { - // this.privKeyBase64 - get: function () { - return plugins.base64.encode(this._privKey); - }, - set: function (privateKeyArg) { - this._privKey = plugins.base64.decode(privateKeyArg); - }, - enumerable: true, - configurable: true - }); - Object.defineProperty(SshKey.prototype, "pubKey", { - // this.pubKey - get: function () { - return this._pubKey; - }, - set: function (publicKeyArg) { - this._pubKey = publicKeyArg; - }, - enumerable: true, - configurable: true - }); + // this.privKeyBase64 + get privKeyBase64() { + return plugins.smartstring.base64.encode(this._privKey); + } + set privKeyBase64(privateKeyArg) { + this._privKey = plugins.smartstring.base64.decode(privateKeyArg); + } + // this.pubKey + get pubKey() { + return this._pubKey; + } + set pubKey(publicKeyArg) { + this._pubKey = publicKeyArg; + } ; - Object.defineProperty(SshKey.prototype, "pubKeyBase64", { - // this.pubKeyBase64 - get: function () { - return plugins.base64.encode(this._pubKey); - }, - set: function (publicKeyArg) { - this._pubKey = plugins.base64.decode(publicKeyArg); - }, - enumerable: true, - configurable: true - }); - Object.defineProperty(SshKey.prototype, "authorized", { - get: function () { - return this._authorized; - }, - set: function (authorizedArg) { - this._authorized = authorizedArg; - }, - enumerable: true, - configurable: true - }); - Object.defineProperty(SshKey.prototype, "type", { - get: function () { - if (this._privKey && this._pubKey) { - return "duplex"; - } - else if (this._privKey) { - return "private"; - } - else if (this._pubKey) { - return "public"; - } - }, - set: function (someVlueArg) { - console.log("the type of an SshKey connot be set. This value is autpcomputed."); - }, - enumerable: true, - configurable: true - }); + // this.pubKeyBase64 + get pubKeyBase64() { + return plugins.smartstring.base64.encode(this._pubKey); + } + set pubKeyBase64(publicKeyArg) { + this._pubKey = plugins.smartstring.base64.decode(publicKeyArg); + } + get authorized() { + return this._authorized; + } + set authorized(authorizedArg) { + this._authorized = authorizedArg; + } + get type() { + if (this._privKey && this._pubKey) { + return 'duplex'; + } + else if (this._privKey) { + return 'private'; + } + else if (this._pubKey) { + return 'public'; + } + } ; + set type(someVlueArg) { + console.log('the type of an SshKey connot be set. This value is autpcomputed.'); + } // methods - SshKey.prototype.read = function (filePathArg) { - }; - SshKey.prototype.store = function (dirPathArg) { + read(filePathArg) { + } + store(dirPathArg) { plugins.fs.ensureDirSync(dirPathArg); - var fileNameBase = this.host; + let fileNameBase = this.host; if (this._privKey) { - var filePath = plugins.path.join(dirPathArg, fileNameBase); + let filePath = plugins.path.join(dirPathArg, fileNameBase); plugins.smartfile.memory.toFsSync(this._privKey, filePath); plugins.shelljs.chmod(600, filePath); } ; if (this._pubKey) { - var filePath = plugins.path.join(dirPathArg, fileNameBase + ".pub"); + let filePath = plugins.path.join(dirPathArg, fileNameBase + '.pub'); plugins.smartfile.memory.toFsSync(this._pubKey, filePath); plugins.shelljs.chmod(600, filePath); } - }; - return SshKey; -}()); + } +} exports.SshKey = SshKey; -var testKey = new SshKey(); - -//# sourceMappingURL=data:application/json;charset=utf8;base64,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 +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/smartssh.plugins.d.ts b/dist/smartssh.plugins.d.ts index 16c8731..e07d399 100644 --- a/dist/smartssh.plugins.d.ts +++ b/dist/smartssh.plugins.d.ts @@ -1,10 +1,11 @@ -import "typings-global"; -export import beautylog = require("beautylog"); -export declare let base64: any; -export declare let fs: any; -export declare let minimatch: any; -export import path = require("path"); -export declare let q: any; -export declare let shelljs: any; -export import smartfile = require("smartfile"); -export import smartpath = require("smartpath"); +import 'typings-global'; +import * as beautylog from 'beautylog'; +import * as fs from 'fs-extra'; +import * as minimatch from 'minimatch'; +import * as path from 'path'; +import * as q from 'q'; +import * as shelljs from 'shelljs'; +import * as smartfile from 'smartfile'; +import * as smartpath from 'smartpath'; +import * as smartstring from 'smartstring'; +export { beautylog, fs, minimatch, path, q, shelljs, smartfile, smartpath, smartstring }; diff --git a/dist/smartssh.plugins.js b/dist/smartssh.plugins.js index f35f312..fd95920 100644 --- a/dist/smartssh.plugins.js +++ b/dist/smartssh.plugins.js @@ -1,13 +1,21 @@ "use strict"; require("typings-global"); -exports.beautylog = require("beautylog"); -exports.base64 = require("js-base64").Base64; -exports.fs = require("fs-extra"); -exports.minimatch = require("minimatch"); -exports.path = require("path"); -exports.q = require("q"); -exports.shelljs = require("shelljs"); -exports.smartfile = require("smartfile"); -exports.smartpath = require("smartpath"); - -//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNtYXJ0c3NoLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQ1AsQ0FBQyxDQURzQjtBQUNULGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDcEMsY0FBTSxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxNQUFNLENBQUM7QUFDckMsVUFBRSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQztBQUN6QixpQkFBUyxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztBQUM5QixZQUFJLFdBQVcsTUFBTSxDQUFDLENBQUM7QUFDMUIsU0FBQyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNqQixlQUFPLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQzFCLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsaUJBQVMsV0FBVyxXQUFXLENBQUMsQ0FBQyIsImZpbGUiOiJzbWFydHNzaC5wbHVnaW5zLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFwidHlwaW5ncy1nbG9iYWxcIlxuZXhwb3J0IGltcG9ydCBiZWF1dHlsb2cgPSByZXF1aXJlKFwiYmVhdXR5bG9nXCIpO1xuZXhwb3J0IGxldCBiYXNlNjQgPSByZXF1aXJlKFwianMtYmFzZTY0XCIpLkJhc2U2NDtcbmV4cG9ydCBsZXQgZnMgPSByZXF1aXJlKFwiZnMtZXh0cmFcIik7XG5leHBvcnQgbGV0IG1pbmltYXRjaCA9IHJlcXVpcmUoXCJtaW5pbWF0Y2hcIik7XG5leHBvcnQgaW1wb3J0IHBhdGggPSByZXF1aXJlKFwicGF0aFwiKTtcbmV4cG9ydCBsZXQgcSA9IHJlcXVpcmUoXCJxXCIpO1xuZXhwb3J0IGxldCBzaGVsbGpzID0gcmVxdWlyZShcInNoZWxsanNcIik7XG5leHBvcnQgaW1wb3J0IHNtYXJ0ZmlsZSA9IHJlcXVpcmUoXCJzbWFydGZpbGVcIik7XG5leHBvcnQgaW1wb3J0IHNtYXJ0cGF0aCA9IHJlcXVpcmUoXCJzbWFydHBhdGhcIik7Il19 +const beautylog = require("beautylog"); +exports.beautylog = beautylog; +const fs = require("fs-extra"); +exports.fs = fs; +const minimatch = require("minimatch"); +exports.minimatch = minimatch; +const path = require("path"); +exports.path = path; +const q = require("q"); +exports.q = q; +const shelljs = require("shelljs"); +exports.shelljs = shelljs; +const smartfile = require("smartfile"); +exports.smartfile = smartfile; +const smartpath = require("smartpath"); +exports.smartpath = smartpath; +const smartstring = require("smartstring"); +exports.smartstring = smartstring; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzc2gucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c3NoLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUF1QjtBQUN2Qix1Q0FBc0M7QUFXbEMsOEJBQVM7QUFWYiwrQkFBOEI7QUFXMUIsZ0JBQUU7QUFWTix1Q0FBc0M7QUFXbEMsOEJBQVM7QUFWYiw2QkFBNEI7QUFXeEIsb0JBQUk7QUFWUix1QkFBc0I7QUFXbEIsY0FBQztBQVZMLG1DQUFrQztBQVc5QiwwQkFBTztBQVZYLHVDQUFzQztBQVdsQyw4QkFBUztBQVZiLHVDQUFzQztBQVdsQyw4QkFBUztBQVZiLDJDQUEwQztBQVd0QyxrQ0FBVyJ9 \ No newline at end of file diff --git a/package.json b/package.json index 2b3893a..d3adc91 100644 --- a/package.json +++ b/package.json @@ -23,19 +23,25 @@ }, "homepage": "https://gitlab.com/pushrocks/smartssh#readme", "dependencies": { - "beautylog": "^5.0.12", - "fs-extra": "^0.30.0", - "js-base64": "^2.1.9", - "minimatch": "^3.0.2", + "@types/fs-extra": "0.0.35", + "@types/js-base64": "^2.1.5", + "@types/minimatch": "^2.0.29", + "@types/q": "0.0.32", + "@types/shelljs": "^0.3.33", + "beautylog": "^6.0.0", + "fs-extra": "^1.0.0", + "minimatch": "^3.0.3", "q": "^1.4.1", - "shelljs": "^0.7.0", - "smartfile": "^4.0.5", - "smartpath": "^3.2.2", - "typings-global": "^1.0.3", - "typings-test": "^1.0.1" + "shelljs": "^0.7.5", + "smartfile": "^4.1.0", + "smartpath": "^3.2.5", + "smartstring": "^2.0.22", + "typings-global": "^1.0.14" }, "devDependencies": { - "npmts-g": "^5.2.6", - "should": "^9.0.2" + "@types/should": "^8.1.30", + "npmts-g": "^5.2.8", + "should": "^11.1.1", + "typings-test": "^1.0.3" } } diff --git a/test/test.d.ts b/test/test.d.ts index b973566..2fd432a 100644 --- a/test/test.d.ts +++ b/test/test.d.ts @@ -1,2 +1 @@ -import "typings-test"; -import "should"; +import 'typings-test'; diff --git a/test/test.js b/test/test.js index e5e9e8f..646b524 100644 --- a/test/test.js +++ b/test/test.js @@ -1,78 +1,77 @@ "use strict"; require("typings-test"); -require("should"); -var smartssh = require("../dist/index"); -var path = require("path"); -describe("smartssh", function () { - var testSshInstance; - var testSshKey; - describe(".SshKey", function () { +const should = require("should"); +const smartssh = require("../dist/index"); +const path = require("path"); +describe('smartssh', function () { + let testSshInstance; + let testSshKey; + describe('.SshKey', function () { it("'new' keyword should create a valid SshKey object", function () { testSshKey = new smartssh.SshKey({ - host: "example.com", - private: "someExamplePrivateKey", - public: "someExamplePublicKey" + host: 'example.com', + private: 'someExamplePrivateKey', + public: 'someExamplePublicKey' }); - testSshKey.should.be.instanceof(smartssh.SshKey); + should(testSshKey).be.instanceof(smartssh.SshKey); }); - it(".type should be a valid type", function () { - testSshKey.type.should.equal("duplex"); + it('.type should be a valid type', function () { + should(testSshKey.type).equal('duplex'); }); - it(".publicKey should be public key", function () { - testSshKey.pubKey.should.equal("someExamplePublicKey"); + it('.publicKey should be public key', function () { + should(testSshKey.pubKey).equal('someExamplePublicKey'); }); - it(".privateKey should be private key", function () { - testSshKey.privKey.should.equal("someExamplePrivateKey"); + it('.privateKey should be private key', function () { + should(testSshKey.privKey).equal('someExamplePrivateKey'); }); - it(".publicKeyBase64 should be public key base 64 encoded", function () { + it('.publicKeyBase64 should be public key base 64 encoded', function () { testSshKey.pubKeyBase64; }); - it(".store() should store the file to disk", function () { - testSshKey.store(path.join(process.cwd(), "test/temp")); + it('.store() should store the file to disk', function () { + testSshKey.store(path.join(process.cwd(), 'test/temp')); }); }); - describe(".SshInstance", function () { + describe('.SshInstance', function () { it("'new' keyword should create a new SshInstance object from class", function () { testSshInstance = new smartssh.SshInstance({ - sshDirPath: path.join(process.cwd(), "test/temp/") + sshDirPath: path.join(process.cwd(), 'test/temp/') }); - testSshInstance.should.be.instanceof(smartssh.SshInstance); + should(testSshInstance).be.instanceof(smartssh.SshInstance); }); - it(".addKey() should accept a new SshKey object", function () { + it('.addKey() should accept a new SshKey object', function () { testSshInstance.addKey(new smartssh.SshKey({ - public: "somePublicKey", - private: "somePrivateKey", - host: "gitlab.com" + public: 'somePublicKey', + private: 'somePrivateKey', + host: 'gitlab.com' })); testSshInstance.addKey(new smartssh.SshKey({ - public: "somePublicKey", - private: "somePrivateKey", - host: "bitbucket.org" + public: 'somePublicKey', + private: 'somePrivateKey', + host: 'bitbucket.org' })); testSshInstance.addKey(new smartssh.SshKey({ - public: "someGitHubPublicKey", - private: "someGitHubPrivateKey", - host: "github.com" + public: 'someGitHubPublicKey', + private: 'someGitHubPrivateKey', + host: 'github.com' })); }); - it(".sshKeys should point to an array of sshKeys", function () { - var sshKeyArray = testSshInstance.sshKeys; - sshKeyArray.should.be.Array(); - sshKeyArray[0].host.should.equal("gitlab.com"); - sshKeyArray[1].host.should.equal("bitbucket.org"); - sshKeyArray[2].host.should.equal("github.com"); + it('.sshKeys should point to an array of sshKeys', function () { + let sshKeyArray = testSshInstance.sshKeys; + should(sshKeyArray).be.Array(); + should(sshKeyArray[0].host).equal('gitlab.com'); + should(sshKeyArray[1].host).equal('bitbucket.org'); + should(sshKeyArray[2].host).equal('github.com'); }); - it(".getKey() should get a specific key selected by host", function () { - testSshInstance.getKey("github.com").pubKey.should.equal("someGitHubPublicKey"); + it('.getKey() should get a specific key selected by host', function () { + should(testSshInstance.getKey('github.com').pubKey).equal('someGitHubPublicKey'); }); - it(".removeKey() should remove a key", function () { - testSshInstance.removeKey(testSshInstance.getKey("bitbucket.org")); - testSshInstance.sshKeys[1].host.should.equal("github.com"); + it('.removeKey() should remove a key', function () { + testSshInstance.removeKey(testSshInstance.getKey('bitbucket.org')); + should(testSshInstance.sshKeys[1].host).equal('github.com'); }); - it("it should store to disk", function () { + it('it should store to disk', function () { testSshInstance.writeToDisk(); }); }); }); - -//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test.ts"],"names":[],"mappings":";AAAA,QAAO,cACP,CAAC,CADoB;AACrB,QAAO,QAAQ,CAAC,CAAA;AAChB,IAAO,QAAQ,WAAW,eAAe,CAAC,CAAC;AAC3C,IAAO,IAAI,WAAW,MAAM,CAAC,CAAC;AAC9B,QAAQ,CAAC,UAAU,EAAC;IAChB,IAAI,eAAoC,CAAC;IACzC,IAAI,UAA0B,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAC;QACf,EAAE,CAAC,mDAAmD,EAAC;YACnD,UAAU,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC;gBAC7B,IAAI,EAAC,aAAa;gBAClB,OAAO,EAAC,uBAAuB;gBAC/B,MAAM,EAAC,sBAAsB;aAChC,CAAC,CAAC;YACH,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,8BAA8B,EAAC;YAC9B,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,iCAAiC,EAAC;YACjC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,mCAAmC,EAAC;YACnC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,uDAAuD,EAAC;YACvD,UAAU,CAAC,YAAY,CAAC;QAC5B,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,wCAAwC,EAAC;YACxC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAC,WAAW,CAAC,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,QAAQ,CAAC,cAAc,EAAC;QACpB,EAAE,CAAC,iEAAiE,EAAC;YACjE,eAAe,GAAG,IAAI,QAAQ,CAAC,WAAW,CAAC;gBACvC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAC,YAAY,CAAC;aACpD,CAAC,CAAC;YACH,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,6CAA6C,EAAC;YAC7C,eAAe,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;gBACvC,MAAM,EAAC,eAAe;gBACtB,OAAO,EAAC,gBAAgB;gBACxB,IAAI,EAAC,YAAY;aACpB,CAAC,CAAC,CAAC;YACJ,eAAe,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;gBACvC,MAAM,EAAC,eAAe;gBACtB,OAAO,EAAC,gBAAgB;gBACxB,IAAI,EAAC,eAAe;aACvB,CAAC,CAAC,CAAC;YACJ,eAAe,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;gBACvC,MAAM,EAAC,qBAAqB;gBAC5B,OAAO,EAAC,sBAAsB;gBAC9B,IAAI,EAAC,YAAY;aACpB,CAAC,CAAC,CAAC;QACR,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,8CAA8C,EAAC;YAC9C,IAAI,WAAW,GAAG,eAAe,CAAC,OAAO,CAAC;YAC1C,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;YAC9B,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC/C,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAClD,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,sDAAsD,EAAC;YACtD,eAAe,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACpF,CAAC,CAAC,CAAA;QACF,EAAE,CAAC,kCAAkC,EAAC;YAClC,eAAe,CAAC,SAAS,CAAC,eAAe,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC;YACnE,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,yBAAyB,EAAC;YACzB,eAAe,CAAC,WAAW,EAAE,CAAC;QAClC,CAAC,CAAC,CAAA;IACN,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAA","file":"test.js","sourcesContent":["import \"typings-test\"\nimport \"should\";\nimport smartssh = require(\"../dist/index\");\nimport path = require(\"path\");\ndescribe(\"smartssh\",function(){\n    let testSshInstance:smartssh.SshInstance;\n    let testSshKey:smartssh.SshKey;\n    describe(\".SshKey\",function(){\n        it(\"'new' keyword should create a valid SshKey object\",function(){\n            testSshKey = new smartssh.SshKey({\n                host:\"example.com\",\n                private:\"someExamplePrivateKey\",\n                public:\"someExamplePublicKey\"\n            });\n            testSshKey.should.be.instanceof(smartssh.SshKey);\n        });\n        it(\".type should be a valid type\",function(){\n            testSshKey.type.should.equal(\"duplex\");\n        });\n        it(\".publicKey should be public key\",function(){\n            testSshKey.pubKey.should.equal(\"someExamplePublicKey\");\n        });\n        it(\".privateKey should be private key\",function(){\n            testSshKey.privKey.should.equal(\"someExamplePrivateKey\");\n        });\n        it(\".publicKeyBase64 should be public key base 64 encoded\",function(){\n            testSshKey.pubKeyBase64;\n        });\n        it(\".store() should store the file to disk\",function(){\n            testSshKey.store(path.join(process.cwd(),\"test/temp\"));\n        });\n    });\n    describe(\".SshInstance\",function(){\n        it(\"'new' keyword should create a new SshInstance object from class\",function(){\n            testSshInstance = new smartssh.SshInstance({\n                sshDirPath: path.join(process.cwd(),\"test/temp/\")\n            });\n            testSshInstance.should.be.instanceof(smartssh.SshInstance);\n        });\n        it(\".addKey() should accept a new SshKey object\",function(){\n            testSshInstance.addKey(new smartssh.SshKey({\n                public:\"somePublicKey\",\n                private:\"somePrivateKey\",\n                host:\"gitlab.com\"\n            }));\n            testSshInstance.addKey(new smartssh.SshKey({\n                public:\"somePublicKey\",\n                private:\"somePrivateKey\",\n                host:\"bitbucket.org\"\n            }));\n            testSshInstance.addKey(new smartssh.SshKey({\n                public:\"someGitHubPublicKey\",\n                private:\"someGitHubPrivateKey\",\n                host:\"github.com\"\n            }));\n        });\n        it(\".sshKeys should point to an array of sshKeys\",function(){\n            let sshKeyArray = testSshInstance.sshKeys;\n            sshKeyArray.should.be.Array();\n            sshKeyArray[0].host.should.equal(\"gitlab.com\");\n            sshKeyArray[1].host.should.equal(\"bitbucket.org\");\n            sshKeyArray[2].host.should.equal(\"github.com\");\n        });\n        it(\".getKey() should get a specific key selected by host\",function(){\n            testSshInstance.getKey(\"github.com\").pubKey.should.equal(\"someGitHubPublicKey\");\n        })\n        it(\".removeKey() should remove a key\",function(){\n            testSshInstance.removeKey(testSshInstance.getKey(\"bitbucket.org\"));\n            testSshInstance.sshKeys[1].host.should.equal(\"github.com\");\n        });\n        it(\"it should store to disk\",function(){\n            testSshInstance.writeToDisk();\n        })\n    });\n})"]} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/test/test.ts b/test/test.ts index 27e6452..b97a92a 100644 --- a/test/test.ts +++ b/test/test.ts @@ -1,75 +1,75 @@ -import "typings-test" -import "should"; -import smartssh = require("../dist/index"); -import path = require("path"); -describe("smartssh",function(){ - let testSshInstance:smartssh.SshInstance; - let testSshKey:smartssh.SshKey; - describe(".SshKey",function(){ +import 'typings-test' +import * as should from 'should' +import smartssh = require('../dist/index') +import path = require('path') +describe('smartssh',function(){ + let testSshInstance: smartssh.SshInstance + let testSshKey: smartssh.SshKey + describe('.SshKey',function(){ it("'new' keyword should create a valid SshKey object",function(){ testSshKey = new smartssh.SshKey({ - host:"example.com", - private:"someExamplePrivateKey", - public:"someExamplePublicKey" - }); - testSshKey.should.be.instanceof(smartssh.SshKey); - }); - it(".type should be a valid type",function(){ - testSshKey.type.should.equal("duplex"); - }); - it(".publicKey should be public key",function(){ - testSshKey.pubKey.should.equal("someExamplePublicKey"); - }); - it(".privateKey should be private key",function(){ - testSshKey.privKey.should.equal("someExamplePrivateKey"); - }); - it(".publicKeyBase64 should be public key base 64 encoded",function(){ - testSshKey.pubKeyBase64; - }); - it(".store() should store the file to disk",function(){ - testSshKey.store(path.join(process.cwd(),"test/temp")); - }); - }); - describe(".SshInstance",function(){ + host: 'example.com', + private: 'someExamplePrivateKey', + public: 'someExamplePublicKey' + }) + should(testSshKey).be.instanceof(smartssh.SshKey) + }) + it('.type should be a valid type',function(){ + should(testSshKey.type).equal('duplex') + }) + it('.publicKey should be public key',function(){ + should(testSshKey.pubKey).equal('someExamplePublicKey') + }) + it('.privateKey should be private key',function(){ + should(testSshKey.privKey).equal('someExamplePrivateKey') + }) + it('.publicKeyBase64 should be public key base 64 encoded',function(){ + testSshKey.pubKeyBase64 + }) + it('.store() should store the file to disk',function(){ + testSshKey.store(path.join(process.cwd(),'test/temp')) + }) + }) + describe('.SshInstance',function(){ it("'new' keyword should create a new SshInstance object from class",function(){ testSshInstance = new smartssh.SshInstance({ - sshDirPath: path.join(process.cwd(),"test/temp/") - }); - testSshInstance.should.be.instanceof(smartssh.SshInstance); - }); - it(".addKey() should accept a new SshKey object",function(){ - testSshInstance.addKey(new smartssh.SshKey({ - public:"somePublicKey", - private:"somePrivateKey", - host:"gitlab.com" - })); - testSshInstance.addKey(new smartssh.SshKey({ - public:"somePublicKey", - private:"somePrivateKey", - host:"bitbucket.org" - })); - testSshInstance.addKey(new smartssh.SshKey({ - public:"someGitHubPublicKey", - private:"someGitHubPrivateKey", - host:"github.com" - })); - }); - it(".sshKeys should point to an array of sshKeys",function(){ - let sshKeyArray = testSshInstance.sshKeys; - sshKeyArray.should.be.Array(); - sshKeyArray[0].host.should.equal("gitlab.com"); - sshKeyArray[1].host.should.equal("bitbucket.org"); - sshKeyArray[2].host.should.equal("github.com"); - }); - it(".getKey() should get a specific key selected by host",function(){ - testSshInstance.getKey("github.com").pubKey.should.equal("someGitHubPublicKey"); + sshDirPath: path.join(process.cwd(),'test/temp/') + }) + should(testSshInstance).be.instanceof(smartssh.SshInstance) }) - it(".removeKey() should remove a key",function(){ - testSshInstance.removeKey(testSshInstance.getKey("bitbucket.org")); - testSshInstance.sshKeys[1].host.should.equal("github.com"); - }); - it("it should store to disk",function(){ - testSshInstance.writeToDisk(); + it('.addKey() should accept a new SshKey object',function(){ + testSshInstance.addKey(new smartssh.SshKey({ + public: 'somePublicKey', + private: 'somePrivateKey', + host: 'gitlab.com' + })) + testSshInstance.addKey(new smartssh.SshKey({ + public: 'somePublicKey', + private: 'somePrivateKey', + host: 'bitbucket.org' + })) + testSshInstance.addKey(new smartssh.SshKey({ + public: 'someGitHubPublicKey', + private: 'someGitHubPrivateKey', + host: 'github.com' + })) }) - }); -}) \ No newline at end of file + it('.sshKeys should point to an array of sshKeys',function(){ + let sshKeyArray = testSshInstance.sshKeys + should(sshKeyArray).be.Array() + should(sshKeyArray[0].host).equal('gitlab.com') + should(sshKeyArray[1].host).equal('bitbucket.org') + should(sshKeyArray[2].host).equal('github.com') + }) + it('.getKey() should get a specific key selected by host',function(){ + should(testSshInstance.getKey('github.com').pubKey).equal('someGitHubPublicKey') + }) + it('.removeKey() should remove a key',function(){ + testSshInstance.removeKey(testSshInstance.getKey('bitbucket.org')) + should(testSshInstance.sshKeys[1].host).equal('github.com') + }) + it('it should store to disk',function(){ + testSshInstance.writeToDisk() + }) + }) +}) diff --git a/ts/index.ts b/ts/index.ts index d587c82..45c0fa4 100644 --- a/ts/index.ts +++ b/ts/index.ts @@ -1,7 +1,7 @@ -import "typings-global" -import * as plugins from "./smartssh.plugins"; +import 'typings-global' +import * as plugins from './smartssh.plugins' -export {SshInstance} from "./smartssh.classes.sshinstance"; -export {SshKey} from "./smartssh.classes.sshkey"; -export {SshDir} from "./smartssh.classes.sshdir"; -export {SshConfig} from "./smartssh.classes.sshconfig"; \ No newline at end of file +export {SshInstance} from './smartssh.classes.sshinstance' +export {SshKey} from './smartssh.classes.sshkey' +export {SshDir} from './smartssh.classes.sshdir' +export {SshConfig} from './smartssh.classes.sshconfig' diff --git a/ts/smartssh.classes.helpers.ts b/ts/smartssh.classes.helpers.ts index a9adcbd..3529d29 100644 --- a/ts/smartssh.classes.helpers.ts +++ b/ts/smartssh.classes.helpers.ts @@ -1,8 +1,8 @@ -import "typings-global" -import * as plugins from "./smartssh.plugins"; -import {SshKey} from "./smartssh.classes.sshkey"; +import 'typings-global' +import * as plugins from './smartssh.plugins' +import {SshKey} from './smartssh.classes.sshkey' -export let sshKeyArrayFromDir = function(dirArg:string):SshKey[]{ - let sshKeyArray = []; //TODO - return sshKeyArray; -} \ No newline at end of file +export let sshKeyArrayFromDir = function(dirArg: string): SshKey[]{ + let sshKeyArray = [] // TODO + return sshKeyArray +} diff --git a/ts/smartssh.classes.sshconfig.ts b/ts/smartssh.classes.sshconfig.ts index 6eb0bcd..0813c7c 100644 --- a/ts/smartssh.classes.sshconfig.ts +++ b/ts/smartssh.classes.sshconfig.ts @@ -1,54 +1,54 @@ -import "typings-global"; -import * as plugins from "./smartssh.plugins"; -import * as helpers from "./smartssh.classes.helpers"; -import {SshKey} from "./smartssh.classes.sshkey" +import 'typings-global' +import * as plugins from './smartssh.plugins' +import * as helpers from './smartssh.classes.helpers' +import {SshKey} from './smartssh.classes.sshkey' export class SshConfig { - private _sshKeyArray:SshKey[]; - constructor(sshKeyArrayArg:SshKey[]){ - this._sshKeyArray = sshKeyArrayArg; + private _sshKeyArray: SshKey[] + constructor(sshKeyArrayArg: SshKey[]) { + this._sshKeyArray = sshKeyArrayArg } /** * stores a config file */ - store(dirPathArg:string){ - let done = plugins.q.defer(); - let configArray:configObject[] = []; - let configString; - for(let key in this._sshKeyArray){ - let sshKey = this._sshKeyArray[key]; - if(sshKey.host){ - configString = "Host " + sshKey.host + "\n" + - " HostName " + sshKey.host + "\n" + - " IdentityFile ~/.ssh/" + sshKey.host + "\n" + - " StrictHostKeyChecking no" + "\n" + store(dirPathArg: string) { + let done = plugins.q.defer() + let configArray: configObject[] = [] + let configString + for (let key in this._sshKeyArray) { + let sshKey = this._sshKeyArray[key] + if (sshKey.host) { + configString = 'Host ' + sshKey.host + '\n' + + ' HostName ' + sshKey.host + '\n' + + ' IdentityFile ~/.ssh/' + sshKey.host + '\n' + + ' StrictHostKeyChecking no' + '\n' } configArray.push({ - configString:configString, + configString: configString, authorized: sshKey.authorized, sshKey: sshKey - }); + }) } - let configFile:string = ""; - for(let key in configArray){ - configFile = configFile + configArray[key].configString + "\n"; + let configFile: string = '' + for (let key in configArray) { + configFile = configFile + configArray[key].configString + '\n' }; - plugins.smartfile.memory.toFsSync(configFile,plugins.path.join(dirPathArg,"config")); - return done.promise; + plugins.smartfile.memory.toFsSync(configFile,plugins.path.join(dirPathArg,'config')) + return done.promise } - read(dirPathArg){ - let done = plugins.q.defer(); - let configArray:configObject[]; - plugins.smartfile.fs.toStringSync(plugins.path.join(dirPathArg,"config")); + read(dirPathArg) { + let done = plugins.q.defer() + let configArray: configObject[] + plugins.smartfile.fs.toStringSync(plugins.path.join(dirPathArg,'config')) - return done.promise; + return done.promise } }; export interface configObject { - configString:string; - authorized:boolean; - sshKey:SshKey; + configString: string + authorized: boolean + sshKey: SshKey }; diff --git a/ts/smartssh.classes.sshdir.ts b/ts/smartssh.classes.sshdir.ts index d0f5239..83948a5 100644 --- a/ts/smartssh.classes.sshdir.ts +++ b/ts/smartssh.classes.sshdir.ts @@ -1,38 +1,38 @@ -import "typings-global"; -import * as plugins from "./smartssh.plugins"; -import * as helpers from "./smartssh.classes.helpers"; -import {SshInstance} from "./smartssh.classes.sshinstance"; -import {SshKey} from "./smartssh.classes.sshkey"; -import {SshConfig} from "./smartssh.classes.sshconfig"; +import 'typings-global' +import * as plugins from './smartssh.plugins' +import * as helpers from './smartssh.classes.helpers' +import {SshInstance} from './smartssh.classes.sshinstance' +import {SshKey} from './smartssh.classes.sshkey' +import {SshConfig} from './smartssh.classes.sshconfig' export class SshDir { // sshDir class -> NOT EXPORTED, ONLY FOR INTERNAL USE - private _path:string; // the path of the ssh directory - private _sshKeyArray:SshKey[]; - private _sshConfig:SshConfig; - constructor(sshKeyArray:SshKey[],sshConfig:SshConfig,sshDirPathArg?:string){ - this._sshKeyArray = sshKeyArray; - this._sshConfig = sshConfig; - if(sshDirPathArg){ - this._path = sshDirPathArg; + private _path: string // the path of the ssh directory + private _sshKeyArray: SshKey[] + private _sshConfig: SshConfig + constructor(sshKeyArray: SshKey[],sshConfig: SshConfig,sshDirPathArg?: string) { + this._sshKeyArray = sshKeyArray + this._sshConfig = sshConfig + if (sshDirPathArg) { + this._path = sshDirPathArg } else { - this._path = plugins.path.join(plugins.smartpath.get.home(),".ssh/"); + this._path = plugins.path.join(plugins.smartpath.get.home(),'.ssh/') }; } - writeToDir(dirPathArg?:string){ // syncs sshInstance to directory - let path = this._path; - if(dirPathArg) path = dirPathArg; + writeToDir(dirPathArg?: string) { // syncs sshInstance to directory + let path = this._path + if (dirPathArg) path = dirPathArg this._sshKeyArray.forEach((sshKeyArg) => { - sshKeyArg.store(path); - }); - this._sshConfig.store(path); + sshKeyArg.store(path) + }) + this._sshConfig.store(path) }; - readFromDir(dirPathArg?:string){ // syncs sshInstance from directory - let path = this._path; - if(dirPathArg) path = dirPathArg; + readFromDir(dirPathArg?: string) { // syncs sshInstance from directory + let path = this._path + if (dirPathArg) path = dirPathArg } - updateDirPath(dirPathArg:string){ - this._path = dirPathArg; + updateDirPath(dirPathArg: string) { + this._path = dirPathArg }; - getKeys(){ - return helpers.sshKeyArrayFromDir(this._path); + getKeys() { + return helpers.sshKeyArrayFromDir(this._path) } -} \ No newline at end of file +} diff --git a/ts/smartssh.classes.sshinstance.ts b/ts/smartssh.classes.sshinstance.ts index 3418281..3b1f396 100644 --- a/ts/smartssh.classes.sshinstance.ts +++ b/ts/smartssh.classes.sshinstance.ts @@ -1,103 +1,103 @@ -import "typings-global" -import * as plugins from "./smartssh.plugins"; -import * as helpers from "./smartssh.classes.helpers"; +import 'typings-global' +import * as plugins from './smartssh.plugins' +import * as helpers from './smartssh.classes.helpers' -import {SshDir} from "./smartssh.classes.sshdir"; -import {SshConfig} from "./smartssh.classes.sshconfig"; -import {SshKey} from "./smartssh.classes.sshkey"; +import {SshDir} from './smartssh.classes.sshdir' +import {SshConfig} from './smartssh.classes.sshconfig' +import {SshKey} from './smartssh.classes.sshkey' export class SshInstance { - private _sshKeyArray:SshKey[]; //holds all ssh keys - private _sshConfig:SshConfig; // sshConfig (e.g. represents ~/.ssh/config) - private _sshDir:SshDir; // points to sshDir class instance. - 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._sshKeyArray = []; - this._sshConfig = new SshConfig(this._sshKeyArray); - this._sshDir = new SshDir(this._sshKeyArray,this._sshConfig,optionsArg.sshDirPath); - this._sshSync = optionsArg.sshSync; - }; - - //altering methods - addKey(sshKeyArg:SshKey){ - this._syncAuto("from"); - this._sshKeyArray.push(sshKeyArg); - this._syncAuto("to"); - }; - removeKey(sshKeyArg:SshKey){ - this._syncAuto("from"); - let filteredArray = this._sshKeyArray.filter((sshKeyArg2:SshKey) => { - return (sshKeyArg != sshKeyArg2); - }); - this._sshKeyArray = filteredArray; - this._syncAuto("to"); - }; - replaceKey(sshKeyOldArg:SshKey,sshKeyNewArg:SshKey){ - this._syncAuto("from"); - this.removeKey(sshKeyOldArg); - this.addKey(sshKeyNewArg); - this._syncAuto("to"); - }; - - // - getKey(hostArg:string):SshKey{ - this._syncAuto("from"); - let filteredArray = this._sshKeyArray.filter(function(keyArg){ - return (keyArg.host == hostArg); - }); - if(filteredArray.length > 0){ - return filteredArray[0]; - } else { - return undefined; - } - }; - get sshKeys():SshKey[] { - this._syncAuto("from"); - return this._sshKeyArray; + private _sshKeyArray: SshKey[] // holds all ssh keys + private _sshConfig: SshConfig // sshConfig (e.g. represents ~/.ssh/config) + private _sshDir: SshDir // points to sshDir class instance. + 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._sshKeyArray = [] + this._sshConfig = new SshConfig(this._sshKeyArray) + this._sshDir = new SshDir(this._sshKeyArray,this._sshConfig,optionsArg.sshDirPath) + this._sshSync = optionsArg.sshSync }; - //FS methods + // altering methods + addKey(sshKeyArg: SshKey) { + this._syncAuto('from') + this._sshKeyArray.push(sshKeyArg) + this._syncAuto('to') + }; + removeKey(sshKeyArg: SshKey) { + this._syncAuto('from') + let filteredArray = this._sshKeyArray.filter((sshKeyArg2: SshKey) => { + return (sshKeyArg != sshKeyArg2) + }) + this._sshKeyArray = filteredArray + this._syncAuto('to') + }; + replaceKey(sshKeyOldArg: SshKey,sshKeyNewArg: SshKey) { + this._syncAuto('from') + this.removeKey(sshKeyOldArg) + this.addKey(sshKeyNewArg) + this._syncAuto('to') + }; + + // + getKey(hostArg: string): SshKey { + this._syncAuto('from') + let filteredArray = this._sshKeyArray.filter(function(keyArg){ + return (keyArg.host === hostArg) + }) + if (filteredArray.length > 0) { + return filteredArray[0] + } else { + return undefined + } + }; + get sshKeys(): SshKey[] { + this._syncAuto('from') + return this._sshKeyArray + }; + + // FS methods /** * write SshInstance to disk */ - writeToDisk(dirPathArg?:string){ - this._sync("to",dirPathArg); + writeToDisk(dirPathArg?: string) { + this._sync('to',dirPathArg) } /** * read ab SshInstance from disk */ - readFromDisk(dirPathArg?:string){ - this._sync("from",dirPathArg); + readFromDisk(dirPathArg?: string) { + this._sync('from',dirPathArg) } /* =============================================================== ========================= Private Methods ======================== ================================================================*/ - private _makeConfig (){ + private _makeConfig () { } /** * method to invoke SshInstance _sync automatically when sshSync is true */ - private _syncAuto(directionArg){ - if(this._sshSync) this._sync(directionArg); + private _syncAuto(directionArg) { + if (this._sshSync) this._sync(directionArg) } /** * private method to sync SshInstance */ - private _sync(directionArg:string,dirPathArg?:string){ - if(directionArg == "from"){ - this._sshDir.readFromDir(dirPathArg); // call sync method of sshDir class; - } else if(directionArg == "to") { - this._sshDir.writeToDir(dirPathArg); + private _sync(directionArg: string,dirPathArg?: string) { + if (directionArg === 'from') { + this._sshDir.readFromDir(dirPathArg) // call sync method of sshDir class; + } else if (directionArg === 'to') { + this._sshDir.writeToDir(dirPathArg) } else { - throw new Error("directionArg not recognised. Must be 'to' or 'from'"); + throw new Error("directionArg not recognised. Must be 'to' or 'from'") } }; } diff --git a/ts/smartssh.classes.sshkey.ts b/ts/smartssh.classes.sshkey.ts index e0c9d9d..cb83b31 100644 --- a/ts/smartssh.classes.sshkey.ts +++ b/ts/smartssh.classes.sshkey.ts @@ -1,96 +1,99 @@ -import "typings-global"; -import * as plugins from "./smartssh.plugins"; -import * as helpers from "./smartssh.classes.helpers"; +import 'typings-global' +import * as plugins from './smartssh.plugins' +import * as helpers from './smartssh.classes.helpers' export class SshKey { - private _privKey:string; - private _pubKey:string; - private _hostVar:string; - private _authorized:boolean; - constructor(optionsArg:{private?:string,public?:string,host?:string,authorized?:boolean}={}){ - this._privKey = optionsArg.private; - this._pubKey = optionsArg.public; - this._hostVar = optionsArg.host; - this._authorized = optionsArg.authorized; + private _privKey: string + private _pubKey: string + private _hostVar: string + private _authorized: boolean + + /** + * the constructor for class SshKey + */ + constructor(optionsArg: {private?: string,public?: string,host?: string,authorized?: boolean}= {}) { + this._privKey = optionsArg.private + this._pubKey = optionsArg.public + this._hostVar = optionsArg.host + this._authorized = optionsArg.authorized }; - + // this.host get host(){ - return this._hostVar; + return this._hostVar }; - set host(hostArg:string){ - this._hostVar = hostArg; + set host(hostArg: string){ + this._hostVar = hostArg }; // this.privKey get privKey(){ - return this._privKey; + return this._privKey }; - set privKey(privateKeyArg:string){ - this._privKey = privateKeyArg; + set privKey(privateKeyArg: string){ + this._privKey = privateKeyArg }; // this.privKeyBase64 get privKeyBase64(){ - return plugins.base64.encode(this._privKey); + return plugins.smartstring.base64.encode(this._privKey) } - set privKeyBase64(privateKeyArg:string) { - this._privKey = plugins.base64.decode(privateKeyArg); + set privKeyBase64(privateKeyArg: string) { + this._privKey = plugins.smartstring.base64.decode(privateKeyArg) } // this.pubKey get pubKey(){ - return this._pubKey; + return this._pubKey } - set pubKey(publicKeyArg:string){ - this._pubKey = publicKeyArg; + set pubKey(publicKeyArg: string){ + this._pubKey = publicKeyArg }; // this.pubKeyBase64 get pubKeyBase64(){ - return plugins.base64.encode(this._pubKey); + return plugins.smartstring.base64.encode(this._pubKey) } - set pubKeyBase64(publicKeyArg:string) { - this._pubKey = plugins.base64.decode(publicKeyArg); + set pubKeyBase64(publicKeyArg: string) { + this._pubKey = plugins.smartstring.base64.decode(publicKeyArg) } get authorized(){ - return this._authorized; + return this._authorized } - set authorized(authorizedArg:boolean){ - this._authorized = authorizedArg; + set authorized(authorizedArg: boolean){ + this._authorized = authorizedArg } get type(){ - if(this._privKey && this._pubKey){ - return "duplex"; - } else if(this._privKey){ - return "private"; - } else if(this._pubKey){ - return "public"; + if (this._privKey && this._pubKey) { + return 'duplex' + } else if (this._privKey) { + return 'private' + } else if (this._pubKey) { + return 'public' } }; - set type(someVlueArg:any){ - console.log("the type of an SshKey connot be set. This value is autpcomputed.") + set type(someVlueArg: any){ + console.log('the type of an SshKey connot be set. This value is autpcomputed.') } // methods - read(filePathArg){ - + read(filePathArg) { + } - store(dirPathArg:string){ - plugins.fs.ensureDirSync(dirPathArg); - let fileNameBase = this.host; - if(this._privKey){ - let filePath = plugins.path.join(dirPathArg,fileNameBase); - plugins.smartfile.memory.toFsSync(this._privKey,filePath); - plugins.shelljs.chmod(600,filePath); + + store(dirPathArg: string) { + plugins.fs.ensureDirSync(dirPathArg) + let fileNameBase = this.host + if (this._privKey) { + let filePath = plugins.path.join(dirPathArg,fileNameBase) + plugins.smartfile.memory.toFsSync(this._privKey,filePath) + plugins.shelljs.chmod(600,filePath) }; - if (this._pubKey){ - let filePath = plugins.path.join(dirPathArg,fileNameBase + ".pub"); - plugins.smartfile.memory.toFsSync(this._pubKey,filePath); - plugins.shelljs.chmod(600,filePath); + if (this._pubKey) { + let filePath = plugins.path.join(dirPathArg,fileNameBase + '.pub') + plugins.smartfile.memory.toFsSync(this._pubKey,filePath) + plugins.shelljs.chmod(600,filePath) } } } - -let testKey = new SshKey(); \ No newline at end of file diff --git a/ts/smartssh.plugins.ts b/ts/smartssh.plugins.ts index 6a8cf77..de0ea4b 100644 --- a/ts/smartssh.plugins.ts +++ b/ts/smartssh.plugins.ts @@ -1,10 +1,22 @@ -import "typings-global" -export import beautylog = require("beautylog"); -export let base64 = require("js-base64").Base64; -export let fs = require("fs-extra"); -export let minimatch = require("minimatch"); -export import path = require("path"); -export let q = require("q"); -export let shelljs = require("shelljs"); -export import smartfile = require("smartfile"); -export import smartpath = require("smartpath"); \ No newline at end of file +import 'typings-global' +import * as beautylog from 'beautylog' +import * as fs from 'fs-extra' +import * as minimatch from 'minimatch' +import * as path from 'path' +import * as q from 'q' +import * as shelljs from 'shelljs' +import * as smartfile from 'smartfile' +import * as smartpath from 'smartpath' +import * as smartstring from 'smartstring' + +export { + beautylog, + fs, + minimatch, + path, + q, + shelljs, + smartfile, + smartpath, + smartstring +} diff --git a/tslint.json b/tslint.json new file mode 100644 index 0000000..45052ad --- /dev/null +++ b/tslint.json @@ -0,0 +1,3 @@ +{ + "extends": "tslint-config-standard" +}