Merge pull request #39 from Spy-Seth/feature/allow-to-depend--on-the-container-itself

Inject the container instance as service dependency

Author: armandabric

index.js

@@ -1,3 +1,22 @@
 'use strict';
 
-module.exports = require('./src/ContainerFactory');
+// ES5 equivalent of ES6 modules `export`
+// @see https://github.com/addyosmani/es6-equivalents-in-es5#modules
+// This allow the end user to do an ES6 import:
+//      `import ContainerFactory, { Container } from 'skippy';`
+
+var _extends = function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+            target[key] = source[key];
+        }
+    }
+
+    return target;
+};
+
+exports.Container = require('./src/Container');
+exports['default'] = require('./src/ContainerFactory');
+
+module.exports = _extends(exports['default'], exports);

src/FunctionArgument.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var CONTAINER_SERVICE_NAME = '@container';
+
 /**
  * @param {*} value
  * @constructor
@@ -36,6 +38,19 @@ FunctionArgument.prototype._isParameterReference = function _isParameterReferenc
     return variableReferenceRegex.test(argumentValue);
 };
 
+/**
+ * @param {*} argumentValue
+ * @return {boolean}
+ * @private
+ */
+FunctionArgument.prototype._isContainerReference = function _isContainerReference(argumentValue) {
+    if (!this._isString(argumentValue)) {
+        return false;
+    }
+
+    return argumentValue === CONTAINER_SERVICE_NAME;
+};
+
 /**
  * @param {*} argumentValue
  * @return {boolean}
@@ -59,6 +74,8 @@ FunctionArgument.prototype._isServiceReference = function _isServiceReference(ar
 FunctionArgument.prototype._detectType = function _detectType(argumentValue) {
     if (this._isParameterReference(argumentValue)) {
         return FunctionArgument.TYPE_PARAMETER_REFERENCE;
+    } else if (this._isContainerReference(argumentValue)) {
+        return FunctionArgument.TYPE_CONTAINER_REFERENCE;
     } else if (this._isServiceReference(argumentValue)) {
         return FunctionArgument.TYPE_SERVICE_REFERENCE;
     }
@@ -123,7 +140,9 @@ FunctionArgument.prototype.isParameterReference = function isParameterReference(
  * @return {*}
  */
 FunctionArgument.prototype.resolve = function resolve(container) {
-    if (FunctionArgument.TYPE_PARAMETER_REFERENCE === this.type) {
+    if (FunctionArgument.TYPE_CONTAINER_REFERENCE === this.type) {
+        return container;
+    } else if (FunctionArgument.TYPE_PARAMETER_REFERENCE === this.type) {
         return container.getParameter(this._extractReferencedParameterName(this.name));
     } else if (FunctionArgument.TYPE_SERVICE_REFERENCE === this.type) {
         return container.getService(this._extractReferencedServiceName(this.name));
@@ -132,6 +151,7 @@ FunctionArgument.prototype.resolve = function resolve(container) {
     return this.name;
 };
 
+FunctionArgument.TYPE_CONTAINER_REFERENCE = 'container-reference';
 FunctionArgument.TYPE_PARAMETER_REFERENCE = 'parameter-reference';
 FunctionArgument.TYPE_SERVICE_REFERENCE = 'service-reference';
 FunctionArgument.TYPE_VALUE = 'simple-value';

tests/fixture/valid/ServiceThatDependOnTheContainer.js

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * @constructor
+ */
+var ServiceThatDependOnTheContainer = function ServiceThatDependOnTheContainer(container) {
+    this.container = container;
+};
+
+ServiceThatDependOnTheContainer.prototype.getContainer = function getContainer() {
+    return this.container;
+};
+
+module.exports = ServiceThatDependOnTheContainer;

tests/fixture/valid/services.js

@@ -46,6 +46,15 @@ module.exports = {
         {
             'name': 'foo.serviceE',
             'service': require('./ServiceE')
-        }
+        },
+
+        {
+            'name': 'foo.service.that.depend.on.the.container',
+            'service': require('./ServiceThatDependOnTheContainer'),
+            'arguments': [
+                '@container',
+            ],
+            'singleton': true
+        },
     ]
 };

tests/functionals/ContainerFactorySpec.js

@@ -7,6 +7,7 @@ var servicesConfigurationErroredWithCyclicDependencies = require('./../fixture/e
 var servicesConfigurationErroredWithUnknownDependencies = require('./../fixture/errored-with-unknown-dependencies/services');
 var servicesConfigurationErroredWithInvalidCalls = require('./../fixture/errored-with-invalid-calls/services');
 var ServiceA = require('./../fixture/valid/ServiceA');
+var ServiceThatDependOnTheContainer = require('./../fixture/valid/ServiceThatDependOnTheContainer');
 
 describe('ContainerFactory', function () {
     it('should return the parameter value', function () {
@@ -159,4 +160,11 @@ describe('ContainerFactory', function () {
             ContainerFactory.create(servicesConfigurationErroredWithInvalidCalls.services, servicesConfigurationErroredWithInvalidCalls.parameters);
         }).to.not.throw();
     });
+
+    it('should inject itself as service dependency', function () {
+        var container = ContainerFactory.create(servicesConfigurationValid.services, servicesConfigurationValid.parameters);
+
+        var service = container.getService('foo.service.that.depend.on.the.container');
+        expect(service.getContainer()).to.be.equal(container);
+    });
 });