rebuild distribution files.

README.md

@@ -70,3 +70,5 @@ App Framework uses code from the following software:
 1) Zepto.js - Thomas Fuchs (MIT X11 License)
 
 2) qUnit - jQuery Foundation (MIT X11 License)
+
+3) ayepromise - Christoph Burgmer (BSD License)

build/appframework.js

@@ -1,4 +1,4 @@
-/*! intel-appframework - v2.1.0 - 2014-02-19 */
+/*! intel-appframework - v2.1.0 - 2014-03-04 */
 
 /**
  * App Framwork  query selector class for HTML5 mobile apps on a WebkitBrowser.
@@ -13,7 +13,7 @@
  */
  /* jshint eqeqeq:false */
   /* global af: true */
- 
+
 if (!window.af || typeof(af) !== "function") {
 
     /**
@@ -1622,7 +1622,8 @@ if (!window.af || typeof(af) !== "function") {
             complete: empty,
             context: undefined,
             timeout: 0,
-            crossDomain: null
+            crossDomain: null,
+            processData: true
         };
         /**
         * Execute a jsonP call, allowing cross domain scripting
@@ -1721,15 +1722,15 @@ if (!window.af || typeof(af) !== "function") {
 
                 if (!settings.url)
                     settings.url = window.location;
-                if (!settings.contentType)
-                    settings.contentType = "application/x-www-form-urlencoded";
+                if (!settings.contentType && settings.contentType!==false)
+                    settings.contentType = "application/x-www-form-urlencoded; charset=UTF-8";
                 if (!settings.headers)
                     settings.headers = {};
 
                 if (!("async" in settings) || settings.async !== false)
                     settings.async = true;
 
-                if ($.isObject(settings.data))
+                if (settings.processData && $.isObject(settings.data))
                     settings.data = $.param(settings.data);
                 if (settings.type.toLowerCase() === "get" && settings.data) {
                     if (settings.url.indexOf("?") === -1)
@@ -1781,8 +1782,8 @@ if (!window.af || typeof(af) !== "function") {
 
                 //ok, we are really using xhr
                 xhr = new window.XMLHttpRequest();
-
-
+                var deferred=$.defer();
+                $.extend(xhr,deferred.promise);
                 xhr.onreadystatechange = function() {
                     var mime = settings.dataType;
                     if (xhr.readyState === 4) {
@@ -1805,16 +1806,21 @@ if (!window.af || typeof(af) !== "function") {
                             //If we"re looking at a local file, we assume that no response sent back means there was an error
                             if (xhr.status === 0 && result.length === 0)
                                 error = true;
-                            if (error)
-                                settings.error.call(context, xhr, "parsererror", error);
+                            if (error){
+                                settings.error.call(context,xhr, "parsererror", error);
+                                deferred.reject.call(context,xhr, "parsererror", error);
+                            }
                             else {
+                                deferred.resolve.call(context,result, "succes", error);
                                 settings.success.call(context, result, "success", xhr);
                             }
                         } else {
                             error = true;
+                            deferred.reject.call(context,xhr, "error");
                             settings.error.call(context, xhr, "error");
                         }
-                        settings.complete.call(context, xhr, error ? "error" : "success");
+                        var respText=error?"error":"success";
+                        settings.complete.call(context, xhr,respText);
                     }
                 };
                 xhr.open(settings.type, settings.url, settings.async);
@@ -1839,7 +1845,7 @@ if (!window.af || typeof(af) !== "function") {
                 xhr.send(settings.data);
             } catch (e) {
                 // General errors (e.g. access denied) should also be sent to the error callback
-                console.log(e);
+                deferred.resolve(context,[xhr, "error",e]);
                 settings.error.call(context, xhr, "error", e);
             }
             return xhr;
@@ -2564,7 +2570,7 @@ if (!window.af || typeof(af) !== "function") {
          * The following are for objects and not DOM nodes
          * @api private
          */
-        
+
         /*
          * Bind an event to an object instead of a DOM Node
            ```
@@ -2823,6 +2829,14 @@ if (!window.af || typeof(af) !== "function") {
             };
         });
 
+        $.defer = function(){
+            return {
+                promise:{
+                },
+                reject:function(){},
+                resolve:function(){}
+            };
+        };
         /**
          * End of APIS
          * @api private
@@ -2855,3 +2869,185 @@ if (!window.af || typeof(af) !== "function") {
         };
     }
 }
+
+/**
+ * ayepromise.js
+ * @license BSD - https://github.com/cburgmer/ayepromise/commit/299eb65b5ce227873b2f1724c8f5b2bfa723680a
+ * https://github.com/cburgmer/ayepromise
+ */
+
+// UMD header
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define(factory);
+    } else if (typeof exports === 'object') {
+        module.exports = factory();
+    } else {
+        root.ayepromise = factory();
+    }
+}(this, function () {
+    'use strict';
+
+    var ayepromise = {};
+
+    /* Wrap an arbitrary number of functions and allow only one of them to be
+       executed and only once */
+    var once = function () {
+        var wasCalled = false;
+
+        return function wrapper(wrappedFunction) {
+            return function () {
+                if (wasCalled) {
+                    return;
+                }
+                wasCalled = true;
+                wrappedFunction.apply(null, arguments);
+            };
+        };
+    };
+
+    var getThenableIfExists = function (obj) {
+        // Make sure we only access the accessor once as required by the spec
+        var then = obj && obj.then;
+
+        if (obj !== null &&
+            typeof obj === "object" &&
+            typeof then === "function") {
+
+            return then.bind(obj);
+        }
+    };
+
+    var aThenHandler = function (onFulfilled, onRejected) {
+        var defer = ayepromise.defer();
+
+        var doHandlerCall = function (func, value) {
+            setTimeout(function () {
+                var returnValue;
+                try {
+                    returnValue = func(value);
+                } catch (e) {
+                    defer.reject(e);
+                    return;
+                }
+
+                if (returnValue === defer.promise) {
+                    defer.reject(new TypeError('Cannot resolve promise with itself'));
+                } else {
+                    defer.resolve(returnValue);
+                }
+            }, 1);
+        };
+
+        return {
+            promise: defer.promise,
+            callFulfilled: function (value) {
+                if (onFulfilled && onFulfilled.call) {
+                    doHandlerCall(onFulfilled, value);
+                } else {
+                    defer.resolve(value);
+                }
+            },
+            callRejected: function (value) {
+                if (onRejected && onRejected.call) {
+                    doHandlerCall(onRejected, value);
+                } else {
+                    defer.reject(value);
+                }
+            }
+        };
+    };
+
+    // States
+    var PENDING = 0,
+        FULFILLED = 1,
+        REJECTED = 2;
+
+    ayepromise.defer = function () {
+        var state = PENDING,
+            outcome,
+            thenHandlers = [];
+
+        var doFulfill = function (value) {
+            state = FULFILLED;
+            outcome = value;
+
+            thenHandlers.forEach(function (then) {
+                then.callFulfilled(outcome);
+            });
+        };
+
+        var doReject = function (error) {
+            state = REJECTED;
+            outcome = error;
+
+            thenHandlers.forEach(function (then) {
+                then.callRejected(outcome);
+            });
+        };
+
+        var executeThenHandlerDirectlyIfStateNotPendingAnymore = function (then) {
+            if (state === FULFILLED) {
+                then.callFulfilled(outcome);
+            } else if (state === REJECTED) {
+                then.callRejected(outcome);
+            }
+        };
+
+        var registerThenHandler = function (onFulfilled, onRejected) {
+            var thenHandler = aThenHandler(onFulfilled, onRejected);
+
+            thenHandlers.push(thenHandler);
+
+            executeThenHandlerDirectlyIfStateNotPendingAnymore(thenHandler);
+
+            return thenHandler.promise;
+        };
+
+        var safelyResolveThenable = function (thenable) {
+            // Either fulfill, reject or reject with error
+            var onceWrapper = once();
+            try {
+                thenable(
+                    onceWrapper(transparentlyResolveThenablesAndFulfill),
+                    onceWrapper(doReject)
+                );
+            } catch (e) {
+                onceWrapper(doReject)(e);
+            }
+        };
+
+        var transparentlyResolveThenablesAndFulfill = function (value) {
+            var thenable;
+
+            try {
+                thenable = getThenableIfExists(value);
+            } catch (e) {
+                doReject(e);
+                return;
+            }
+
+            if (thenable) {
+                safelyResolveThenable(thenable);
+            } else {
+                doFulfill(value);
+            }
+        };
+
+        var onceWrapper = once();
+        return {
+            resolve: onceWrapper(transparentlyResolveThenablesAndFulfill),
+            reject: onceWrapper(doReject),
+            promise: {
+                then: registerThenHandler,
+                fail: function (onRejected) {
+                    return registerThenHandler(null, onRejected);
+                }
+            }
+        };
+    };
+    return ayepromise;
+}));
+(function(){
+    $.defer=ayepromise.defer;
+})(af);