Software: Apache/2.2.16 (Debian). PHP/5.3.3-7+squeeze19 uname -a: Linux mail.tri-specialutilitydistrict.com 2.6.32-5-amd64 #1 SMP Tue May 13 16:34:35 UTC uid=33(www-data) gid=33(www-data) groups=33(www-data) Safe-mode: OFF (not secure) /usr/lib/python2.6/dist-packages/nevow/js/Divmod/ drwxr-xr-x |
Viewing file: Select action/file-type: // -*- test-case-name: nevow.test.test_javascript -*- // import Divmod Divmod.Defer.AlreadyCalledError = Divmod.Class.subclass("Divmod.Defer.AlreadyCalledError"); Divmod.Defer.Failure = Divmod.Class.subclass("Divmod.Defer.Failure"); Divmod.Defer.Failure.methods( function __init__(self, error) { self.error = error; }, /** * Return the underlying Error instance if it is an instance of the given * error class, otherwise return null; */ function check(self, errorType) { if (self.error instanceof errorType) { return self.error; } return null; }, function toString(self) { return 'Failure: ' + self.error; }, function parseStack(self) { var stackString = self.error.stack; var frames = []; var line; var parts; var func; var rest; var divide; var fname; var lineNumber; var lines = stackString.split('\n'); for (var i = 0, line = lines[i]; i < lines.length; ++i, line = lines[i]) { if (line.indexOf('@') == -1) { continue; } parts = line.split('@', 2); func = parts.shift(); rest = parts.shift(); divide = rest.lastIndexOf(':'); if (divide == -1) { fname = rest; lineNumber = 0; } else { fname = rest.substr(0, divide); lineNumber = parseInt(rest.substr(divide + 1, rest.length)); } frames.unshift({func: func, fname: fname, lineNumber: lineNumber}); } return frames; }, /** * Return a list of 'frames' from the stack, with many of the frames * filtered out. The removed frames are those which are added for every * single method call. * * @return: [{fname: <filename as string>, * lineNumber: <line number as int>, * func: <function that the frame is inside as string>}] */ function filteredParseStack(self) { var frames = self.parseStack(); var ret = []; for (var i = 0; i < frames.length; ++i) { var f = frames[i]; if (f.fname == "" && f.lineNumber == 0) { ret.pop(); continue; } ret.push(f); }; return ret; }, /** * Format a single frame from L{Failure.filteredParseStack} as a pretty * string. * * @return: string */ function frameToPrettyText(self, frame) { return ' Function "' + frame.func + '":\n ' + frame.fname + ':' + frame.lineNumber; }, /** * Return a nicely formatted stack trace using L{Failure.frameToPrettyText}. */ function toPrettyText(self, /* optional */ frames) { if (frames == undefined) { frames = self.parseStack(); } var ret = 'Traceback (most recent call last):\n'; for (var i = 0; i < frames.length; ++i) { ret += self.frameToPrettyText(frames[i]) + '\n'; } return ret + self.error; }, function toPrettyNode(self) { var stack = self.error.stack; if (!stack) { return document.createTextNode(self.toString()); } var frames = self.parseStack(); var resultNode = document.createElement('div'); resultNode.style.overflow = 'scroll'; resultNode.style.height = 640; resultNode.style.width = 480; var frameNode; for (var i = 0, f = frames[i]; i < frames.length; ++i, f = frames[i]) { if (f.lineNumber == 0) { continue; } frameNode = document.createElement('div'); frameNode.appendChild(document.createTextNode(f.fname + '|' + f.lineNumber)); resultNode.appendChild(frameNode); frameNode = document.createElement('div'); frameNode.appendChild(document.createTextNode(f.func)); resultNode.appendChild(frameNode); } return resultNode; }); Divmod.Defer.Deferred = Divmod.Class.subclass("Divmod.Defer.Deferred"); Divmod.Defer.Deferred.methods( function __init__(self) { self._callbacks = []; self._called = false; self._pauseLevel = 0; }, function addCallbacks(self, callback, errback, callbackArgs, errbackArgs) { if (!callbackArgs) { callbackArgs = []; } if (!errbackArgs) { errbackArgs = []; } self._callbacks.push([callback, errback, callbackArgs, errbackArgs]); if (self._called) { self._runCallbacks(); } return self; }, function addCallback(self, callback) { var callbackArgs = []; for (var i = 2; i < arguments.length; ++i) { callbackArgs.push(arguments[i]); } self.addCallbacks(callback, null, callbackArgs, null); return self; }, function addErrback(self, errback) { var errbackArgs = []; for (var i = 2; i < arguments.length; ++i) { errbackArgs.push(arguments[i]); } self.addCallbacks(null, errback, null, errbackArgs); return self; }, function addBoth(self, callback) { var callbackArgs = []; for (var i = 2; i < arguments.length; ++i) { callbackArgs.push(arguments[i]); } self.addCallbacks(callback, callback, callbackArgs, callbackArgs); return self; }, function _pause(self) { self._pauseLevel++; }, function _unpause(self) { self._pauseLevel--; if (self._pauseLevel) { return; } if (!self._called) { return; } self._runCallbacks(); }, function _isFailure(self, obj) { return (obj instanceof Divmod.Defer.Failure); }, function _isDeferred(self, obj) { return (obj instanceof Divmod.Defer.Deferred); }, function _continue(self, result) { self._result = result; self._unpause(); }, function _runCallbacks(self) { if (!self._pauseLevel) { var cb = self._callbacks; self._callbacks = []; while (cb.length) { var item = cb.shift(); if (self._isFailure(self._result)) { var callback = item[1]; var args = item[3]; } else { var callback = item[0]; var args = item[2]; } if (callback == null) { continue; } args.unshift(self._result); try { self._result = callback.apply(null, args); if (self._isDeferred(self._result)) { self._callbacks = cb; self._pause(); self._result.addBoth(function (r) { self._continue(r); }); break; } } catch (e) { self._result = Divmod.Defer.Failure(e); } } } if (self._isFailure(self._result)) { // This might be spurious Divmod.err(self._result.error); } }, function _startRunCallbacks(self, result) { if (self._called) { throw new Divmod.Defer.AlreadyCalledError(); } self._called = true; self._result = result; self._runCallbacks(); }, function callback(self, result) { self._startRunCallbacks(result); }, function errback(self, err) { if (!self._isFailure(err)) { err = new Divmod.Defer.Failure(err); } self._startRunCallbacks(err); }); Divmod.Defer.succeed = function succeed(result) { var d = new Divmod.Defer.Deferred(); d.callback(result); return d; }; Divmod.Defer.fail = function fail(err) { var d = new Divmod.Defer.Deferred(); d.errback(err); return d; }; /** * First error to occur in a DeferredList if fireOnOneErrback is set. * * @ivar err: the L{Divmod.Defer.Failure} that occurred. * * @ivar index: the index of the Deferred in the DeferredList where it * happened. */ Divmod.Defer.FirstError = Divmod.Error.subclass('Divmod.Defer.FirstError'); Divmod.Defer.FirstError.methods( function __init__(self, err, index) { Divmod.Defer.FirstError.upcall(self, '__init__'); self.err = err; self.index = index; }, function toString(self) { return '<FirstError @ ' + self.index + ': ' + self.err.toString() + '>'; }); /* * I combine a group of deferreds into one callback. * * I track a list of L{Deferred}s for their callbacks, and make a single * callback when they have all completed, a list of (success, result) tuples, * 'success' being a boolean. * * Note that you can still use a L{Deferred} after putting it in a * DeferredList. For example, you can suppress 'Unhandled error in Deferred' * messages by adding errbacks to the Deferreds *after* putting them in the * DeferredList, as a DeferredList won't swallow the errors. (Although a more * convenient way to do this is simply to set the consumeErrors flag) */ Divmod.Defer.DeferredList = Divmod.Defer.Deferred.subclass('Divmod.Defer.DeferredList'); Divmod.Defer.DeferredList.methods( /* Initialize a DeferredList. * * @type deferredList: C{Array} of L{Divmod.Defer.Deferred}s * * @param deferredList: The list of deferreds to track. * * @param fireOnOneCallback: A flag indicating that only one callback needs * to be fired for me to call my callback. * * @param fireOnOneErrback: A flag indicating that only one errback needs to * be fired for me to call my errback. * * @param consumeErrors: A flag indicating that any errors raised in the * original deferreds should be consumed by this DeferredList. This is * useful to prevent spurious warnings being logged. */ function __init__(self, deferredList, /* optional */ fireOnOneCallback /* = false */, fireOnOneErrback /* = false */, consumeErrors /* = false */) { self.resultList = new Array(deferredList.length); Divmod.Defer.DeferredList.upcall(self, '__init__'); // don't callback in the fireOnOneCallback case because the result // type is different. if (deferredList.length == 0 && !fireOnOneCallback) { self.callback(self.resultList); } if (fireOnOneCallback == undefined) { fireOnOneCallback = false; } if (fireOnOneErrback == undefined) { fireOnOneErrback = false; } if (consumeErrors == undefined) { consumeErrors = false; } /* These flags need to be set *before* attaching callbacks to the * deferreds, because the callbacks use these flags, and will run * synchronously if any of the deferreds are already fired. */ self.fireOnOneCallback = fireOnOneCallback; self.fireOnOneErrback = fireOnOneErrback; self.consumeErrors = consumeErrors; self.finishedCount = 0; for (var index = 0; index < deferredList.length; ++index) { deferredList[index].addCallbacks(function(result, index) { self._cbDeferred(result, true, index); }, function(err, index) { self._cbDeferred(err, false, index); }, [index], [index]); } }, function _cbDeferred(self, result, success, index) { self.resultList[index] = [success, result]; self.finishedCount += 1; if (!self._called) { if (success && self.fireOnOneCallback) { self.callback([result, index]); } else if (!success && self.fireOnOneErrback) { self.errback(new Divmod.Defer.FirstError(result, index)); } else if (self.finishedCount == self.resultList.length) { self.callback(self.resultList); } } if (!success && self.consumeErrors) { return null; } else { return result; } }); /* Returns list with result of given Deferreds. * * This builds on C{DeferredList} but is useful since you don't need to parse * the result for success/failure. * * @type deferredList: C{Array} of L{Divmod.Defer.Deferred}s */ Divmod.Defer.gatherResults = function gatherResults(deferredList) { var d = new Divmod.Defer.DeferredList(deferredList, false, true, false); d.addCallback(function(results) { var undecorated = []; for (var i = 0; i < results.length; ++i) { undecorated.push(results[i][1]); } return undecorated; }); return d; }; |
:: Command execute :: | |
--[ c99shell v. 2.0 [PHP 7 Update] [25.02.2019] maintained by KaizenLouie | C99Shell Github | Generation time: 0.02 ]-- |