implements the new .eageryLoadAll()

lib/examplesSpec.js

@@ -13,19 +13,21 @@ test('bind to instance', function* (t) {
   t.is(yield bind.get('myInstance'), anInstance)
 })
 
-test.skip('bind to instance, with bundle', function* (t) {
-  const anInstance = Promise.resolve({}) // Promises will be resolved
+test('bind to instance, with eager loading', function* (t) {
+  const anInstance = Promise.resolve('my instance object')
   const bind = pluto()
-  bind('myInstance').toInstance(anInstance)
+  bind('myInstance').toInstance(anInstance)  // Promises will be resolved
 
   // bind.get will return a Promise, since we may have asynchronous resolution to
-  t.is(yield bind.get('myInstance'), anInstance)
+  t.is(yield bind.get('myInstance'), 'my instance object')
 
   // ... or eagerly load everything
-  const app = bind.eagerlyLoadAll()
+  const app = yield bind.eagerlyLoadAll()
 
-  // ...and then everything can be retrieved synchronously
-  t.is(app.get('myInstance'), anInstance)
+  // ...and then everything can be retrieved synchronously.
+  // All factory and constructor functions will be called.
+  // All Promise results will be resolved.
+  t.is(app.get('myInstance'), 'my instance object')
 })
 
 test('bind to constructor', function* (t) {

lib/pluto.js

@@ -7,7 +7,7 @@ function isPromise(obj) {
 }
 
 function pluto() {
-  const namesToResolvers = {}
+  const namesToResolvers = new Map()
 
   function createInstanceResolver(instance) {
     return function () {
@@ -90,7 +90,7 @@ function pluto() {
 
   const get = _.memoize((name) => {
     return new Promise((resolve, reject) => {
-      const resolver = namesToResolvers[name]
+      const resolver = namesToResolvers.get(name)
       if (!resolver) {
         reject(new Error(`nothing is mapped for name '${name}'`))
       }
@@ -106,14 +106,21 @@ function pluto() {
   }
 
   function eagerlyLoadAll() {
-    _.keys(namesToResolvers).forEach(function (name) {
-      get(name)
+    const result = new Map()
+    const promises = []
+    for (let name of namesToResolvers.keys()) {
+      promises.push(get(name).then((value) => {
+        result.set(name, value)
+      }))
+    }
+    return Promise.all(promises).then(() => {
+      return result
     })
   }
 
   function bind(name) {
     function validateBinding(target) {
-      if (_.has(namesToResolvers, name)) {
+      if (namesToResolvers.has(name)) {
         throw Error(`module already contains a mapping with the name '${name}'`)
       }
       if (_.isUndefined(target)) {
@@ -133,17 +140,17 @@ function pluto() {
     return {
       toInstance: function (instance) {
         validateBinding(instance)
-        namesToResolvers[name] = createInstanceResolver(instance)
+        namesToResolvers.set(name, createInstanceResolver(instance))
       },
       toFactory: function (factory) {
         validateBinding(factory)
         validateTargetIsAFunction(factory)
-        namesToResolvers[name] = createFactoryResolver(factory)
+        namesToResolvers.set(name, createFactoryResolver(factory))
       },
       toConstructor: function (constructor) {
         validateBinding(constructor)
         validateTargetIsAFunction(constructor)
-        namesToResolvers[name] = createConstructorResolver(constructor)
+        namesToResolvers.set(name, createConstructorResolver(constructor))
       }
     }
   }

lib/plutoSpec.js

@@ -464,20 +464,28 @@ test('Module.getAll([names]) throws if a name is unmapped', function* (t) {
   t.is(error.message, "nothing is mapped for name 'totally bogus key'")
 })
 
-test.skip('Module.eageryLoadAll executes all factory and constructor functions', function* (t) {
+test('bind.eageryLoadAll executes all factory and constructor functions', function* (t) {
   let constructorCalled = false
   let factoryCalled = false
 
-  const bind = pluto()
-  bind('Constructor').toConstructor(function FakeConstructor() {
+  function FakeConstructor() {
     constructorCalled = true
-  })
-  bind('factory').toFactory(function fakeFactory() {
+  }
+
+  function fakeFactory() {
     factoryCalled = true
-  })
+    return Promise.resolve('fake-factory-result')
+  }
 
-  bind.eagerlyLoadAll()
+  const bind = pluto()
+  bind('Constructor').toConstructor(FakeConstructor)
+  bind('factory').toFactory(fakeFactory)
+
+  const app = yield bind.eagerlyLoadAll()
 
   t.truthy(constructorCalled, 'constructor is called')
   t.truthy(factoryCalled, 'factory function is called')
+
+  t.truthy(app.get('Constructor') instanceof FakeConstructor)
+  t.is(app.get('factory'), 'fake-factory-result')
 })