Subversion Repositories SmartDukaan

/**

 * Debug Toolbar Javascript.

 *

 * Creates the DEBUGKIT namespace and provides methods for extending

 * and enhancing the Html toolbar. Includes library agnostic Event, Element,

 * Cookie and Request wrappers.

 *

 *

 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)

 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 *

 * Licensed under The MIT License

 * Redistributions of files must retain the above copyright notice.

 *

 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 * @link          http://cakephp.org CakePHP(tm) Project

 * @since         DebugKit 0.1

 * @license       http://www.opensource.org/licenses/mit-license.php MIT License

 */

/* jshint jquery: true */

var DEBUGKIT = function () {

	var undef;

	return {

		module: function (newmodule) {

			if (this[newmodule] === undef) {

				this[newmodule] = {};

				return this[newmodule];

			}

			return this[newmodule];

		}

	};

}();

(function () {

	function versionGTE(a, b) {

		var len = Math.min(a.length, b.length);

		for (var i = 0; i < len; i++) {

			a[i] = parseInt(a[i], 10);

			b[i] = parseInt(b[i], 10);

			if (a[i] > b[i]) {

				return true;

			}

			if (a[i] < b[i]) {

				return false;

			}

		}

		return true;

	}

	function versionWithin(version, min, max) {

		version = version.split('.');

		min = min.split('.');

		max = max.split('.');

		return versionGTE(version, min) && versionGTE(max, version);

	}

	// Look for existing jQuery that matches the requirements.

	if (window.jQuery && versionWithin(jQuery.fn.jquery, "1.8", "2.1")) {

		DEBUGKIT.$ = window.jQuery;

	} else {

		// sync load the file. Using document.write() does not block

		// in recent versions of chrome.

		var req = new XMLHttpRequest();

		req.onload = function () {

			eval(this.responseText);

			// Restore both $ and jQuery to the original values.

			DEBUGKIT.$ = jQuery.noConflict(true);

		};

		req.open('get', window.DEBUGKIT_JQUERY_URL, false);

		req.send();

	}

})();

DEBUGKIT.loader = function () {

	return {

		// List of methods to run on startup.

		_startup: [],

		// Register a new method to be run on dom ready.

		register: function (method) {

			this._startup.push(method);

		},

		init: function () {

			for (var i = 0, callback; callback = this._startup[i]; i++) {

				callback.init();

			}

		}

	};

}();

DEBUGKIT.module('sqlLog');

DEBUGKIT.sqlLog = function () {

	var $ = DEBUGKIT.$;

	return {

		init : function () {

			var sqlPanel = $('#sql_log-tab');

			var buttons = sqlPanel.find('input');

			// Button handling code for explain links.

			// Performs XHR request to get explain query.

			var handleButton = function (event) {

				event.preventDefault();

				var form = $(this.form),

					data = form.serialize(),

					dbName = form.find('input[name*=ds]').val() || 'default';

				var fetch = $.ajax({

					url: this.form.action,

					data: data,

					type: 'POST',

					success : function (response) {

						$('#sql-log-explain-' + dbName).html(response);

					},

					error : function () {

						alert('Could not fetch EXPLAIN for query.');

					}

				});

			};

			buttons.filter('.sql-explain-link').on('click', handleButton);

		}

	};

}();

DEBUGKIT.loader.register(DEBUGKIT.sqlLog);

//

// NOTE DEBUGKIT.Util.Element is Deprecated.

//

// Util module and Element utility class.

DEBUGKIT.module('Util');

DEBUGKIT.Util.Element = {

	// Test if an element is a name node.

	nodeName: function (element, name) {

		return element.nodeName && element.nodeName.toLowerCase() === name.toLowerCase();

	},

	// Return a boolean if the element has the classname

	hasClass: function (element, className) {

		if (!element.className) {

			return false;

		}

		return element.className.indexOf(className) > -1;

	},

	addClass: function (element, className) {

		if (!element.className) {

			element.className = className;

			return;

		}

		element.className = element.className.replace(/^(.*)$/, '$1 ' + className);

	},

	removeClass: function (element, className) {

		if (DEBUGKIT.Util.isArray(element)) {

			DEBUGKIT.Util.Collection.apply(element, function (element) {

				DEBUGKIT.Util.Element.removeClass(element, className);

			});

		}

		if (!element.className) {

			return false;

		}

		element.className = element.className.replace(new RegExp(' ?(' + className + ') ?'), '');

	},

	swapClass: function (element, removeClass, addClass) {

		if (!element.className) {

			return false;

		}

		element.className = element.className.replace(removeClass, addClass);

	},

	show: function (element) {

		element.style.display = 'block';

	},

	hide: function (element) {

		element.style.display = 'none';

	},

	// Go between hide() and show() depending on element.style.display

	toggle: function (element) {

		if (element.style.display === 'none') {

			this.show(element);

			return;

		}

		this.hide(element);

	},

	_walk: function (element, walk) {

		var sibling = element[walk];

		while (true) {

			if (sibling.nodeType == 1) {

				break;

			}

			sibling = sibling[walk];

		}

		return sibling;

	},

	getNext: function (element) {

		return this._walk(element, 'nextSibling');

	},

	getPrevious: function (element) {

		return this._walk(element, 'previousSibling');

	},

	// Get or set an element's height, omit value to get, add value (integer) to set.

	height: function (element, value) {

		// Get value

		if (value === undefined) {

			return parseInt(this.getStyle(element, 'height'), 10);

		}

		element.style.height = value + 'px';

	},

	// Gets the style in css format for property

	getStyle: function (element, property) {

		if (element.currentStyle) {

			property = property.replace(/-[a-z]/g, function (match) {

				return match.charAt(1).toUpperCase();

			});

			return element.currentStyle[property];

		}

		if (window.getComputedStyle) {

			return document.defaultView.getComputedStyle(element, null).getPropertyValue(property);

		}

	}

};

//

// NOTE DEBUGKIT.Util.Collection is Deprecated.

//

DEBUGKIT.Util.Collection = {

	/**

	 * Apply the passed function to each item in the collection.

	 * The current element in the collection will be `this` in the callback

	 * The callback is also passed the element and the index as arguments.

	 * Optionally you can supply a binding parameter to change `this` in the callback.

	 */

	apply: function (collection, callback, binding) {

		var name, thisVar, i = 0, len = collection.length;

		if (len === undefined) {

			for (name in collection) {

				thisVar = (binding === undefined) ? collection[name] : binding;

				callback.apply(thisVar, [collection[name], name]);

			}

		} else {

			for (; i < len; i++) {

				thisVar = (binding === undefined) ? collection[i] : binding;

				callback.apply(thisVar, [collection[i], i]);

			}

		}

	}

};

//

// NOTE DEBUGKIT.Util.Event is Deprecated.

//

// Event binding

DEBUGKIT.Util.Event = function () {

	var _listeners = {},

		_eventId = 0;

	var preventDefault = function () {

		this.returnValue = false;

	};

	var stopPropagation = function () {

		this.cancelBubble = true;

	};

	// Fixes IE's broken event object, adds in common methods + properties.

	var fixEvent = function (event) {

		if (!event.preventDefault) {

			event.preventDefault = preventDefault;

		}

		if (!event.stopPropagation) {

			event.stopPropagation = stopPropagation;

		}

		if (!event.target) {

			event.target = event.srcElement || document;

		}

		if (event.pageX === null && event.clientX !== null) {

			var doc = document.body;

			event.pageX = event.clientX + (doc.scrollLeft || 0) - (doc.clientLeft || 0);

			event.pageY = event.clientY + (doc.scrollTop || 0) - (doc.clientTop || 0);

		}

		return event;

	};

	return {

		// Bind an event listener of type to element, handler is your method.

		addEvent: function (element, type, handler, capture) {

			capture = (capture === undefined) ? false : capture;

			var callback = function (event) {

				event = fixEvent(event || window.event);

				handler.apply(element, [event]);

			};

			if (element.addEventListener) {

				element.addEventListener(type, callback, capture);

			} else if (element.attachEvent) {

				type = 'on' + type;

				element.attachEvent(type, callback);

			} else {

				type = 'on' + type;

				element[type] = callback;

			}

			_listeners[++_eventId] = {element: element, type: type, handler: callback};

		},

		// Destroy an event listener. requires the exact same function as was used for attaching

		// the event.

		removeEvent: function (element, type, handler) {

			if (element.removeEventListener) {

				element.removeEventListener(type, handler, false);

			} else if (element.detachEvent) {

				type = 'on' + type;

				element.detachEvent(type, handler);

			} else {

				type = 'on' + type;

				element[type] = null;

			}

		},

		// Bind an event to the DOMContentLoaded or other similar event.

		domready: function (callback) {

			if (document.addEventListener) {

				return document.addEventListener('DOMContentLoaded', callback, false);

			}

			if (document.all && !window.opera) {

				// Define a "blank" external JavaScript tag

				document.write(

					'<script type="text/javascript" id="__domreadywatcher" defer="defer" src="javascript:void(0)"><\/script>'

				);

				var contentloadtag = document.getElementById('__domreadywatcher');

				contentloadtag.onreadystatechange = function () {

					if (this.readyState === 'complete') {

						callback();

					}

				};

				contentloadtag = null;

				return;

			}

			if (/Webkit/i.test(navigator.userAgent)) {

				var _timer = setInterval(function () {

					if (/loaded|complete/.test(document.readyState)) {

						clearInterval(_timer);

						callback();

					}

				}, 10);

			}

		},

		// Unload all the events attached by DebugKit. Fix any memory leaks.

		unload: function () {

			var listener;

			for (var i in _listeners) {

				listener = _listeners[i];

				try {

					this.removeEvent(listener.element, listener.type, listener.handler);

				} catch (e) {}

				delete _listeners[i];

			}

			delete _listeners;

		}

	};

}();

// Cookie utility

DEBUGKIT.Util.Cookie = function () {

	var cookieLife = 60;

// Public methods

	return {

		/**

		 * Write to cookie.

		 *

		 * @param [string] name Name of cookie to write.

		 * @param [mixed] value Value to write to cookie.

		 */

		write: function (name, value) {

			var date = new Date();

			date.setTime(date.getTime() + (cookieLife * 24 * 60 * 60 * 1000));

			var expires = '; expires=' + date.toGMTString();

			document.cookie = name + '=' + value + expires + '; path=/';

			return true;

		},

		/**

		 * Read from the cookie.

		 *

		 * @param [string] name Name of cookie to read.

		 */

		read: function (name) {

			name = name + '=';

			var cookieJar = document.cookie.split(';');

			var cookieJarLength = cookieJar.length;

			for (var i = 0; i < cookieJarLength; i++) {

				var chips = cookieJar[i];

				// Trim leading spaces

				while (chips.charAt(0) === ' ') {

					chips = chips.substring(1, chips.length);

				}

				if (chips.indexOf(name) === 0) {

					return chips.substring(name.length, chips.length);

				}

			}

			return false;

		},

		/**

		 * Delete a cookie by name.

		 *

		 * @param [string] name of cookie to delete.

		 */

		del: function (name) {

			var date = new Date();

			date.setFullYear(2000, 0, 1);

			var expires = ' ; expires=' + date.toGMTString();

			document.cookie = name + '=' + expires + '; path=/';

		}

	};

}();

//

// NOTE DEBUGKIT.Util.merge is Deprecated.

//

/**

 * Object merge takes any number of arguments and glues them together.

 *

 * @param [Object] one first object

 * @return object

 */

DEBUGKIT.Util.merge = function () {

	var out = {};

	var argumentsLength = arguments.length;

	for (var i = 0; i < argumentsLength; i++) {

		var current = arguments[i];

		for (var prop in current) {

			if (current[prop] !== undefined) {

				out[prop] = current[prop];

			}

		}

	}

	return out;

};

//

// NOTE DEBUGKIT.Util.isArray is Deprecated.

//

/**

 * Check if the given object is an array.

 */

DEBUGKIT.Util.isArray = function (test) {

	return Object.prototype.toString.call(test) === '[object Array]';

};

//

// NOTE DEBUGKIT.Util.Request is Deprecated.

//

// Simple wrapper for XmlHttpRequest objects.

DEBUGKIT.Util.Request = function (options) {

	var _defaults = {

		onComplete : function () {},

		onRequest : function () {},

		onFail : function () {},

		method : 'GET',

		async : true,

		headers : {

			'X-Requested-With': 'XMLHttpRequest',

			'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'

		}

	};

	var self = this;

	this.options = DEBUGKIT.Util.merge(_defaults, options);

	this.options.method = this.options.method.toUpperCase();

	var ajax = this.createObj();

	this.transport = ajax;

	// Event assignment

	this.onComplete = this.options.onComplete;

	this.onRequest = this.options.onRequest;

	this.onFail = this.options.onFail;

	this.send = function (url, data) {

		if (this.options.method === 'GET' && data) {

			url = url + ((url.charAt(url.length - 1) === '?') ? '&' : '?') + data; //check for ? at the end of the string

			data = null;

		}

		// Open connection

		this.transport.open(this.options.method, url, this.options.async);

		// Set statechange and pass the active XHR object to it. From here it handles all status changes.

		this.transport.onreadystatechange = function () {

			self.onReadyStateChange.apply(self, arguments);

		};

		for (var key in this.options.headers) {

			this.transport.setRequestHeader(key, this.options.headers[key]);

		}

		if (typeof data === 'object') {

			data = this.serialize(data);

		}

		if (data) {

			this.transport.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');

		}

		this.onRequest();

		this.transport.send(data);

	};

};

DEBUGKIT.Util.Request.prototype.onReadyStateChange = function () {

	if (this.transport.readyState !== 4) {

		return;

	}

	if (this.transport.status === 200 || this.transport.status > 300 && this.transport.status < 400) {

		this.response = {

			xml: this.transport.responseXML,

			text: this.transport.responseText

		};

		if (typeof this.onComplete === 'function') {

			this.onComplete.apply(this, [this, this.response]);

		} else {

			return this.response;

		}

	} else if (this.transport.status > 400) {

		if (typeof this.onFail === 'function') {

			this.onFail.apply(this, []);

		} else {

			console.error('Request failed');

		}

	}

};

/**

 * Creates cross-broswer XHR object used for requests.

 * Tries using the standard XmlHttpRequest, then IE's wacky ActiveX Objects.

 */

DEBUGKIT.Util.Request.prototype.createObj = function () {

	var request = null;

	try {

		request = new XMLHttpRequest();

	} catch (MS) {

		try {

			request = new ActiveXObject('Msxml2.XMLHTTP');

		} catch (old_MS) {

			try {

				request = new ActiveXObject('Microsoft.XMLHTTP');

			} catch (failure) {

				request = null;

			}

		}

	}

	return request;

};

/**

 * Serializes an object literal into a querystring.

 */

DEBUGKIT.Util.Request.prototype.serialize = function (data) {

	var out = '';

	for (var name in data) {

		if (data.hasOwnProperty(name)) {

			out += name + '=' + data[name] + '&';

		}

	}

	return out.substring(0, out.length - 1);

};

// Basic toolbar module.

DEBUGKIT.toolbar = function () {

	// Shortcuts

	var Cookie = DEBUGKIT.Util.Cookie,

		$ = DEBUGKIT.$,

		toolbarHidden = false;

	return {

		elements: {},

		panels: {},

		init: function () {

			var i, element, lists, index, _this = this;

			this.elements.toolbar = $('#debug-kit-toolbar');

			if (this.elements.toolbar.length === 0) {

				throw new Error('Toolbar not found, make sure you loaded it.');

			}

			this.elements.panel = $('#panel-tabs');

			this.elements.panel.find('.panel-tab').each(function (i, panel) {

				_this.addPanel(panel);

			});

			lists = this.elements.toolbar.find('.depth-0');

			this.makeNeatArray(lists);

			this.deactivatePanel(true);

		},

		// Add a panel to the toolbar

		addPanel: function (tab) {

			var button, content, _this = this;

			var panel = {

				id : false,

				element : tab,

				button : undefined,

				content : undefined,

				active : false

			};

			tab = $(tab);

			button = tab.children('a');

			panel.id = button.attr('href').replace(/^#/, '');

			panel.button = button;

			panel.content = tab.find('.panel-content');

			if (!panel.id || panel.content.length === 0) {

				return false;

			}

			this.makePanelDraggable(panel);

			this.makePanelMinMax(panel);

			button.on('click', function (event) {

				event.preventDefault();

				_this.togglePanel(panel.id);

			});

			this.panels[panel.id] = panel;

			return panel.id;

		},

		// Find the handle element and make the panel drag resizable.

		makePanelDraggable: function (panel) {

			// Create a variable in the enclosing scope, for scope tricks.

			var currentElement = null;

			// Use the elements startHeight stored Event.pageY and current Event.pageY to

			// resize the panel.

			var mouseMoveHandler = function (event) {

				event.preventDefault();

				if (!currentElement) {

					return;

				}

				var newHeight = currentElement.data('startHeight') + (event.pageY - currentElement.data('startY'));

				currentElement.parent().height(newHeight);

			};

			// Handle the mouseup event, remove the other listeners so the panel

			// doesn't continue to resize.

			var mouseUpHandler = function (event) {

				currentElement = null;

				$(document).off('mousemove', mouseMoveHandler).off('mouseup', mouseUpHandler);

			};

			var mouseDownHandler = function (event) {

				event.preventDefault();

				currentElement = $(this);

				currentElement.data('startY', event.pageY);

				currentElement.data('startHeight', currentElement.parent().height());

				// Attach to document so mouse doesn't have to stay precisely on the 'handle'.

				$(document).on('mousemove', mouseMoveHandler)

					.on('mouseup', mouseUpHandler);

			};

			panel.content.find('.panel-resize-handle').on('mousedown', mouseDownHandler);

		},

		// Make the maximize button work on the panels.

		makePanelMinMax: function (panel) {

			var _oldHeight;

			var maximize = function () {

				if (!_oldHeight) {

					_oldHeight = this.parentNode.offsetHeight;

				}

				var windowHeight = window.innerHeight;

				var panelHeight = windowHeight - this.parentNode.offsetTop;

				$(this.parentNode).height(panelHeight);

				$(this).text('-');

			};

			var minimize = function () {

				$(this.parentNode).height(_oldHeight);

				$(this).text('+');

				_oldHeight = null;

			};

			var state = 1;

			var toggle = function (event) {

				event.preventDefault();

				if (state === 1) {

					maximize.call(this);

					state = 0;

				} else {

					state = 1;

					minimize.call(this);

				}

			};

			panel.content.find('.panel-toggle').on('click', toggle);

		},

		// Toggle a panel

		togglePanel: function (id) {

			if (this.panels[id] && this.panels[id].active) {

				this.deactivatePanel(true);

			} else {

				this.deactivatePanel(true);

				this.activatePanel(id);

			}

		},

		// Make a panel active.

		activatePanel: function (id, unique) {

			if (this.panels[id] !== undefined && !this.panels[id].active) {

				var panel = this.panels[id];

				if (panel.content.length > 0) {

					panel.content.css('display', 'block');

				}

				var contentHeight = panel.content.find('.panel-content-data').height() + 70;

				if (contentHeight <= (window.innerHeight / 2)) {

					panel.content.height(contentHeight);

				}

				panel.button.addClass('active');

				panel.active = true;

				return true;

			}

			return false;

		},

		// Deactivate a panel. use true to hide all panels.

		deactivatePanel: function (id) {

			if (id === true) {

				for (var i in this.panels) {

					this.deactivatePanel(i);

				}

				return true;

			}

			if (this.panels[id] !== undefined) {

				var panel = this.panels[id];

				if (panel.content !== undefined) {

					panel.content.hide();

				}

				panel.button.removeClass('active');

				panel.active = false;

				return true;

			}

			return false;

		},

		// Bind events for all the collapsible arrays.

		makeNeatArray: function (lists) {

			lists.find('ul').hide()

				.parent().addClass('expandable collapsed');

			lists.on('click', 'li', function (event) {

				event.stopPropagation();

				$(this).children('ul').toggle().toggleClass('expanded collapsed');

			});

		}

	};

}();

DEBUGKIT.loader.register(DEBUGKIT.toolbar);

DEBUGKIT.module('historyPanel');

DEBUGKIT.historyPanel = function () {

	var toolbar = DEBUGKIT.toolbar,

		$ = DEBUGKIT.$,

		historyLinks;

	// Private methods to handle JSON response and insertion of

	// new content.

	var switchHistory = function (response) {

		historyLinks.removeClass('loading');

		$.each(toolbar.panels, function (id, panel) {

			if (panel.content === undefined || response[id] === undefined) {

				return;

			}

			var regionDiv = panel.content.find('.panel-resize-region');

			if (!regionDiv.length) {

				return;

			}

			var regionDivs = regionDiv.children();

			regionDivs.filter('div').hide();

			regionDivs.filter('.panel-history').each(function (i, panelContent) {

				var panelId = panelContent.id.replace('-history', '');

				if (response[panelId]) {

					panelContent = $(panelContent);

					panelContent.html(response[panelId]);

					var lists = panelContent.find('.depth-0');

					toolbar.makeNeatArray(lists);

				}

				panelContent.show();

			});

		});

	};

	// Private method to handle restoration to current request.

	var restoreCurrentState = function () {

		var id, i, panelContent, tag;

		historyLinks.removeClass('loading');

		$.each(toolbar.panels, function (panel, id) {

			if (panel.content === undefined) {

				return;

			}

			var regionDiv = panel.content.find('.panel-resize-region');

			if (!regionDiv.length) {

				return;

			}

			var regionDivs = regionDiv.children();

			regionDivs.filter('div').show()

				.end()

				.filter('.panel-history').hide();

		});

	};

	function handleHistoryLink(event) {

		event.preventDefault();

		historyLinks.removeClass('active');

		$(this).addClass('active loading');

		if (this.id === 'history-restore-current') {

			restoreCurrentState();

			return false;

		}

		var xhr = $.ajax({

			url: this.href,

			type: 'GET',

			dataType: 'json'

		});

		xhr.success(switchHistory).fail(function () {

			alert('History retrieval failed');

		});

	}

	return {

		init : function () {

			if (toolbar.panels.history === undefined) {

				return;

			}

			historyLinks = toolbar.panels.history.content.find('.history-link');

			historyLinks.on('click', handleHistoryLink);

		}

	};

}();

DEBUGKIT.loader.register(DEBUGKIT.historyPanel);

//Add events + behaviors for toolbar collapser.

DEBUGKIT.toolbarToggle = function () {

	var toolbar = DEBUGKIT.toolbar,

		$ = DEBUGKIT.$,

		Cookie = DEBUGKIT.Util.Cookie,

		toolbarHidden = false;

	return {

		init: function () {

			var button = $('#hide-toolbar'),

				self = this;

			button.on('click', function (event) {

				event.preventDefault();

				self.toggleToolbar();

			});

			var toolbarState = Cookie.read('toolbarDisplay');

			if (toolbarState !== 'show') {

				toolbarHidden = false;

				this.toggleToolbar();

			}

		},

		toggleToolbar: function () {

			var display = toolbarHidden ? 'show' : 'hide';

			$.each(toolbar.panels, function (i, panel) {

				$(panel.element)[display]();

				Cookie.write('toolbarDisplay', display);

			});

			toolbarHidden = !toolbarHidden;

			if (toolbarHidden) {

				$('#debug-kit-toolbar').addClass('minimized');

			} else {

				$('#debug-kit-toolbar').removeClass('minimized');

			}

			return false;

		}

	};

}();

DEBUGKIT.loader.register(DEBUGKIT.toolbarToggle);

DEBUGKIT.$(document).ready(function () {

	DEBUGKIT.loader.init();

});