Created
September 8, 2009 10:32
-
-
Save tjcrowder/182838 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* TEMPORARY TESTING VERSION INCLUDING NEW SUPERCALLS FROM | |
http://github.com/tjcrowder/prototype/commit/79d3e1dfd32220299f0a5aceacfc6fd3ffa2a089 | |
*/ | |
/* Prototype JavaScript framework, version 1.6.1 | |
* (c) 2005-2009 Sam Stephenson | |
* | |
* Prototype is freely distributable under the terms of an MIT-style license. | |
* For details, see the Prototype web site: http://www.prototypejs.org/ | |
* | |
*--------------------------------------------------------------------------*/ | |
var Prototype = { | |
Version: '1.6.1', | |
Browser: (function(){ | |
var ua = navigator.userAgent; | |
var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]'; | |
return { | |
IE: !!window.attachEvent && !isOpera, | |
Opera: isOpera, | |
WebKit: ua.indexOf('AppleWebKit/') > -1, | |
Gecko: ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1, | |
MobileSafari: /Apple.*Mobile.*Safari/.test(ua) | |
} | |
})(), | |
BrowserFeatures: { | |
XPath: !!document.evaluate, | |
SelectorsAPI: !!document.querySelector, | |
ElementExtensions: (function() { | |
var constructor = window.Element || window.HTMLElement; | |
return !!(constructor && constructor.prototype); | |
})(), | |
SpecificElementExtensions: (function() { | |
if (typeof window.HTMLDivElement !== 'undefined') | |
return true; | |
var div = document.createElement('div'); | |
var form = document.createElement('form'); | |
var isSupported = false; | |
if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) { | |
isSupported = true; | |
} | |
div = form = null; | |
return isSupported; | |
})() | |
}, | |
ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>', | |
JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/, | |
emptyFunction: function() { }, | |
K: function(x) { return x } | |
}; | |
if (Prototype.Browser.MobileSafari) | |
Prototype.BrowserFeatures.SpecificElementExtensions = false; | |
var Abstract = { }; | |
var Try = { | |
these: function() { | |
var returnValue; | |
for (var i = 0, length = arguments.length; i < length; i++) { | |
var lambda = arguments[i]; | |
try { | |
returnValue = lambda(); | |
break; | |
} catch (e) { } | |
} | |
return returnValue; | |
} | |
}; | |
/* Based on Alex Arnell's inheritance implementation. */ | |
var Class = (function() { | |
function subclass() {}; | |
function create() { | |
var parent = null, properties = $A(arguments); | |
if (Object.isFunction(properties[0])) | |
parent = properties.shift(); | |
function klass() { | |
this.initialize.apply(this, arguments); | |
} | |
Object.extend(klass, Class.Methods); | |
klass.superclass = parent; | |
klass.subclasses = []; | |
if (parent) { | |
subclass.prototype = parent.prototype; | |
klass.prototype = new subclass; | |
parent.subclasses.push(klass); | |
} | |
for (var i = 0; i < properties.length; i++) | |
klass.addMethods(properties[i]); | |
if (!klass.prototype.initialize) | |
klass.prototype.initialize = Prototype.emptyFunction; | |
klass.prototype.constructor = klass; | |
return klass; | |
} | |
function addMethods(source) { | |
var ancestor = this.superclass && this.superclass.prototype; | |
var properties = Object.keys(source); | |
if (!Object.keys({ toString: true }).length) { | |
if (source.toString != Object.prototype.toString) | |
properties.push("toString"); | |
if (source.valueOf != Object.prototype.valueOf) | |
properties.push("valueOf"); | |
} | |
for (var i = 0, length = properties.length; i < length; i++) { | |
var property = properties[i], value = source[property]; | |
if (Object.isFunction(value)) { | |
if (ancestor && value.argumentNames().first() == "$super") { | |
var method = value; | |
value = (function(m) { | |
return function() { return ancestor[m].apply(this, arguments); }; | |
})(property).wrap(method); | |
value.valueOf = method.valueOf.bind(method); | |
value.toString = method.toString.bind(method); | |
} | |
var baseValue = ancestor && ancestor[property]; | |
if (Object.isFunction(baseValue)) { | |
value.$super = baseValue; | |
} | |
for (var subIndex = this.subclasses.length - 1; subIndex >= 0; --subIndex) { | |
var subValue = this.subclasses[subIndex].prototype[property]; | |
if (Object.isFunction(subValue)) { | |
subValue.$super = value; | |
} | |
} | |
} | |
this.prototype[property] = value; | |
} | |
return this; | |
} | |
return { | |
create: create, | |
Methods: { | |
addMethods: addMethods | |
} | |
}; | |
})(); | |
(function() { | |
var _toString = Object.prototype.toString; | |
function extend(destination, source) { | |
for (var property in source) | |
destination[property] = source[property]; | |
return destination; | |
} | |
function inspect(object) { | |
try { | |
if (isUndefined(object)) return 'undefined'; | |
if (object === null) return 'null'; | |
return object.inspect ? object.inspect() : String(object); | |
} catch (e) { | |
if (e instanceof RangeError) return '...'; | |
throw e; | |
} | |
} | |
function toJSON(object) { | |
var type = typeof object; | |
switch (type) { | |
case 'undefined': | |
case 'function': | |
case 'unknown': return; | |
case 'boolean': return object.toString(); | |
} | |
if (object === null) return 'null'; | |
if (object.toJSON) return object.toJSON(); | |
if (isElement(object)) return; | |
var results = []; | |
for (var property in object) { | |
var value = toJSON(object[property]); | |
if (!isUndefined(value)) | |
results.push(property.toJSON() + ': ' + value); | |
} | |
return '{' + results.join(', ') + '}'; | |
} | |
function toQueryString(object) { | |
return $H(object).toQueryString(); | |
} | |
function toHTML(object) { | |
return object && object.toHTML ? object.toHTML() : String.interpret(object); | |
} | |
function keys(object) { | |
var results = []; | |
for (var property in object) | |
results.push(property); | |
return results; | |
} | |
function values(object) { | |
var results = []; | |
for (var property in object) | |
results.push(object[property]); | |
return results; | |
} | |
function clone(object) { | |
return extend({ }, object); | |
} | |
function isElement(object) { | |
return !!(object && object.nodeType == 1); | |
} | |
function isArray(object) { | |
return _toString.call(object) == "[object Array]"; | |
} | |
function isHash(object) { | |
return object instanceof Hash; | |
} | |
function isFunction(object) { | |
return typeof object === "function"; | |
} | |
function isString(object) { | |
return _toString.call(object) == "[object String]"; | |
} | |
function isNumber(object) { | |
return _toString.call(object) == "[object Number]"; | |
} | |
function isUndefined(object) { | |
return typeof object === "undefined"; | |
} | |
extend(Object, { | |
extend: extend, | |
inspect: inspect, | |
toJSON: toJSON, | |
toQueryString: toQueryString, | |
toHTML: toHTML, | |
keys: keys, | |
values: values, | |
clone: clone, | |
isElement: isElement, | |
isArray: isArray, | |
isHash: isHash, | |
isFunction: isFunction, | |
isString: isString, | |
isNumber: isNumber, | |
isUndefined: isUndefined | |
}); | |
})(); | |
Object.extend(Function.prototype, (function() { | |
var slice = Array.prototype.slice; | |
function update(array, args) { | |
var arrayLength = array.length, length = args.length; | |
while (length--) array[arrayLength + length] = args[length]; | |
return array; | |
} | |
function merge(array, args) { | |
array = slice.call(array, 0); | |
return update(array, args); | |
} | |
function argumentNames() { | |
var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1] | |
.replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '') | |
.replace(/\s+/g, '').split(','); | |
return names.length == 1 && !names[0] ? [] : names; | |
} | |
function bind(context) { | |
if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this; | |
var __method = this, args = slice.call(arguments, 1); | |
return function() { | |
var a = merge(args, arguments); | |
return __method.apply(context, a); | |
} | |
} | |
function bindAsEventListener(context) { | |
var __method = this, args = slice.call(arguments, 1); | |
return function(event) { | |
var a = update([event || window.event], args); | |
return __method.apply(context, a); | |
} | |
} | |
function curry() { | |
if (!arguments.length) return this; | |
var __method = this, args = slice.call(arguments, 0); | |
return function() { | |
var a = merge(args, arguments); | |
return __method.apply(this, a); | |
} | |
} | |
function delay(timeout) { | |
var __method = this, args = slice.call(arguments, 1); | |
timeout = timeout * 1000 | |
return window.setTimeout(function() { | |
return __method.apply(__method, args); | |
}, timeout); | |
} | |
function defer() { | |
var args = update([0.01], arguments); | |
return this.delay.apply(this, args); | |
} | |
function wrap(wrapper) { | |
var __method = this; | |
return function() { | |
var a = update([__method.bind(this)], arguments); | |
return wrapper.apply(this, a); | |
} | |
} | |
function methodize() { | |
if (this._methodized) return this._methodized; | |
var __method = this; | |
return this._methodized = function() { | |
var a = update([this], arguments); | |
return __method.apply(null, a); | |
}; | |
} | |
return { | |
argumentNames: argumentNames, | |
bind: bind, | |
bindAsEventListener: bindAsEventListener, | |
curry: curry, | |
delay: delay, | |
defer: defer, | |
wrap: wrap, | |
methodize: methodize | |
} | |
})()); | |
Date.prototype.toJSON = function() { | |
return '"' + this.getUTCFullYear() + '-' + | |
(this.getUTCMonth() + 1).toPaddedString(2) + '-' + | |
this.getUTCDate().toPaddedString(2) + 'T' + | |
this.getUTCHours().toPaddedString(2) + ':' + | |
this.getUTCMinutes().toPaddedString(2) + ':' + | |
this.getUTCSeconds().toPaddedString(2) + 'Z"'; | |
}; | |
RegExp.prototype.match = RegExp.prototype.test; | |
RegExp.escape = function(str) { | |
return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1'); | |
}; | |
var PeriodicalExecuter = Class.create({ | |
initialize: function(callback, frequency) { | |
this.callback = callback; | |
this.frequency = frequency; | |
this.currentlyExecuting = false; | |
this.registerCallback(); | |
}, | |
registerCallback: function(% |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
what does it do?