From 1d4808ed4a977a806257bd47bb923792bc6d618f Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Mon, 20 Jun 2016 10:45:43 +0200 Subject: [PATCH] ready for primetime --- dist/index.d.ts | 2 +- dist/index.js | 26 +++++++++++++++----------- test/assets/env.yml | 2 ++ test/assets/qenv.yml | 4 ++++ test/test.d.ts | 2 ++ test/test.js | 23 +++++++++++++++++++++++ test/test.ts | 24 ++++++++++++++++++++++++ ts/index.ts | 18 +++++++++++------- 8 files changed, 82 insertions(+), 19 deletions(-) create mode 100644 test/assets/env.yml create mode 100644 test/assets/qenv.yml create mode 100644 test/test.d.ts create mode 100644 test/test.js diff --git a/dist/index.d.ts b/dist/index.d.ts index bcccce1..a5a8c1f 100644 --- a/dist/index.d.ts +++ b/dist/index.d.ts @@ -1,4 +1,4 @@ -export declare class qenv { +export declare class Qenv { requiredEnvVars: string[]; availableEnvVars: string[]; missingEnvVars: string[]; diff --git a/dist/index.js b/dist/index.js index 5cea318..b3a7c25 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,15 +1,18 @@ "use strict"; var plugins = require("./qenv.plugins"); -var qenv = (function () { - function qenv(basePathArg, envYmlPathArg) { +var Qenv = (function () { + function Qenv(basePathArg, envYmlPathArg) { if (basePathArg === void 0) { basePathArg = process.cwd(); } this.requiredEnvVars = getRequiredEnvVars(basePathArg); this.availableEnvVars = getAvailableEnvVars(this.requiredEnvVars, envYmlPathArg); this.missingEnvVars = getMissingEnvVars(this.requiredEnvVars, this.availableEnvVars); + for (var keyArg in this.missingEnvVars) { + plugins.beautylog.warn(this.missingEnvVars[keyArg] + " is required, but missing!"); + } } - return qenv; + return Qenv; }()); -exports.qenv = qenv; +exports.Qenv = Qenv; ; var getRequiredEnvVars = function (pathArg) { var result = []; @@ -22,6 +25,7 @@ var getRequiredEnvVars = function (pathArg) { }; var getAvailableEnvVars = function (requiredEnvVarsArg, envYmlPathArg) { var result = []; + envYmlPathArg = plugins.path.join(envYmlPathArg, "env.yml"); var envYml; try { envYml = plugins.smartfile.local.toObjectSync(envYmlPathArg); @@ -30,13 +34,13 @@ var getAvailableEnvVars = function (requiredEnvVarsArg, envYmlPathArg) { envYml = {}; } for (var keyArg in requiredEnvVarsArg) { - var envVar = requiredEnvVarsArg[keyArg]; - if (process.env[envVar]) { - result.push(envVar); + var requiredEnvVar = requiredEnvVarsArg[keyArg]; + if (process.env[requiredEnvVar]) { + result.push(requiredEnvVar); } - else if (envYml.hasOwnPropery(envVar)) { - process.env[envVar] = envYml.envVar; - result.push(envVar); + else if (envYml.hasOwnProperty(requiredEnvVar)) { + process.env[requiredEnvVar] = envYml[requiredEnvVar]; + result.push(requiredEnvVar); } } return result; @@ -45,4 +49,4 @@ var getMissingEnvVars = function (requiredEnvVarsArray, availableEnvVarsArray) { return plugins.lodash.difference(requiredEnvVarsArray, availableEnvVarsArray); }; -//# 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/assets/env.yml b/test/assets/env.yml new file mode 100644 index 0000000..a40e730 --- /dev/null +++ b/test/assets/env.yml @@ -0,0 +1,2 @@ +key1: fromYml +key2: fromYml \ No newline at end of file diff --git a/test/assets/qenv.yml b/test/assets/qenv.yml new file mode 100644 index 0000000..66f816f --- /dev/null +++ b/test/assets/qenv.yml @@ -0,0 +1,4 @@ +vars: + - key1 + - key2 + - key3 \ No newline at end of file diff --git a/test/test.d.ts b/test/test.d.ts new file mode 100644 index 0000000..b973566 --- /dev/null +++ b/test/test.d.ts @@ -0,0 +1,2 @@ +import "typings-test"; +import "should"; diff --git a/test/test.js b/test/test.js new file mode 100644 index 0000000..02cbe1b --- /dev/null +++ b/test/test.js @@ -0,0 +1,23 @@ +"use strict"; +require("typings-test"); +var path = require("path"); +require("should"); +var index_1 = require("../dist/index"); +process.cwd = function () { + return path.join(__dirname, "./assets/"); +}; +process.env["key1"] = "original"; +var qenvTestObject; +describe("Qenv class", function () { + it("should create a new class", function () { + qenvTestObject = new index_1.Qenv(process.cwd(), process.cwd()); + }); + it("key1 should be not be overwritten since it is already present", function () { + process.env.key1.should.equal("original"); + }); + it("key2 should be read from Yml", function () { + process.env.key2.should.equal("fromYml"); + }); +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/test/test.ts b/test/test.ts index e69de29..dd2668f 100644 --- a/test/test.ts +++ b/test/test.ts @@ -0,0 +1,24 @@ +import "typings-test"; +import * as path from "path"; +import "should"; +import {Qenv} from "../dist/index"; + +process.cwd = () => { + return path.join(__dirname,"./assets/"); +} + +process.env["key1"] = "original" + +let qenvTestObject:Qenv; +describe("Qenv class",function(){ + it("should create a new class",function(){ + qenvTestObject = new Qenv(process.cwd(),process.cwd()); + }); + it("key1 should be not be overwritten since it is already present",function(){ + process.env.key1.should.equal("original"); + }); + it("key2 should be read from Yml",function(){ + process.env.key2.should.equal("fromYml"); + }) + +}); \ No newline at end of file diff --git a/ts/index.ts b/ts/index.ts index cf395fa..b00b519 100644 --- a/ts/index.ts +++ b/ts/index.ts @@ -1,6 +1,6 @@ import * as plugins from "./qenv.plugins"; -export class qenv { +export class Qenv { requiredEnvVars:string[]; availableEnvVars:string[]; missingEnvVars:string[]; @@ -8,6 +8,9 @@ export class qenv { this.requiredEnvVars = getRequiredEnvVars(basePathArg); this.availableEnvVars = getAvailableEnvVars(this.requiredEnvVars,envYmlPathArg); this.missingEnvVars = getMissingEnvVars(this.requiredEnvVars,this.availableEnvVars); + for(let keyArg in this.missingEnvVars){ + plugins.beautylog.warn(this.missingEnvVars[keyArg] + " is required, but missing!") + } } }; @@ -23,6 +26,7 @@ let getRequiredEnvVars = (pathArg:string):string[] => { let getAvailableEnvVars = (requiredEnvVarsArg:string[],envYmlPathArg:string):string[] => { let result = []; + envYmlPathArg = plugins.path.join(envYmlPathArg,"env.yml") let envYml; try { envYml = plugins.smartfile.local.toObjectSync(envYmlPathArg); @@ -31,12 +35,12 @@ let getAvailableEnvVars = (requiredEnvVarsArg:string[],envYmlPathArg:string):str envYml = {}; } for(let keyArg in requiredEnvVarsArg){ - let envVar:string = requiredEnvVarsArg[keyArg]; - if(process.env[envVar]){ - result.push(envVar); - } else if(envYml.hasOwnPropery(envVar)){ - process.env[envVar] = envYml.envVar; - result.push(envVar); + let requiredEnvVar:string = requiredEnvVarsArg[keyArg]; + if(process.env[requiredEnvVar]){ + result.push(requiredEnvVar); + } else if(envYml.hasOwnProperty(requiredEnvVar)){ + process.env[requiredEnvVar] = envYml[requiredEnvVar]; + result.push(requiredEnvVar); } } return result;