prototype.js

应用泛型以及反射编写的单表操作框架

	values: function() {
		return this.pluck('value');
	},

	merge: function(hash) {
		return $H(hash).inject($H(this), function(mergedHash, pair) {
			mergedHash[pair.key] = pair.value;
			return mergedHash;
		});
	},

	toQueryString: function() {
		return this.map(function(pair) {
			return pair.map(encodeURIComponent).join('=');
		}).join('&');
	},

	inspect: function() {
		return '#<Hash:{' + this.map(function(pair) {
			return pair.map(Object.inspect).join(': ');
		}).join(', ') + '}>';
	}
}

function $H(object) {
	var hash = Object.extend({}, object || {});
	Object.extend(hash, Enumerable);
	Object.extend(hash, Hash);
	return hash;
}
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
	initialize: function(start, end, exclusive) {
		this.start = start;
		this.end = end;
		this.exclusive = exclusive;
	},

	_each: function(iterator) {
		var value = this.start;
		while (this.include(value)) {
			iterator(value);
			value = value.succ();
		}
	},

	include: function(value) {
		if (value < this.start)
			return false;
		if (this.exclusive)
			return value < this.end;
		return value <= this.end;
	}
});

var $R = function(start, end, exclusive) {
	return new ObjectRange(start, end, exclusive);
}

var Ajax = {
	getTransport: function() {
		return Try.these(
				function() {
					return new XMLHttpRequest()
				},
				function() {
					return new ActiveXObject('Msxml2.XMLHTTP')
				},
				function() {
					return new ActiveXObject('Microsoft.XMLHTTP')
				}
				) || false;
	},

	activeRequestCount: 0
}

Ajax.Responders = {
	responders: [],

	_each: function(iterator) {
		this.responders._each(iterator);
	},

	register: function(responderToAdd) {
		if (!this.include(responderToAdd))
			this.responders.push(responderToAdd);
	},

	unregister: function(responderToRemove) {
		this.responders = this.responders.without(responderToRemove);
	},

	dispatch: function(callback, request, transport, json) {
		this.each(function(responder) {
			if (responder[callback] && typeof responder[callback] == 'function') {
				try {
					responder[callback].apply(responder, [request, transport, json]);
				} catch (e) {
				}
			}
		});
	}
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
	onCreate: function() {
		Ajax.activeRequestCount++;
	},

	onComplete: function() {
		Ajax.activeRequestCount--;
	}
});

Ajax.Base = function() {
};
Ajax.Base.prototype = {
	setOptions: function(options) {
		this.options = {
			method:	   'post',
			asynchronous: true,
			contentType:  'application/x-www-form-urlencoded',
			parameters:   ''
		}
		Object.extend(this.options, options || {});
	},

	responseIsSuccess: function() {
		return this.transport.status == undefined
				|| this.transport.status == 0
				|| (this.transport.status >= 200 && this.transport.status < 300);
	},

	responseIsFailure: function() {
		return !this.responseIsSuccess();
	}
}

Ajax.Request = Class.create();
Ajax.Request.Events =
['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
	initialize: function(url, options) {
		this.transport = Ajax.getTransport();
		this.setOptions(options);
		this.request(url);
	},

	request: function(url) {
		var parameters = this.options.parameters || '';
		if (parameters.length > 0) parameters += '&_=';

		/* Simulate other verbs over post */
		if (this.options.method != 'get' && this.options.method != 'post') {
			parameters += (parameters.length > 0 ? '&' : '') + '_method=' + this.options.method;
			this.options.method = 'post';
		}

		try {
			this.url = url;
			if (this.options.method == 'get' && parameters.length > 0)
				this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

			Ajax.Responders.dispatch('onCreate', this, this.transport);

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

			if (this.options.asynchronous)
				setTimeout(function() {
					this.respondToReadyState(1)
				}.bind(this), 10);

			this.transport.onreadystatechange = this.onStateChange.bind(this);
			this.setRequestHeaders();

			var body = this.options.postBody ? this.options.postBody : parameters;
			this.transport.send(this.options.method == 'post' ? body : null);

			/* Force Firefox to handle ready state 4 for synchronous requests */
			if (!this.options.asynchronous && this.transport.overrideMimeType)
				this.onStateChange();

		} catch (e) {
			this.dispatchException(e);
		}
	},

	setRequestHeaders: function() {
		var requestHeaders =
				['X-Requested-With', 'XMLHttpRequest',
						'X-Prototype-Version', Prototype.Version,
						'Accept', 'text/javascript, text/html, application/xml, text/xml, */*'];

		if (this.options.method == 'post') {
			requestHeaders.push('Content-type', this.options.contentType);

			/* Force "Connection: close" for Mozilla browsers to work around
						* a bug where XMLHttpReqeuest sends an incorrect Content-length
						* header. See Mozilla Bugzilla #246651.
						*/
			if (this.transport.overrideMimeType)
				requestHeaders.push('Connection', 'close');
		}

		if (this.options.requestHeaders)
			requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

		for (var i = 0; i < requestHeaders.length; i += 2)
			this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i + 1]);
	},

	onStateChange: function() {
		var readyState = this.transport.readyState;
		if (readyState != 1)
			this.respondToReadyState(this.transport.readyState);
	},

	header: function(name) {
		try {
			return this.transport.getResponseHeader(name);
		} catch (e) {
		}
	},

	evalJSON: function() {
		try {
			return eval('(' + this.header('X-JSON') + ')');
		} catch (e) {
		}
	},

	evalResponse: function() {
		try {
			return eval(this.transport.responseText);
		} catch (e) {
			this.dispatchException(e);
		}
	},

	respondToReadyState: function(readyState) {
		var event = Ajax.Request.Events[readyState];
		var transport = this.transport, json = this.evalJSON();

		if (event == 'Complete') {
			try {
				(this.options['on' + this.transport.status]
						|| this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
						|| Prototype.emptyFunction)(transport, json);
			} catch (e) {
				this.dispatchException(e);
			}

			if ((this.header('Content-type') || '').match(/^text\/javascript/i))
				this.evalResponse();
		}

		try {
			(this.options['on' + event] || Prototype.emptyFunction)(transport, json);
			Ajax.Responders.dispatch('on' + event, this, transport, json);
		} catch (e) {
			this.dispatchException(e);
		}

		/* Avoid memory leak in MSIE: clean up the oncomplete event handler */
		if (event == 'Complete')
			this.transport.onreadystatechange = Prototype.emptyFunction;
	},

	dispatchException: function(exception) {
		(this.options.onException || Prototype.emptyFunction)(this, exception);
		Ajax.Responders.dispatch('onException', this, exception);
	}
});

Ajax.Updater = Class.create();

Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
	initialize: function(container, url, options) {
		this.containers = {
			success: container.success ? $(container.success) : $(container),
			failure: container.failure ? $(container.failure) :
					 (container.success ? null : $(container))
		}

		this.transport = Ajax.getTransport();
		this.setOptions(options);

		var onComplete = this.options.onComplete || Prototype.emptyFunction;
		this.options.onComplete = (function(transport, object) {
			this.updateContent();
			onComplete(transport, object);
		}).bind(this);

		this.request(url);
	},

	updateContent: function() {
		var receiver = this.responseIsSuccess() ?
					   this.containers.success : this.containers.failure;
		var response = this.transport.responseText;

		if (!this.options.evalScripts)
			response = response.stripScripts();

		if (receiver) {
			if (this.options.insertion) {
				new this.options.insertion(receiver, response);
			} else {
				Element.update(receiver, response);
			}
		}

		if (this.responseIsSuccess()) {
			if (this.onComplete)
				setTimeout(this.onComplete.bind(this), 10);
		}
	}
});

Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
	initialize: function(container, url, options) {
		this.setOptions(options);
		this.onComplete = this.options.onComplete;

		this.frequency = (this.options.frequency || 2);
		this.decay = (this.options.decay || 1);

		this.updater = {};
		this.container = container;
		this.url = url;

		this.start();
	},

	start: function() {
		this.options.onComplete = this.updateComplete.bind(this);
		this.onTimerEvent();
	},

	stop: function() {
		this.updater.options.onComplete = undefined;
		clearTimeout(this.timer);
		(this.onComplete || Prototype.emptyFunction).apply(this, arguments);
	},

	updateComplete: function(request) {
		if (this.options.decay) {
			this.decay = (request.responseText == this.lastText ?
						  this.decay * this.options.decay : 1);

			this.lastText = request.responseText;
		}
		this.timer = setTimeout(this.onTimerEvent.bind(this),
				this.decay * this.frequency * 1000);
	},

	onTimerEvent: function() {
		this.updater = new Ajax.Updater(this.container, this.url, this.options);
	}
});
function $() {
	var results = [], element;
	for (var i = 0; i < arguments.length; i++) {
		element = arguments[i];
		if (typeof element == 'string')
			element = document.getElementById(element);
		results.push(Element.extend(element));
	}
	return results.reduce();
}

document.getElementsByClassName = function(className, parentElement) {
	var children = ($(parentElement) || document.body).getElementsByTagName('*');
	return $A(children).inject([], function(elements, child) {
		if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
			elements.push(Element.extend(child));
		return elements;
	});
}

/*--------------------------------------------------------------------------*/

if (!window.Element)
	var Element = new Object();

Element.extend = function(element) {
	if (!element) return;
	if (_nativeExtensions) return element;

	if (!element._extended && element.tagName && element != window) {
		var methods = Object.clone(Element.Methods), cache = Element.extend.cache;

		if (element.tagName == 'FORM')
			Object.extend(methods, Form.Methods);
		if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
			Object.extend(methods, Form.Element.Methods);

		for (var property in methods) {
			var value = methods[property];
			if (typeof value == 'function')
				element[property] = cache.findOrStore(value);
		}
	}

	element._extended = true;
	return element;
}

Element.extend.cache = {
	findOrStore: function(value) {
		return this[value] = this[value] || function() {
			return value.apply(null, [this].concat($A(arguments)));
		}
	}
}

Element.Methods = {
	visible: function(element) {
		return $(element).style.display != 'none';
	},

	toggle: function(element) {
		element = $(element);
		Element[Element.visible(element) ? 'hide' : 'show'](element);
		return element;
	},

	hide: function(element) {
		$(element).style.display = 'none';
		return element;
	},

	show: function(element) {
		$(element).style.display = '';
		return element;
	},

	remove: function(element) {
		element = $(element);
		element.parentNode.removeChild(element);
		return element;
	},

	update: function(element, html) {
		$(element).innerHTML = html.stripScripts();
		setTimeout(function() {
			html.evalScripts()
		}, 10);
		return element;
	},

	replace: function(element, html) {
		element = $(element);
		if (element.outerHTML) {
			element.outerHTML = html.stripScripts();
		} else {
			var range = element.ownerDocument.createRange();
			range.selectNodeContents(element);
			element.parentNode.replaceChild(
					range.createContextualFragment(html.stripScripts()), element);
		}
		setTimeout(function() {
			html.evalScripts()
		}, 10);
		return element;
	},

	inspect: function(element) {
		element = $(element);
		var result = '<' + element.tagName.toLowerCase();
		$H({'id': 'id', 'className': 'class'}).each(function(pair) {
			var property = pair.first(), attribute = pair.last();
			var value = (element[property] || '').toString();
			if (value) result += ' ' + attribute + '=' + value.inspect(true);
		});
		return result + '>';
	},

	recursivelyCollect: function(element, property) {
		element = $(element);
		var elements = [];
		while (element = element[property])
			if (element.nodeType == 1)
				elements.push(Element.extend(element));
		return elements;
	},

	ancestors: function(element) {
		return $(element).recursivelyCollect('parentNode');
	},

	descendants: function(element) {
		element = $(element);
		return $A(element.getElementsByTagName('*'));
	},

	previousSiblings: function(element) {
		return $(element).recursivelyCollect('previousSibling');
	},

	nextSiblings: function(element) {
		return $(element).recursivelyCollect('nextSibling');
	},

	siblings: function(element) {
		element = $(element);
		return element.previousSiblings().reverse().concat(element.nextSiblings());
	},

	match: function(element, selector) {
		element = $(element);
		if (typeof selector == 'string')
			selector = new Selector(selector);
		return selector.match(element);
	},

	up: function(element, expression, index) {
		return Selector.findElement($(element).ancestors(), expression, index);
	},

	down: function(element, expression, index) {
		return Selector.findElement($(element).descendants(), expression, index);
	},

	previous: function(element, expression, index) {
		return Selector.findElement($(element).previousSiblings(), expression, index);
	},

	next: function(element, expression, index) {
		return Selector.findElement($(element).nextSiblings(), expression, index);
	},

	getElementsBySelector: function() {
		var args = $A(arguments), element = $(args.shift());
		return Selector.findChildElements(element, args);
	},

	getElementsByClassName: function(element, className) {
		element = $(element);
		return document.getElementsByClassName(className, element);
	},

	getHeight: function(element) {
		element = $(element);
		return element.offsetHeight;
	},

	classNames: function(element) {
		return new Element.ClassNames(element);
	},

	hasClassName: function(element, className) {
		if (!(element = $(element))) return;
		return Element.classNames(element).include(className);
	},

	addClassName: function(element, className) {
		if (!(element = $(element))) return;
		Element.classNames(element).add(className);
		return element;
	},