Merge pull request ecomfe#30 from ecomfe/develop

release 0.3.0

Author: Exodia

README.md

@@ -256,6 +256,61 @@ var ioc = IoC({ components: components });
 
 如上代码：appData 与 creativeData 重用了 requestStrategy 的配置，并覆盖了 args 的配置项。
 
+## 集合操作符 $list 与 $map
+
+$list 与 $map 让我们可以声明某个依赖为数组或映射表集合，在集合配置中，我们还可以**嵌套的使用 uioc 提供的各种操作符（$import, $ref, $list, $map）进行更深层次的依赖声明**。
+
+$list 可以让一系列的依赖以数组集合的形式注入到实例上，$list的配置为数组：{$list: ['value', {$ref: 'dep'}, {$list: ['nested value']}]}
+
+$map 则是让一系列的依赖以对象集合的形式注入到实例上，$map的配置为简单的对象: {$map: {value: 1, dep: {$ref: 'dep'}, nest: {$map: {nestProp: 'nested prop'}}}
+
+demo 如下：
+
+```javascript
+var components = {
+      a: {
+          creator: function () {
+              this.say = function () {
+                  console.log('a');
+              };
+          }
+      },
+      b: {
+         creator: function () {
+             this.say = function () {
+                  console.log('b');
+              };
+         }
+      },
+      main: {
+         creator: function (name, listArg) {
+            this.name = name;
+            this.listArg = listArg;
+            this.say = function () {
+                console.log(this.name);
+                this.listArg.forEach(function (item) {
+                    item.say();
+                });
+            };
+         },
+         args: ['main', {$list: [{$ref: 'a'}, {$ref: 'b'}]}],
+         properties: {
+              mapCollection: {
+                    a: {$ref: 'a'},
+                    b: {$ref: 'b'}
+              }
+         }
+      }
+};
+
+var ioc = IoC({components: components});
+ioc.getComponent('main', function (main) {
+    main.say(); // 输出：main a b
+    main.mapCollection.a.say(); // 输出 a
+    main.mapCollection.b.say(); // 输出 b
+});
+
+```
 
 ## [API](http://ecomfe.github.io/uioc/doc/IoC.html)
 

package.json

@@ -1,6 +1,6 @@
 {
     "name": "uioc",
-    "version": "0.2.1",
+    "version": "0.3.0",
     "description": "an ioc framework",
     "main": "main.js",
     "maintainers": {

src/Container.js

@@ -44,4 +44,4 @@ void function (define) {
             return DependencyNode;
         });
 
-}(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory; });
+}(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });

src/DependencyParser.js

@@ -0,0 +1,112 @@
+void function (define) {
+    define(
+        function (require) {
+            var u = require('./util');
+
+            function Injector(context) {
+                this.context = context;
+                this.singletons = {};
+            }
+
+            Injector.prototype.createInstance = function (component, cb) {
+                if (!component) {
+                    return cb(null);
+                }
+
+                var id = component.id;
+                if (component.scope === 'singleton' && u.hasOwn(this.singletons, id)) {
+                    return cb(this.singletons[id]);
+                }
+
+                if (component.scope === 'static') {
+                    return cb(component.creator);
+                }
+
+                var me = this;
+                this.injectArgs(component, function (args) {
+                    var instance = component.creator.apply(null, args);
+                    if (component.scope === 'singleton') {
+                        me.singletons[id] = instance;
+                    }
+                    cb(instance);
+                });
+            };
+
+            Injector.prototype.injectArgs = function (componentConfig, cb) {
+                var argConfigs = componentConfig.args;
+                var count = argConfigs.length;
+                var args = new Array(count);
+                var ref = this.context.operators.ref;
+                if (!count) {
+                    return cb(args);
+                }
+
+                var done = function (index) {
+                    return function (instance) {
+                        args[index] = instance;
+                        --count === 0 && cb(args);
+                    };
+                };
+
+                for (var i = argConfigs.length - 1; i > -1; --i) {
+                    var arg = argConfigs[i];
+                    ref.has(arg) ? this.context.getComponent(arg.$ref, done(i)) : done(i)(arg);
+                }
+            };
+
+            Injector.prototype.injectProperties = function injectProperties(instance, componentConfig, cb) {
+                var deps = componentConfig.propDeps;
+                var props = componentConfig.properties;
+                var ref = this.context.operators.ref;
+                var setter = this.context.operators.setter;
+
+                this.context.getComponent(deps, function () {
+                    for (var k in props) {
+                        var property = props[k];
+                        var value = ref.has(property) ? arguments[u.indexOf(deps, property.$ref)] : property;
+                        setter.setProperty(instance, k, value, setter.has(property) && property.$setter);
+                    }
+                    cb();
+                });
+            };
+
+            Injector.prototype.injectSetters = function (instance, componentConfig, cb) {
+                var deps = componentConfig.setterDeps || [];
+                var setter = this.context.operators.setter;
+
+                this.context.getComponent(deps, function () {
+                    for (var i = deps.length - 1; i > -1; --i) {
+                        var dep = deps[i];
+                        setter.setProperty(instance, dep, arguments[i]);
+                    }
+                    cb();
+                });
+            };
+
+            Injector.prototype.injectDependencies = function (instance, componentConfig, cb) {
+                var complete = {
+                    prop: false,
+                    setter: false
+                };
+                var done = function (type) {
+                    complete[type] = true;
+                    complete.prop && complete.setter && cb();
+                };
+                this.injectProperties(instance, componentConfig, u.bind(done, null, 'prop'));
+                this.injectSetters(instance, componentConfig, u.bind(done, null, 'setter'));
+            };
+
+            Injector.prototype.dispose = function () {
+                var singletons = this.singletons;
+                for (var k in singletons) {
+                    var instance = singletons[k];
+                    instance && typeof instance.dispose === 'function' && instance.dispose();
+                }
+
+                this.singletons = null;
+            };
+
+            return Injector;
+        });
+
+}(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });