<?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="generator" content="Docutils 0.4: http://docutils.sourceforge.net/" /> <title>MochiKit.Async - manage asynchronous tasks</title> <link rel="stylesheet" href="../../../include/css/documentation.css" type="text/css" /> <script type="text/javascript" src="../../../packed/lib/MochiKit/MochiKit.js"></script> <script type="text/javascript" src="../../js/toc.js"></script> </head> <body> <a href="http://mochikit.com"><img id="mainlink" src="../../../include/_img/g_logo_doc.gif" alt="MochiKit" /></a> <a class='indexlink' href='index.html'>Back to docs index</a> <div class="document"> <div class="section"> <h1><a id="name" name="name">Name</a></h1> <p>MochiKit.Async - manage asynchronous tasks</p> </div> <div class="section"> <h1><a id="synopsis" name="synopsis">Synopsis</a></h1> <pre class="literal-block"> var url = "/src/b/bo/bob/MochiKit.Async/META.json"; /* META.json looks something like this: {"name": "MochiKit", "version": "0.5"} */ var d = loadJSONDoc(url); var gotMetadata = function (meta) { if (MochiKit.Async.VERSION == meta.version) { alert("You have the newest MochiKit.Async!"); } else { alert("MochiKit.Async " + meta.version + " is available, upgrade!"); } }; var metadataFetchFailed = function (err) { alert("The metadata for MochiKit.Async could not be fetched :("); }; d.addCallbacks(gotMetadata, metadataFetchFailed); </pre> </div> <div class="section"> <h1><a id="description" name="description">Description</a></h1> <p>MochiKit.Async provides facilities to manage asynchronous (as in AJAX <a class="footnote-reference" href="#id7" id="id1" name="id1">[1]</a>) tasks. The model for asynchronous computation used in this module is heavily inspired by Twisted <a class="footnote-reference" href="#id8" id="id2" name="id2">[2]</a>.</p> </div> <div class="section"> <h1><a id="dependencies" name="dependencies">Dependencies</a></h1> <ul class="simple"> <li><a class="mochiref reference" href="Base.html">MochiKit.Base</a></li> </ul> </div> <div class="section"> <h1><a id="security-concerns" name="security-concerns">Security Concerns</a></h1> <p>The current implementation of evalJSONRequest does no input validation. Invalid JSON can execute arbitrary JavaScript code in the client. This isn't normally a concern because of the same-origin policy in web browsers; the server is already sending arbitrary code to the client (your program!).</p> <p>While this isn't directly relevant to MochiKit, server-side code that produces JSON should consider potential cross-site request forgery. Currently known exploits require a JSON array to be the outer-most object, and the data to be leaked must be known keys in objects contained by that array:</p> <pre class="literal-block"> [{"some_known_key": "this can be leaked"}, "but not this"] </pre> <p>This exploit does not apply to the most common usage of JSON, sending an object:</p> <pre class="literal-block"> {"some_known_key": "this can't be leaked"} </pre> <p>There are several ways to avoid this, here are a few:</p> <ul class="simple"> <li>Use some non-standard addition to JSON that adds constructs to prevent script tag parsing, such as wrapping the data in a comment or an infinite loop. MochiKit supports comment-wrapped JSON, but it's up to the server to send it that way.</li> <li>Require some kind of authentication token in the URL.</li> <li>Allow only POST requests to access sensitive JSON.</li> <li>Only send JSON objects, not arrays. JSON objects aren't valid JavaScript syntax on their own without parentheses.</li> </ul> </div> <div class="section"> <h1><a id="overview" name="overview">Overview</a></h1> <div class="section"> <h2><a id="deferred" name="deferred">Deferred</a></h2> <p>The Deferred constructor encapsulates a single value that is not available yet. The most important example of this in the context of a web browser would be an <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> to a server. The importance of the Deferred is that it allows a consistent API to be exposed for all asynchronous computations that occur exactly once.</p> <p>The producer of the Deferred is responsible for doing all of the complicated work behind the scenes. This often means waiting for a timer to fire, or waiting for an event (e.g. <tt class="docutils literal"><span class="pre">onreadystatechange</span></tt> of <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt>). It could also be coordinating several events (e.g. <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> with a timeout, or several Deferreds (e.g. fetching a set of XML documents that should be processed at the same time).</p> <p>Since these sorts of tasks do not respond immediately, the producer of the Deferred does the following steps before returning to the consumer:</p> <ol class="arabic simple"> <li>Create a <tt class="docutils literal"><span class="pre">new</span></tt> <a class="mochiref reference" href="#fn-deferred">Deferred();</a> object and keep a reference to it, because it will be needed later when the value is ready.</li> <li>Setup the conditions to create the value requested (e.g. create a new <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt>, set its <tt class="docutils literal"><span class="pre">onreadystatechange</span></tt>).</li> <li>Return the <a class="mochiref reference" href="#fn-deferred">Deferred</a> object.</li> </ol> <p>Since the value is not yet ready, the consumer attaches a function to the Deferred that will be called when the value is ready. This is not unlike <tt class="docutils literal"><span class="pre">setTimeout</span></tt>, or other similar facilities you may already be familiar with. The consumer can also attach an "errback" to the <a class="mochiref reference" href="#fn-deferred">Deferred</a>, which is a callback for error handling.</p> <p>When the value is ready, the producer simply calls <tt class="docutils literal"><span class="pre">myDeferred.callback(theValue)</span></tt>. If an error occurred, it should call <tt class="docutils literal"><span class="pre">myDeferred.errback(theValue)</span></tt> instead. As soon as this happens, the callback that the consumer attached to the <a class="mochiref reference" href="#fn-deferred">Deferred</a> is called with <tt class="docutils literal"><span class="pre">theValue</span></tt> as the only argument.</p> <p>There are quite a few additional "advanced" features baked into <a class="mochiref reference" href="#fn-deferred">Deferred</a>, such as cancellation and callback chains, so take a look at the API reference if you would like to know more!</p> </div> </div> <div class="section"> <h1><a id="api-reference" name="api-reference">API Reference</a></h1> <div class="section"> <h2><a id="errors" name="errors">Errors</a></h2> <p> <a name="fn-alreadycallederror"></a> <a class="mochidef reference" href="#fn-alreadycallederror">AlreadyCalledError</a>:</p> <blockquote> <p>Thrown by a <a class="mochiref reference" href="#fn-deferred">Deferred</a> if <tt class="docutils literal"><span class="pre">.callback</span></tt> or <tt class="docutils literal"><span class="pre">.errback</span></tt> are called more than once.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-browsercomplianceerror"></a> <a class="mochidef reference" href="#fn-browsercomplianceerror">BrowserComplianceError</a>:</p> <blockquote> <p>Thrown when the JavaScript runtime is not capable of performing the given function. Currently, this happens if the browser does not support <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt>.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-cancellederror"></a> <a class="mochidef reference" href="#fn-cancellederror">CancelledError</a>:</p> <blockquote> <p>Thrown by a <a class="mochiref reference" href="#fn-deferred">Deferred</a> when it is cancelled, unless a canceller is present and throws something else.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-genericerror"></a> <a class="mochidef reference" href="#fn-genericerror">GenericError</a>:</p> <blockquote> <p>Results passed to <tt class="docutils literal"><span class="pre">.fail</span></tt> or <tt class="docutils literal"><span class="pre">.errback</span></tt> of a <a class="mochiref reference" href="#fn-deferred">Deferred</a> are wrapped by this <tt class="docutils literal"><span class="pre">Error</span></tt> if <tt class="docutils literal"><span class="pre">!(result</span> <span class="pre">instanceof</span> <span class="pre">Error)</span></tt>.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-xmlhttprequesterror"></a> <a class="mochidef reference" href="#fn-xmlhttprequesterror">XMLHttpRequestError</a>:</p> <blockquote> <p>Thrown when an <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> does not complete successfully for any reason. The <tt class="docutils literal"><span class="pre">req</span></tt> property of the error is the failed <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> object, and for convenience the <tt class="docutils literal"><span class="pre">number</span></tt> property corresponds to <tt class="docutils literal"><span class="pre">req.status</span></tt>.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> </div> <div class="section"> <h2><a id="constructors" name="constructors">Constructors</a></h2> <p> <a name="fn-deferred"></a> <a class="mochidef reference" href="#fn-deferred">Deferred()</a>:</p> <blockquote> Encapsulates a sequence of callbacks in response to a value that may not yet be available. This is modeled after the Deferred class from Twisted <a class="footnote-reference" href="#id9" id="id3" name="id3">[3]</a>.</blockquote> <blockquote> <p>Why do we want this? JavaScript has no threads, and even if it did, threads are hard. Deferreds are a way of abstracting non-blocking events, such as the final response to an <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt>.</p> <p>The sequence of callbacks is internally represented as a list of 2-tuples containing the callback/errback pair. For example, the following call sequence:</p> <pre class="literal-block"> var d = new Deferred(); d.addCallback(myCallback); d.addErrback(myErrback); d.addBoth(myBoth); d.addCallbacks(myCallback, myErrback); </pre> <p>is translated into a <a class="mochiref reference" href="#fn-deferred">Deferred</a> with the following internal representation:</p> <pre class="literal-block"> [ [myCallback, null], [null, myErrback], [myBoth, myBoth], [myCallback, myErrback] ] </pre> <p>The <a class="mochiref reference" href="#fn-deferred">Deferred</a> also keeps track of its current status (fired). Its status may be one of the following three values:</p> <blockquote> <table border="1" class="docutils"> <colgroup> <col width="14%" /> <col width="86%" /> </colgroup> <thead valign="bottom"> <tr><th class="head">Value</th> <th class="head">Condition</th> </tr> </thead> <tbody valign="top"> <tr><td>-1</td> <td>no value yet (initial condition)</td> </tr> <tr><td>0</td> <td>success</td> </tr> <tr><td>1</td> <td>error</td> </tr> </tbody> </table> </blockquote> <p>A <a class="mochiref reference" href="#fn-deferred">Deferred</a> will be in the error state if one of the following conditions are met:</p> <ol class="arabic simple"> <li>The result given to callback or errback is "<tt class="docutils literal"><span class="pre">instanceof</span> <span class="pre">Error</span></tt>"</li> <li>The callback or errback threw while executing. If the thrown object is not <tt class="docutils literal"><span class="pre">instanceof</span> <span class="pre">Error</span></tt>, it will be wrapped with <a class="mochiref reference" href="#fn-genericerror">GenericError</a>.</li> </ol> <p>Otherwise, the <a class="mochiref reference" href="#fn-deferred">Deferred</a> will be in the success state. The state of the <a class="mochiref reference" href="#fn-deferred">Deferred</a> determines the next element in the callback sequence to run.</p> <p>When a callback or errback occurs with the example deferred chain, something equivalent to the following will happen (imagine that exceptions are caught and returned as-is):</p> <pre class="literal-block"> // d.callback(result) or d.errback(result) if (!(result instanceof Error)) { result = myCallback(result); } if (result instanceof Error) { result = myErrback(result); } result = myBoth(result); if (result instanceof Error) { result = myErrback(result); } else { result = myCallback(result); } </pre> <p>The result is then stored away in case another step is added to the callback sequence. Since the <a class="mochiref reference" href="#fn-deferred">Deferred</a> already has a value available, any new callbacks added will be called immediately.</p> <p>There are two other "advanced" details about this implementation that are useful:</p> <p>Callbacks are allowed to return <a class="mochiref reference" href="#fn-deferred">Deferred</a> instances, so you can build complicated sequences of events with (relative) ease.</p> <p>The creator of the <a class="mochiref reference" href="#fn-deferred">Deferred</a> may specify a canceller. The canceller is a function that will be called if <a class="mochiref reference" href="#fn-deferred.prototype.cancel">Deferred.prototype.cancel</a> is called before the <a class="mochiref reference" href="#fn-deferred">Deferred</a> fires. You can use this to allow an <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> to be cleanly cancelled, for example. Note that cancel will fire the <a class="mochiref reference" href="#fn-deferred">Deferred</a> with a <a class="mochiref reference" href="#fn-cancellederror">CancelledError</a> (unless your canceller throws or returns a different <tt class="docutils literal"><span class="pre">Error</span></tt>), so errbacks should be prepared to handle that <tt class="docutils literal"><span class="pre">Error</span></tt> gracefully for cancellable <a class="mochiref reference" href="#fn-deferred">Deferred</a> instances.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferred.prototype.addboth"></a> <a class="mochidef reference" href="#fn-deferred.prototype.addboth">Deferred.prototype.addBoth(func)</a>:</p> <blockquote> <p>Add the same function as both a callback and an errback as the next element on the callback sequence. This is useful for code that you want to guarantee to run, e.g. a finalizer.</p> <p>If additional arguments are given, then <tt class="docutils literal"><span class="pre">func</span></tt> will be replaced with <a class="mochiref reference" href="Base.html#fn-partial">MochiKit.Base.partial.apply(null, arguments)</a>. This differs from <a class="reference" href="http://twistedmatrix.com/">Twisted</a>, because the result of the callback or errback will be the <em>last</em> argument passed to <tt class="docutils literal"><span class="pre">func</span></tt>.</p> <p>If <tt class="docutils literal"><span class="pre">func</span></tt> returns a <a class="mochiref reference" href="#fn-deferred">Deferred</a>, then it will be chained (its value or error will be passed to the next callback). Note that once the returned <tt class="docutils literal"><span class="pre">Deferred</span></tt> is chained, it can no longer accept new callbacks.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferred.prototype.addcallback"></a> <a class="mochidef reference" href="#fn-deferred.prototype.addcallback">Deferred.prototype.addCallback(func[, ...])</a>:</p> <blockquote> <p>Add a single callback to the end of the callback sequence.</p> <p>If additional arguments are given, then <tt class="docutils literal"><span class="pre">func</span></tt> will be replaced with <a class="mochiref reference" href="Base.html#fn-partial">MochiKit.Base.partial.apply(null, arguments)</a>. This differs from <a class="reference" href="http://twistedmatrix.com/">Twisted</a>, because the result of the callback will be the <em>last</em> argument passed to <tt class="docutils literal"><span class="pre">func</span></tt>.</p> <p>If <tt class="docutils literal"><span class="pre">func</span></tt> returns a <a class="mochiref reference" href="#fn-deferred">Deferred</a>, then it will be chained (its value or error will be passed to the next callback). Note that once the returned <tt class="docutils literal"><span class="pre">Deferred</span></tt> is chained, it can no longer accept new callbacks.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferred.prototype.addcallbacks"></a> <a class="mochidef reference" href="#fn-deferred.prototype.addcallbacks">Deferred.prototype.addCallbacks(callback, errback)</a>:</p> <blockquote> <p>Add separate callback and errback to the end of the callback sequence. Either callback or errback may be <tt class="docutils literal"><span class="pre">null</span></tt>, but not both.</p> <p>If <tt class="docutils literal"><span class="pre">callback</span></tt> or <tt class="docutils literal"><span class="pre">errback</span></tt> returns a <a class="mochiref reference" href="#fn-deferred">Deferred</a>, then it will be chained (its value or error will be passed to the next callback). Note that once the returned <tt class="docutils literal"><span class="pre">Deferred</span></tt> is chained, it can no longer accept new callbacks.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferred.prototype.adderrback"></a> <a class="mochidef reference" href="#fn-deferred.prototype.adderrback">Deferred.prototype.addErrback(func)</a>:</p> <blockquote> <p>Add a single errback to the end of the callback sequence.</p> <p>If additional arguments are given, then <tt class="docutils literal"><span class="pre">func</span></tt> will be replaced with <a class="mochiref reference" href="Base.html#fn-partial">MochiKit.Base.partial.apply(null, arguments)</a>. This differs from <a class="reference" href="http://twistedmatrix.com/">Twisted</a>, because the result of the errback will be the <em>last</em> argument passed to <tt class="docutils literal"><span class="pre">func</span></tt>.</p> <p>If <tt class="docutils literal"><span class="pre">func</span></tt> returns a <a class="mochiref reference" href="#fn-deferred">Deferred</a>, then it will be chained (its value or error will be passed to the next callback). Note that once the returned <tt class="docutils literal"><span class="pre">Deferred</span></tt> is chained, it can no longer accept new callbacks.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferred.prototype.callback"></a> <a class="mochidef reference" href="#fn-deferred.prototype.callback">Deferred.prototype.callback([result])</a>:</p> <blockquote> <p>Begin the callback sequence with a non-<tt class="docutils literal"><span class="pre">Error</span></tt> result. Result may be any value except for a <a class="mochiref reference" href="#fn-deferred">Deferred</a>.</p> <p>Either <tt class="docutils literal"><span class="pre">.callback</span></tt> or <tt class="docutils literal"><span class="pre">.errback</span></tt> should be called exactly once on a <a class="mochiref reference" href="#fn-deferred">Deferred</a>.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferred.prototype.cancel"></a> <a class="mochidef reference" href="#fn-deferred.prototype.cancel">Deferred.prototype.cancel()</a>:</p> <blockquote> <p>Cancels a <a class="mochiref reference" href="#fn-deferred">Deferred</a> that has not yet received a value, or is waiting on another <a class="mochiref reference" href="#fn-deferred">Deferred</a> as its value.</p> <p>If a canceller is defined, the canceller is called. If the canceller did not return an <tt class="docutils literal"><span class="pre">Error</span></tt>, or there was no canceller, then the errback chain is started with <a class="mochiref reference" href="#fn-cancellederror">CancelledError</a>.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferred.prototype.errback"></a> <a class="mochidef reference" href="#fn-deferred.prototype.errback">Deferred.prototype.errback([result])</a>:</p> <blockquote> <p>Begin the callback sequence with an error result. Result may be any value except for a <a class="mochiref reference" href="#fn-deferred">Deferred</a>, but if <tt class="docutils literal"><span class="pre">!(result</span> <span class="pre">instanceof</span> <span class="pre">Error)</span></tt>, it will be wrapped with <a class="mochiref reference" href="#fn-genericerror">GenericError</a>.</p> <p>Either <tt class="docutils literal"><span class="pre">.callback</span></tt> or <tt class="docutils literal"><span class="pre">.errback</span></tt> should be called exactly once on a <a name="fn-deferred"></a> <a class="mochidef reference" href="#fn-deferred">Deferred</a>.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferredlock"></a> <a class="mochidef reference" href="#fn-deferredlock">DeferredLock()</a>:</p> <blockquote> <p>A lock for asynchronous systems.</p> <p>The <tt class="docutils literal"><span class="pre">locked</span></tt> property of a <a class="mochiref reference" href="#fn-deferredlock">DeferredLock</a> will be <tt class="docutils literal"><span class="pre">true</span></tt> if it locked, <tt class="docutils literal"><span class="pre">false</span></tt> otherwise. Do not change this property.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferredlock.prototype.acquire"></a> <a class="mochidef reference" href="#fn-deferredlock.prototype.acquire">DeferredLock.prototype.acquire()</a>:</p> <blockquote> <p>Attempt to acquire the lock. Returns a <a class="mochiref reference" href="#fn-deferred">Deferred</a> that fires on lock acquisition with the <a class="mochiref reference" href="#fn-deferredlock">DeferredLock</a> as the value. If the lock is locked, then the <a class="mochiref reference" href="#fn-deferred">Deferred</a> goes into a waiting list.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferredlock.prototype.release"></a> <a class="mochidef reference" href="#fn-deferredlock.prototype.release">DeferredLock.prototype.release()</a>:</p> <blockquote> <p>Release the lock. If there is a waiting list, then the first <a class="mochiref reference" href="#fn-deferred">Deferred</a> in that waiting list will be called back.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-deferredlist"></a> <a class="mochidef reference" href="#fn-deferredlist">DeferredList(list, [fireOnOneCallback, fireOnOneErrback, consumeErrors, canceller])</a>:</p> <blockquote> <p>Combine a list of <a class="mochiref reference" href="#fn-deferred">Deferred</a> into one. Track the callbacks and return a list of (success, result) tuples, 'success' being a boolean indicating whether result is a normal result or an error.</p> <p>Once created, you have access to all <a class="mochiref reference" href="#fn-deferred">Deferred</a> methods, like addCallback, addErrback, addBoth. The behaviour can be changed by the following options:</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">fireOnOneCallback</span></tt>:</dt> <dd>Flag for launching the callback once the first Deferred of the list has returned.</dd> <dt><tt class="docutils literal"><span class="pre">fireOnOneErrback</span></tt>:</dt> <dd>Flag for calling the errback at the first error of a Deferred.</dd> <dt><tt class="docutils literal"><span class="pre">consumeErrors</span></tt>:</dt> <dd>Flag indicating that any errors raised in the Deferreds should be consumed by the DeferredList.</dd> </dl> <p>Example:</p> <pre class="literal-block"> // We need to fetch data from 2 different urls var d1 = loadJSONDoc(url1); var d2 = loadJSONDoc(url2); var l1 = new DeferredList([d1, d2], false, false, true); l1.addCallback(function (resultList) { MochiKit.Base.map(function (result) { if (result[0]) { alert("Data is here: " + result[1]); } else { alert("Got an error: " + result[1]); } }, resultList); }); </pre> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> </div> <div class="section"> <h2><a id="functions" name="functions">Functions</a></h2> <p> <a name="fn-calllater"></a> <a class="mochidef reference" href="#fn-calllater">callLater(seconds, func[, args...])</a>:</p> <blockquote> <p>Call <tt class="docutils literal"><span class="pre">func(args...)</span></tt> after at least <tt class="docutils literal"><span class="pre">seconds</span></tt> seconds have elapsed. This is a convenience method for:</p> <pre class="literal-block"> func = partial.apply(extend(null, arguments, 1)); return wait(seconds).addCallback(function (res) { return func() }); </pre> <p>Returns a cancellable <a class="mochiref reference" href="#fn-deferred">Deferred</a>.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-doxhr"></a> <a class="mochidef reference" href="#fn-doxhr">doXHR(url[, {option: value, ...}])</a>:</p> <blockquote> <p>Perform a customized <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> and wrap it with a <a class="mochiref reference" href="#fn-deferred">Deferred</a> that may be cancelled.</p> <p>Note that only <tt class="docutils literal"><span class="pre">200</span></tt> (OK), <tt class="docutils literal"><span class="pre">201</span></tt> (CREATED), <tt class="docutils literal"><span class="pre">204</span></tt> (NO CONTENT) and <tt class="docutils literal"><span class="pre">304</span></tt> (NOT MODIFIED) are considered success codes. All other status codes will result in an errback with an <tt class="docutils literal"><span class="pre">XMLHttpRequestError</span></tt>.</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">url</span></tt>:</dt> <dd>The URL for this request.</dd> </dl> <p>The following options are currently accepted:</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">method</span></tt>:</dt> <dd>The HTTP method. Default is <tt class="docutils literal"><span class="pre">'GET'</span></tt>.</dd> <dt><tt class="docutils literal"><span class="pre">sendContent</span></tt>:</dt> <dd>The content to send (e.g. with POST). Default is no content.</dd> <dt><tt class="docutils literal"><span class="pre">queryString</span></tt>:</dt> <dd>If present it will be used to build a query string to append to the url using <a class="mochiref reference" href="Base.html#fn-querystring">MochiKit.Base.queryString</a>. Default is no query string.</dd> <dt><tt class="docutils literal"><span class="pre">username</span></tt>:</dt> <dd>The username for the request. Default is no username.</dd> <dt><tt class="docutils literal"><span class="pre">password</span></tt>:</dt> <dd>The password for the request. Default is no password.</dd> <dt><tt class="docutils literal"><span class="pre">headers</span></tt>:</dt> <dd>Additional headers to set in the request, either as an object such as <tt class="docutils literal"><span class="pre">{'Accept':</span> <span class="pre">'text/xml'}</span></tt> or as an Array of 2-Arrays <tt class="docutils literal"><span class="pre">[['Accept',</span> <span class="pre">'text/xml']]</span></tt>. Default is no additional headers.</dd> <dt><tt class="docutils literal"><span class="pre">mimeType</span></tt>:</dt> <dd>An override mime type. The typical use of this is to pass 'text/xml' to force XMLHttpRequest to attempt to parse responseXML. Default is no override.</dd> <dt><em>returns</em>:</dt> <dd><a class="mochiref reference" href="#fn-deferred">Deferred</a> that will callback with the <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> instance on success</dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.4+.</dd> </dl> </blockquote> <p> <a name="fn-dosimplexmlhttprequest"></a> <a class="mochidef reference" href="#fn-dosimplexmlhttprequest">doSimpleXMLHttpRequest(url[, queryArguments...])</a>:</p> <blockquote> <p>Perform a simple <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> and wrap it with a <a class="mochiref reference" href="#fn-deferred">Deferred</a> that may be cancelled.</p> <p>Note that only <tt class="docutils literal"><span class="pre">200</span></tt> (OK), <tt class="docutils literal"><span class="pre">201</span></tt> (CREATED), <tt class="docutils literal"><span class="pre">204</span></tt> (NO CONTENT) and <tt class="docutils literal"><span class="pre">304</span></tt> (NOT MODIFIED) are considered success codes. All other status codes will result in an errback with an <tt class="docutils literal"><span class="pre">XMLHttpRequestError</span></tt>.</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">url</span></tt>:</dt> <dd>The URL to GET</dd> <dt><tt class="docutils literal"><span class="pre">queryArguments</span></tt>:</dt> <dd><p class="first">If this function is called with more than one argument, a <tt class="docutils literal"><span class="pre">"?"</span></tt> and the result of <a class="mochiref reference" href="Base.html#fn-querystring">MochiKit.Base.queryString</a> with the rest of the arguments are appended to the URL.</p> <p>For example, this will do a GET request to the URL <tt class="docutils literal"><span class="pre">http://example.com?bar=baz</span></tt>:</p> <pre class="last literal-block"> doSimpleXMLHttpRequest("http://example.com", {bar: "baz"}); </pre> </dd> <dt><em>returns</em>:</dt> <dd><a class="mochiref reference" href="#fn-deferred">Deferred</a> that will callback with the <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> instance on success</dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+. Support for 201 and 204 were added in MochiKit 1.4.</dd> </dl> </blockquote> <p> <a name="fn-evaljsonrequest"></a> <a class="mochidef reference" href="#fn-evaljsonrequest">evalJSONRequest(req)</a>:</p> <blockquote> <p>Evaluate a JSON <a class="footnote-reference" href="#id10" id="id4" name="id4">[4]</a> <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt></p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">req</span></tt>:</dt> <dd>The request whose <tt class="docutils literal"><span class="pre">.responseText</span></tt> property is to be evaluated. If the JSON is wrapped in a comment, the comment will be stripped before evaluation.</dd> <dt><em>returns</em>:</dt> <dd>A JavaScript object</dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-fail"></a> <a class="mochidef reference" href="#fn-fail">fail([result])</a>:</p> <blockquote> <p>Return a <a class="mochiref reference" href="#fn-deferred">Deferred</a> that has already had <tt class="docutils literal"><span class="pre">.errback(result)</span></tt> called.</p> <p>See <tt class="docutils literal"><span class="pre">succeed</span></tt> documentation for rationale.</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">result</span></tt>:</dt> <dd>The result to give to <a class="mochiref reference" href="#fn-deferred.prototype.errback">Deferred.prototype.errback(result)</a>.</dd> <dt><em>returns</em>:</dt> <dd>A <tt class="docutils literal"><span class="pre">new</span></tt> <a class="mochiref reference" href="#fn-deferred">Deferred()</a></dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-gatherresults"></a> <a class="mochidef reference" href="#fn-gatherresults">gatherResults(deferreds)</a>:</p> <blockquote> <p>A convenience function that returns a <a class="mochiref reference" href="#fn-deferredlist">DeferredList</a> from the given <tt class="docutils literal"><span class="pre">Array</span></tt> of <a class="mochiref reference" href="#fn-deferred">Deferred</a> instances that will callback with an <tt class="docutils literal"><span class="pre">Array</span></tt> of just results when they're available, or errback on the first array.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-getxmlhttprequest"></a> <a class="mochidef reference" href="#fn-getxmlhttprequest">getXMLHttpRequest()</a>:</p> <blockquote> <p>Return an <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> compliant object for the current platform.</p> <p>In order of preference:</p> <ul class="simple"> <li><tt class="docutils literal"><span class="pre">new</span> <span class="pre">XMLHttpRequest()</span></tt></li> <li><tt class="docutils literal"><span class="pre">new</span> <span class="pre">ActiveXObject('Msxml2.XMLHTTP')</span></tt></li> <li><tt class="docutils literal"><span class="pre">new</span> <span class="pre">ActiveXObject('Microsoft.XMLHTTP')</span></tt></li> <li><tt class="docutils literal"><span class="pre">new</span> <span class="pre">ActiveXObject('Msxml2.XMLHTTP.4.0')</span></tt></li> </ul> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-maybedeferred"></a> <a class="mochidef reference" href="#fn-maybedeferred">maybeDeferred(func[, argument...])</a>:</p> <blockquote> <p>Call a <tt class="docutils literal"><span class="pre">func</span></tt> with the given arguments and ensure the result is a <a class="mochiref reference" href="#fn-deferred">Deferred</a>.</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">func</span></tt>:</dt> <dd>The function to call.</dd> <dt><em>returns</em>:</dt> <dd>A new <a class="mochiref reference" href="#fn-deferred">Deferred</a> based on the call to <tt class="docutils literal"><span class="pre">func</span></tt>. If <tt class="docutils literal"><span class="pre">func</span></tt> does not naturally return a <a class="mochiref reference" href="#fn-deferred">Deferred</a>, its result or error value will be wrapped by one.</dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-loadjsondoc"></a> <a class="mochidef reference" href="#fn-loadjsondoc">loadJSONDoc(url[, queryArguments...])</a>:</p> <blockquote> <p>Do a simple <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> to a URL and get the response as a JSON <a class="footnote-reference" href="#id10" id="id5" name="id5">[4]</a> document.</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">url</span></tt>:</dt> <dd>The URL to GET</dd> <dt><tt class="docutils literal"><span class="pre">queryArguments</span></tt>:</dt> <dd><p class="first">If this function is called with more than one argument, a <tt class="docutils literal"><span class="pre">"?"</span></tt> and the result of <a class="mochiref reference" href="Base.html#fn-querystring">MochiKit.Base.queryString</a> with the rest of the arguments are appended to the URL.</p> <p>For example, this will do a GET request to the URL <tt class="docutils literal"><span class="pre">http://example.com?bar=baz</span></tt>:</p> <pre class="last literal-block"> loadJSONDoc("http://example.com", {bar: "baz"}); </pre> </dd> <dt><em>returns</em>:</dt> <dd><a class="mochiref reference" href="#fn-deferred">Deferred</a> that will callback with the evaluated JSON <a class="footnote-reference" href="#id10" id="id6" name="id6">[4]</a> response upon successful <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt></dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-sendxmlhttprequest"></a> <a class="mochidef reference" href="#fn-sendxmlhttprequest">sendXMLHttpRequest(req[, sendContent])</a>:</p> <blockquote> <p>Set an <tt class="docutils literal"><span class="pre">onreadystatechange</span></tt> handler on an <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> object and send it off. Will return a cancellable <a class="mochiref reference" href="#fn-deferred">Deferred</a> that will callback on success.</p> <p>Note that only <tt class="docutils literal"><span class="pre">200</span></tt> (OK), <tt class="docutils literal"><span class="pre">201</span></tt> (CREATED), <tt class="docutils literal"><span class="pre">204</span></tt> (NO CONTENT) and <tt class="docutils literal"><span class="pre">304</span></tt> (NOT MODIFIED) are considered success codes. All other status codes will result in an errback with an <tt class="docutils literal"><span class="pre">XMLHttpRequestError</span></tt>.</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">req</span></tt>:</dt> <dd>An preconfigured <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> object (open has been called).</dd> <dt><tt class="docutils literal"><span class="pre">sendContent</span></tt>:</dt> <dd>Optional string or DOM content to send over the <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt>.</dd> <dt><em>returns</em>:</dt> <dd><a class="mochiref reference" href="#fn-deferred">Deferred</a> that will callback with the <tt class="docutils literal"><span class="pre">XMLHttpRequest</span></tt> instance on success.</dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+. Support for 201 and 204 were added in MochiKit 1.4.</dd> </dl> </blockquote> <p> <a name="fn-succeed"></a> <a class="mochidef reference" href="#fn-succeed">succeed([result])</a>:</p> <blockquote> <p>Return a <a class="mochiref reference" href="#fn-deferred">Deferred</a> that has already had <tt class="docutils literal"><span class="pre">.callback(result)</span></tt> called.</p> <p>This is useful when you're writing synchronous code to an asynchronous interface: i.e., some code is calling you expecting a <a class="mochiref reference" href="#fn-deferred">Deferred</a> result, but you don't actually need to do anything asynchronous. Just return <tt class="docutils literal"><span class="pre">succeed(theResult)</span></tt>.</p> <p>See <tt class="docutils literal"><span class="pre">fail</span></tt> for a version of this function that uses a failing <a class="mochiref reference" href="#fn-deferred">Deferred</a> rather than a successful one.</p> <dl class="docutils"> <dt><tt class="docutils literal"><span class="pre">result</span></tt>:</dt> <dd>The result to give to <a class="mochiref reference" href="#fn-deferred.prototype.callback">Deferred.prototype.callback(result)</a></dd> <dt><em>returns</em>:</dt> <dd>a <tt class="docutils literal"><span class="pre">new</span></tt> <a class="mochiref reference" href="#fn-deferred">Deferred</a></dd> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> <p> <a name="fn-wait"></a> <a class="mochidef reference" href="#fn-wait">wait(seconds[, res])</a>:</p> <blockquote> <p>Return a new cancellable <a class="mochiref reference" href="#fn-deferred">Deferred</a> that will <tt class="docutils literal"><span class="pre">.callback(res)</span></tt> after at least <tt class="docutils literal"><span class="pre">seconds</span></tt> seconds have elapsed.</p> <dl class="docutils"> <dt><em>Availability</em>:</dt> <dd>Available in MochiKit 1.3.1+</dd> </dl> </blockquote> </div> </div> <div class="section"> <h1><a id="see-also" name="see-also">See Also</a></h1> <table class="docutils footnote" frame="void" id="id7" rules="none"> <colgroup><col class="label" /><col /></colgroup> <tbody valign="top"> <tr><td class="label"><a class="fn-backref" href="#id1" name="id7">[1]</a></td><td>AJAX, Asynchronous JavaScript and XML: <a class="reference" href="http://en.wikipedia.org/wiki/AJAX">http://en.wikipedia.org/wiki/AJAX</a></td></tr> </tbody> </table> <table class="docutils footnote" frame="void" id="id8" rules="none"> <colgroup><col class="label" /><col /></colgroup> <tbody valign="top"> <tr><td class="label"><a class="fn-backref" href="#id2" name="id8">[2]</a></td><td>Twisted, an event-driven networking framework written in Python: <a class="reference" href="http://twistedmatrix.com/">http://twistedmatrix.com/</a></td></tr> </tbody> </table> <table class="docutils footnote" frame="void" id="id9" rules="none"> <colgroup><col class="label" /><col /></colgroup> <tbody valign="top"> <tr><td class="label"><a class="fn-backref" href="#id3" name="id9">[3]</a></td><td>Twisted Deferred Reference: <a class="reference" href="http://twistedmatrix.com/projects/core/documentation/howto/defer.html">http://twistedmatrix.com/projects/core/documentation/howto/defer.html</a></td></tr> </tbody> </table> <table class="docutils footnote" frame="void" id="id10" rules="none"> <colgroup><col class="label" /><col /></colgroup> <tbody valign="top"> <tr><td class="label"><a name="id10">[4]</a></td><td><em>(<a class="fn-backref" href="#id4">1</a>, <a class="fn-backref" href="#id5">2</a>, <a class="fn-backref" href="#id6">3</a>)</em> JSON, JavaScript Object Notation: <a class="reference" href="http://json.org/">http://json.org/</a></td></tr> </tbody> </table> </div> <div class="section"> <h1><a id="authors" name="authors">Authors</a></h1> <ul class="simple"> <li>Bob Ippolito <<a class="reference" href="mailto:bob@redivi.com">bob@redivi.com</a>></li> </ul> </div> <div class="section"> <h1><a id="copyright" name="copyright">Copyright</a></h1> <p>Copyright 2005 Bob Ippolito <<a class="reference" href="mailto:bob@redivi.com">bob@redivi.com</a>>. This program is dual-licensed free software; you can redistribute it and/or modify it under the terms of the <a class="reference" href="http://www.opensource.org/licenses/mit-license.php">MIT License</a> or the <a class="reference" href="http://www.opensource.org/licenses/afl-2.1.php">Academic Free License v2.1</a>.</p> </div> </div> </body> </html>