Skip to content

Commit

Permalink
Added support for a Promise of an Array for Deft.Promise.any(), all()…
Browse files Browse the repository at this point in the history 
…, map(), reduce()

Fixes #6
  • Loading branch information
John Yanarella committed Aug 1, 2012
1 parent 01631e2 commit 767e913
Show file tree
Hide file tree
Showing 4 changed files with 405 additions and 348 deletions.
262 changes: 141 additions & 121 deletions build/deft-debug.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1439,110 +1439,120 @@ Ext.define('Deft.promise.Promise', {
*/

all: function(promisesOrValues) {
var cancelFunction, canceller, complete, createSuccessFunction, deferred, failureFunction, index, progressFunction, promiseOrValue, rejecter, resolvedCount, resolvedValues, resolver, total, updater, _i, _len;
deferred = Ext.create('Deft.promise.Deferred');
total = promisesOrValues.length;
resolvedValues = new Array(promisesOrValues);
resolvedCount = 0;
updater = function(progress) {
deferred.update(progress);
};
resolver = function(index, value) {
resolvedValues[index] = value;
resolvedCount++;
if (resolvedCount === total) {
complete();
deferred.resolve(resolvedValues);
}
};
rejecter = function(error) {
complete();
deferred.reject(error);
};
canceller = function(reason) {
complete();
deferred.cancel(reason);
};
complete = function() {
return updater = resolver = rejecter = canceller = Ext.emptyFn;
};
createSuccessFunction = function(index) {
return function(value) {
return resolver(index, value);
};
};
failureFunction = function(value) {
return rejecter(value);
};
progressFunction = function(value) {
return updater(value);
};
cancelFunction = function(value) {
return canceller(value);
};
for (index = _i = 0, _len = promisesOrValues.length; _i < _len; index = ++_i) {
promiseOrValue = promisesOrValues[index];
if (index in promisesOrValues) {
this.when(promiseOrValue).then({
success: createSuccessFunction(index),
failure: failureFunction,
progress: progressFunction,
cancel: cancelFunction
});
}
}
return deferred.getPromise();
return this.when(promisesOrValues).then({
success: function(promisesOrValues) {
var cancelFunction, canceller, complete, createSuccessFunction, deferred, failureFunction, index, progressFunction, promiseOrValue, rejecter, resolvedCount, resolvedValues, resolver, total, updater, _i, _len;
deferred = Ext.create('Deft.promise.Deferred');
total = promisesOrValues.length;
resolvedValues = new Array(promisesOrValues);
resolvedCount = 0;
updater = function(progress) {
deferred.update(progress);
};
resolver = function(index, value) {
resolvedValues[index] = value;
resolvedCount++;
if (resolvedCount === total) {
complete();
deferred.resolve(resolvedValues);
}
};
rejecter = function(error) {
complete();
deferred.reject(error);
};
canceller = function(reason) {
complete();
deferred.cancel(reason);
};
complete = function() {
return updater = resolver = rejecter = canceller = Ext.emptyFn;
};
createSuccessFunction = function(index) {
return function(value) {
return resolver(index, value);
};
};
failureFunction = function(value) {
return rejecter(value);
};
progressFunction = function(value) {
return updater(value);
};
cancelFunction = function(value) {
return canceller(value);
};
for (index = _i = 0, _len = promisesOrValues.length; _i < _len; index = ++_i) {
promiseOrValue = promisesOrValues[index];
if (index in promisesOrValues) {
this.when(promiseOrValue).then({
success: createSuccessFunction(index),
failure: failureFunction,
progress: progressFunction,
cancel: cancelFunction
});
}
}
return deferred.getPromise();
},
scope: this
});
},
/**
Returns a new {@link Deft.promise.Promise} that will only resolve once any one of the the specified `promisesOrValues` has resolved.
The resolution value will be the resolution value of the triggering `promiseOrValue`.
*/

any: function(promisesOrValues) {
var cancelFunction, canceller, complete, deferred, failureFunction, index, progressFunction, promiseOrValue, rejecter, resolver, successFunction, updater, _i, _len;
deferred = Ext.create('Deft.promise.Deferred');
updater = function(progress) {
deferred.update(progress);
};
resolver = function(value) {
complete();
deferred.resolve(value);
};
rejecter = function(error) {
complete();
deferred.reject(error);
};
canceller = function(reason) {
complete();
return deferred.cancel(reason);
};
complete = function() {
return updater = resolver = rejecter = canceller = Ext.emptyFn;
};
successFunction = function(value) {
return resolver(value);
};
failureFunction = function(value) {
return rejecter(value);
};
progressFunction = function(value) {
return updater(value);
};
cancelFunction = function(value) {
return canceller(value);
};
for (index = _i = 0, _len = promisesOrValues.length; _i < _len; index = ++_i) {
promiseOrValue = promisesOrValues[index];
if (index in promisesOrValues) {
this.when(promiseOrValue).then({
success: successFunction,
failure: failureFunction,
progress: progressFunction,
cancel: cancelFunction
});
}
}
return deferred.getPromise();
return this.when(promisesOrValues).then({
success: function(promisesOrValues) {
var cancelFunction, canceller, complete, deferred, failureFunction, index, progressFunction, promiseOrValue, rejecter, resolver, successFunction, updater, _i, _len;
deferred = Ext.create('Deft.promise.Deferred');
updater = function(progress) {
deferred.update(progress);
};
resolver = function(value) {
complete();
deferred.resolve(value);
};
rejecter = function(error) {
complete();
deferred.reject(error);
};
canceller = function(reason) {
complete();
return deferred.cancel(reason);
};
complete = function() {
return updater = resolver = rejecter = canceller = Ext.emptyFn;
};
successFunction = function(value) {
return resolver(value);
};
failureFunction = function(value) {
return rejecter(value);
};
progressFunction = function(value) {
return updater(value);
};
cancelFunction = function(value) {
return canceller(value);
};
for (index = _i = 0, _len = promisesOrValues.length; _i < _len; index = ++_i) {
promiseOrValue = promisesOrValues[index];
if (index in promisesOrValues) {
this.when(promiseOrValue).then({
success: successFunction,
failure: failureFunction,
progress: progressFunction,
cancel: cancelFunction
});
}
}
return deferred.getPromise();
},
scope: this
});
},
/**
Returns a new function that wraps the specified function and caches the results for previously processed inputs.
Expand All @@ -1560,36 +1570,46 @@ Ext.define('Deft.promise.Promise', {
*/

map: function(promisesOrValues, mapFunction) {
var index, promiseOrValue, results, _i, _len;
results = new Array(promisesOrValues.length);
for (index = _i = 0, _len = promisesOrValues.length; _i < _len; index = ++_i) {
promiseOrValue = promisesOrValues[index];
if (index in promisesOrValues) {
results[index] = this.when(promiseOrValue).then(mapFunction);
}
}
return this.reduce(results, this.reduceIntoArray, results);
return this.when(promisesOrValues).then({
success: function(promisesOrValues) {
var index, promiseOrValue, results, _i, _len;
results = new Array(promisesOrValues.length);
for (index = _i = 0, _len = promisesOrValues.length; _i < _len; index = ++_i) {
promiseOrValue = promisesOrValues[index];
if (index in promisesOrValues) {
results[index] = this.when(promiseOrValue).then(mapFunction);
}
}
return this.reduce(results, this.reduceIntoArray, results);
},
scope: this
});
},
/**
Traditional reduce function, similar to `Array.reduce()`, that allows input to contain promises and/or values.
*/

reduce: function(promisesOrValues, reduceFunction, initialValue) {
var reduceArguments, whenFn;
whenFn = this.when;
reduceArguments = [
function(previousValueOrPromise, currentValueOrPromise, currentIndex) {
return whenFn(previousValueOrPromise).then(function(previousValue) {
return whenFn(currentValueOrPromise).then(function(currentValue) {
return reduceFunction(previousValue, currentValue, currentIndex, promisesOrValues);
});
});
}
];
if (arguments.length === 3) {
reduceArguments.push(initialValue);
}
return this.when(this.reduceArray.apply(promisesOrValues, reduceArguments));
return this.when(promisesOrValues).then({
success: function(promisesOrValues) {
var reduceArguments, whenFunction;
whenFunction = this.when;
reduceArguments = [
function(previousValueOrPromise, currentValueOrPromise, currentIndex) {
return whenFunction(previousValueOrPromise).then(function(previousValue) {
return whenFunction(currentValueOrPromise).then(function(currentValue) {
return reduceFunction(previousValue, currentValue, currentIndex, promisesOrValues);
});
});
}
];
if (arguments.length === 3) {
reduceArguments.push(initialValue);
}
return this.when(this.reduceArray.apply(promisesOrValues, reduceArguments));
},
scope: this
});
},
/**
Fallback implementation when Array.reduce is not available.
Expand Down
Loading

0 comments on commit 767e913

Please sign in to comment.