Synnefo

/*!

 * MockJax - jQuery Plugin to Mock Ajax requests

 *

 * Version:  1.4.0

 * Released: 2011-02-04

 * Source:   http://github.com/appendto/jquery-mockjax

 * Docs:     http://enterprisejquery.com/2010/07/mock-your-ajax-requests-with-mockjax-for-rapid-development

 * Plugin:   mockjax

 * Author:   Jonathan Sharp (http://jdsharp.com)

 * License:  MIT,GPL

 * 

 * Copyright (c) 2010 appendTo LLC.

 * Dual licensed under the MIT or GPL licenses.

 * http://appendto.com/open-source-licenses

 */

(function($) {

        var _ajax = $.ajax,

                mockHandlers = [];

        function parseXML(xml) {

                if ( window['DOMParser'] == undefined && window.ActiveXObject ) {

                        DOMParser = function() { };

                        DOMParser.prototype.parseFromString = function( xmlString ) {

                                var doc = new ActiveXObject('Microsoft.XMLDOM');

                        doc.async = 'false';

                        doc.loadXML( xmlString );

                                return doc;

                        };

                }

                try {

                        var xmlDoc         = ( new DOMParser() ).parseFromString( xml, 'text/xml' );

                        if ( $.isXMLDoc( xmlDoc ) ) {

                                var err = $('parsererror', xmlDoc);

                                if ( err.length == 1 ) {

                                        throw('Error: ' + $(xmlDoc).text() );

                                }

                        } else {

                                throw('Unable to parse XML');

                        }

                } catch( e ) {

                        var msg = ( e.name == undefined ? e : e.name + ': ' + e.message );

                        $(document).trigger('xmlParseError', [ msg ]);

                        return undefined;

                }

                return xmlDoc;

        }

        $.extend({

                ajax: function(origSettings) {

                        var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),

                            mock = false;

                        // Iterate over our mock handlers (in registration order) until we find

                        // one that is willing to intercept the request

                        $.each(mockHandlers, function(k, v) {

                                if ( !mockHandlers[k] ) {

                                        return;

                                }

                                var m = null;

                                // If the mock was registered with a function, let the function decide if we 

                                // want to mock this request

                                if ( $.isFunction(mockHandlers[k]) ) {

                                        m = mockHandlers[k](s);

                                } else {

                                        m = mockHandlers[k];

                                        // Inspect the URL of the request and check if the mock handler's url 

                                        // matches the url for this ajax request

                                        if ( $.isFunction(m.url.test) ) {

                                                // The user provided a regex for the url, test it

                                                if ( !m.url.test( s.url ) ) {

                                                        m = null;

                                                }

                                        } else {

                                                // Look for a simple wildcard '*' or a direct URL match

                                                var star = m.url.indexOf('*');

                                                if ( ( m.url != '*' && m.url != s.url && star == -1 ) ||

                                                        ( star > -1 && m.url.substr(0, star) != s.url.substr(0, star) ) ) {

                                                         // The url we tested did not match the wildcard *

                                                         m = null;

                                                }

                                        }

                                        if ( m ) {

                                                // Inspect the data submitted in the request (either POST body or GET query string)

                                                if ( m.data && s.data ) {

                                                        var identical = false;

                                                        // Deep inspect the identity of the objects

                                                        (function ident(mock, live) {

                                                                // Test for situations where the data is a querystring (not an object)

                                                                if (typeof live === 'string') {

                                                                        // Querystring may be a regex

                                                                        identical = $.isFunction( mock.test ) ? mock.test(live) : mock == live;

                                                                        return identical;

                                                                }

                                                                $.each(mock, function(k, v) {

                                                                        if ( live[k] === undefined ) {

                                                                                identical = false;

                                                                                return false;

                                                                        } else {

                                                                                identical = true;

                                                                                if ( typeof live[k] == 'object' ) {

                                                                                        return ident(mock[k], live[k]);

                                                                                } else {

                                                                                        if ( $.isFunction( mock[k].test ) ) {

                                                                                                identical = mock[k].test(live[k]);

                                                                                        } else {

                                                                                                identical = ( mock[k] == live[k] );

                                                                                        }

                                                                                        return identical;

                                                                                }

                                                                        }

                                                                });

                                                        })(m.data, s.data);

                                                        // They're not identical, do not mock this request

                                                        if ( identical == false ) {

                                                                m = null;

                                                        }

                                                }

                                                // Inspect the request type

                                                if ( m && m.type && m.type != s.type ) {

                                                        // The request type doesn't match (GET vs. POST)

                                                        m = null;

                                                }

                                        }

                                }

                                if ( m ) {

                                        mock = true;

                                        // Handle console logging

                                        var c = $.extend({}, $.mockjaxSettings, m);

                                        if ( c.log && $.isFunction(c.log) ) {

                                                c.log('MOCK ' + s.type.toUpperCase() + ': ' + s.url, $.extend({}, s));

                                        }

                                        var jsre = /=\?(&|$)/, jsc = (new Date()).getTime();

                                        // Handle JSONP Parameter Callbacks, we need to replicate some of the jQuery core here

                                        // because there isn't an easy hook for the cross domain script tag of jsonp

                                        if ( s.dataType === "jsonp" ) {

                                                if ( s.type.toUpperCase() === "GET" ) {

                                                        if ( !jsre.test( s.url ) ) {

                                                                s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";

                                                        }

                                                } else if ( !s.data || !jsre.test(s.data) ) {

                                                        s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";

                                                }

                                                s.dataType = "json";

                                        }

                                        // Build temporary JSONP function

                                        if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {

                                                jsonp = s.jsonpCallback || ("jsonp" + jsc++);

                                                // Replace the =? sequence both in the query string and the data

                                                if ( s.data ) {

                                                        s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");

                                                }

                                                s.url = s.url.replace(jsre, "=" + jsonp + "$1");

                                                // We need to make sure

                                                // that a JSONP style response is executed properly

                                                s.dataType = "script";

                                                // Handle JSONP-style loading

                                                window[ jsonp ] = window[ jsonp ] || function( tmp ) {

                                                        data = tmp;

                                                        success();

                                                        complete();

                                                        // Garbage collect

                                                        window[ jsonp ] = undefined;

                                                        try {

                                                                delete window[ jsonp ];

                                                        } catch(e) {}

                                                        if ( head ) {

                                                                head.removeChild( script );

                                                        }

                                                };

                                        }

                                        var rurl = /^(\w+:)?\/\/([^\/?#]+)/,

                                                parts = rurl.exec( s.url ),

                                                remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);

                                        // Test if we are going to create a script tag (if so, intercept & mock)

                                        if ( s.dataType === "script" && s.type.toUpperCase() === "GET" && remote ) {

                                                // Synthesize the mock request for adding a script tag

                                                var callbackContext = origSettings && origSettings.context || s;

                                                function success() {

                                                        // If a local callback was specified, fire it and pass it the data

                                                        if ( s.success ) {

                                                                s.success.call( callbackContext, ( m.response ? m.response.toString() : m.responseText || ''), status, {} );

                                                        }

                                                        // Fire the global callback

                                                        if ( s.global ) {

                                                                trigger( "ajaxSuccess", [{}, s] );

                                                        }

                                                }

                                                function complete() {

                                                        // Process result

                                                        if ( s.complete ) {

                                                                s.complete.call( callbackContext, {} , status );

                                                        }

                                                        // The request was completed

                                                        if ( s.global ) {

                                                                trigger( "ajaxComplete", [{}, s] );

                                                        }

                                                        // Handle the global AJAX counter

                                                        if ( s.global && ! --jQuery.active ) {

                                                                jQuery.event.trigger( "ajaxStop" );

                                                        }

                                                }

                                                function trigger(type, args) {

                                                        (s.context ? jQuery(s.context) : jQuery.event).trigger(type, args);

                                                }

                                                if ( m.response && $.isFunction(m.response) ) {

                                                        m.response(origSettings);

                                                } else {

                                                        $.globalEval(m.responseText);

                                                }

                                                success();

                                                complete();

                                                return false;

                                        }

                                        mock = _ajax.call($, $.extend(true, {}, origSettings, {

                                                // Mock the XHR object

                                                xhr: function() {

                                                        // Extend with our default mockjax settings

                                                        m = $.extend({}, $.mockjaxSettings, m);

                                                        if ( m.contentType ) {

                                                                m.headers['content-type'] = m.contentType;

                                                        }

                                                        // Return our mock xhr object

                                                        return {

                                                                status: m.status,

                                                                readyState: 1,

                                                                open: function() { },

                                                                send: function() {

                                                                        // This is a substitute for < 1.4 which lacks $.proxy

                                                                        var process = (function(that) {

                                                                                return function() {

                                                                                        return (function() {

                                                                                                // The request has returned

                                                                                                 this.status                 = m.status;

                                                                                                this.readyState         = 4;

                                                                                                // We have an executable function, call it to give 

                                                                                                // the mock handler a chance to update it's data

                                                                                                if ( $.isFunction(m.response) ) {

                                                                                                        m.response(origSettings);

                                                                                                }

                                                                                                // Copy over our mock to our xhr object before passing control back to 

                                                                                                // jQuery's onreadystatechange callback

                                                                                                if ( s.dataType == 'json' && ( typeof m.responseText == 'object' ) ) {

                                                                                                        this.responseText = JSON.stringify(m.responseText);

                                                                                                } else if ( s.dataType == 'xml' ) {

                                                                                                        if ( typeof m.responseXML == 'string' ) {

                                                                                                                this.responseXML = parseXML(m.responseXML);

                                                                                                        } else {

                                                                                                                this.responseXML = m.responseXML;

                                                                                                        }

                                                                                                } else {

                                                                                                        this.responseText = m.responseText;

                                                                                                }

                                                                                                // jQuery < 1.4 doesn't have onreadystate change for xhr

                                                                                                if ( $.isFunction(this.onreadystatechange) ) {

                                                                                                        this.onreadystatechange( m.isTimeout ? 'timeout' : undefined );

                                                                                                }

                                                                                        }).apply(that);

                                                                                };

                                                                        })(this);

                                                                        if ( m.proxy ) {

                                                                                // We're proxying this request and loading in an external file instead

                                                                                _ajax({

                                                                                        global: false,

                                                                                        url: m.proxy,

                                                                                        type: m.proxyType,

                                                                                        data: m.data,

                                                                                        dataType: s.dataType,

                                                                                        complete: function(xhr, txt) {

                                                                                                m.responseXML = xhr.responseXML;

                                                                                                m.responseText = xhr.responseText;

                                                                                                this.responseTimer = setTimeout(process, m.responseTime || 0);

                                                                                        }

                                                                                });

                                                                        } else {

                                                                                // type == 'POST' || 'GET' || 'DELETE'

                                                                                if ( s.async === false ) {

                                                                                        // TODO: Blocking delay

                                                                                        process();

                                                                                } else {

                                                                                        this.responseTimer = setTimeout(process, m.responseTime || 50);

                                                                                }

                                                                        }

                                                                },

                                                                abort: function() {

                                                                        clearTimeout(this.responseTimer);

                                                                },

                                                                setRequestHeader: function() { },

                                                                getResponseHeader: function(header) {

                                                                        // 'Last-modified', 'Etag', 'content-type' are all checked by jQuery

                                                                        if ( m.headers && m.headers[header] ) {

                                                                                // Return arbitrary headers

                                                                                return m.headers[header];

                                                                        } else if ( header.toLowerCase() == 'last-modified' ) {

                                                                                return m.lastModified || (new Date()).toString();

                                                                        } else if ( header.toLowerCase() == 'etag' ) {

                                                                                return m.etag || '';

                                                                        } else if ( header.toLowerCase() == 'content-type' ) {

                                                                                return m.contentType || 'text/plain';

                                                                        }

                                                                },

                                                                getAllResponseHeaders: function() {

                                                                        var headers = '';

                                                                        $.each(m.headers, function(k, v) {

                                                                                headers += k + ': ' + v + "\n";

                                                                        });

                                                                        return headers;

                                                                }

                                                        };

                                                }

                                        }));

                                        return false;

                                }

                        });

                        // We don't have a mock request, trigger a normal request

                        if ( !mock ) {

                                return _ajax.apply($, arguments);

                        } else {

                                return mock;

                        }

                }

        });

        $.mockjaxSettings = {

                //url:        null,

                //type:       'GET',

                log:          function(msg) {

                                      window['console'] && window.console.log && window.console.log(msg);

                              },

                status:       200,

                responseTime: 500,

                isTimeout:    false,

                contentType:  'text/plain',

                response:     '', 

                responseText: '',

                responseXML:  '',

                proxy:        '',

                proxyType:    'GET',

                lastModified: null,

                etag:         '',

                headers: {

                        etag: 'IJF@H#@923uf8023hFO@I#H#',

                        'content-type' : 'text/plain'

                }

        };

        $.mockjax = function(settings) {

                var i = mockHandlers.length;

                mockHandlers[i] = settings;

                return i;

        };

        $.mockjaxClear = function(i) {

                if ( arguments.length == 1 ) {

                        mockHandlers[i] = null;

                } else {

                        mockHandlers = [];

                }

        };

})(jQuery);