Fiber(myFunc).run();
};
tryUsingFutures()
// using separate Future npm package
var FutureLib = require('future')
var context = { "whoami": "annie" };
var err;
var whoami = "main";
console.log("create")
var f1 = FutureLib.create(context);
// future.setTimeout(100);
f1.whenever(function (error, data) {
if (error) {
throw err;
}
console.log("f1 inner", " data: ", data, this.whoami );
});
console.log("deliver")
f1.deliver(err, {whoami: "annie"});
f1.deliver(err, {whoami: "bob"});
self.deliverer = function () {
var future = Future.create();
self.add(future);
return future.deliver;
};
(function () {
"use strict";
var npm = require('npm')
, Future = require('future')
, forEachAsync = require('forEachAsync')
, getNpmPackageInfo = require('./get-npm-package-info').getNpmPackageInfo
, future = Future.create()
, fs = require('fs')
, path = require('path')
, allModules = {}
;
function isBuiltIn(builtIns, modulename) {
return -1 !== builtIns.indexOf(modulename);
}
function sortDeps(packageTree, builtIns, callback) {
var missingDeps = {}
, npmDeps = {}
, localDeps = {}
, builtIn = {}
, superDependencyTree = {}
, dependencyList = {}
;
function sortDepsHelper(dependencyTree, callback) {
function eachDep(next, modulename) {
var module = dependencyTree[modulename]
;
function onReady() {
// prevent super recursion
if (dependencyList[modulename]) {
next();
return;
}
dependencyList[modulename] = true;
sortDepsHelper(module.dependencyTree, next);
}
function onNpm(err, map, array) {
if (err) {
missingDeps[modulename] = module;
} else {
npmDeps[modulename] = array[0];
module.npm = true;
}
onReady();
}
if (isBuiltIn(builtIns, modulename)) {
builtIn[modulename] = module;
}
else if (module.error) {
missingDeps[modulename] = module;
}
else if (module.pathname && !module.warning) {
// fixes ISSUE#5
localDeps[modulename] = localDeps[modulename] || module;
if (module.require) {
localDeps[modulename].requiredAs[module.require] = true;
}
}
else {
// possibly something like foo/bar, for which foo is the real dependency
modulename = modulename.split('/')[0];
getNpmPackageInfo(modulename, onNpm);
return;
}
onReady();
}
function onDone() {
callback(null, missingDeps, builtIn, localDeps, npmDeps);
}
forEachAsync(Object.keys(dependencyTree || {}), eachDep).then(onDone);
}
superDependencyTree[packageTree.modulepath || packageTree.name] = packageTree;
sortDepsHelper(superDependencyTree, callback);
}
npm.load({}, future.fulfill);
module.exports.sortTreeByTypes = function () {
var args = arguments;
future.when(function () {
sortDeps.apply(null, args);
});
};
}());
function Join(global_context) {
var self = this
, data = []
, ready = []
, subs = []
, promise_only = false
, begun = false
, updated = 0
, join_future = Future.create(global_context)
;
global_context = global_context || null;
if (!isJoin(this)) {
return new Join(global_context);
}
function relay() {
var i;
if (!begun || updated !== data.length) {
return;
}
updated = 0;
join_future.deliver.apply(join_future, data);
data = new Array(data.length);
ready = new Array(ready.length);
//for (i = 0; i < data.length; i += 1) {
// data[i] = undefined;
//}
}
function init() {
var type = (promise_only ? "when" : "whenever");
begun = true;
data = new Array(subs.length);
ready = new Array(ready.length);
subs.forEach(function (sub, id) {
sub[type](function () {
var args = Array.prototype.slice.call(arguments);
data[id] = args;
if (!ready[id]) {
ready[id] = true;
updated += 1;
}
relay();
});
});
}
self.deliverer = function () {
var future = Future.create();
self.add(future);
return future.deliver;
};
self.newCallback = self.deliverer;
// fn, ctx
self.when = function () {
if (!begun) {
init();
}
join_future.when.apply(join_future, arguments);
};
// fn, ctx
self.whenever = function () {
if (!begun) {
init();
}
join_future.whenever.apply(join_future, arguments);
};
self.add = function () {
if (begun) {
throw new Error("`Join().add(Array<future> | subs1, [subs2, ...])` requires that all additions be completed before the first `when()` or `whenever()`");
}
var args = Array.prototype.slice.call(arguments);
if (0 === args.length) {
return self.newCallback();
}
args = Array.isArray(args[0]) ? args[0] : args;
args.forEach(function (sub) {
if (!sub.whenever) {
promise_only = true;
}
if (!sub.when) {
throw new Error("`Join().add(future)` requires either a promise or future");
}
subs.push(sub);
});
};
}