Adding value loader to allow for component injection in testing

index.js

@@ -39,7 +39,8 @@ canister.Parser = require('./src/parser');
 canister.ModuleLoader = require('./src/loader');
 canister.definitionLoader = {
 	YAML: require('./src/definition-loader/yaml'),
-	Environment: require('./src/definition-loader/env')
+	Environment: require('./src/definition-loader/env'),
+	Value: require('./src/definition-loader/value')
 };
 
 module.exports = canister;

src/definition-loader/env.js

@@ -13,26 +13,24 @@ module.exports = class EnvironmentLoader {
 			return key.replace(prefix, '').toLowerCase().split('__').join('.');
 		},
 		castValue = value => {
-			if (value === "true") {
+			if (value === 'true') {
 				return true;
 			}
-			if (value === "false") {
+			if (value === 'false') {
 				return false;
 			}
 			if (isNaN(value)) {
 				return value;
 			}
-			return +value; //cast to number
+			return Number(value).valueOf();
 		}
 	} = {}) {
-
 		Object.keys(this.config).forEach(key => {
 			if (!prefix.test(key)) {
 				return;
 			}
 			this.dictionary[getKey(key, prefix)] = castValue(this.config[key]);
-		})
-
+		});
 	}
 
 	toJS() {

src/definition-loader/value.js

@@ -0,0 +1,21 @@
+module.exports = class ValueLoader {
+
+	constructor() {
+		this.dictionary = {
+			parameters: {},
+			components: {}
+		};
+	}
+
+	parameter(name, value) {
+		this.dictionary.parameters[name] = value;
+	}
+
+	component(name, value) {
+		this.dictionary.components[name] = {value};
+	}
+
+	toJS() {
+		return this.dictionary;
+	}
+};

src/parser.js

@@ -79,6 +79,11 @@ module.exports = class Parser {
 			if (Object.prototype.hasOwnProperty.call(dictionary.components, id)) {
 				let yieldValue = null;
 				let value = dictionary.components[id];
+
+				if (value.value) {
+					yieldValue = Definition.parameter(id, value.value);
+				}
+
 				if (value.module) {
 					let {module} = value;
 					yieldValue = Definition.module(id, this.__getPath(module));

tests/component/test.js

@@ -6,13 +6,21 @@ const classFixture = require('./class');
 describe('Canister.js', function() {
 	it('can build container from yml config file', function() {
 
+		const injectedComponent = String('ABC');
+		const injectedParameter = 12398;
+
+
 		const moduleLoader = new canister.ModuleLoader(__dirname);
 		const builder = new canister.Builder(moduleLoader);
 		const yamlLoader = new canister.definitionLoader.YAML();
 		const envLoader = new canister.definitionLoader.Environment({CONFIG_OVERRIDE: 1, CONFIG_NESTED_A_BIT__OVERRIDE: 2});
+		const valueLoader = new canister.definitionLoader.Value();
+
 
 		yamlLoader.fromFile(path.join(__dirname, './wiring.yml'));
 		envLoader.load();
+		valueLoader.parameter('injected.parameter', injectedParameter);
+		valueLoader.component('injected.component', injectedComponent);
 
 		const parser = new canister.Parser();
 
@@ -24,6 +32,10 @@ describe('Canister.js', function() {
 			builder.addDefinition(definition);
 		}
 
+		for (let definition of parser.parse(valueLoader.toJS())) {
+			builder.addDefinition(definition);
+		}
+
 		const container = builder.build();
 
 		expect(container.get('my.parameter')).to.equal('parameterValue');
@@ -84,5 +96,8 @@ describe('Canister.js', function() {
 
 		expect(container.get('override')).to.be.eql(1);
 		expect(container.get('nested_a_bit.override')).to.be.eql(2);
+
+		expect(container.get('injected.component')).to.be.equal(injectedComponent);
+		expect(container.get('injected.parameter')).to.be.equal(injectedParameter);
 	})
 })

tests/spec/parser.spec.js

@@ -270,7 +270,7 @@ describe('Parser', function() {
 		const compare = Definition.class('my.class', 'B', 'lib/smth', false);
 
 		expect(definition).to.be.eql(compare);
-	})
+	});
 
 	it('parses references to container', function() {
 		const parser = new Parser('/basePath');
@@ -288,5 +288,21 @@ describe('Parser', function() {
 		compare.constructWith(Definition.self());
 
 		expect(definition).to.be.eql(compare);
-	})
+	});
+
+	it('parses injected values as parameters', function() {
+		const parser = new Parser();
+
+		const definition = parser.parse({
+			components: { 'my.injected': {
+				value: parser,
+			}}
+		}).next().value;
+
+		expect(definition).to.be.an.instanceOf(Definition);
+
+		const compare = Definition.parameter('my.injected', parser);
+
+		expect(definition).to.be.eql(compare);
+	});
 });