### Install script dataType and ajaxPrefilter for script requests

Source: https://github.com/ejwa/gitinspector/wiki/examples/pango_output.emb.html

Sets up the script dataType with its accepts, contents, and converters, and adds an ajaxPrefilter that disables caching and forces GET for cross-domain script requests.

```javascript
// Install script dataType
jQuery.ajaxSetup({
	accepts: {
		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
	},
	contents: {
		script: /javascript|ecmascript/
	},
	converters: {
		"text script": function( text ) {
			jQuery.globalEval( text );
			return text;
		}
	}
});

// Handle cache's special case and global
jQuery.ajaxPrefilter( "script", function( s ) {
	if ( s.cache === undefined ) {
		s.cache = false;
	}
	if ( s.crossDomain ) {
		s.type = "GET";
		s.global = false;
	}
});
```

--------------------------------

### jQuery.ajax main method

Source: https://github.com/ejwa/gitinspector/wiki/examples/django_output.emb.html

The core ajax function that handles request setup, jqXHR creation, and response processing. It manages headers, status codes, and callbacks.

```javascript
// Main method
ajax: function( url, options ) {
    // If url is an object, simulate pre-1.5 signature
    if ( typeof url === "object" ) {
        options = url;
        url = undefined;
    }
    // Force options to be an object
    options = options || {};
    var
        // if-modified key
        ifModifiedKey,
        // Response headers
        responseHeadersString,
        responseHeaders,
        // transport
        transport,
        // timeout handle
        timeoutTimer,
        // Cross-domain detection vars
        parts,
        // To know if global events are to be dispatched
        fireGlobals,
        // Loop variable
        i,
        // Create the final options object
        s = jQuery.ajaxSetup( {}, options ),
        // Callbacks context
        callbackContext = s.context || s,
        // Context for global events
        // It's the callbackContext if one was provided in the options
        // and if it's a DOM node or a jQuery collection
        globalEventContext = callbackContext !== s &&
            ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
                jQuery( callbackContext ) : jQuery.event,
        // Deferreds
        deferred = jQuery.Deferred(),
        completeDeferred = jQuery.Callbacks( "once memory" ),
        // Status-dependent callbacks
        statusCode = s.statusCode || {},
        // Headers (they are sent all at once)
        requestHeaders = {},
        requestHeadersNames = {},
        // The jqXHR state
        state = 0,
        // Default abort message
        strAbort = "canceled",
        // Fake xhr
        jqXHR = {
            readyState: 0,
            // Caches the header
            setRequestHeader: function( name, value ) {
                if ( !state ) {
                    var lname = name.toLowerCase();
                    name = requestHeadersNames[ lname ] =
                        requestHeadersNames[ lname ] || name;
                    requestHeaders[ name ] = value;
                }
                return this;
            },
            // Raw string
            getAllResponseHeaders: function() {
                return state === 2 ? responseHeadersString : null;
            },
            // Builds headers hashtable if needed
            getResponseHeader: function( key ) {
                var match;
                if ( state === 2 ) {
                    if ( !responseHeaders ) {
                        responseHeaders = {};
                        while( ( match = rheaders.exec( responseHeadersString ) ) ) {
                            responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
                        }
                    }
                    match = responseHeaders[ key.toLowerCase() ];
                }
                return match === undefined ? null : match;
            },
            // Overrides response content-type header
            overrideMimeType: function( type ) {
                if ( !state ) {
                    s.mimeType = type;
                }
                return this;
            },
            // Cancel the request
            abort: function( statusText ) {
                statusText = statusText || strAbort;
                if ( transport ) {
                    transport.abort( statusText );
                }
                done( 0, statusText );
                return this;
            }
        };

    // Callback for when everything is done
    // It is defined here because jslint complains if it is declared
    // at the end of the function (which would be more logical and readable)
    function done( status, nativeStatusText, responses, headers ) {
        var isSuccess, success, error, response, modified,
            statusText = nativeStatusText;
        // Called once
        if ( state === 2 ) {
            return;
        }
        // State is "done" now
        state = 2;
        // Clear timeout if it exists
        if ( timeoutTimer ) {
            clearTimeout( timeoutTimer );
        }
        // Dereference transport for early garbage collection
        // (no matter how long the jqXHR object will be used)
        transport = undefined;
        // Cache response headers
        responseHeadersString = headers || "";
        // Set readyState
        jqXHR.readyState = status > 0 ? 4 : 0;
        // Get response data
        if ( responses ) {
            response = ajaxHandleResponses( s, jqXHR, responses );
        }
        // If successful, handle type chaining
        if ( status >= 200 && status < 300 || status === 304 ) {
            // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
        }
    }
}
```

--------------------------------

### Setup grid and axes

Source: https://github.com/ejwa/gitinspector/wiki/examples/jquery_output.html

Initializes plotOffset from grid margin, adds border width, sets axis visibility and reserveSpace, and if grid is shown, generates ticks and measures labels for allocated axes.

```javascript
function setupGrid() { var i, axes = allAxes(), showGrid = options.grid.show; // Initialize the plot's offset from the edge of the canvas for (var a in plotOffset) { var margin = options.grid.margin || 0; plotOffset[a] = typeof margin == "number" ? margin : margin[a] || 0; } executeHooks(hooks.processOffset, [plotOffset]); // If the grid is visible, add its border width to the offset for (var a in plotOffset) { if(typeof(options.grid.borderWidth) == "object") { plotOffset[a] += showGrid ? options.grid.borderWidth[a] : 0; } else { plotOffset[a] += showGrid ? options.grid.borderWidth : 0; } } // init axes $.each(axes, function (_, axis) { axis.show = axis.options.show; if (axis.show == null) axis.show = axis.used; // by default an axis is visible if it's got data axis.reserveSpace = axis.show || axis.options.reserveSpace; setRange(axis); }); if (showGrid) { var allocatedAxes = $.grep(axes, function (axis) { return axis.reserveSpace; }); $.each(allocatedAxes, function (_, axis) { // make the ticks setupTickGeneration(axis); setTicks(axis); snapRangeToTicks(axis, axis.ticks); // find labelWidth/Height for axis measureTickLabels(axis); }); // with all dimensions calculated, we can compute the
```

--------------------------------

### Setup Canvases for Plot

Source: https://github.com/ejwa/gitinspector/wiki/examples/jquery_output.html

Clears the placeholder, creates base and overlay canvases, binds event holder, and shuts down any existing plot. Saves the plot instance in placeholder data.

```JavaScript
function setupCanvases() {
 // Make sure the placeholder is clear of everything except canvases
 // from a previous plot in this container that we'll try to re-use.
 placeholder.css("padding", 0) // padding messes up the positioning
 .children(":not(.flot-base,.flot-overlay)").remove();
 if (placeholder.css("position") == 'static')
 placeholder.css("position", "relative"); // for positioning labels and overlay
 surface = new Canvas("flot-base", placeholder);
 overlay = new Canvas("flot-overlay", placeholder); // overlay canvas for interactive features
 ctx = surface.context;
 octx = overlay.context;
 // define which element we're listening for events on
 eventHolder = $(overlay.element).unbind();
 // If we're re-using a plot object, shut down the old one
 var existing = placeholder.data("plot");
 if (existing) {
 existing.shutdown();
 overlay.clear();
 }
 // save in case we get replotted
 placeholder.data("plot", plot);
}
```

--------------------------------

### jQuery AJAX JSONP and Script Transport Setup

Source: https://github.com/ejwa/gitinspector/wiki/examples/django_output.emb.html

Configures jQuery's AJAX layer for JSONP and script requests. Sets default JSONP callback handling, installs a prefilter for JSON/JSONP data types, and defines a script transport for cross-domain requests. Includes XHR creation with ActiveXObject fallback for IE7/IE8. Use when customizing jQuery's AJAX behavior for JSONP or script loading.

```javascript
Default jsonp settings
jQuery.ajaxSetup({ jsonp: "callback", jsonpCallback: function() { var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) ); this[ callback ] = true; return callback; } });
// Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
	var callbackName, overwritten, responseContainer,
		data = s.data,
		url = s.url,
		hasCallback = s.jsonp !== false,
		replaceInUrl = hasCallback && rjsonp.test( url ),
		replaceInData = hasCallback && !replaceInUrl && typeof data === "string" &&
			!( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") &&
			rjsonp.test( data );

	// Handle iff the expected data type is "jsonp" or we have a parameter to set
	if ( s.dataTypes[ 0 ] === "jsonp" || replaceInUrl || replaceInData ) {

		// Get callback name, remembering preexisting value associated with it
		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
			s.jsonpCallback() : s.jsonpCallback;
		overwritten = window[ callbackName ];

		// Insert callback into url or form data
		if ( replaceInUrl ) {
			s.url = url.replace( rjsonp, "$1" + callbackName );
		} else if ( replaceInData ) {
			s.data = data.replace( rjsonp, "$1" + callbackName );
		} else if ( hasCallback ) {
			s.url += ( rquestion.test( url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
		}

		// Use data converter to retrieve json after script execution
		s.converters["script json"] = function() {
			if ( !responseContainer ) {
				jQuery.error( callbackName + " was not called" );
			}
			return responseContainer[ 0 ];
		};

		// force json dataType
		s.dataTypes[ 0 ] = "json";

		// Install callback
		window[ callbackName ] = function() {
			responseContainer = arguments;
		};

		// Clean-up function (fires after converters)
		jqXHR.always(function() {

			// Restore preexisting value
			window[ callbackName ] = overwritten;

			// Save back as free if
			if ( s[ callbackName ] ) {

				// make sure that re-using the options doesn't screw things around
				s.jsonpCallback = originalSettings.jsonpCallback;

				// save the callback name for future use
				oldCallbacks.push( callbackName );
			}

			// Call if it was a function and we have a response
			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
				overwritten( responseContainer[ 0 ] );
			}
			responseContainer = overwritten = undefined;
		});

		// Delegate to script
		return "script";
	}
});

// Install script dataType
jQuery.ajaxSetup({
	accepts: {
		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
	},
	contents: {
		script: /javascript|ecmascript/
	},
	converters: {
		"text script": function( text ) {
			jQuery.globalEval( text );
			return text;
		}
	}
});

// Handle cache's special case and global
jQuery.ajaxPrefilter( "script", function( s ) {
	if ( s.cache === undefined ) {
		s.cache = false;
	}
	if ( s.crossDomain ) {
		s.type = "GET";
		s.global = false;
	}
});

// Bind script tag hack transport
jQuery.ajaxTransport( "script", function(s) {

	// This transport only deals with cross domain requests
	if ( s.crossDomain ) {

		var script,
			head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;

		return {

			send: function( _, callback ) {

				script = document.createElement( "script" );

				script.async = "async";

				if ( s.scriptCharset ) {
					script.charset = s.scriptCharset;
				}

				script.src = s.url;

				// Attach handlers for all browsers
				script.onload = script.onreadystatechange = function( _, isAbort ) {

					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {

						// Handle memory leak in IE
						script.onload = script.onreadystatechange = null;

						// Remove the script
						if ( head && script.parentNode ) {
							head.removeChild( script );
						}

						// Dereference the script
						script = undefined;

						// Callback if not abort
						if ( !isAbort ) {
							callback( 200, "success" );
						}
					}
				};

				// Use insertBefore instead of appendChild to circumvent an IE6 bug.
				// This arises when a base node is used (#2709 and #4378).
				head.insertBefore( script, head.firstChild );
			},

			abort: function() {
				if ( script ) {
					script.onload( 0, 1 );
				}
			}
		};
	}
});

var xhrCallbacks,

	// #5280: Internet Explorer will keep connections alive if we don't abort on unload
	xhrOnUnloadAbort = window.ActiveXObject ? function() {

		// Abort all pending requests
		for ( var key in xhrCallbacks ) {
			xhrCallbacks[ key ]( 0, 1 );
		}

	} : false,
	xhrId = 0;

// Functions to create xhrs
function createStandardXHR() {
	try {
		return new window.XMLHttpRequest();
	} catch( e ) {}
}

function createActiveXHR() {
	try {
		return new window.ActiveXObject( "Microsoft.XMLHTTP" );
	} catch( e ) {}
}

// Create the request object
// (This is still attached to ajaxSettings for backward compatibility)
jQuery.ajaxSettings.xhr = window.ActiveXObject ?
	/* Microsoft failed to properly
	 * implement the XMLHttpRequest in IE7 (can't request local files),
	 * so we use the ActiveXObject when it is available
	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
	 * we need a fallback.
```

--------------------------------

### Tablesorter Configuration and Parser Setup

Source: https://github.com/ejwa/gitinspector/wiki/examples/django_output.emb.html

Configures the tablesorter plugin with custom parsers for various data types (text, digit, currency, IP address, URL, ISO date, short date, percent). Includes event bindings for sorting, updating, and applying widgets. Use this to enable advanced sorting and formatting in a table.

```javascript
totalRows=($this[0].tBodies[0]&&$this[0].tBodies[0].rows.length)||0;if(!this.sortDisabled&&totalRows>0){$this.trigger("sortStart");var $cell=$(this);var i=this.column;this.order=this.count++%2;if(this.lockedOrder)this.order=this.lockedOrder;if(!e[config.sortMultiSortKey]){config.sortList=[];if(config.sortForce!=null){var a=config.sortForce;for(var j=0;j<a.length;j++){if(a[j][0]!=i){config.sortList.push(a[j]);}}}config.sortList.push([i,this.order]);}else{if(isValueInArray(i,config.sortList)){for(var j=0;j<config.sortList.length;j++){var s=config.sortList[j],o=config.headerList[s[0]];if(s[0]==i){o.count=s[1];o.count++;s[1]=o.count%2;}}}else{config.sortList.push([i,this.order]);}};setTimeout(function(){setHeadersCss($this[0],$headers,config.sortList,sortCSS);appendToTable($this[0],multisort($this[0],config.sortList,cache));},1);return false;}}).mousedown(function(){if(config.cancelSelection){this.onselectstart=function(){return false};return false;}});$this.bind("update",function(){var me=this;setTimeout(function(){me.config.parsers=buildParserCache(me,$headers);cache=buildCache(me);},1);}).bind("updateCell",function(e,cell){var config=this.config;var pos=[(cell.parentNode.rowIndex-1),cell.cellIndex];cache.normalized[pos[0]][pos[1]]=config.parsers[pos[1]].format(getElementText(config,cell),cell);}).bind("sorton",function(e,list){$(this).trigger("sortStart");config.sortList=list;var sortList=config.sortList;updateHeaderSortCount(this,sortList);setHeadersCss(this,$headers,sortList,sortCSS);appendToTable(this,multisort(this,sortList,cache));}).bind("appendCache",function(){appendToTable(this,cache);}).bind("applyWidgetId",function(e,id){getWidgetById(id).format(this);}).bind("applyWidgets",function(){applyWidget(this);});if($.metadata&&($(this).metadata()&&$(this).metadata().sortlist)){config.sortList=$(this).metadata().sortlist;}if(config.sortList.length>0){$this.trigger("sorton",[config.sortList]);}applyWidget(this);});};this.addParser=function(parser){var l=parsers.length,a=true;for(var i=0;i<l;i++){if(parsers[i].id.toLowerCase()==parser.id.toLowerCase()){a=false;}}if(a){parsers.push(parser);};};this.addWidget=function(widget){widgets.push(widget);};this.formatFloat=function(s){var i=parseFloat(s);return(isNaN(i))?0:i;};this.formatInt=function(s){var i=parseInt(s);return(isNaN(i))?0:i;};this.isDigit=function(s,config){return/^[-+]?\d*$/.test($.trim(s.replace(/[,.' ]/g,'')));};this.clearTableBody=function(table){if($.browser.msie){function empty(){while(this.firstChild)this.removeChild(this.firstChild);}empty.apply(table.tBodies[0]);}else{table.tBodies[0].innerHTML="";}};}});$.fn.extend({tablesorter:$.tablesorter.construct});var ts=$.tablesorter;ts.addParser({id:"text",is:function(s){return true;},format:function(s){return $.trim(s.toLocaleLowerCase());},type:"text"});ts.addParser({id:"digit",is:function(s,table){var c=table.config;return $.tablesorter.isDigit(s,c);},format:function(s){return $.tablesorter.formatFloat(s);},type:"numeric"});ts.addParser({id:"currency",is:function(s){return/^[$?.]/.test(s);},format:function(s){return $.tablesorter.formatFloat(s.replace(new RegExp(/[$]/g),""));},type:"numeric"});ts.addParser({id:"ipAddress",is:function(s){return/^\d{2,3}[\.]\d{2,3}[\.]\d{2,3}[\.]\d{2,3}$/.test(s);},format:function(s){var a=s.split("."),r="",l=a.length;for(var i=0;i<l;i++){var item=a[i];if(item.length==2){r+="0"+item;}else{r+=item;}}return $.tablesorter.formatFloat(r);},type:"numeric"});ts.addParser({id:"url",is:function(s){return/^(https?|ftp|file):\/\/$/.test(s);},format:function(s){return jQuery.trim(s.replace(new RegExp(/(https?|ftp|file):\/\//),''));},type:"text"});ts.addParser({id:"isoDate",is:function(s){return/^\d{4}[\/-]\d{1,2}[\/-]\d{1,2}$/.test(s);},format:function(s){return $.tablesorter.formatFloat((s!="")?new Date(s.replace(new RegExp(/-/g),"/")).getTime():"0");},type:"numeric"});ts.addParser({id:"percent",is:function(s){return/\%$/.test($.trim(s));},format:function(s){return $.tablesorter.formatFloat(s.replace(new RegExp(/%/g),""));},type:"numeric"});ts.addParser({id:"usLongDate",is:function(s){return s.match(new RegExp(/^[A-Za-z]{3,10}\.? [0-9]{1,2}, ([0-9]{4}|'?[0-9]{2}) (([0-2]?[0-9]:[0-5][0-9])|([0-1]?[0-9]:[0-5][0-9]\s(AM|PM)))$/));},format:function(s){return $.tablesorter.formatFloat(new Date(s).getTime());},type:"numeric"});ts.addParser({id:"shortDate",is:function(s){return/\d{1,2}[\/-]\d{1,2}[\/-]\d{2,4}/.test(s);},format:function(s,table){var c=table.config;s=s.replace(/\-/g,"/");if(c.dateFormat=="us"){s=s.replace(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{4})/,"$3/$1/$2");}else if(c.dateFormat=="uk"){s=s.replace(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{4})/,"$3/$2/$1");}else if(c.dateFormat=="dd/mm/yy"||c.dateFormat=="dd-mm-yy"){s=s.replace(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{2})/,"$1/$2/$3");}return 
```

--------------------------------

### jQuery.access and related functions

Source: https://github.com/ejwa/gitinspector/wiki/examples/django_output.emb.html

This snippet contains the implementation of the `jQuery.access` method, which is used to get and set values on a collection. It also includes the `jQuery.ready.promise` function that handles document ready events, and the `createOptions` function that parses string-formatted options into an object. The code is from the jQuery library and is minified.

```javascript
if ( !jQuery.isFunction( fn ) ) { return undefined; } // Simulated bind args = core\_slice.call( arguments, 2 ); proxy = function() { return fn.apply( context, args.concat( core\_slice.call( arguments ) ) ); }; // Set the guid of unique handler to the same of original handler, so it can be removed proxy.guid = fn.guid = fn.guid || jQuery.guid++; return proxy; }, // Multifunctional method to get and set values of a collection // The value/s can optionally be executed if it's a function access: function( elems, fn, key, value, chainable, emptyGet, pass ) { var exec, bulk = key == null, i = 0, length = elems.length; // Sets many values if ( key && typeof key === "object" ) { for ( i in key ) { jQuery.access( elems, fn, i, key\[i\], 1, emptyGet, value ); } chainable = 1; // Sets one value } else if ( value !== undefined ) { // Optionally, function values get executed if exec is true exec = pass === undefined && jQuery.isFunction( value ); if ( bulk ) { // Bulk operations only iterate when executing function values if ( exec ) { exec = fn; fn = function( elem, key, value ) { return exec.call( jQuery( elem ), value ); }; // Otherwise they run against the entire set } else { fn.call( elems, value ); fn = null; } } if ( fn ) { for (; i < length; i++ ) { fn( elems\[i\], key, exec ? value.call( elems\[i\], i, fn( elems\[i\], key ) ) : value, pass ); } } chainable = 1; } return chainable ? elems : // Gets bulk ? fn.call( elems ) : length ? fn( elems\[0\], key ) : emptyGet; }, now: function() { return ( new Date() ).getTime(); } }); jQuery.ready.promise = function( obj ) { if ( !readyList ) { readyList = jQuery.Deferred(); // Catch cases where $(document).ready() is called after the browser event has already occurred. // we once tried to use readyState "interactive" here, but it caused issues like the one // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15 if ( document.readyState === "complete" ) { // Handle it asynchronously to allow scripts the opportunity to delay ready setTimeout( jQuery.ready, 1 ); // Standards-based browsers support DOMContentLoaded } else if ( document.addEventListener ) { // Use the handy event callback document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); // A fallback to window.onload, that will always work window.addEventListener( "load", jQuery.ready, false ); // If IE event model is used } else { // Ensure firing before onload, maybe late but safe also for iframes document.attachEvent( "onreadystatechange", DOMContentLoaded ); // A fallback to window.onload, that will always work window.attachEvent( "onload", jQuery.ready ); // If IE and not a frame // continually check to see if the document is ready var top = false; try { top = window.frameElement == null && document.documentElement; } catch(e) {} if ( top && top.doScroll ) { (function doScrollCheck() { if ( !jQuery.isReady ) { try { // Use the trick by Diego Perini // http://javascript.nwbox.com/IEContentLoaded/ top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // and execute any waiting functions jQuery.ready(); } })(); } } } return readyList.promise( obj ); }; // Populate the class2type map jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { class2type\[ "\[object " + name + "]" \] = name.toLowerCase(); }); // All jQuery objects should point back to these rootjQuery = jQuery(document); // String to Object options format cache var optionsCache = {}; // Convert String-formatted options into Object-formatted ones and store in cache function createOptions( options ) { var object = optionsCache\[ options \] = {}; jQuery.each( options.split( core\_rspace ), function( \_, flag ) { object\[ flag \] = true; }); return object; } /* \n * Create a callback list using the following parameters: \n * \n * options: an optional list of space-separated options that will change how \n * the callback list behaves or a more traditional option object \n * \n * By default a callback list will act like an event callback list and can be \n * "fired" multiple times. \n * \n * Possible options: \n * \n * once: will ensure the callback list can only be fired once (like a Deferred) \n * \n * memory: will keep track of previous values and will call any callback added \n * after the list has been fired right away with the latest "memorized" \n * values (like a Deferred) \n * \n * unique: will ensure a callback can only be added once (no duplicate in the list) \n * \n * stopOnFalse: interrupt callings when a callback returns false \n */ jQuery.Callbacks = function( options ) { // Convert options from String-formatted to Object-formatted if needed // (we check in cache first) options = typeof options === "string" ? ( optionsCache\[ options \] || createOptions( options ) ) : jQuery.extend( {}, options ); var // Last fire value (for non-forgettable lists) memory, // Flag to know if list was already fired fired, // Flag to know if list is currently firing firing, // First callback
```

--------------------------------

### Canvas constructor with pixel ratio and text overlay setup

Source: https://github.com/ejwa/gitinspector/wiki/examples/jquery_output.html

Initializes the canvas element, computes the pixel ratio from device and backing store ratios, resizes to match the container, and sets up text overlay containers and caches.

```javascript
var devicePixelRatio = window.devicePixelRatio || 1,
    backingStoreRatio = context.webkitBackingStorePixelRatio ||
        context.mozBackingStorePixelRatio ||
        context.msBackingStorePixelRatio ||
        context.oBackingStorePixelRatio ||
        context.backingStorePixelRatio || 1;

this.pixelRatio = devicePixelRatio / backingStoreRatio;

// Size the canvas to match the internal dimensions of its container
this.resize(container.width(), container.height());

// Collection of HTML div layers for text overlaid onto the canvas
this.textContainer = null;
this.text = {};

// Cache of text fragments and metrics, so we can avoid expensively
// re-calculating them when the plot is re-rendered in a loop.
this._textCache = {};
```

--------------------------------

### jQuery Animation: Tween Start Value Computation

Source: https://github.com/ejwa/gitinspector/wiki/examples/pango_output.emb.html

Computes the starting value for a tween when the unit is not 'px' and a start value is provided. It iteratively approximates the start value using the current CSS property or a fallback, adjusting by a scale factor until convergence or the maximum number of iterations is reached.

```javascript
// We need to compute starting value
if ( unit !== "px" && start ) {
    // Iteratively approximate from a nonzero starting point
    // Prefer the current property, because this process will be trivial if it uses the same units
    // Fallback to end or a simple constant
    start = jQuery.css( tween.elem, prop, true ) || end || 1;

    do {
        // If previous iteration zeroed out, double until we get \*something\*
        // Use a string for doubling factor so we don't accidentally see scale as unchanged below
        scale = scale || ".5";
        // Adjust and apply
        start = start / scale;
        jQuery.style( tween.elem, prop, start + unit );

        // Update scale, tolerating zero or NaN from tween.cur()
        // And breaking the loop if scale is unchanged or perfect, or if we've just had enough
    } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
}

tween.unit = unit;
tween.start = start;
// If a +=/-= token was provided, we're doing a relative animation
tween.end = parts\[1\] ? start + ( parts\[1\] + 1 ) \* end : end;
}
return tween;
}\];
// Animations created synchronously will run synchronously
function createFxNow() {
    setTimeout(function() {
        fxNow = undefined;
    }, 0 );
    return ( fxNow = jQuery.now() );
}
function createTweens( animation, props ) {
    jQuery.each( props, function( prop, value ) {
        var collection = ( tweeners\[ prop \] || \[\] ).concat( tweeners\[ "\*" \] ),
            index = 0,
            length = collection.length;
        for ( ; index < length ; index++ ) {
            if ( collection\[ index \].call( animation, prop, value ) ) {
                // we're done with this property
                return;
            }
        }
    });
}
function Animation( elem, properties, options ) {
    var result,
        index = 0,
        tweenerIndex = 0,
        length = animationPrefilters.length,
        deferred = jQuery.Deferred().always( function() {
            // don't match elem in the :animated selector
            delete tick.elem;
        }),
        tick = function() {
            var currentTime = fxNow || createFxNow(),
                remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
                // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
                temp = remaining / animation.duration || 0,
                percent = 1 - temp,
                index = 0,
                length = animation.tweens.length;
            for ( ; index < length ; index++ ) {
                animation.tweens\[ index \].run( percent );
            }
            deferred.notifyWith( elem, \[ animation, percent, remaining \]);
            if ( percent < 1 && length ) {
                return remaining;
            } else {
                deferred.resolveWith( elem, \[ animation \] );
                return false;
            }
        },
        animation = deferred.promise({
            elem: elem,
            props: jQuery.extend( {}, properties ),
            opts: jQuery.extend( true, { specialEasing: {} }, options ),
            originalProperties: properties,
            originalOptions: options,
            startTime: fxNow || createFxNow(),
            duration: options.duration,
            tweens: \[\],
            createTween: function( prop, end, easing ) {
                var tween = jQuery.Tween( elem, animation.opts, prop, end, animation.opts.specialEasing\[ prop \] || animation.opts.easing );
                animation.tweens.push( tween );
                return tween;
            },
            stop: function( gotoEnd ) {
                var index = 0,
                    // if we are going to the end, we want to run all the tweens
                    // otherwise we skip this part
                    length = gotoEnd ? animation.tweens.length : 0;
                for ( ; index < length ; index++ ) {
                    animation.tweens\[ index \].run( 1 );
                }
                // resolve when we played the last frame
                // otherwise, reject
                if ( gotoEnd ) {
                    deferred.resolveWith( elem, \[ animation, gotoEnd \] );
                } else {
                    deferred.rejectWith( elem, \[ animation, gotoEnd \] );
                }
                return this;
            }
        }),
        props = animation.props;
    propFilter( props, animation.opts.specialEasing );
    for ( ; index < length ; index++ ) {
        result = animationPrefilters\[ index \].call( animation, elem, props, animation.opts );
        if ( result ) {
            return result;
        }
    }
    createTweens( animation, props );
    if ( jQuery.isFunction( animation.opts.start ) ) {
        animation.opts.start.call( elem, animation );
    }
    jQuery.fx.timer( jQuery.extend( tick, { anim: animation, queue: animation.opts.queue, elem: elem }) );
    // attach callbacks from options
    return animation.progress( animation.opts.progress )
        .done( animation.opts.done, animation.opts.complete )
        .fail( animation.opts.fail )
        .always( animation.opts.always );
}
function propFilter( props, specialEasing ) {
    var index, name, easing, value, hooks;
    // camelCase, specialEasing and expand cssHook pass
    for ( index in props ) {
        name = jQuery.camelCase( index );
        easing = specialEasing\[ name \];
        value = props\[ index \];
        if ( jQuery.isArray( value ) ) {
            easing = value\[ 1 \];
            value = props\[ index \] = value\[ 0 \];
        }
        if ( index !== name ) {
            props\[ name \] = value;
            delete props\[ index \];
        }
        hooks = jQuery.cssHooks\[ name \];
        if ( hooks && "expand" in hooks ) {
            value = hooks.expand( value );
            delete props\[ name \];
            // not quite $.extend, this wont overwrite keys already present.
            // also - reusing 'index' from above because we have the correct "name"
            for ( index in value ) {
                if ( !( index in props ) ) {
                    props\[ index \] = value\[ index \];
                    specialEasing\[ index \] = easing;
                }
            }
        } else {
            specialEasing\[ name \] = easing;
        }
    }
}

jQuery.Animation = jQuery.extend( Animation, {
    tweener: function( props,
```

--------------------------------

### jQuery source excerpt: access, ready.promise, and Callbacks

Source: https://github.com/ejwa/gitinspector/wiki/examples/jquery_output.emb.html

This snippet is a verbatim excerpt from jQuery's source code, showing the implementation of jQuery.access, jQuery.ready.promise, and the beginning of jQuery.Callbacks. It includes the handling of function arguments, DOM ready events, and the creation of callback lists with options like once, memory, unique, and stopOnFalse.

```javascript
if ( !jQuery.isFunction( fn ) ) { return undefined; } // Simulated bind args = core\_slice.call( arguments, 2 ); proxy = function() { return fn.apply( context, args.concat( core\_slice.call( arguments ) ) ); }; // Set the guid of unique handler to the same of original handler, so it can be removed proxy.guid = fn.guid = fn.guid || jQuery.guid++; return proxy; }, // Multifunctional method to get and set values of a collection // The value/s can optionally be executed if it's a function access: function( elems, fn, key, value, chainable, emptyGet, pass ) { var exec, bulk = key == null, i = 0, length = elems.length; // Sets many values if ( key && typeof key === "object" ) { for ( i in key ) { jQuery.access( elems, fn, i, key\[i\], 1, emptyGet, value ); } chainable = 1; // Sets one value } else if ( value !== undefined ) { // Optionally, function values get executed if exec is true exec = pass === undefined && jQuery.isFunction( value ); if ( bulk ) { // Bulk operations only iterate when executing function values if ( exec ) { exec = fn; fn = function( elem, key, value ) { return exec.call( jQuery( elem ), value ); }; // Otherwise they run against the entire set } else { fn.call( elems, value ); fn = null; } } if ( fn ) { for (; i < length; i++ ) { fn( elems\[i\], key, exec ? value.call( elems\[i\], i, fn( elems\[i\], key ) ) : value, pass ); } } chainable = 1; } return chainable ? elems : // Gets bulk ? fn.call( elems ) : length ? fn( elems\[0\], key ) : emptyGet; }, now: function() { return ( new Date() ).getTime(); } }); jQuery.ready.promise = function( obj ) { if ( !readyList ) { readyList = jQuery.Deferred(); // Catch cases where $(document).ready() is called after the browser event has already occurred. // we once tried to use readyState "interactive" here, but it caused issues like the one // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15 if ( document.readyState === "complete" ) { // Handle it asynchronously to allow scripts the opportunity to delay ready setTimeout( jQuery.ready, 1 ); // Standards-based browsers support DOMContentLoaded } else if ( document.addEventListener ) { // Use the handy event callback document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); // A fallback to window.onload, that will always work window.addEventListener( "load", jQuery.ready, false ); // If IE event model is used } else { // Ensure firing before onload, maybe late but safe also for iframes document.attachEvent( "onreadystatechange", DOMContentLoaded ); // A fallback to window.onload, that will always work window.attachEvent( "onload", jQuery.ready ); // If IE and not a frame // continually check to see if the document is ready var top = false; try { top = window.frameElement == null && document.documentElement; } catch(e) {} if ( top && top.doScroll ) { (function doScrollCheck() { if ( !jQuery.isReady ) { try { // Use the trick by Diego Perini // http://javascript.nbox.com/IEContentLoaded/ top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // and execute any waiting functions jQuery.ready(); } })(); } } } return readyList.promise( obj ); }; // Populate the class2type map jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { class2type\[ "\[object " + name + "\]" \] = name.toLowerCase(); }); // All jQuery objects should point back to these rootjQuery = jQuery(document); // String to Object options format cache var optionsCache = {}; // Convert String-formatted options into Object-formatted ones and store in cache function createOptions( options ) { var object = optionsCache\[ options \] = {}; jQuery.each( options.split( core\_rspace ), function( \_, flag ) { object\[ flag \] = true; }); return object; } /* \* Create a callback list using the following parameters: \* \* options: an optional list of space-separated options that will change how \* the callback list behaves or a more traditional option object \* \* By default a callback list will act like an event callback list and can be \* "fired" multiple times. \* \* Possible options: \* \* once: will ensure the callback list can only be fired once (like a Deferred) \* \* memory: will keep track of previous values and will call any callback added \* after the list has been fired right away with the latest "memorized" \* values (like a Deferred) \* \* unique: will ensure a callback can only be added once (no duplicate in the list) \* \* stopOnFalse: interrupt callings when a callback returns false \* \*/ jQuery.Callbacks = function( options ) { // Convert options from String-formatted to Object-formatted if needed // (we check in cache first) options = typeof options === "string" ? ( optionsCache\[ options \] || createOptions( options ) ) : jQuery.extend( {}, options ); var // Last fire value (for non-forgettable lists) memory, // Flag to know if list was already fired fired, // Flag to know if list is currently firing firing, // First callback
```

--------------------------------

### Flot setupGrid function with axis scaling and datapoint processing

Source: https://github.com/ejwa/gitinspector/wiki/examples/django_output.html

This code is part of the Flot library's setupGrid function. It processes datapoints, handles bar alignment, and updates axis scales. It also includes the setTransformationHelpers function that defines p2c and c2p conversion functions for axes.

```javascript
if (insertSteps && k > 0 && points[k - ps] != null && points[k - ps] != points[k] && points[k - ps + 1] != points[k + 1]) { // copy the point to make room for a middle point for (m = 0; m < ps; ++m) points[k + ps + m] = points[k + m]; // middle point has same y points[k + 1] = points[k - ps + 1]; // we've added a point, better reflect that k += ps; } } } } // give the hooks a chance to run for (i = 0; i < series.length; ++i) { s = series[i]; executeHooks(hooks.processDatapoints, [ s, s.datapoints]); } // second pass: find datamax/datamin for auto-scaling for (i = 0; i < series.length; ++i) { s = series[i]; points = s.datapoints.points; ps = s.datapoints.pointsize; format = s.datapoints.format; var xmin = topSentry, ymin = topSentry, xmax = bottomSentry, ymax = bottomSentry; for (j = 0; j < points.length; j += ps) { if (points[j] == null) continue; for (m = 0; m < ps; ++m) { val = points[j + m]; f = format[m]; if (!f || f.autoscale === false || val == fakeInfinity || val == -fakeInfinity) continue; if (f.x) { if (val < xmin) xmin = val; if (val > xmax) xmax = val; } if (f.y) { if (val < ymin) ymin = val; if (val > ymax) ymax = val; } } } if (s.bars.show) { // make sure we got room for the bar on the dancing floor var delta; switch (s.bars.align) { case "left": delta = 0; break; case "right": delta = -s.bars.barWidth; break; case "center": delta = -s.bars.barWidth / 2; break; default: throw new Error("Invalid bar alignment: " + s.bars.align); } if (s.bars.horizontal) { ymin += delta; ymax += delta + s.bars.barWidth; } else { xmin += delta; xmax += delta + s.bars.barWidth; } } updateAxis(s.xaxis, xmin, xmax); updateAxis(s.yaxis, ymin, ymax); } $.each(allAxes(), function (_, axis) { if (axis.datamin == topSentry) axis.datamin = null; if (axis.datamax == bottomSentry) axis.datamax = null; }); }
```