+
+##### JavaScript
+
+ var imgProps = $('myImage').getProperty('src'); //Returns: 'mootools.png'.
+
+
+
+Element Method: getProperties {#Element:getProperties}
+------------------------------------------------------
+
+Gets multiple element attributes.
+
+### Syntax:
+
+ var myProps = myElement.getProperties(properties);
+
+### Arguments:
+
+* properties - (*strings*) Any number of properties to be retrieved.
+
+### Returns:
+
+* (*object*) An object containing all of the Element's requested properties.
+
+### Examples:
+
+##### HTML
+
+ 
+
+
+
+Element Method: removeProperty {#Element:removeProperty}
+--------------------------------------------------------
+
+Removes an attribute from the Element.
+
+
+### Syntax:
+
+ myElement.removeProperty(property);
+
+### Arguments:
+
+1. property - (*string*) The attribute to remove.
+
+### Returns:
+
+* (*element*) This Element.
+
+### Examples:
+
+##### HTML
+
+ ');if(m===DIFF_DELETE){html.push('
JSSpec
', + '- ',
+ JSSpec.options.rerun ? '
- [X] ' + JSSpec.util.escapeTags(decodeURIComponent(JSSpec.options.rerun)) + ' ' : '', + '
- ' + JSSpec.runner.totalExamples + ' examples ', + '
- 0 failures ', + '
- 0 errors ', + '
- 0% done ', + '
- 0 secs ', + '
List
', + '- ',
+ function() {
+ var specs = JSSpec.runner.getSpecs();
+ var sb = [];
+ for(var i = 0; i < specs.length; i++) {
+ var spec = specs[i];
+ sb.push('
' + JSSpec.util.escapeTags(specs[i].context) + ' [rerun]
');
+ }
+ return sb.join("");
+ }(),
+ '
Log
', + '- ',
+ function() {
+ var specs = JSSpec.runner.getSpecs();
+ var sb = [];
+ for(var i = 0; i < specs.length; i++) {
+ var spec = specs[i];
+ sb.push('
- ');
+ sb.push('
' + JSSpec.util.escapeTags(specs[i].context) + ' [rerun]
'); + sb.push('- ');
+ for(var j = 0; j < spec.examples.length; j++) {
+ var example = spec.examples[j];
+ sb.push('
- ');
+ sb.push('
' + JSSpec.util.escapeTags(example.name) + '
'); + sb.push('
'); + sb.push(''+JSSpec.util.escapeTags(example.target.toString())+'');
+ }
+ sb.push('
');
+ }
+ return sb.join("");
+ }(),
+ ' - ');
+ sb.push('
" + " at " + example.exception.fileName + ", line " + example.exception.lineNumber + "
actual value:
'); + sb.push('' + JSSpec.util.inspect(this.actual, false, this.expected) + '
'); + sb.push('should ' + (this.condition ? '' : 'not') + ' include:
'); + sb.push('' + JSSpec.util.inspect(this.expected) + '
'); + return sb.join(""); +}; + +JSSpec.IncludeMatcher.prototype.makeExplainForArray = function() { + var matches; + if(this.condition) { + for(var i = 0; i < this.actual.length; i++) { + matches = JSSpec.EqualityMatcher.createInstance(this.expected, this.actual[i]).matches(); + if(matches) { + this.match = true; + break; + } + } + } else { + for(var i = 0; i < this.actual.length; i++) { + matches = JSSpec.EqualityMatcher.createInstance(this.expected, this.actual[i]).matches(); + if(matches) { + this.match = false; + break; + } + } + } + + if(this.match) return ""; + + var sb = []; + sb.push('actual value:
'); + sb.push('' + JSSpec.util.inspect(this.actual, false, this.condition ? null : i) + '
'); + sb.push('should ' + (this.condition ? '' : 'not') + ' include:
'); + sb.push('' + JSSpec.util.inspect(this.expected) + '
'); + return sb.join(""); +}; + +/** + * PropertyLengthMatcher + */ +JSSpec.PropertyLengthMatcher = function(num, property, o, condition) { + this.num = num; + this.o = o; + this.property = property; + if((property == 'characters' || property == 'items') && typeof o.length != 'undefined') { + this.property = 'length'; + } + + this.condition = condition; + this.conditionMet = function(x) { + if(condition == 'exactly') return x.length == num; + if(condition == 'at least') return x.length >= num; + if(condition == 'at most') return x.length <= num; + + throw "Unknown condition '" + condition + "'"; + }; + this.match = false; + this.explaination = this.makeExplain(); +}; + +JSSpec.PropertyLengthMatcher.prototype.makeExplain = function() { + if(this.o._type == 'String' && this.property == 'length') { + this.match = this.conditionMet(this.o); + return this.match ? '' : this.makeExplainForString(); + } else if(typeof this.o.length != 'undefined' && this.property == "length") { + this.match = this.conditionMet(this.o); + return this.match ? '' : this.makeExplainForArray(); + } else if(typeof this.o[this.property] != 'undefined' && this.o[this.property] != null) { + this.match = this.conditionMet(this.o[this.property]); + return this.match ? '' : this.makeExplainForObject(); + } else if(typeof this.o[this.property] == 'undefined' || this.o[this.property] == null) { + this.match = false; + return this.makeExplainForNoProperty(); + } + + this.match = true; +}; + +JSSpec.PropertyLengthMatcher.prototype.makeExplainForString = function() { + var sb = []; + + var exp = this.num == 0 ? + 'be an empty string' : + 'have ' + this.condition + ' ' + this.num + ' characters'; + + sb.push('actual value has ' + this.o.length + ' characters:
'); + sb.push('' + JSSpec.util.inspect(this.o) + '
'); + sb.push('but it should ' + exp + '.
'); + + return sb.join(""); +}; + +JSSpec.PropertyLengthMatcher.prototype.makeExplainForArray = function() { + var sb = []; + + var exp = this.num == 0 ? + 'be an empty array' : + 'have ' + this.condition + ' ' + this.num + ' items'; + + sb.push('actual value has ' + this.o.length + ' items:
'); + sb.push('' + JSSpec.util.inspect(this.o) + '
'); + sb.push('but it should ' + exp + '.
'); + + return sb.join(""); +}; + +JSSpec.PropertyLengthMatcher.prototype.makeExplainForObject = function() { + var sb = []; + + var exp = this.num == 0 ? + 'be empty' : + 'have ' + this.condition + ' ' + this.num + ' ' + this.property + '.'; + + sb.push('actual value has ' + this.o[this.property].length + ' ' + this.property + ':
'); + sb.push('' + JSSpec.util.inspect(this.o, false, this.property) + '
'); + sb.push('but it should ' + exp + '.
'); + + return sb.join(""); +}; + +JSSpec.PropertyLengthMatcher.prototype.makeExplainForNoProperty = function() { + var sb = []; + + sb.push('actual value:
'); + sb.push('' + JSSpec.util.inspect(this.o) + '
'); + sb.push('should have ' + this.condition + ' ' + this.num + ' ' + this.property + ' but there\'s no such property.
'); + + return sb.join(""); +}; + +JSSpec.PropertyLengthMatcher.prototype.matches = function() { + return this.match; +}; + +JSSpec.PropertyLengthMatcher.prototype.explain = function() { + return this.explaination; +}; + +JSSpec.PropertyLengthMatcher.createInstance = function(num, property, o, condition) { + return new JSSpec.PropertyLengthMatcher(num, property, o, condition); +}; + +/** + * EqualityMatcher + */ +JSSpec.EqualityMatcher = {}; + +JSSpec.EqualityMatcher.createInstance = function(expected, actual) { + if(expected == null || actual == null) { + return new JSSpec.NullEqualityMatcher(expected, actual); + } else if(expected._type && expected._type == actual._type) { + if(expected._type == "String") { + return new JSSpec.StringEqualityMatcher(expected, actual); + } else if(expected._type == "Date") { + return new JSSpec.DateEqualityMatcher(expected, actual); + } else if(expected._type == "Number") { + return new JSSpec.NumberEqualityMatcher(expected, actual); + } else if(expected._type == "Array") { + return new JSSpec.ArrayEqualityMatcher(expected, actual); + } else if(expected._type == "Boolean") { + return new JSSpec.BooleanEqualityMatcher(expected, actual); + } + } + + return new JSSpec.ObjectEqualityMatcher(expected, actual); +}; + +JSSpec.EqualityMatcher.basicExplain = function(expected, actual, expectedDesc, actualDesc) { + var sb = []; + + sb.push(actualDesc || 'actual value:
'); + sb.push('' + JSSpec.util.inspect(actual) + '
'); + sb.push(expectedDesc || 'should be:
'); + sb.push('' + JSSpec.util.inspect(expected) + '
'); + + return sb.join(""); +}; + +JSSpec.EqualityMatcher.diffExplain = function(expected, actual) { + var sb = []; + + sb.push('diff:
'); + sb.push(''); + + var dmp = new diff_match_patch(); + var diff = dmp.diff_main(expected, actual); + dmp.diff_cleanupEfficiency(diff); + + sb.push(JSSpec.util.inspect(dmp.diff_prettyHtml(diff), true)); + + sb.push('
'); + + return sb.join(""); +}; + +/** + * BooleanEqualityMatcher + */ +JSSpec.BooleanEqualityMatcher = function(expected, actual) { + this.expected = expected; + this.actual = actual; +}; + +JSSpec.BooleanEqualityMatcher.prototype.explain = function() { + var sb = []; + + sb.push('actual value:
'); + sb.push('' + JSSpec.util.inspect(this.actual) + '
'); + sb.push('should be:
'); + sb.push('' + JSSpec.util.inspect(this.expected) + '
'); + + return sb.join(""); +}; + +JSSpec.BooleanEqualityMatcher.prototype.matches = function() { + return this.expected == this.actual; +}; + +/** + * NullEqualityMatcher + */ +JSSpec.NullEqualityMatcher = function(expected, actual) { + this.expected = expected; + this.actual = actual; +}; + +JSSpec.NullEqualityMatcher.prototype.matches = function() { + return this.expected == this.actual && typeof this.expected == typeof this.actual; +}; + +JSSpec.NullEqualityMatcher.prototype.explain = function() { + return JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual); +}; + +JSSpec.DateEqualityMatcher = function(expected, actual) { + this.expected = expected; + this.actual = actual; +}; + +JSSpec.DateEqualityMatcher.prototype.matches = function() { + return this.expected.getTime() == this.actual.getTime(); +}; + +JSSpec.DateEqualityMatcher.prototype.explain = function() { + var sb = []; + + sb.push(JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual)); + sb.push(JSSpec.EqualityMatcher.diffExplain(this.expected.toString(), this.actual.toString())); + + return sb.join(""); +}; + +/** + * ObjectEqualityMatcher + */ +JSSpec.ObjectEqualityMatcher = function(expected, actual) { + this.expected = expected; + this.actual = actual; + this.match = this.expected == this.actual; + this.explaination = this.makeExplain(); +}; + +JSSpec.ObjectEqualityMatcher.prototype.matches = function() {return this.match}; + +JSSpec.ObjectEqualityMatcher.prototype.explain = function() {return this.explaination}; + +JSSpec.ObjectEqualityMatcher.prototype.makeExplain = function() { + if(this.expected == this.actual) { + this.match = true; + return ""; + } + + if(JSSpec.util.isDomNode(this.expected)) { + return this.makeExplainForDomNode(); + } + + var key, expectedHasItem, actualHasItem; + + for(key in this.expected) { + expectedHasItem = this.expected[key] != null && typeof this.expected[key] != 'undefined'; + actualHasItem = this.actual[key] != null && typeof this.actual[key] != 'undefined'; + if(expectedHasItem && !actualHasItem) return this.makeExplainForMissingItem(key); + } + for(key in this.actual) { + expectedHasItem = this.expected[key] != null && typeof this.expected[key] != 'undefined'; + actualHasItem = this.actual[key] != null && typeof this.actual[key] != 'undefined'; + if(actualHasItem && !expectedHasItem) return this.makeExplainForUnknownItem(key); + } + + for(key in this.expected) { + var matcher = JSSpec.EqualityMatcher.createInstance(this.expected[key], this.actual[key]); + if(!matcher.matches()) return this.makeExplainForItemMismatch(key); + } + + this.match = true; +}; + +JSSpec.ObjectEqualityMatcher.prototype.makeExplainForDomNode = function(key) { + var sb = []; + + sb.push(JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual)); + + return sb.join(""); +}; + +JSSpec.ObjectEqualityMatcher.prototype.makeExplainForMissingItem = function(key) { + var sb = []; + + sb.push('actual value has no item named ' + JSSpec.util.inspect(key) + '
'); + sb.push('' + JSSpec.util.inspect(this.actual, false, key) + '
'); + sb.push('but it should have the item whose value is ' + JSSpec.util.inspect(this.expected[key]) + '
'); + sb.push('' + JSSpec.util.inspect(this.expected, false, key) + '
'); + + return sb.join(""); +}; + +JSSpec.ObjectEqualityMatcher.prototype.makeExplainForUnknownItem = function(key) { + var sb = []; + + sb.push('actual value has item named ' + JSSpec.util.inspect(key) + '
'); + sb.push('' + JSSpec.util.inspect(this.actual, false, key) + '
'); + sb.push('but there should be no such item
'); + sb.push('' + JSSpec.util.inspect(this.expected, false, key) + '
'); + + return sb.join(""); +}; + +JSSpec.ObjectEqualityMatcher.prototype.makeExplainForItemMismatch = function(key) { + var sb = []; + + sb.push('actual value has an item named ' + JSSpec.util.inspect(key) + ' whose value is ' + JSSpec.util.inspect(this.actual[key]) + '
'); + sb.push('' + JSSpec.util.inspect(this.actual, false, key) + '
'); + sb.push('but it\'s value should be ' + JSSpec.util.inspect(this.expected[key]) + '
'); + sb.push('' + JSSpec.util.inspect(this.expected, false, key) + '
'); + + return sb.join(""); +}; + + + + +/** + * ArrayEqualityMatcher + */ +JSSpec.ArrayEqualityMatcher = function(expected, actual) { + this.expected = expected; + this.actual = actual; + this.match = this.expected == this.actual; + this.explaination = this.makeExplain(); +}; + +JSSpec.ArrayEqualityMatcher.prototype.matches = function() {return this.match}; + +JSSpec.ArrayEqualityMatcher.prototype.explain = function() {return this.explaination}; + +JSSpec.ArrayEqualityMatcher.prototype.makeExplain = function() { + if(this.expected.length != this.actual.length) return this.makeExplainForLengthMismatch(); + + for(var i = 0; i < this.expected.length; i++) { + var matcher = JSSpec.EqualityMatcher.createInstance(this.expected[i], this.actual[i]); + if(!matcher.matches()) return this.makeExplainForItemMismatch(i); + } + + this.match = true; +}; + +JSSpec.ArrayEqualityMatcher.prototype.makeExplainForLengthMismatch = function() { + return JSSpec.EqualityMatcher.basicExplain( + this.expected, + this.actual, + 'but it should be ' + this.expected.length + '
', + 'actual value has ' + this.actual.length + ' items
' + ); +}; + +JSSpec.ArrayEqualityMatcher.prototype.makeExplainForItemMismatch = function(index) { + var postfix = ["th", "st", "nd", "rd", "th"][Math.min((index + 1) % 10,4)]; + + var sb = []; + + sb.push('' + (index + 1) + postfix + ' item (index ' + index + ') of actual value is ' + JSSpec.util.inspect(this.actual[index]) + ':
'); + sb.push('' + JSSpec.util.inspect(this.actual, false, index) + '
'); + sb.push('but it should be ' + JSSpec.util.inspect(this.expected[index]) + ':
'); + sb.push('' + JSSpec.util.inspect(this.expected, false, index) + '
'); + + return sb.join(""); +}; + +/** + * NumberEqualityMatcher + */ +JSSpec.NumberEqualityMatcher = function(expected, actual) { + this.expected = expected; + this.actual = actual; +}; + +JSSpec.NumberEqualityMatcher.prototype.matches = function() { + if(this.expected == this.actual) return true; +}; + +JSSpec.NumberEqualityMatcher.prototype.explain = function() { + return JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual); +}; + +/** + * StringEqualityMatcher + */ +JSSpec.StringEqualityMatcher = function(expected, actual) { + this.expected = expected; + this.actual = actual; +}; + +JSSpec.StringEqualityMatcher.prototype.matches = function() { + return this.expected == this.actual; +}; + +JSSpec.StringEqualityMatcher.prototype.explain = function() { + var sb = []; + + sb.push(JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual)); + sb.push(JSSpec.EqualityMatcher.diffExplain(this.expected, this.actual)); + return sb.join(""); +}; + +/** + * PatternMatcher + */ +JSSpec.PatternMatcher = function(actual, pattern, condition) { + this.actual = actual; + this.pattern = pattern; + this.condition = condition; + this.match = false; + this.explaination = this.makeExplain(); +}; + +JSSpec.PatternMatcher.createInstance = function(actual, pattern, condition) { + return new JSSpec.PatternMatcher(actual, pattern, condition); +}; + +JSSpec.PatternMatcher.prototype.makeExplain = function() { + var sb; + if(this.actual == null || this.actual._type != 'String') { + sb = []; + sb.push('actual value:
'); + sb.push('' + JSSpec.util.inspect(this.actual) + '
'); + sb.push('should ' + (this.condition ? '' : 'not') + ' match with pattern:
'); + sb.push('' + JSSpec.util.inspect(this.pattern) + '
'); + sb.push('but pattern matching cannot be performed.
'); + return sb.join(""); + } else { + this.match = this.condition == !!this.actual.match(this.pattern); + if(this.match) return ""; + + sb = []; + sb.push('actual value:
'); + sb.push('' + JSSpec.util.inspect(this.actual) + '
'); + sb.push('should ' + (this.condition ? '' : 'not') + ' match with pattern:
'); + sb.push('' + JSSpec.util.inspect(this.pattern) + '
'); + return sb.join(""); + } +}; + +JSSpec.PatternMatcher.prototype.matches = function() { + return this.match; +}; + +JSSpec.PatternMatcher.prototype.explain = function() { + return this.explaination; +}; + +/** + * Domain Specific Languages + */ +JSSpec.DSL = {}; + +JSSpec.DSL.forString = { + normalizeHtml: function() { + var html = this; + + // Uniformize quotation, turn tag names and attribute names into lower case + html = html.replace(/<(\/?)(\w+)([^>]*?)>/img, function(str, closingMark, tagName, attrs) { + var sortedAttrs = JSSpec.util.sortHtmlAttrs(JSSpec.util.correctHtmlAttrQuotation(attrs).toLowerCase()) + return "<" + closingMark + tagName.toLowerCase() + sortedAttrs + ">" + }); + + // validation self-closing tags + html = html.replace(/<(br|hr|img)([^>]*?)>/mg, function(str, tag, attrs) { + return "<" + tag + attrs + " />"; + }); + + // append semi-colon at the end of style value + html = html.replace(/style="(.*?)"/mg, function(str, styleStr) { + styleStr = JSSpec.util.sortStyleEntries(styleStr.strip()); // for Safari + if(styleStr.charAt(styleStr.length - 1) != ';') styleStr += ";" + + return 'style="' + styleStr + '"' + }); + + // sort style entries + + // remove empty style attributes + html = html.replace(/ style=";"/mg, ""); + + // remove new-lines + html = html.replace(/\r/mg, ''); + html = html.replace(/\n/mg, ''); + + return html; + } +}; + + +JSSpec.DSL.describe = function(context, entries, base) { + if(base) { + for(var i = 0; i < JSSpec.specs.length; i++) { + if(JSSpec.specs[i].context === base) { + base = JSSpec.specs[i]; + break; + } + } + + for(var i = 0; i < base.examples.length; i++) { + var example = base.examples[i]; + + if(!entries[example.name]) entries[example.name] = example.target; + } + } + + JSSpec.specs.push(new JSSpec.Spec(context, entries)); +}; + +JSSpec.DSL.value_of = function(target) { + if(JSSpec._secondPass) return {}; + + var subject = new JSSpec.DSL.Subject(target); + return subject; +}; + +JSSpec.DSL.Subject = function(target) { + this.target = target; +}; + +JSSpec.DSL.Subject.prototype._type = 'Subject'; + +JSSpec.DSL.Subject.prototype.should_fail = function(message) { + JSSpec._assertionFailure = {message:message}; + throw JSSpec._assertionFailure; +}; + +JSSpec.DSL.Subject.prototype.should_be = function(expected) { + var matcher = JSSpec.EqualityMatcher.createInstance(expected, this.target); + if(!matcher.matches()) { + JSSpec._assertionFailure = {message:matcher.explain()}; + throw JSSpec._assertionFailure; + } +}; + +JSSpec.DSL.Subject.prototype.should_not_be = function(expected) { + // TODO JSSpec.EqualityMatcher should support 'condition' + var matcher = JSSpec.EqualityMatcher.createInstance(expected, this.target); + if(matcher.matches()) { + JSSpec._assertionFailure = {message:"'" + this.target + "' should not be '" + expected + "'"}; + throw JSSpec._assertionFailure; + } +}; + +JSSpec.DSL.Subject.prototype.should_be_empty = function() { + this.should_have(0, this.getType() == 'String' ? 'characters' : 'items'); +}; + +JSSpec.DSL.Subject.prototype.should_not_be_empty = function() { + this.should_have_at_least(1, this.getType() == 'String' ? 'characters' : 'items'); +}; + +JSSpec.DSL.Subject.prototype.should_be_true = function() { + this.should_be(true); +}; + +JSSpec.DSL.Subject.prototype.should_be_false = function() { + this.should_be(false); +}; + +JSSpec.DSL.Subject.prototype.should_be_null = function() { + this.should_be(null); +}; + +JSSpec.DSL.Subject.prototype.should_be_undefined = function() { + this.should_be(undefined); +}; + +JSSpec.DSL.Subject.prototype.should_not_be_null = function() { + this.should_not_be(null); +}; + +JSSpec.DSL.Subject.prototype.should_not_be_undefined = function() { + this.should_not_be(undefined); +}; + +JSSpec.DSL.Subject.prototype._should_have = function(num, property, condition) { + var matcher = JSSpec.PropertyLengthMatcher.createInstance(num, property, this.target, condition); + if(!matcher.matches()) { + JSSpec._assertionFailure = {message:matcher.explain()}; + throw JSSpec._assertionFailure; + } +}; + +JSSpec.DSL.Subject.prototype.should_have = function(num, property) { + this._should_have(num, property, "exactly"); +}; + +JSSpec.DSL.Subject.prototype.should_have_exactly = function(num, property) { + this._should_have(num, property, "exactly"); +}; + +JSSpec.DSL.Subject.prototype.should_have_at_least = function(num, property) { + this._should_have(num, property, "at least"); +}; + +JSSpec.DSL.Subject.prototype.should_have_at_most = function(num, property) { + this._should_have(num, property, "at most"); +}; + +JSSpec.DSL.Subject.prototype.should_include = function(expected) { + var matcher = JSSpec.IncludeMatcher.createInstance(this.target, expected, true); + if(!matcher.matches()) { + JSSpec._assertionFailure = {message:matcher.explain()}; + throw JSSpec._assertionFailure; + } +}; + +JSSpec.DSL.Subject.prototype.should_not_include = function(expected) { + var matcher = JSSpec.IncludeMatcher.createInstance(this.target, expected, false); + if(!matcher.matches()) { + JSSpec._assertionFailure = {message:matcher.explain()}; + throw JSSpec._assertionFailure; + } +}; + +JSSpec.DSL.Subject.prototype.should_match = function(pattern) { + var matcher = JSSpec.PatternMatcher.createInstance(this.target, pattern, true); + if(!matcher.matches()) { + JSSpec._assertionFailure = {message:matcher.explain()}; + throw JSSpec._assertionFailure; + } +} +JSSpec.DSL.Subject.prototype.should_not_match = function(pattern) { + var matcher = JSSpec.PatternMatcher.createInstance(this.target, pattern, false); + if(!matcher.matches()) { + JSSpec._assertionFailure = {message:matcher.explain()}; + throw JSSpec._assertionFailure; + } +}; + +JSSpec.DSL.Subject.prototype.getType = function() { + if(typeof this.target == 'undefined') { + return 'undefined'; + } else if(this.target == null) { + return 'null'; + } else if(this.target._type) { + return this.target._type; + } else if(JSSpec.util.isDomNode(this.target)) { + return 'DomNode'; + } else { + return 'object'; + } +}; + +/** + * Utilities + */ +JSSpec.util = { + escapeTags: function(string) { + return string.replace(//img, '>'); + }, + escapeMetastring: function(string) { + return string.replace(/\r/img, '\\r').replace(/\n/img, '\\n').replace(/\¶\;\Paragraph
', 'Link']; + var parent = new Element('div').set('html', html); + value_of(parent.innerHTML.toLowerCase()).should_be(html.join('').toLowerCase()); + }, + + "should set the html of a select Element": function(){ + var html = ''; + var select = new Element('select').set('html', html); + value_of(select.getChildren().length).should_be(2); + value_of(select.options.length).should_be(2); + value_of(select.selectedIndex).should_be(1); + }, + + "should set the html of a table Element": function(){ + var html = '',
+ '',
+ '',
+ '
'
+ ].join('');
+ Container = new Element('div', {style: 'position:absolute;top:0;left:0;visibility:hidden;', html: html});
+ document.body.appendChild(Container);
+
+ test = new Element('div', {id:'inject-test'});
+ },
+
+ 'after all': function(){
+ document.body.removeChild(Container);
+ Container.set('html', '');
+ Container = null;
+ test = null;
+ },
+
+ 'should inject the Element before an Element': function(){
+ test.inject($('first'), 'before');
+ value_of(Container.childNodes[0]).should_be(test);
+
+ test.inject($('second-child'), 'before');
+ value_of(Container.childNodes[1].childNodes[1]).should_be(test);
+ },
+
+ 'should inject the Element after an Element': function(){
+ test.inject($('first'), 'after');
+ value_of(Container.childNodes[1]).should_be(test);
+
+ test.inject($('first-child'), 'after');
+ value_of(Container.childNodes[1].childNodes[1]).should_be(test);
+ },
+
+ 'should inject the Element at bottom of an Element': function(){
+ var first = $('first');
+ test.inject(first, 'bottom');
+ value_of(first.childNodes[0]).should_be(test);
+
+ var second = $('second');
+ test.inject(second, 'bottom');
+ value_of(second.childNodes[2]).should_be(test);
+
+ test.inject(Container, 'bottom');
+ value_of(Container.childNodes[2]).should_be(test);
+ },
+
+ 'should inject the Element inside an Element': function(){
+ var first = $('first');
+ test.inject(first, 'inside');
+ value_of(first.childNodes[0]).should_be(test);
+
+ var second = $('second');
+ test.inject(second, 'inside');
+ value_of(second.childNodes[2]).should_be(test);
+
+ test.inject(Container, 'inside');
+ value_of(Container.childNodes[2]).should_be(test);
+ },
+
+ 'should inject the Element at the top of an Element': function(){
+ test.inject(Container, 'top');
+ value_of(Container.childNodes[0]).should_be(test);
+
+ var second = $('second');
+ test.inject(second, 'top');
+ value_of(second.childNodes[0]).should_be(test);
+ },
+
+ 'should inject the Element in an Element': function(){
+ var first = $('first');
+ test.inject(first);
+ value_of(first.childNodes[0]).should_be(test);
+
+ var second = $('second');
+ test.inject(second);
+ value_of(second.childNodes[2]).should_be(test);
+
+ test.inject(Container);
+ value_of(Container.childNodes[2]).should_be(test);
+ }
+
+});
+
+describe('Element.replaces', {
+
+ 'should replace an Element with the Element': function(){
+ var parent = new Element('div');
+ var div = new Element('div', {id: 'original'}).inject(parent);
+ var el = new Element('div', {id: 'replaced'});
+ el.replaces(div);
+ value_of(parent.childNodes[0]).should_be(el);
+ }
+
+});
+
+describe('Element.grab', {
+
+ 'before all': function(){
+ var html = [
+ '',
+ '',
+ '',
+ '',
+ '
'
+ ].join('');
+ Container = new Element('div', {style: 'position:absolute;top:0;left:0;visibility:hidden;', html: html}).inject(document.body);
+
+ test = new Element('div', {id:'grab-test'});
+ },
+
+ 'after all': function(){
+ document.body.removeChild(Container);
+ Container.set('html', '');
+ Container = null;
+ test = null;
+ },
+
+ 'should grab the Element before this Element': function(){
+ $('first').grab(test, 'before');
+ value_of(Container.childNodes[0]).should_be(test);
+
+ $('second-child').grab(test, 'before');
+ value_of(Container.childNodes[1].childNodes[1]).should_be(test);
+ },
+
+ 'should grab the Element after this Element': function(){
+ $('first').grab(test, 'after');
+ value_of(Container.childNodes[1]).should_be(test);
+
+ $('first-child').grab(test, 'after');
+ value_of(Container.childNodes[1].childNodes[1]).should_be(test);
+ },
+
+ 'should grab the Element at the bottom of this Element': function(){
+ var first = $('first');
+ first.grab(test, 'bottom');
+ value_of(first.childNodes[0]).should_be(test);
+
+ var second = $('second');
+ second.grab(test, 'bottom');
+ value_of(second.childNodes[2]).should_be(test);
+
+ Container.grab(test, 'bottom');
+ value_of(Container.childNodes[2]).should_be(test);
+ },
+
+ 'should grab the Element inside this Element': function(){
+ var first = $('first');
+ first.grab(test, 'inside');
+ value_of(first.childNodes[0]).should_be(test);
+
+ var second = $('second');
+ second.grab(test, 'inside');
+ value_of(second.childNodes[2]).should_be(test);
+
+ Container.grab(test, 'inside');
+ value_of(Container.childNodes[2]).should_be(test);
+ },
+
+ 'should grab the Element at the top of this Element': function(){
+ Container.grab(test, 'top');
+ value_of(Container.childNodes[0]).should_be(test);
+
+ var second = $('second');
+ second.grab(test, 'top');
+ value_of(second.childNodes[0]).should_be(test);
+ },
+
+ 'should grab an Element in the Element': function(){
+ var first = $('first').grab(test);
+ value_of(first.childNodes[0]).should_be(test);
+
+ var second = $('second').grab(test);
+ value_of(second.childNodes[2]).should_be(test);
+
+ Container.grab(test);
+ value_of(Container.childNodes[2]).should_be(test);
+ }
+
+});
+
+describe('Element.wraps', {
+
+ 'should replace and adopt the Element': function(){
+ var div = new Element('div');
+ var child = new Element('p').inject(div);
+
+ var wrapper = new Element('div', {id: 'wrapper'}).wraps(div.childNodes[0]);
+ value_of(div.childNodes[0]).should_be(wrapper);
+ value_of(wrapper.childNodes[0]).should_be(child);
+ }
+
+});
+
+describe('Element.appendText', {
+
+ 'before all': function(){
+ Container = new Element('div', {style: 'position:absolute;top:0;left:0;visibility:hidden;'}).inject(document.body);
+ },
+
+ 'before each': function(){
+ var html = [
+ '',
+ '',
+ '',
+ '',
+ '
'
+ ].join('');
+ Container.set('html', html);
+ },
+
+ 'after all': function(){
+ document.body.removeChild(Container);
+ Container.set('html', '');
+ Container = null;
+ test = null;
+ },
+
+ 'should append a TextNode before this Element': function(){
+ $('first').appendText('test', 'before');
+ value_of(Container.childNodes[0].nodeValue).should_be('test');
+
+ $('second-child').appendText('test', 'before');
+ value_of(Container.childNodes[2].childNodes[1].nodeValue).should_be('test');
+ },
+
+ 'should append a TextNode the Element after this Element': function(){
+ $('first').appendText('test', 'after');
+ value_of(Container.childNodes[1].nodeValue).should_be('test');
+
+ $('first-child').appendText('test', 'after');
+ value_of(Container.childNodes[2].childNodes[1].nodeValue).should_be('test');
+ },
+
+ 'should append a TextNode the Element at the bottom of this Element': function(){
+ var first = $('first');
+ first.appendText('test', 'bottom');
+ value_of(first.childNodes[0].nodeValue).should_be('test');
+
+ var second = $('second');
+ second.appendText('test', 'bottom');
+ value_of(second.childNodes[2].nodeValue).should_be('test');
+
+ Container.appendText('test', 'bottom');
+ value_of(Container.childNodes[2].nodeValue).should_be('test');
+ },
+
+ 'should append a TextNode the Element inside this Element': function(){
+ var first = $('first');
+ first.appendText('test', 'inside');
+ value_of(first.childNodes[0].nodeValue).should_be('test');
+
+ var second = $('second');
+ second.appendText('test', 'inside');
+ value_of(second.childNodes[2].nodeValue).should_be('test');
+
+ Container.appendText('test', 'inside');
+ value_of(Container.childNodes[2].nodeValue).should_be('test');
+ },
+
+ 'should append a TextNode the Element at the top of this Element': function(){
+ Container.appendText('test', 'top');
+ value_of(Container.childNodes[0].nodeValue).should_be('test');
+
+ var second = $('second');
+ second.appendText('test', 'top');
+ value_of(second.childNodes[0].nodeValue).should_be('test');
+ },
+
+ 'should append a TextNode an Element in the Element': function(){
+ var first = $('first').appendText('test');
+ value_of(first.childNodes[0].nodeValue).should_be('test');
+
+ var second = $('second').appendText('test');
+ value_of(second.childNodes[2].nodeValue).should_be('test');
+
+ Container.appendText('test');
+ value_of(Container.childNodes[2].nodeValue).should_be('test');
+ }
+
+});
+
+describe('Element.adopt', {
+
+ 'before all': function(){
+ Container = new Element('div').inject(document.body);
+ },
+
+ 'after all': function(){
+ document.body.removeChild(Container);
+ Container.set('html', '');
+ Container = null;
+ },
+
+ 'before each': function(){
+ Container.empty();
+ },
+
+ 'should adopt an Element by its id': function(){
+ var child = new Element('div', {id: 'adopt-me'});
+ document.body.appendChild(child);
+ Container.adopt('adopt-me');
+ value_of(Container.childNodes[0]).should_be(child);
+ },
+
+ 'should adopt an Element': function(){
+ var child = new Element('p');
+ Container.adopt(child);
+ value_of(Container.childNodes[0]).should_be(child);
+ },
+
+ 'should adopt any number of Elements or ids': function(){
+ var children = [];
+ (4).times(function(i){ children[i] = new Element('span', {id: 'child-' + i}); });
+ Container.adopt(children);
+ value_of(Container.childNodes).should_have(4, 'items');
+ value_of(Container.childNodes[3]).should_be(children[3]);
+ }
+
+});
+
+describe('Element.dispose', {
+
+ 'before all': function(){
+ Container = new Element('div').inject(document.body);
+ },
+
+ 'after all': function(){
+ document.body.removeChild(Container);
+ Container.set('html', '');
+ Container = null;
+ },
+
+ 'should dispose the Element from the DOM': function(){
+ var child = new Element('div').inject(Container);
+ child.dispose();
+ value_of(Container.childNodes.length).should_be(0);
+ }
+
+});
+
+describe('Element.clone', {
+
+ 'before all': function(){
+ Container = new Element('div', {'id': 'outer', 'class': 'moo'});
+ Container.innerHTML = 'under
';
+ },
+
+ 'after all': function(){
+ Container = null;
+ },
+
+ 'should return a clone': function(){
+ var div = new Element('div');
+ var clone = div.clone();
+ value_of(div).should_not_be(clone);
+ value_of($type(div)).should_be('element');
+ value_of($type(clone)).should_be('element');
+ },
+
+ 'should remove id from clone and clone children by default': function(){
+ var clone = Container.clone();
+ value_of(clone.getElementsByTagName('*').length).should_be(3);
+ value_of(clone.className).should_be('moo');
+ value_of(clone.id).should_be('');
+ value_of(Container.id).should_be('outer');
+ },
+
+ 'should remove all ids': function(){
+ var clone = Container.clone(true);
+ value_of(clone.id).should_be('');
+ value_of(clone.childNodes.length).should_be(2);
+ value_of(clone.childNodes[0].id).should_be('');
+ value_of(clone.childNodes[0].childNodes[0].id).should_be('');
+ value_of(clone.childNodes[0].className).should_be('foo');
+ },
+
+ 'should keep id if specified': function(){
+ var clone = Container.clone(true, true);
+ value_of(clone.id).should_be('outer');
+ value_of(clone.childNodes.length).should_be(2);
+ value_of(clone.childNodes[0].id).should_be('inner1');
+ value_of(clone.childNodes[0].childNodes[0].id).should_be('sixfeet');
+ value_of(clone.childNodes[0].className).should_be('foo');
+ },
+
+ 'should clone empty href attribute': function(){
+ var clone = new Element('div', {
+ html: 'empty anchor'
+ }).getFirst().clone();
+
+ value_of(clone.getAttribute('href', 2)).should_be('');
+ },
+
+ 'should not clone Element Storage': function(){
+ Container.store('drink', 'milk');
+ var clone = Container.clone();
+ value_of(clone.retrieve('drink')).should_be_null();
+ value_of(Container.retrieve('drink')).should_be('milk');
+ },
+
+ 'should clone child nodes and not copy their uid': function(){
+ var cloned = Container.clone(true).getElements('*');
+ var old = Container.getElements('*');
+ value_of(cloned.length).should_be(3);
+ value_of(old.length).should_be(3);
+ value_of($$(old, cloned).length).should_be(6);
+ },
+
+ 'should clone a text input and retain value': function(){
+ var inputs = new Element('div', { 'html': '' +
+ '' +
+ ''
+ }).getChildren();
+
+ var input1 = inputs[0].clone();
+ var input2 = inputs[1].clone(false, true);
+
+ value_of(!input1.id).should_be_true();
+ value_of(input2.id).should_be('input2');
+ value_of(input1.value).should_be('Some Value');
+ value_of(input2.value).should_be('');
+ },
+
+ 'should clone a textarea and retain value': function(){
+ var textareas = new Element('div', { 'html': '' +
+ '' +
+ ''
+ }).getChildren();
+
+ var textarea1 = textareas[0].clone();
+ var textarea2 = textareas[1].clone(false, true);
+
+ value_of(!textarea1.id).should_be_true();
+ value_of(textarea2.id).should_be('textarea2');
+ value_of(textarea1.value).should_be('');
+ value_of(textarea2.value).should_be('Some-Text-Here');
+ },
+
+ 'should clone a checkbox and retain checked state': function(){
+ var checks = new Element('div', { 'html': '' +
+ '' +
+ ''
+ }).getChildren();
+
+ var check1 = checks[0].clone();
+ var check2 = checks[1].clone(false, true);
+
+ value_of(!check1.id).should_be_true();
+ value_of(check2.id).should_be('check2');
+ value_of(check1.checked).should_be_false();
+ value_of(check2.checked).should_be_true();
+ },
+
+ 'should clone a select and retain selected state': function(){
+ var selects = new Element('div', { 'html': '' +
+ '' +
+ ''
+ }).getChildren();
+
+ var select1 = selects[0].clone(true);
+ var select2 = selects[1].clone(true, true);
+
+ value_of(!select1.id).should_be_true();
+ value_of(select2.id).should_be('select2');
+ value_of(select1.selectedIndex).should_be(3);
+ value_of(select2.options[3].selected).should_be_true();
+ value_of(select2.options[4].selected).should_be_true();
+ },
+
+ 'should clone custom attributes': function(){
+ var div = new Element('div');
+ div.setAttribute('foo', 'FOO');
+ div.setAttribute('bar', ['BAR']);
+ var clone = div.clone();
+
+ value_of(clone.getAttribute('foo')).should_be('FOO');
+ value_of(clone.getAttribute('bar')).should_be(['BAR']);
+ }
+
+});
+
+describe('Element className methods', {
+
+ 'should return true if the Element has the given class': function(){
+ var div = new Element('div', {'class': 'header bold'});
+ value_of(div.hasClass('header')).should_be_true();
+ value_of(div.hasClass('bold')).should_be_true();
+ value_of(div.hasClass('random')).should_be_false();
+ },
+
+ 'should add the class to the Element': function(){
+ var div = new Element('div');
+ div.addClass('myclass');
+ value_of(div.hasClass('myclass')).should_be_true();
+ },
+
+ 'should append classes to the Element': function(){
+ var div = new Element('div', {'class': 'myclass'});
+ div.addClass('aclass');
+ value_of(div.hasClass('aclass')).should_be_true();
+ },
+
+ 'should remove the class in the Element': function(){
+ var div = new Element('div', {'class': 'myclass'});
+ div.removeClass('myclass');
+ value_of(div.hasClass('myclass')).should_be_false();
+ },
+
+ 'should only remove the specific class': function(){
+ var div = new Element('div', {'class': 'myclass aclass'});
+ div.removeClass('myclass');
+ value_of(div.hasClass('myclass')).should_be_false();
+ },
+
+ 'should not remove any class if the class is not found': function(){
+ var div = new Element('div', {'class': 'myclass'});
+ div.removeClass('extra');
+ value_of(div.hasClass('myclass')).should_be_true();
+ },
+
+ 'should add the class if the Element does not have the class': function(){
+ var div = new Element('div');
+ div.toggleClass('myclass');
+ value_of(div.hasClass('myclass')).should_be_true();
+ },
+
+ 'should remove the class if the Element does have the class': function(){
+ var div = new Element('div', {'class': 'myclass'});
+ div.toggleClass('myclass');
+ value_of(div.hasClass('myclass')).should_be_false();
+ }
+
+});
+
+describe('Element.empty', {
+
+ 'should remove all children': function(){
+ var children = [];
+ (5).times(function(i){ children[i] = new Element('p'); });
+ var div = new Element('div').adopt(children);
+ div.empty();
+ value_of(div.get('html')).should_be('');
+ }
+
+});
+
+describe('Element.destroy', {
+
+ 'should obliterate the Element from the universe': function(){
+ var div = new Element('div', {id: 'destroy-test'}).inject(document.body);
+ var result = div.destroy();
+ value_of(result).should_be_null();
+ value_of($('destroy-test')).should_be_null();
+ }
+
+});
+
+describe('Element.toQueryString', {
+
+ 'should return an empty string for an Element that does not have form Elements': function(){
+ var div = new Element('div');
+ value_of(div.toQueryString()).should_be('');
+ },
+
+ 'should ignore any form Elements that do not have a name, disabled, or whose value is false': function(){
+ var form = new Element('form').adopt(
+ new Element('input', { name: 'input', disabled: true, type: 'checkbox', checked: true, value: 'checked' }),
+ new Element('select').adopt(
+ new Element('option', { name: 'volvo', value: false, html: 'Volvo' }),
+ new Element('option', { value: 'saab', html: 'Saab', selected: true })
+ ),
+ new Element('textarea', { name: 'textarea', disabled: true, value: 'textarea-value' })
+ );
+ value_of(form.toQueryString()).should_be('');
+ },
+
+ "should return a query string from the Element's form Elements": function(){
+ var form = new Element('form', { 'html': '' +
+ '' +
+ '' +
+ ''
+ });
+ value_of(form.toQueryString()).should_be('input=checked&select[]=saab&select[]=opel&textarea=textarea-value');
+ },
+
+ "should return a query string containing even empty values, single select must have a selected option": function() {
+ var form = new Element('form').adopt(
+ new Element('input', {name: 'input', type: 'checkbox', checked: true, value: ''}),
+ new Element('select', {name: 'select[]'}).adopt(
+ new Element('option', {name: 'none', value: '', html: '--', selected: true}),
+ new Element('option', {name: 'volvo', value: 'volvo', html: 'Volvo'}),
+ new Element('option', {name: 'saab', value: 'saab', html: 'Saab'}),
+ new Element('option', {name: 'opel', value: 'opel', html: 'Opel'}),
+ new Element('option', {name: 'bmw', value: 'bmw', html: 'BMW'})
+ ),
+ new Element('textarea', {name: 'textarea', value: ''})
+ );
+ value_of(form.toQueryString()).should_be('input=&select[]=&textarea=');
+ value_of(form.getElementsByTagName('select')[0].selectedIndex).should_be(0);
+ },
+
+ "should return a query string containing even empty values, multiple select may have no selected options": function() {
+ var form = new Element('form',{'html':
+ '' +
+ '' +
+ ''
+ });
+ value_of(form.toQueryString()).should_be('input=&textarea=');
+ }
+
+});
+
+describe('Element.getProperty', {
+
+ 'should getProperty from an Element': function(){
+ var anchor1 = new Element('a');
+ anchor1.href = 'http://mootools.net';
+ value_of(anchor1.getProperty('href')).should_be('http://mootools.net');
+
+ var anchor2 = new Element('a');
+ anchor2.href = '#someLink';
+ value_of(anchor2.getProperty('href')).should_be('#someLink');
+ },
+
+ 'should getProperty type of an input Element': function(){
+ var input1 = new Element('input', {type: 'text'});
+ value_of(input1.getProperty('type')).should_be('text');
+
+ var input2 = new Element('input', {type: 'checkbox'});
+ value_of(input2.getProperty('type')).should_be('checkbox');
+ },
+
+ 'should getPropety checked from an input Element': function(){
+ var checked1 = new Element('input', { type: 'checkbox' });
+ checked1.checked = 'checked';
+ value_of(checked1.getProperty('checked')).should_be_true();
+
+ var checked2 = new Element('input', { type: 'checkbox' });
+ checked2.checked = true;
+ value_of(checked2.getProperty('checked')).should_be_true();
+
+ var checked3 = new Element('input', { type: 'checkbox' });
+ checked3.checked = false;
+ value_of(checked3.getProperty('checked')).should_be_false();
+ },
+
+ 'should getProperty disabled from an input Element': function(){
+ var disabled1 = new Element('input', { type: 'text' });
+ disabled1.disabled = 'disabled';
+ value_of(disabled1.getProperty('disabled')).should_be_true();
+
+ var disabled2 = new Element('input', { type: 'text' });
+ disabled2.disabled = true;
+ value_of(disabled2.getProperty('disabled')).should_be_true();
+
+ var disabled3 = new Element('input', { type: 'text' });
+ disabled3.disabled = false;
+ value_of(disabled3.getProperty('disabled')).should_be_false();
+ },
+
+ 'should getProperty readonly from an input Element': function(){
+ var readonly1 = new Element('input', { type: 'text' });
+ readonly1.readOnly = 'readonly';
+ value_of(readonly1.getProperty('readonly')).should_be_true();
+
+ var readonly2 = new Element('input', { type: 'text' });
+ readonly2.readOnly = true;
+ value_of(readonly2.getProperty('readonly')).should_be_true();
+
+ var readonly3 = new Element('input', { type: 'text' });
+ readonly3.readOnly = false;
+ value_of(readonly3.getProperty('readonly')).should_be_false();
+ }
+
+});
+
+describe('Element.setProperty', {
+
+ 'should setProperty from an Element': function(){
+ var anchor1 = new Element('a').setProperty('href', 'http://mootools.net/');
+ value_of(anchor1.getProperty('href')).should_be('http://mootools.net/');
+
+ var anchor2 = new Element('a').setProperty('href', '#someLink');
+ value_of(anchor2.getProperty('href')).should_be('#someLink');
+ },
+
+ 'should setProperty type of an input Element': function(){
+ var input1 = new Element('input').setProperty('type', 'text');
+ value_of(input1.getProperty('type')).should_be('text');
+
+ var input2 = new Element('input').setProperty('type', 'checkbox');
+ value_of(input2.getProperty('type')).should_be('checkbox');
+ },
+
+ 'should setProperty checked from an input Element': function(){
+ var checked1 = new Element('input', { type: 'checkbox' }).setProperty('checked', 'checked');
+ value_of(checked1.getProperty('checked')).should_be_true();
+
+ var checked2 = new Element('input', { type: 'checkbox' }).setProperty('checked', true);
+ value_of(checked2.getProperty('checked')).should_be_true();
+
+ var checked3 = new Element('input', { type: 'checkbox' }).setProperty('checked', false);
+ value_of(checked3.getProperty('checked')).should_be_false();
+ },
+
+ 'should setProperty disabled of an input Element': function(){
+ var disabled1 = new Element('input', { type: 'text' }).setProperty('disabled', 'disabled');
+ value_of(disabled1.getProperty('disabled')).should_be_true();
+
+ var disabled2 = new Element('input', { type: 'text' }).setProperty('disabled', true);
+ value_of(disabled2.getProperty('disabled')).should_be_true();
+
+ var disabled3 = new Element('input', { type: 'text' }).setProperty('disabled', false);
+ value_of(disabled3.getProperty('disabled')).should_be_false();
+ },
+
+ 'should setProperty readonly of an input Element': function(){
+ var readonly1 = new Element('input', { type: 'text' }).setProperty('readonly', 'readonly');
+ value_of(readonly1.getProperty('readonly')).should_be_true();
+
+ var readonly2 = new Element('input', { type: 'text' }).setProperty('readonly', true);
+ value_of(readonly2.getProperty('readonly')).should_be_true();
+
+ var readonly3 = new Element('input', { type: 'text' }).setProperty('readonly', false);
+ value_of(readonly3.getProperty('readonly')).should_be_false();
+ }
+
+});
+
+describe('Element.getProperties', {
+
+ 'should return an object associate with the properties passed': function(){
+ var readonly = new Element('input', { type: 'text', readonly: 'readonly' });
+ var props = readonly.getProperties('type', 'readonly');
+ value_of(props).should_be({ type: 'text', readonly: true });
+ }
+
+});
+
+describe('Element.setProperties', {
+
+ 'should set each property to the Element': function(){
+ var readonly = new Element('input').setProperties({ type: 'text', readonly: 'readonly' });
+ var props = readonly.getProperties('type', 'readonly');
+ value_of(props).should_be({ type: 'text', readonly: true });
+ }
+
+});
+
+describe('Element.removeProperty', {
+
+ 'should removeProperty from an Element': function () {
+ var readonly = new Element('input', { type: 'text', readonly: 'readonly' });
+ readonly.removeProperty('readonly');
+ var props = readonly.getProperties('type', 'readonly');
+ value_of(props).should_be({ type: 'text', readonly: false });
+ }
+
+});
+
+describe('Element.removeProperties', {
+
+ 'should remove each property from the Element': function(){
+ var anchor = new Element('a', {href: '#', title: 'title', rel: 'left'});
+ anchor.removeProperties('title', 'rel');
+ value_of(anchor.getProperties('href', 'title', 'rel')).should_be({ href: '#' });
+ }
+
+});
+
+describe('Element.getPrevious', {
+
+ 'should return the previous Element, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(children);
+ value_of(children[1].getPrevious()).should_be(children[0]);
+ value_of(children[0].getPrevious()).should_be_null();
+ },
+
+ 'should return the previous Element that matches, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('a'), new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(children);
+ value_of(children[1].getPrevious('a')).should_be(children[0]);
+ value_of(children[1].getPrevious('span')).should_be_null();
+ }
+
+});
+
+describe('Element.getAllPrevious', {
+
+ 'should return all the previous Elements, otherwise an empty array': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(children);
+ value_of(children[2].getAllPrevious()).should_be([children[1], children[0]]);
+ value_of(children[0].getAllPrevious()).should_be([]);
+ },
+
+ 'should return all the previous Elements that match, otherwise an empty array': function(){
+ var container = new Element('div');
+ var children = [new Element('a'), new Element('div'), new Element('a'), new Element('div')];
+ container.adopt(children);
+ value_of(children[3].getAllPrevious('a')).should_be([children[2], children[0]]);
+ value_of(children[1].getAllPrevious('span')).should_be([]);
+ }
+
+});
+
+describe('Element.getNext', {
+
+ 'should return the next Element, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(children);
+ value_of(children[1].getNext()).should_be(children[2]);
+ value_of(children[2].getNext()).should_be_null();
+ },
+
+ 'should return the previous Element that matches, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('div'), new Element('div'), new Element('a')];
+ container.adopt(children);
+ value_of(children[1].getNext('a')).should_be(children[3]);
+ value_of(children[1].getNext('span')).should_be_null();
+ }
+
+});
+
+describe('Element.getAllNext', {
+
+ 'should return all the next Elements, otherwise an empty array': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(children);
+ value_of(children[0].getAllNext()).should_be(children.slice(1));
+ value_of(children[2].getAllNext()).should_be([]);
+ },
+
+ 'should return all the next Elements that match, otherwise an empty array': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('a'), new Element('div'), new Element('a')];
+ container.adopt(children);
+ value_of(children[0].getAllNext('a')).should_be([children[1], children[3]]);
+ value_of(children[0].getAllNext('span')).should_be([]);
+ }
+
+});
+
+describe('Element.getFirst', {
+
+ 'should return the first Element in the Element, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('a'), new Element('div')];
+ container.adopt(children);
+ value_of(container.getFirst()).should_be(children[0]);
+ value_of(children[0].getFirst()).should_be_null();
+ },
+
+ 'should return the first Element in the Element that matches, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('a'), new Element('div')];
+ container.adopt(children);
+ value_of(container.getFirst('a')).should_be(children[1]);
+ value_of(container.getFirst('span')).should_be_null();
+ }
+
+});
+
+describe('Element.getLast | Element.getLastChild', {
+
+ 'should return the last Element in the Element, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('a'), new Element('div')];
+ container.adopt(children);
+ value_of(container.getLast()).should_be(children[2]);
+ value_of(children[0].getLast()).should_be_null();
+ },
+
+ 'should return the last Element in the Element that matches, otherwise null': function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('a'), new Element('div'), new Element('a')];
+ container.adopt(children);
+ value_of(container.getLast('a')).should_be(children[3]);
+ value_of(container.getLast('span')).should_be_null();
+ }
+
+});
+
+describe('Element.getParent', {
+
+ 'should return the parent of the Element, otherwise null': function(){
+ var container = new Element('p');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(children);
+ value_of(children[1].getParent()).should_be(container);
+ value_of(container.getParent()).should_be_null();
+ },
+
+ 'should return the parent of the Element that matches, otherwise null': function(){
+ var container = new Element('p');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(new Element('div').adopt(children));
+ value_of(children[1].getParent('p')).should_be(container);
+ value_of(children[1].getParent('table')).should_be_null();
+ }
+
+});
+
+describe('Element.getParents', {
+
+ 'should return the parents of the Element, otherwise returns an empty array': function(){
+ var container = new Element('p');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(new Element('div').adopt(new Element('div').adopt(children)));
+ value_of(children[1].getParents()).should_be([container.getFirst().getFirst(), container.getFirst(), container]);
+ value_of(container.getParents()).should_be([]);
+ },
+
+ 'should return the parents of the Element that match, otherwise returns an empty array': function(){
+ var container = new Element('p');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(new Element('div').adopt(new Element('div').adopt(children)));
+ value_of(children[1].getParents('div')).should_be([container.getFirst().getFirst(), container.getFirst()]);
+ value_of(children[1].getParents('table')).should_be([]);
+ }
+
+});
+
+describe('Element.getChildren', {
+
+ "should return the Element's children, otherwise returns an empty array": function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('div'), new Element('div')];
+ container.adopt(children);
+ value_of(container.getChildren()).should_be(children);
+ value_of(children[0].getChildren()).should_be([]);
+ },
+
+ "should return the Element's children that match, otherwise returns an empty array": function(){
+ var container = new Element('div');
+ var children = [new Element('div'), new Element('a'), new Element('a')];
+ container.adopt(children);
+ value_of(container.getChildren('a')).should_be([children[1], children[2]]);
+ value_of(container.getChildren('span')).should_be([]);
+ }
+
+});
+
+describe('Element.hasChild', {
+
+ "before all": function(){
+ window.Local = {};
+ Local.container = new Element('div');
+ Local.children = [new Element('div'), new Element('div'), new Element('div')];
+ Local.container.adopt(Local.children);
+ Local.grandchild = new Element('div').inject(Local.children[1]);
+ },
+
+ "after all": function(){
+ Local = null;
+ },
+
+ "should return true if the Element is a child or grandchild": function(){
+ value_of(Local.container.hasChild(Local.children[0])).should_be_true();
+ value_of(Local.container.hasChild(Local.children[2])).should_be_true();
+ value_of(Local.container.hasChild(Local.grandchild)).should_be_true();
+ },
+
+ "should return false if it's the Element itself": function(){
+ value_of(Local.container.hasChild(Local.container)).should_be_false();
+ },
+
+ "should return false if the Element is the parent or a sibling": function(){
+ value_of(Local.children[2].hasChild(Local.container)).should_be_false();
+ value_of(Local.children[2].hasChild(Local.children[1])).should_be_false();
+ }
+
+});
diff --git a/assets/mootools-core/Specs/Native/Array.js b/assets/mootools-core/Specs/Native/Array.js
new file mode 100644
index 00000000..37d28e6b
--- /dev/null
+++ b/assets/mootools-core/Specs/Native/Array.js
@@ -0,0 +1,207 @@
+/*
+Script: Array.js
+ Specs for Array.js
+
+License:
+ MIT-style license.
+*/
+
+describe("Array Methods", {
+
+ // Array.flatten
+
+ 'should flatten a multidimensional array': function(){
+ var arr = [1,2,3,[4,5,[6,7,[8]]], [[[[[9]]]]]];
+ value_of(arr.flatten()).should_be([1,2,3,4,5,6,7,8,9]);
+ },
+
+ 'should flatten arguments': function(){
+ var test = function(){
+ return Array.flatten(arguments);
+ };
+ value_of(test(1,2,3)).should_be([1,2,3]);
+ value_of(test([1,2,3])).should_be([1,2,3]);
+ value_of(test(1,2,[3])).should_be([1,2,3]);
+ },
+
+ // Array.filter
+
+ 'should filter an array': function(){
+ var array = [1,2,3,0,0,0];
+ var arr = array.concat([false, null, 4]).filter(Number.type);
+ value_of(arr).should_be(array.concat(4));
+ },
+
+ // Array.clean
+
+ 'should clean an array from undefined and null values': function(){
+ var array = [null, 1, 0, true, false, "foo", undefined];
+ var arr = array.clean();
+ value_of(arr).should_be([1, 0, true, false, "foo"]);
+ },
+
+ // Array.map
+
+ 'should return a mapping of an array': function(){
+ var arr = [1,2,3,0,0,0].map(function(item){
+ return (item + 1);
+ });
+
+ value_of(arr).should_be([2,3,4,1,1,1]);
+ },
+
+ // Array.every
+
+ 'should return true if every item matches the comparator, otherwise false': function(){
+ value_of([1,2,3,0,0,0].every(Number.type)).should_be_true();
+
+ value_of(['1',2,3,0].every(Number.type)).should_be_false();
+ },
+
+ // Array.some
+
+ 'should return true if some of the items in the array match the comparator, otherwise false': function(){
+ value_of(['1',2,3,0].some(Number.type)).should_be_true();
+
+ value_of([1,2,3,0,0,0].map(String).some(Number.type)).should_be_false();
+ },
+
+ // Array.indexOf
+
+ 'should return the index of the item': function(){
+ value_of([1,2,3,0,0,0].indexOf(0)).should_be(3);
+ },
+
+ 'should return -1 if the item is not found in the array': function(){
+ value_of([1,2,3,0,0,0].indexOf('not found')).should_be(-1);
+ },
+
+ // Array.erase
+
+ 'should remove all items in the array that match the specified item': function(){
+ var arr = [1,2,3,0,0,0].erase(0);
+ value_of(arr).should_be([1,2,3]);
+ },
+
+ // Array.contains
+
+ 'should return true if the array contains the specified item': function(){
+ value_of([1,2,3,0,0,0].contains(0)).should_be_true();
+ },
+
+ 'should return false if the array does not contain the specified item': function(){
+ value_of([0,1,2].contains('not found')).should_be_false();
+ },
+
+ // Array.associate
+
+ 'should associate an array with a specified array': function(){
+ var obj = [1,2,3,0,0,0].associate(['a', 'b', 'c', 'd']);
+ value_of(obj).should_be({a:1, b:2, c:3, d:0});
+ },
+
+ // Array.link
+
+ 'should link an array items to a new object according to the specified matchers': function(){
+ var el = document.createElement('div');
+ var assoc2 = [100, 'Hello', {foo: 'bar'}, el, false].link({
+ myNumber: Number.type,
+ myElement: Element.type,
+ myObject: Object.type,
+ myString: String.type,
+ myBoolean: $defined
+ });
+
+ value_of(assoc2).should_be({
+ myNumber: 100,
+ myElement: el,
+ myObject: {foo: 'bar'},
+ myString: 'Hello',
+ myBoolean: false
+ });
+ },
+
+ // Array.extend
+
+ 'should extend an array': function(){
+ var a = [1,2,4];
+ var b = [2,3,4,5];
+ a.extend(b);
+ value_of(a).should_be([1,2,4,2,3,4,5]);
+ value_of(b).should_be([2,3,4,5]);
+ },
+
+ // Array.combine
+
+ 'should combine an array': function(){
+ var arr = [1,2,3,4].combine([3,1,4,5,6,7]);
+ value_of(arr).should_be([1,2,3,4,5,6,7]);
+ },
+
+ // Array.include
+
+ 'should include only new items': function(){
+ var arr = [1,2,3,4].include(1).include(5);
+ value_of(arr).should_be([1,2,3,4,5]);
+ },
+
+ // Array.getLast
+
+ 'should return the last item in the array': function(){
+ value_of([1,2,3,0,0,0].getLast()).should_be(0);
+ value_of([3].getLast()).should_be(3);
+ },
+
+ 'should return null if there are no items': function(){
+ value_of([].getLast()).should_be(null);
+ },
+
+ // Array.empty
+
+ 'should empty the array': function(){
+ var arr = [1,2,3,4].empty();
+ value_of(arr).should_be([]);
+ }
+
+});
+
+describe("Array Color Methods", {
+
+ // Array.hexToRgb
+
+ 'should return null if the length of the array is not 3': function(){
+ value_of([].hexToRgb()).should_be_null();
+ },
+
+ 'should return a CSS rgb string': function(){
+ value_of(['0','0','0'].hexToRgb()).should_be('rgb(0,0,0)');
+ },
+
+ 'should support shorthand hex': function(){
+ value_of(['c','c','c'].hexToRgb()).should_be('rgb(204,204,204)');
+ },
+
+ 'should return an array with 16-based numbers when passed true': function(){
+ value_of(['ff','ff','ff'].hexToRgb(true)).should_be([255,255,255]);
+ },
+
+ // Array.rgbToHex
+
+ 'should return null if the array does not have at least 3 times': function(){
+ value_of([0,1].rgbToHex()).should_be_null();
+ },
+
+ 'should return a css hexadecimal string': function(){
+ value_of(['255', '0', '0'].rgbToHex()).should_be('#ff0000');
+ value_of([0,0,255].rgbToHex()).should_be('#0000ff');
+ },
+
+ 'should return an array with hexadecimal string items': function(){
+ value_of([0,255,0].rgbToHex(true)).should_be(['00', 'ff', '00']);
+ },
+
+ 'should return `transparent` if the fourth item is 0 and first param is not true': function(){
+ value_of([0,0,0,0].rgbToHex()).should_be('transparent');
+ }
+
+});
\ No newline at end of file
diff --git a/assets/mootools-core/Specs/Native/Function.js b/assets/mootools-core/Specs/Native/Function.js
new file mode 100644
index 00000000..61a5dd1b
--- /dev/null
+++ b/assets/mootools-core/Specs/Native/Function.js
@@ -0,0 +1,155 @@
+/*
+Script: Function.js
+ Specs for Function.js
+
+License:
+ MIT-style license.
+*/
+
+(function(){
+
+var fn = function(){
+ return $A(arguments);
+};
+
+var Rules = function(){
+ return this + ' rules';
+};
+
+var Args = function(){
+ return [this].concat($A(arguments));
+};
+
+describe("Function Methods", {
+
+ // Function.create
+
+ 'should return a new function': function(){
+ var fnc = $empty.create();
+ value_of($empty === fnc).should_be_false();
+ },
+
+ 'should return a new function with specified argument': function(){
+ var fnc = fn.create({'arguments': 'rocks'});
+ value_of(fnc()).should_be(['rocks']);
+ },
+
+ 'should return a new function with multiple arguments': function(){
+ var fnc = fn.create({'arguments': ['MooTools', 'rocks']});
+ value_of(fnc()).should_be(['MooTools', 'rocks']);
+ },
+
+ 'should return a new function bound to an object': function(){
+ var fnc = Rules.create({'bind': 'MooTools'});
+ value_of(fnc()).should_be('MooTools rules');
+ },
+
+ 'should return a new function as an event': function(){
+ var fnc = fn.create({'arguments': [0, 1], 'event': true});
+ value_of(fnc('an Event occurred')).should_be(['an Event occurred', 0, 1]);
+ },
+
+ // Function.bind
+
+ 'should return the function bound to an object': function(){
+ var fnc = Rules.bind('MooTools');
+ value_of(fnc()).should_be('MooTools rules');
+ },
+
+ 'should return the function bound to an object with specified argument': function(){
+ var fnc = Args.bind('MooTools', 'rocks');
+ value_of(fnc()).should_be(['MooTools', 'rocks']);
+ },
+
+ 'should return the function bound to an object with multiple arguments': function(){
+ var fnc = Args.bind('MooTools', ['rocks', 'da house']);
+ value_of(fnc()).should_be(['MooTools', 'rocks', 'da house']);
+ },
+
+ 'should return the function bound to an object and make the function an event listener': function(){
+ var fnc = Args.bindWithEvent('MooTools');
+ value_of(fnc('an Event ocurred')).should_be(['MooTools', 'an Event ocurred']);
+ },
+
+ 'should return the function bound to an object and make the function event listener with multiple arguments': function(){
+ var fnc = Args.bindWithEvent('MooTools', ['rocks', 'da house']);
+ value_of(fnc('an Event ocurred')).should_be(['MooTools', 'an Event ocurred', 'rocks', 'da house']);
+ },
+
+ // Function.pass
+
+ 'should return a function that when called passes the specified arguments to the original function': function(){
+ var fnc = fn.pass('MooTools is beautiful and elegant');
+ value_of(fnc()).should_be(['MooTools is beautiful and elegant']);
+ },
+
+ 'should pass multiple arguments and bind the function to a specific object when it is called': function(){
+ var fnc = Args.pass(['rocks', 'da house'], 'MooTools');
+ value_of(fnc()).should_be(['MooTools', 'rocks', 'da house']);
+ },
+
+ // Function.run
+
+ 'should run the function': function(){
+ var result = fn.run();
+ value_of(result).should_be([]);
+ },
+
+ 'should run the function with multiple arguments': function(){
+ var result = fn.run(['MooTools', 'beautiful', 'elegant']);
+ value_of(result).should_be(['MooTools', 'beautiful', 'elegant']);
+ },
+
+ 'should run the function with multiple arguments and bind the function to an object': function(){
+ var result = Args.run(['beautiful', 'elegant'], 'MooTools');
+ value_of(result).should_be(['MooTools', 'beautiful', 'elegant']);
+ },
+
+ // Function.extend
+
+ "should extend the function's properties": function(){
+ var fnc = (function(){}).extend({a: 1, b: 'c'});
+ value_of(fnc.a).should_be(1);
+ value_of(fnc.b).should_be('c');
+ },
+
+ // Function.attempt
+
+ 'should call the function without raising an exception': function(){
+ var fnc = function(){
+ this_should_not_work();
+ };
+ fnc.attempt();
+ },
+
+ "should return the function's return value": function(){
+ var fnc = $lambda('hello world!');
+ value_of(fnc.attempt()).should_be('hello world!');
+ },
+
+ 'should return null if the function raises an exception': function(){
+ var fnc = function(){
+ this_should_not_work();
+ };
+ value_of(fnc.attempt()).should_be_null();
+ },
+
+ // Function.delay
+
+ 'delay should return a timer pointer': function(){
+ var timer = $empty.delay(10000);
+ value_of(Number.type(timer)).should_be_true();
+ $clear(timer);
+ },
+
+ // Function.periodical
+
+ 'periodical should return a timer pointer': function(){
+ var timer = $empty.periodical(10000);
+ value_of(Number.type(timer)).should_be_true();
+ $clear(timer);
+ }
+
+});
+
+})();
\ No newline at end of file
diff --git a/assets/mootools-core/Specs/Native/Hash.js b/assets/mootools-core/Specs/Native/Hash.js
new file mode 100644
index 00000000..ff75a33b
--- /dev/null
+++ b/assets/mootools-core/Specs/Native/Hash.js
@@ -0,0 +1,203 @@
+/*
+Script: Hash.js
+ Specs for Hash.js
+
+License:
+ MIT-style license.
+*/
+
+(function(){
+
+var hash2 = new Hash({ a: 'string', b: 233, c: {} });
+
+describe("Hash Methods", {
+
+ // Hash.constructor
+
+ 'should return a new hash': function(){
+ value_of(Hash.type(new Hash())).should_be_true();
+ },
+
+ 'should return a copy of a hash': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ var copy = new Hash(hash);
+ value_of(copy !== hash).should_be_true();
+ value_of(copy).should_be(hash);
+ },
+
+ // Hash.erase
+
+ 'should remove a key and its value from the hash': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.erase('a')).should_be(new Hash({b:2,c:3}));
+ value_of(hash.erase('d')).should_be(new Hash({b:2,c:3}));
+
+ hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.erase('a')).should_be(new Hash({b:2,c:3}));
+ value_of(hash.erase('d')).should_be(new Hash({b:2,c:3}));
+ },
+
+ // Hash.get
+
+ 'should return the value corresponding to the specified key otherwise null': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.get('c')).should_be(3);
+ value_of(hash.get('d')).should_be_null();
+ },
+
+ // Hash.set
+
+ 'should set the key with the corresponding value': function(){
+ var myHash = new Hash({a: 1, b: 2, c: 3}).set('c', 7).set('d', 8);
+ value_of(myHash).should_be(new Hash({a:1,b:2,c:7,d:8}));
+ },
+
+ // Hash.empty
+
+ 'should empty the hash': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.empty()).should_be(new Hash());
+ },
+
+ // Hash.include
+
+ 'should include a key value if the hash does not have the key otherwise ignore': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.include('e', 7)).should_be(new Hash({a:1,b:2,c:3,e:7}));
+ value_of(hash.include('a', 7)).should_be(new Hash({a:1,b:2,c:3,e:7}));
+ },
+
+ // Hash.keyOf | Hash.indexOf
+
+ 'should return the key of the value or null if not found': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3, d: 1});
+ value_of(hash.keyOf(1)).should_be('a');
+ value_of(hash.keyOf('not found')).should_be_null();
+
+ value_of(hash.indexOf(1)).should_be('a');
+ value_of(hash.indexOf('not found')).should_be_null();
+ },
+
+ // Hash.has
+
+ 'should return true if the hash has the key otherwise false': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.has('a')).should_be_true();
+ value_of(hash.has('d')).should_be_false();
+ },
+
+ // Hash.hasValue | Hash.contains
+
+ 'should return true if the hash hasValue otherwise false': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.hasValue(1)).should_be_true();
+ value_of(hash.hasValue('not found')).should_be_false();
+
+ value_of(hash.contains(1)).should_be_true();
+ value_of(hash.contains('not found')).should_be_false();
+ },
+
+ // Hash.getClean
+
+ 'should getClean JavaScript object': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.getClean()).should_be({a:1,b:2,c:3});
+ },
+
+ // Hash.extend
+
+ 'should extend a Hash with an object': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.extend({a:4,d:7,e:8})).should_be(new Hash({a:4,b:2,c:3,d:7,e:8}));
+ },
+
+ 'should extend a Hash with another Hash': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.extend(new Hash({a:4,d:7,e:8}))).should_be(new Hash({a:4,b:2,c:3,d:7,e:8}));
+ },
+
+ // Hash.combine
+
+ 'should merge a Hash with an object': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.combine({a:4,d:7,e:8})).should_be(new Hash({a:1,b:2,c:3,d:7,e:8}));
+ },
+
+ 'should merge a Hash with another Hash': function(){
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ value_of(hash.combine(new Hash({a:4,d:7,e:8}))).should_be(new Hash({a:1,b:2,c:3,d:7,e:8}));
+ },
+
+ // Hash.each
+
+ 'should iterate through each property': function(){
+ var newHash = new Hash();
+ var hash = new Hash({a: 1, b: 2, c: 3});
+ hash.each(function(value, key){
+ newHash.set(key, value);
+ });
+ value_of(newHash).should_be(hash);
+ },
+
+ // Hash.map
+
+ 'should map a new Hash according to the comparator': function(){
+ value_of(hash2.map(Number.type)).should_be(new Hash({a:false,b:true,c:false}));
+ },
+
+ // Hash.filter
+
+ 'should filter the Hash according to the comparator': function(){
+ value_of(hash2.filter(Number.type)).should_be(new Hash({b:233}));
+ },
+
+ // Hash.every
+
+ 'should return true if every value matches the comparator, otherwise false': function(){
+ value_of(hash2.every($defined)).should_be_true();
+ value_of(hash2.every(Number.type)).should_be_false();
+ },
+
+ // Hash.some
+
+ 'should return true if some of the values match the comparator, otherwise false': function(){
+ value_of(hash2.some(Number.type)).should_be_true();
+ value_of(hash2.some(Array.type)).should_be_false();
+ },
+
+ // Hash.getKeys
+
+ 'getKeys should return an empty array': function(){
+ value_of(new Hash().getKeys()).should_be([]);
+ },
+
+ 'should return an array containing the keys of the hash': function(){
+ value_of(hash2.getKeys()).should_be(['a', 'b', 'c']);
+ },
+
+ // Hash.getValues
+
+ 'getValues should return an empty array': function(){
+ value_of(new Hash().getValues()).should_be([]);
+ },
+
+ 'should return an array with the values of the hash': function(){
+ value_of(hash2.getValues()).should_be(['string', 233, {}]);
+ },
+
+ // Hash.toQueryString
+
+ 'should return a query string': function(){
+ var myHash = new Hash({apple: "red", lemon: "yellow"});
+ value_of(myHash.toQueryString()).should_be('apple=red&lemon=yellow');
+
+ var myHash2 = new Hash({apple: ['red', 'yellow'], lemon: ['green', 'yellow']});
+ value_of(myHash2.toQueryString()).should_be('apple[0]=red&apple[1]=yellow&lemon[0]=green&lemon[1]=yellow');
+
+ var myHash3 = new Hash({fruits: {apple: ['red', 'yellow'], lemon: ['green', 'yellow']}});
+ value_of(myHash3.toQueryString()).should_be('fruits[apple][0]=red&fruits[apple][1]=yellow&fruits[lemon][0]=green&fruits[lemon][1]=yellow');
+ }
+
+});
+
+})();
\ No newline at end of file
diff --git a/assets/mootools-core/Specs/Native/Number.js b/assets/mootools-core/Specs/Native/Number.js
new file mode 100644
index 00000000..3ccdf189
--- /dev/null
+++ b/assets/mootools-core/Specs/Native/Number.js
@@ -0,0 +1,114 @@
+/*
+Script: Number.js
+ Specs for Number.js
+
+License:
+ MIT-style license.
+*/
+
+describe("Number Methods", {
+
+ // Number.toInt
+
+ 'should convert a number to an integer': function(){
+ value_of((111).toInt()).should_be(111);
+ },
+
+ 'should convert a number depending on the radix provided': function(){
+ value_of((111).toInt(2)).should_be(7);
+ value_of((0x16).toInt(10)).should_be(22); //ECMA standard, radix is optional so if starts with 0x then parsed as hexadecimal
+ value_of((016).toInt(10)).should_be(14); //ECMA standard, radix is optional so if starts with 0 then parsed as octal
+ },
+
+ // Number.toFloat
+
+ 'should convert a number to a float': function(){
+ value_of((1.00).toFloat()).should_be(1);
+ value_of((1.12 - 0.12).toFloat()).should_be(1);
+ value_of((0.0010).toFloat()).should_be(0.001);
+ value_of((Number.MIN_VALUE).toFloat()).should_be(Number.MIN_VALUE);
+ },
+
+ // Number.limit
+
+ 'should limit a number within a range': function(){
+ value_of((-1).limit(0, 1)).should_be(0);
+ value_of((3).limit(1, 2)).should_be(2);
+ },
+
+ 'should not limit a number if within the range': function(){
+ value_of((2).limit(0,4)).should_be(2);
+ },
+
+ // Number.round
+
+ 'should round a number to the nearest whole number if units place is not specified': function(){
+ value_of((0.01).round()).should_be(0);
+ },
+
+ 'should round a number according the units place specified': function(){
+ value_of((0.01).round(2)).should_be(0.01);
+ value_of((1).round(3)).should_be(1);
+ value_of((-1.01).round()).should_be(-1);
+ value_of((-1.01).round(2)).should_be(-1.01);
+ value_of((111).round(-1)).should_be(110);
+ value_of((-111).round(-2)).should_be(-100);
+ value_of((100).round(-5)).should_be(0);
+ },
+
+ // Number.times
+
+ 'should call the function for the specified number of times': function(){
+ var found = 0;
+ (3).times(function(i){
+ found = i;
+ });
+
+ var found2 = -1;
+ (0).times(function(i){
+ found2 = i;
+ });
+
+ value_of(found).should_be(2);
+ value_of(found2).should_be(-1);
+ },
+
+ 'should bind and call the function for the specified number of times': function(){
+ var aTest = 'hi';
+ var found3 = false;
+ (1).times(function(i){
+ found3 = (this == aTest);
+ }, aTest);
+ value_of(found3).should_be_true();
+ }
+
+});
+
+(function(math){
+ var examples = {};
+ new Hash(math).each(function(value, key){
+ var example = {};
+ var b = value.test[1];
+ examples['should return the ' + value.title + ' value of the number' + ((b) ? ' and the passed number' : '')] = function(){
+ value_of(value.test[0][key](b)).should_be(Math[key].apply(null, value.test));
+ };
+ });
+ describe("Number Math Methods", examples);
+})({
+ abs: { test: [-1], title: 'absolute' },
+ acos: { test: [0], title: 'arc cosine' },
+ asin: { test: [0.5], title: 'arc sine' },
+ atan: { test: [0.5], title: 'arc tangent' },
+ atan2: { test: [0.1, 0.5], title: 'arc tangent' },
+ ceil: { test: [0.6], title: 'number closest to and not less than the' },
+ cos: { test: [30], title: 'cosine' },
+ exp: { test: [2], title: 'exponent' },
+ floor: { test: [2.4], title: 'integer closet to and not greater than' },
+ log: { test: [2], title: 'log' },
+ max: { test: [5, 3], title: 'maximum' },
+ min: { test: [-4, 2], title: 'minimum' },
+ pow: { test: [2, 2], title: 'power' },
+ sin: { test: [0.5], title: 'sine' },
+ sqrt: { test: [4], title: 'square root' },
+ tan: { test: [0.3], title: 'tangent' }
+});
\ No newline at end of file
diff --git a/assets/mootools-core/Specs/Native/String.js b/assets/mootools-core/Specs/Native/String.js
new file mode 100644
index 00000000..caa54000
--- /dev/null
+++ b/assets/mootools-core/Specs/Native/String.js
@@ -0,0 +1,158 @@
+/*
+Script: String.js
+ Specs for String.js
+
+License:
+ MIT-style license.
+*/
+
+describe("String Methods", {
+
+ // String.capitalize
+
+ 'should capitalize each word': function(){
+ value_of('i like cookies'.capitalize()).should_be('I Like Cookies');
+ value_of('I Like cOOKIES'.capitalize()).should_be('I Like COOKIES');
+ },
+
+ // String.camelCase
+
+ 'should convert a hyphenated string into a camel cased string': function(){
+ value_of('i-like-cookies'.camelCase()).should_be('iLikeCookies');
+ value_of('I-Like-Cookies'.camelCase()).should_be('ILikeCookies');
+ },
+
+ // String.hyphenate
+
+ 'should convert a camel cased string into a hyphenated string': function(){
+ value_of('iLikeCookies'.hyphenate()).should_be('i-like-cookies');
+ value_of('ILikeCookies'.hyphenate()).should_be('-i-like-cookies');
+ },
+
+ // String.clean
+
+ 'should clean all extraneous whitespace from the string': function(){
+ value_of(' i like cookies '.clean()).should_be("i like cookies");
+ value_of(' i\nlike \n cookies \n\t '.clean()).should_be("i like cookies");
+ },
+
+ // String.trim
+
+ 'should trim left and right whitespace from the string': function(){
+ value_of(' i like cookies '.trim()).should_be('i like cookies');
+ value_of(' i \tlike cookies '.trim()).should_be('i \tlike cookies');
+ },
+
+ // String.contains
+
+ 'should return true if the string contains a string otherwise false': function(){
+ value_of('i like cookies'.contains('cookies')).should_be_true();
+ value_of('i,like,cookies'.contains('cookies')).should_be_true();
+ value_of('mootools'.contains('inefficient javascript')).should_be_false();
+ },
+
+ 'should return true if the string constains the string and separator otherwise false': function(){
+ value_of('i like cookies'.contains('cookies', ' ')).should_be_true();
+ value_of('i like cookies'.contains('cookies', ',')).should_be_false();
+
+ value_of('i,like,cookies'.contains('cookies', ' ')).should_be_false();
+ value_of('i,like,cookies'.contains('cookies', ',')).should_be_true();
+ },
+
+ // String.test
+
+ 'should return true if the test matches the string otherwise false': function(){
+ value_of('i like teh cookies'.test('cookies')).should_be_true();
+ value_of('i like cookies'.test('ke coo')).should_be_true();
+ value_of('I LIKE COOKIES'.test('cookie', 'i')).should_be_true();
+ value_of('i like cookies'.test('cookiez')).should_be_false();
+ },
+
+ 'should return true if the regular expression test matches the string otherwise false': function(){
+ value_of('i like cookies'.test(/like/)).should_be_true();
+ value_of('i like cookies'.test(/^l/)).should_be_false();
+ },
+
+ // String.toInt
+
+ 'should convert the string into an integer': function(){
+ value_of('10'.toInt()).should_be(10);
+ value_of('10px'.toInt()).should_be(10);
+ value_of('10.10em'.toInt()).should_be(10);
+ },
+
+ 'should convert the string into an integer with a specific base': function(){
+ value_of('10'.toInt(5)).should_be(5);
+ },
+
+ // String.toFloat
+
+ 'should convert the string into a float': function(){
+ value_of('10.11'.toFloat()).should_be(10.11);
+ value_of('10.55px'.toFloat()).should_be(10.55);
+ },
+
+ // String.rgbToHex
+
+ 'should convert the string into a CSS hex string': function(){
+ value_of('rgb(255,255,255)'.rgbToHex()).should_be('#ffffff');
+ value_of('rgb(255,255,255,0)'.rgbToHex()).should_be('transparent');
+ },
+
+ // String.hexToRgb
+
+ 'should convert the CSS hex string into a CSS rgb string': function(){
+ value_of('#fff'.hexToRgb()).should_be('rgb(255,255,255)');
+ value_of('ff00'.hexToRgb()).should_be('rgb(255,0,0)');
+ value_of('#000000'.hexToRgb()).should_be('rgb(0,0,0)');
+ },
+
+ // String.stripScripts
+
+ 'should strip all script tags from a string': function(){
+ value_of(''.stripScripts()).should_be('');
+ },
+
+ 'should execute the stripped tags from the string': function(){
+ value_of(''.stripScripts(true)).should_be('');
+ value_of(window.stripScriptsSpec).should_be(42);
+ value_of(''.stripScripts(true)).should_be('');
+ value_of(window.stripScriptsSpec).should_be(24);
+ value_of(''.stripScripts(true)).should_be('');
+ value_of(window.stripScriptsSpec).should_be(4242);
+ },
+
+ // String.substitute
+
+ 'should substitute values from objects': function(){
+ value_of('This is {color}.'.substitute({'color': 'blue'})).should_be('This is blue.');
+ value_of('This is {color} and {size}.'.substitute({'color': 'blue', 'size': 'small'})).should_be('This is blue and small.');
+ },
+
+ 'should substitute values from arrays': function(){
+ value_of('This is {0}.'.substitute(['blue'])).should_be('This is blue.');
+ value_of('This is {0} and {1}.'.substitute(['blue', 'small'])).should_be('This is blue and small.');
+ },
+
+ 'should remove undefined values': function(){
+ value_of('Checking {0}, {1}, {2}, {3} and {4}.'.substitute([1, 0, undefined, null])).should_be('Checking 1, 0, , and .');
+ value_of('This is {not-set}.'.substitute({})).should_be('This is .');
+ },
+
+ 'should ignore escaped placeholders': function(){
+ value_of('Ignore \\{this} but not {that}.'.substitute({'that': 'the others'})).should_be('Ignore {this} but not the others.');
+ },
+
+ 'should substitute with a custom regex': function(){
+ var php = (/\$([\w-]+)/g);
+ value_of('I feel so $language.'.substitute({'language': 'PHP'}, php)).should_be('I feel so PHP.');
+ var ror = (/#\{([^}]+)\}/g);
+ value_of('I feel so #{language}.'.substitute({'language': 'RoR'}, ror)).should_be('I feel so RoR.');
+ },
+
+ 'should substitute without goofing up nested curly braces': function(){
+ value_of("fred {is {not} very} cool".substitute({ 'is {not':'BROKEN' })).should_not_be("fred BROKEN very} cool");
+ value_of('this {should {break} mo} betta'.substitute({ 'break':'work' })).should_be('this {should work mo} betta');
+ }
+
+});
diff --git a/assets/mootools-core/Specs/Plugins/Selectors.Children.js b/assets/mootools-core/Specs/Plugins/Selectors.Children.js
new file mode 100644
index 00000000..8f7a43c2
--- /dev/null
+++ b/assets/mootools-core/Specs/Plugins/Selectors.Children.js
@@ -0,0 +1,61 @@
+/*
+Script: Selectors.Children.js
+ Specification Examples of Pseudo Selector :children.
+
+License:
+ MIT-style license.
+*/
+
+var Container, Children = [];
+
+describe('PSeudo Selector :children', {
+
+ 'before all': function(){
+ Container = new Element('div', {styles: {position: 'absolute', top: 0, left: 0, visibility: 'hidden'}});
+ (10).times(function(i){
+ Children.push(new Element('span', {id: 'child-' + i}).set('html', i));
+ });
+ Container.adopt(Children).inject(document.body);
+ },
+
+ 'after all': function(){
+ Container.destroy();
+ },
+
+ 'should use zero-based indexing': function(){
+ value_of(Container.getElement(':children(0)')).should_be(Children[0]);
+ },
+
+ 'should use negative indexing': function(){
+ value_of(Container.getElement(':children(-2)')).should_be(Children[8]);
+ },
+
+ 'should return a range of child nodes': function(){
+ value_of(Container.getElements(':children(0:2)')).should_be(Children.slice(0,3));
+ },
+
+ 'should return a range of child nodes including negative index sorted from first to last node': function(){
+ var children = Children.slice(0,3).extend(Children.slice(8));
+ value_of(Container.getElements(':children(-2:2)')).should_be(children);
+ value_of(Container.getElements(':children(2:-2)')).should_be(Children.slice(2,9));
+ },
+
+ 'should return the node and n-number of child nodes to the right': function(){
+ value_of(Container.getElements(':children(3+2)')).should_be(Children.slice(3,6));
+ },
+
+ 'should return the node and n-number of child nodes to the right and wrap if necessary and sorting from first to last': function(){
+ var children = Children.slice(0,3).extend(Children.slice(8));
+ value_of(Container.getElements(':children(8+4)')).should_be(children);
+ },
+
+ 'should return the node and n-number of child nodes to the left': function(){
+ value_of(Container.getElements(':children(5-5)')).should_be(Children.slice(0,6));
+ },
+
+ 'should return the node and n-number of child nodes to the left and wrap if necessary and sorting from first to last': function(){
+ var children = Children.slice(0,3).extend(Children.slice(7));
+ value_of(Container.getElements(':children(2-5)')).should_be(children);
+ }
+
+});
\ No newline at end of file
diff --git a/assets/mootools-core/Specs/Utilities/Color.js b/assets/mootools-core/Specs/Utilities/Color.js
new file mode 100644
index 00000000..205ea874
--- /dev/null
+++ b/assets/mootools-core/Specs/Utilities/Color.js
@@ -0,0 +1,62 @@
+var myColor;
+//colors compared with photoshop values.
+
+describe('Color constructor, hex', {
+
+ 'before all': function(){
+ myColor = new Color('#a2c240');
+ },
+
+ 'should have the correct rgb': function(){
+ value_of(myColor).should_be([162, 194, 64]);
+ },
+
+ 'should have the correct hsb': function(){
+ value_of(myColor.hsb).should_be([75, 67, 76]);
+ },
+
+ 'should have the correct hex': function(){
+ value_of(myColor.hex).should_be('#a2c240');
+ }
+
+});
+
+describe('Color constructor, hsb', {
+
+ 'before all': function(){
+ myColor = new Color('hsb(75, 67, 76)');
+ },
+
+ 'should have the correct rgb': function(){
+ value_of(myColor).should_be([161, 194, 64]);
+ },
+
+ 'should have the correct hsb': function(){
+ value_of(myColor.hsb).should_be([75, 67, 76]);
+ },
+
+ 'should have the correct hex': function(){
+ value_of(myColor.hex).should_be('#a1c240');
+ }
+
+});
+
+describe('Color constructor, rgb', {
+
+ 'before all': function(){
+ myColor = new Color('rgb(162, 194, 64)');
+ },
+
+ 'should have the correct rgb': function(){
+ value_of(myColor).should_be([162, 194, 64]);
+ },
+
+ 'should have the correct hsb': function(){
+ value_of(myColor.hsb).should_be([75, 67, 76]);
+ },
+
+ 'should have the correct hex': function(){
+ value_of(myColor.hex).should_be('#a2c240');
+ }
+
+});
\ No newline at end of file
diff --git a/assets/mootools-core/Specs/Utilities/Selectors.js b/assets/mootools-core/Specs/Utilities/Selectors.js
new file mode 100644
index 00000000..30dca7fb
--- /dev/null
+++ b/assets/mootools-core/Specs/Utilities/Selectors.js
@@ -0,0 +1,8 @@
+/*
+Script: Selectors.js
+ Specs for Selectors.js
+
+License:
+ MIT-style license.
+*/
+
diff --git a/assets/mootools-core/Specs/Utilities/index.html b/assets/mootools-core/Specs/Utilities/index.html
new file mode 100644
index 00000000..bfb493aa
--- /dev/null
+++ b/assets/mootools-core/Specs/Utilities/index.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+
diff --git a/assets/mootools-core/Specs/application.xml b/assets/mootools-core/Specs/application.xml
new file mode 100644
index 00000000..94e21e3f
--- /dev/null
+++ b/assets/mootools-core/Specs/application.xml
@@ -0,0 +1,16 @@
+
+
+
+
+ test
+ test
+ test
+ test
+
+ My name is .
+
diff --git a/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.capitalization.js b/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.capitalization.js
new file mode 100644
index 00000000..ff8edba1
--- /dev/null
+++ b/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.capitalization.js
@@ -0,0 +1,14 @@
+{
+ tests: [
+ {
+ title: "Simple Prompt :: capitalization enabled", //the title of the test
+ description: "Prompts the user to enter their name and then capitalizes it for them.", //a one liner description of the test
+ verify: "Was your name added to the test frame capitalized?", //the question the user should answer
+ //"yes" to that signifies success
+ before: function(){
+ simplePrompt(get("usersName"), "Enter your name (lower case):", "fred flintstone", true);
+ }
+ }
+ ],
+ otherScripts: ["getElement"] //getElement isn't in our dependency chain, but I use it in the test itself
+}
diff --git a/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.nocaps.html b/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.nocaps.html
new file mode 100644
index 00000000..908ac83b
--- /dev/null
+++ b/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.nocaps.html
@@ -0,0 +1,3 @@
+
+ My name is .
+
diff --git a/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.nocaps.js b/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.nocaps.js
new file mode 100644
index 00000000..39d9ff96
--- /dev/null
+++ b/assets/mootools-core/Tests/DemoTests/PromptUser/SimplePrompt.nocaps.js
@@ -0,0 +1,14 @@
+{
+ tests: [
+ {
+ title: "Simple Prompt :: capitalization disabled", //the title of the test
+ description: "Prompts the user to enter their name; does NOT capitalize it for them.", //a one liner description of the test
+ verify: "Was your name added to the test frame (not capitalized)?", //the question the user should answer
+ //"yes" to that signifies success
+ before: function(){
+ simplePrompt(get("usersName"), "Enter your name (lower case):", "fred flintstone", false);
+ }
+ }
+ ],
+ otherScripts: ["getElement"] //getElement isn't in our dependency chain, but I use it in the test itself
+}
diff --git a/assets/mootools-core/Tests/DemoTests/tests.json b/assets/mootools-core/Tests/DemoTests/tests.json
new file mode 100644
index 00000000..a7ee0ae1
--- /dev/null
+++ b/assets/mootools-core/Tests/DemoTests/tests.json
@@ -0,0 +1,5 @@
+{
+ "PromptUser":{
+ "SimplePrompt":['capitalization', 'nocaps']
+ }
+}
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/UserTests/Element/Element.Dimensions.offsets.html b/assets/mootools-core/Tests/UserTests/Element/Element.Dimensions.offsets.html
new file mode 100644
index 00000000..0c3e1c9d
--- /dev/null
+++ b/assets/mootools-core/Tests/UserTests/Element/Element.Dimensions.offsets.html
@@ -0,0 +1,77 @@
+
+
+
+
+
+
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+
diff --git a/assets/mootools-core/Tests/UserTests/Element/Element.Dimensions.offsets.js b/assets/mootools-core/Tests/UserTests/Element/Element.Dimensions.offsets.js
new file mode 100644
index 00000000..5cd875ba
--- /dev/null
+++ b/assets/mootools-core/Tests/UserTests/Element/Element.Dimensions.offsets.js
@@ -0,0 +1,10 @@
+{
+ tests: [
+ {
+ title: "Element.offsets",
+ description: "Tests the offset logic for elements.",
+ verify: "When you scroll does offset value remain fixed in place?"
+ }
+ ],
+ otherScripts: ['DomReady']
+}
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/UserTests/Request/Request.all.html b/assets/mootools-core/Tests/UserTests/Request/Request.all.html
new file mode 100644
index 00000000..42489094
--- /dev/null
+++ b/assets/mootools-core/Tests/UserTests/Request/Request.all.html
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/UserTests/Request/Request.all.js b/assets/mootools-core/Tests/UserTests/Request/Request.all.js
new file mode 100644
index 00000000..508aed02
--- /dev/null
+++ b/assets/mootools-core/Tests/UserTests/Request/Request.all.js
@@ -0,0 +1,26 @@
+{
+ tests: [
+ {
+ title: "Request",
+ description: "Sends an AJAX request to the server.",
+ verify: "Did the ajax log to the screen a success?",
+ before: function(){
+ new Request({
+ url: 'UserTests/Request/simple.php',
+ method: 'get',
+ onRequest: function(){
+ $('log').adopt(new Element('li', {
+ html: 'attempting request...'
+ }))
+ },
+ onSuccess: function(r){
+ $('log').adopt(new Element('li', {
+ html: 'success: ' + r
+ }))
+ }
+ }).send();
+ }
+ }
+ ],
+ otherScripts: ['Element']
+}
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/UserTests/Request/simple.php b/assets/mootools-core/Tests/UserTests/Request/simple.php
new file mode 100644
index 00000000..90a00351
--- /dev/null
+++ b/assets/mootools-core/Tests/UserTests/Request/simple.php
@@ -0,0 +1,7 @@
+
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/UserTests/tests.json b/assets/mootools-core/Tests/UserTests/tests.json
new file mode 100644
index 00000000..1c17de77
--- /dev/null
+++ b/assets/mootools-core/Tests/UserTests/tests.json
@@ -0,0 +1,8 @@
+{
+ "Element": {
+ "Element.Dimensions":['offsets']
+ },
+ "Request": {
+ "Request":['all']
+ }
+}
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/assets/Debugger.cnet.js b/assets/mootools-core/Tests/assets/Debugger.cnet.js
new file mode 100644
index 00000000..15ba2931
--- /dev/null
+++ b/assets/mootools-core/Tests/assets/Debugger.cnet.js
@@ -0,0 +1,23 @@
+//adds the debugger for non FF browsers (or FF w/o firebug)
+//sets up the dbug alias; see dbug.js in Clientside lib
+window.addEvent('domready', function(){
+ try {
+ if (!window.debug || !window.debug.path){
+ var debug = {
+ path: 'assets/moobugger/'
+ };
+ var script = document.createElement('script');
+ script.id = 'debug-bookmarklet';
+ script.src = debug.path + 'debugger.js';
+ script.onload = function(){
+ if (typeof dbug == "undefined") return;
+ (function(){
+ dbug.firebug = true;
+ dbug.enable();
+ }).delay(400);
+ };
+ document.getElementsByTagName('head')[0].appendChild(script);
+ }
+ } catch(e){
+ }
+});
diff --git a/assets/mootools-core/Tests/assets/UnitTester.js b/assets/mootools-core/Tests/assets/UnitTester.js
new file mode 100644
index 00000000..d5ef0f21
--- /dev/null
+++ b/assets/mootools-core/Tests/assets/UnitTester.js
@@ -0,0 +1,581 @@
+setCNETAssetBaseHref('assets/');
+/*
+Script: UnitTester.js
+
+License:
+ MIT-style license.
+*/
+
+$E = document.getElement.bind(document);
+
+/* redefine Request so it always execs scripts and uses method: get */
+
+var Request = new Class({
+
+ Extends: Request,
+
+ options: {
+ method: 'get',
+ includeScripts: true
+ },
+
+/* redefine processScripts so that it doesn't attempt to read headers; this enables the tester to
+ run locally w/o a web server for browsers that allow it */
+
+ processScripts: function(text){
+ return text;
+ if (this.options.evalResponse) return $exec(text);
+ return text.stripScripts(this.options.evalScripts);
+ }
+
+});
+
+
+/*
+Script: UnitTester.js
+ Automatically builds unit tests based on an external js script, loading the html, js, and any depedencies.
+
+License:
+ MIT-style license.
+*/
+
+
+var UnitTester = new Class({
+ Implements: [Events, Options],
+ options: {
+ autoplay: true
+ },
+ testScripts: {
+ //include as many sources as you like
+ //provide the directory that contians tests.json
+ demos: 'DemoTests/'
+ },
+ tests: {},
+ sources: {
+ //list any locations that contain a MooTools organized
+ //code repository (eg: Source/scripts.json)
+ DemoScripts: 'DemoScripts/'
+ },
+ data: {},
+ initialize: function(sources, testScripts, options){
+ this.setOptions(options);
+ this.sources = sources || this.sources;
+ this.testScripts = testScripts || this.testScripts;
+ this.waiter = new Waiter($('script'), {
+ msg: 'Loading dependencies'
+ });
+ //when sources are loaded, inject the tree of tests into the nav
+ this.addEvent('onReady', function(target, sources){
+ if (sources == this.sources) this.mapTree();
+ else this.setupLoaderSelection();
+ }.bind(this));
+ //load each test and source
+ $each(this.sources, function(v, k){
+ this.loadSource(k, '/Source/scripts.json', this.data, this.sources);
+ }, this);
+ $each(this.testScripts, function(v, k){
+ this.loadSource(k, '/tests.json', this.tests, this.testScripts);
+ }, this);
+ //set up the textarea that lets you run your own code
+ this.setupManual();
+ },
+ //fetch the test iframe
+ getFrame: function(){
+ if (Browser.Engine.webkit) return frames["testFrame"];
+ return $('testFrame').contentWindow;
+ },
+ //load a scripts.json set
+ loadSource: function(source, suffix, target, sources){
+ this.request(sources[source]+suffix, function(result){
+ this.loadJson(source, result, target, sources);
+ }.bind(this));
+ },
+ //handle scripts.json decoding
+ loadJson: function(source, result, target, sources){
+ if (result){
+ target[source] = JSON.decode(result);
+ this.dataLoaded(target, sources);
+ }
+ },
+ //manage loaded data; fire onReady when all sources are loaded
+ dataLoaded: function(target, sources){
+ var loaded = true;
+ $each(sources, function(v, k){
+ if (!target[k]) loaded = false;
+ }, this);
+ if (loaded) this.fireEvent('onReady', [target, sources]);
+ },
+ //map dependencies
+ deps: {},
+ pathMap: {},
+ //create a map of source to paths
+ mapTree: function(){
+ $each(this.data, function(data, source){
+ $each(data, function(scripts, folder){
+ $each(scripts, function(details, script){
+ this.deps[source+':'+folder+':'+script] = details.deps;
+ this.pathMap[script] = source+':'+folder+':'+script;
+ }, this);
+ }, this);
+ }, this);
+ },
+ //get the dependencies for a given script
+ getDepsForScript: function(script){
+ return this.deps[this.pathMap[script]];
+ },
+ //calculate the dependencies for a given script
+ calculateDependencies: function(script){
+ var reqs = [];
+ if (script == "None") return reqs;
+ var deps = this.getDepsForScript(script);
+ if (!deps){
+ dbug.log('dependencies not mapped: script: %o, map: %o, :deps: %o', script, this.pathMap, this.deps);
+ } else {
+ deps.each(function(scr){
+ if (scr == script || scr == "None") return;
+ if (!reqs.contains(scr)) reqs.combine(this.calculateDependencies(scr));
+ reqs.include(scr);
+ }, this);
+ return reqs;
+ }
+ },
+ //get the path for a script
+ getPath: function(script){
+ try {
+ var chunks = this.pathMap[script].split(':');
+ var dir = this.sources[chunks[0]] + '/Source/';
+ chunks.erase(chunks[0]);
+ return dir + chunks.join('/') + '.js';
+ } catch(e){
+ return script;
+ }
+ },
+ //dbug is loaded already by default - technically, it maps to the dbug in the parent window
+ loadedScripts: ['dbug'],
+ //load the missing dependencies for a given script
+ loadDependencies: function(script, target, win){
+ var scripts = this.calculateDependencies(script).include(script);
+ scripts = scripts.filter(function(s){return !this.loadedScripts.contains(s)}, this);
+ this.loadedScripts.combine(scripts);
+ if (scripts.length){
+ scripts.filter(function(scr){
+ return scr != "None"
+ }).each(function(scr){
+ this.loadScr(scr, target, win);
+ }.bind(this));
+ } else {
+ this.fireEvent('scriptsLoaded');
+ }
+ },
+ //keep track of how many scripts we're loading at a given time so the user
+ //this just stacks up scripts so that they have a buffer of 100ms between loading
+ //I found that injecting them into the iframe without it caused issues in
+ //some browsers
+ loaders: [],
+ clearLoaders: function(){
+ this.loaders.empty();
+ },
+ //loads a script; if there is a script loading, pushes it onto the stack
+ loadScr: function(scr, target, win){
+ var run = this.loaders.length == 0;
+ this.waiter.start();
+ win = win||this.getFrame();
+ target = target||win.document.getElementsByTagName('head')[0];
+ var finish = function(){
+ if (this.loaders[0]){
+ try {
+ this.loaders[0].apply(this);
+ } catch(e){}
+ } else {
+ this.waiter.stop();
+ this.fireEvent('scriptsLoaded');
+ }
+ };
+ this.loaders.push(function(){
+ if (scr.contains('dbug.js')){
+ finish.delay(100, this);
+ } else if (Browser.Engine.trident){
+ win.$LoadScript(this.getPath(scr));
+ finish.delay(100, this);
+ } else {
+ try {
+ var s = new Element('script', {
+ src: this.getPath(scr)+"?noCache="+new Date().getTime(),
+ 'type': 'text/javascript',
+ events: {
+ load: finish.bind(this)
+ }
+ }).inject(target);
+ } catch(e){
+ }
+ }
+ this.loaders.erase(this.loaders[0]);
+ });
+ if (run) this.loaders[0].delay(100, this);
+ },
+ //creates the left nav of all the tests
+ setupLoaderSelection: function(){
+ var sel = $('testLoaderSel').empty();
+ $('testLoaderSel').setStyle('opacity', 0);
+ var dts = [];
+ var dds = [];
+ $each(this.tests, function(tests, section){
+ new Element('h3', {html: section}).inject(sel);
+ $each(tests, function(dir, dirName){
+ new Element('h4', {html: dirName}).inject(sel);
+ $each(dir, function(tests, script){
+ var dt = new Element('dt', {html: script}).inject(sel);
+ dts.push(dt);
+ var container = new Element('div', {'class':'testList'}).inject(dt, 'after');
+ dds.push(container);
+ if (tests.length == 1){
+ var dd = new Element('dd').inject(container).hide();
+ dd.store('testindex', 0);
+ dd.store('testPath', section+'/'+dirName+'/'+script+'/'+tests[0]);
+ dt.addEvent('click', function(){
+ this.loadTest(section+'/'+dirName+'/'+script+'/'+tests[0]);
+ selectTest(dd);
+ }.bind(this));
+ dt.store('testPath', section+'/'+dirName+'/'+script+'/'+tests[0]);
+ } else {
+ tests.each(function(test, i){
+ var dd = new Element('dd', {
+ html: '» '+test
+ }).inject(container);
+ dd.store('testindex', i);
+ dd.store('testPath', section+'/'+dirName+'/'+script+'/'+tests);
+ dd.addEvent('click', function(){
+ this.loadTest(section+'/'+dirName+'/'+script+'/'+test);
+ selectTest(dd);
+ }.bind(this));
+ }, this);
+ }
+ }, this);
+ }, this);
+ }, this);
+ var selectTest = function(container){
+ dds.each(function(div){
+ div.getElements('dd').each(function(dd){
+ if (container != dd) dd.removeClass('selected');
+ else dd.addClass('selected');
+ });
+ div.getElements('dt').removeClass('selected');
+ });
+ var dt = $E('dd.selected').getParent().getPrevious('dt');
+ if (dt) dt.addClass('selected');
+ };
+ new Accordion(dts, dds, {
+ duration: 250
+ });
+ $('testLoaderSel').tween('opacity', 1);
+ },
+ //gets the test json for a given path
+ getTestFilePath: function(testPath){
+ var chunks = testPath.split('/');
+ var base = chunks[0];
+ var dir = chunks[1];
+ chunks.splice(chunks.indexOf(base), 1);
+ if (chunks.contains(dir) >= 0) chunks.splice(chunks.indexOf(dir), 1);
+ var script = chunks[0];
+ var file = chunks.join('.');
+ var name = base+': '+dir+' » '+file;
+ var filePath = this.testScripts[base]+dir+'/'+file;
+ return {
+ filePath: filePath,
+ script: script,
+ name: name,
+ dir: dir,
+ file: file,
+ base: base
+ };
+ },
+ //loads a test given a path
+ loadTest: function(testPath){
+ console.log('load: ', testPath);
+ this.clearLoaders();
+ this.getFrame().location.href = this.getFrame().location.href.split("#")[0];
+ $('testFrame').removeEvents('load');
+ $('testFrame').addEvent('load', function(){
+ testPath = testPath || $('testLoaderSel').get('value');
+ if (!testPath) return;
+ var test = this.getTestFilePath(testPath);
+ this.removeEvents('scriptsLoaded').addEvent('scriptsLoaded', function(){
+ var dr = function(){
+ this.removeEvents('scriptsLoaded');
+ this.exec(this.currentTest['scripts']);
+ dbug.log('test scripts loaded');
+ this.loadScr('assets/fireDomReady.js');
+ if (this.options.autoplay) this.runTest.delay(100, this, 0);
+ }.bind(this);
+ this.removeEvents('scriptsLoaded').addEvent('scriptsLoaded', dr);
+ if (this.testObjs.otherScripts){
+ var head = this.getFrame().document.getElementsByTagName('head')[0];
+ this.testObjs.otherScripts.each(function(s){
+ this.loadDependencies(s, head, this.getFrame())
+ }, this);
+ } else {
+ dr();
+ }
+ });
+ this.request(test.filePath+'.html', function(result){
+ this.loadTestHtml(test.name, result, test.script);
+ this.request(test.filePath+'.js', function(result){
+ this.loadTestJs(result);
+ }.bind(this));
+ }.bind(this));
+ }.bind(this));
+ },
+ //the current test
+ currentTest: {},
+ //load the html into the iframe
+ loadTestHtml: function(name, html, script){
+ if ($defined(name)){
+ this.currentTest['name'] = name;
+ this.currentTest['html'] = html;
+ }
+ var head = this.getFrame().document.getElementsByTagName('head')[0];
+ this.loadedScripts.empty();
+ this.loadDependencies(script, head, this.getFrame())
+
+ var body = this.getFrame().document.body;
+ body.innerHTML = 'FIXED
+ SCROLL+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+ SCROLL
+
'+this.currentTest['name']+'
'; + var scripts = ''; + var styles = ''; + var links = ''; + var text = this.currentTest['html'].replace(/
+
+
+
+
+
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/assets/moobugger/debugger-iframe.js b/assets/mootools-core/Tests/assets/moobugger/debugger-iframe.js
new file mode 100644
index 00000000..0d57f47e
--- /dev/null
+++ b/assets/mootools-core/Tests/assets/moobugger/debugger-iframe.js
@@ -0,0 +1,372 @@
+/*
+Script: Debugger.js
+ Creates Firebug The MooBugger.
+moobugger - bookmark it!
++ */ + + log: function(){ + return debug.$log($A(arguments)); + }, + + /* + Property: time + Starts a timer. + Argument: + name - the name of the timer + */ + + time: function(name){ + if (debug.$timers[name]){ + debug.error("a timer called " + name + ' already exists'); + } else { + debug.$pre(name + ' started', 'time'); + debug.$timers[name] = new Date().getTime(); + } + return debug.$nil; + }, + + /* + Property: timeEnd + Ends a timer and logs that value to the console. + Argument: + name - the name of the timer + */ + + timeEnd: function(name){ + if (debug.$timers[name]) debug.$pre(name + ' ended: ' + (new Date().getTime() - debug.$timers[name]) + ' ms', 'time'); + else debug.error("no such timer called " + name); + return debug.$nil; + }, + + group: function(name){ + if (debug.$groups.keys.contains(name)){ + debug.error('a group called ' + name + ' already exists'); + } else { + var pre = debug.$pre('Group: ' + name, 'group'); + var grp = new Element('div', {'class': 'group'}).inject(debug.$groups.values.getLast()); + pre.addEvent('click', function(){ + var none = (grp.getStyle('display') == 'none'); + var name = none ? 'block' : 'none'; + grp.setStyle('display', name); + this.toggleClass('group-closed'); + }); + debug.$groups.keys.push(name); + debug.$groups.values.push(grp); + } + return debug.$nil; + }, + + groupEnd: function(name){ + var idx = debug.$groups.keys.indexOf(name); + if (idx >= 0){ + debug.$groups.values.remove(debug.$groups.values[idx]); + debug.$groups.keys.remove(name); + } else { + debug.error('no such group called ' + name); + } + return debug.$nil; + }, + + error: function(){ + debug.$special($A(arguments), 'error'); + return debug.$nil; + }, + + warn: function(warning){ + debug.$special($A(arguments), 'warning'); + return debug.$nil; + }, + + info: function(){ + debug.$special($A(arguments), 'info'); + return debug.$nil; + } + +}; + +debug.$init(); + +window.addEvent('load', debug.$load); \ No newline at end of file diff --git a/assets/mootools-core/Tests/assets/moobugger/debugger.css b/assets/mootools-core/Tests/assets/moobugger/debugger.css new file mode 100644 index 00000000..ecc6991a --- /dev/null +++ b/assets/mootools-core/Tests/assets/moobugger/debugger.css @@ -0,0 +1,190 @@ +body { + margin: 0; + padding: 0; +} + +#debug { + display: none; + font-family: arial, helvetica; + width: 100%; + border-top: 1px solid #B9ACAC; + z-index: 9999; +} + +#debug-header { + height: 16px; + border-top: 1px solid #F3F1F1; + border-bottom: 1px solid #B9ACAC; + background: #DBD6D6; + text-align: right; + padding: 3px 7px 0; + font-size: 10px; + color: #B9ACAC; +} + +#debug-mootools-net:link, #debug-mootools-net:visited { + display: block; + float: left; + width: 14px; + height: 14px; + margin-top: -1px; + background: url(images/icon.png) no-repeat top left; +} + +#debug-mootools-net:hover, #debug-mootools-net:active { + background-position: bottom left; +} + +#debug-header span { + cursor: pointer; + width: 13px; + height: 13px; + display: block; + float: right; + margin-left: 5px; +} + +#debug-header b { + display: block; + clear: both; +} + +#debug-button-close { + background: url(images/close.png); +} + +#debug-button-max { + background: url(images/max.png); +} + +#debug-button-min { + background: url(images/min.png); +} + +#debug-messages { + height: 133px; + border-top: 1px solid #EEE; + overflow: auto; + background: #FFF url(images/mootools.png) no-repeat center center; +} + +#debug-messages pre { + white-space: normal; + padding: 3px 5px; + margin: 0; + font: 11px "Andale Mono", Monaco, "Courier New"; + border-bottom: 1px solid #ccc; + color: #444; + background-color: #FFF; +} + +#debug-messages pre.error { + background: #F0F0F0 url(images/error.png) no-repeat 5px 50%; + color: #da5d0b; + padding-left: 25px; +} + +#debug-messages pre.error span.string { + color: #da5d0b; +} + +#debug-messages pre.warning { + background: #F0F0F0 url(images/warning.png) no-repeat 5px 50%; + color: #ce7a2a; + padding-left: 25px; +} + +#debug-messages pre.warning span.string { + color: #ce7a2a; +} + +#debug-messages pre.info { + background: #F0F0F0 url(images/info.png) no-repeat 5px 50%; + color: #528CE0; + padding-left: 25px; +} + +#debug-messages pre.info span.string { + color: #528CE0; +} + +#debug-messages pre.time { + background: #F0F0F0 url(images/time.png) no-repeat 5px 50%; + color: #111; + padding-left: 25px; +} + +#debug-messages pre.group { + background: #f9f9f9 url(images/group-close.png) no-repeat 6px 50%; + color: #222; + padding-left: 25px; + cursor: pointer; +} + +#debug-messages pre.group-closed { + background-image: url(images/group-open.png); +} + +#debug-messages div.group { + padding: 2px 0 2px 10px; + background: #ccc; +} + +#debug-messages pre.logger { + color: #4373B8; +} + +#debug-input-area { + overflow: hidden; + border-top: 1px solid #B9ACAC; +} + +#debug-input { + width: 100% !important; + width: 90%; + color: #222; + font: 12px Andale Mono, Monaco, "Courier New"; + margin: 0; + border: 0; + padding: 4px 5px 3px 30px; + background: #fff url(images/lick.png) no-repeat 7px 63%; +} + +#debug-messages a:link, #debug-messages a:visited { + color: #333; + text-decoration: none; +} + +#debug-messages a:hover, #debug-messages a:active { + background-color: #757E8A; + color: #fff; +} + +#debug-messages a:hover span, #debug-messages a:active span { + color: #EECFCF; +} + +#debug-messages span.number { + color: #B33F3F; +} + +#debug-messages span.boolean { + color: #A652E0; +} + +#debug-messages span.undefined, #debug-messages span.false { + color: #888; + background-color: #eee; +} + +#debug-messages span.key { + color: #888; +} + +#debug-messages span.tag { + color: #528CE0; +} + +#debug-messages span.string { + color: #8B9E41; +} \ No newline at end of file diff --git a/assets/mootools-core/Tests/assets/moobugger/debugger.html b/assets/mootools-core/Tests/assets/moobugger/debugger.html new file mode 100644 index 00000000..60dd577a --- /dev/null +++ b/assets/mootools-core/Tests/assets/moobugger/debugger.html @@ -0,0 +1,25 @@ + + +
+ +
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/assets/mootools-1.2.js b/assets/mootools-core/Tests/assets/mootools-1.2.js
new file mode 100644
index 00000000..25e33a59
--- /dev/null
+++ b/assets/mootools-core/Tests/assets/mootools-1.2.js
@@ -0,0 +1,341 @@
+//MooTools, The MooBugger.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+ +Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+s around + // "paragraphs" that are wrapped in non-block-level tags, such as anchors, + // phrase emphasis, and spans. The list of tags we're looking for is + // hard-coded: + var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del" + var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math" + + // First, look for nested blocks, e.g.: + //
+ //
+ //
+ // The outermost tags must start at the left margin for this to match, and
+ // the inner nested divs must be indented.
+ // We need to do this before the next, more liberal match, because the next
+ // match will start at the first `
+ // tags for inner block must be indented.
+ //
+ // ` and stop at the first `
`.
+
+ // attacklab: This regex can be expensive when it fails.
+ /*
+ var text = text.replace(/
+ ( // save in $1
+ ^ // start of line (with /m)
+ <($block_tags_a) // start tag = $2
+ \b // word break
+ // attacklab: hack around khtml/pcre bug...
+ [^\r]*?\n // any number of lines, minimally matching
+ // the matching end tag
+ [ \t]* // trailing spaces/tabs
+ (?=\n+) // followed by a newline
+ ) // attacklab: there are sentinel newlines at end of document
+ /gm,function(){...}};
+ */
+ text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del)\b[^\r]*?\n<\/\2>[ \t]*(?=\n+))/gm,hashElement);
+
+ //
+ // Now match more liberally, simply from `\n. It was easier to make a special case than + // to make the other regex more complicated. + + /* + text = text.replace(/ + ( // save in $1 + \n\n // Starting after a blank line + [ ]{0,3} + (<(hr) // start tag = $2 + \b // word break + ([^<>])*? // + \/?>) // the matching end tag + [ \t]* + (?=\n{2,}) // followed by a blank line + ) + /g,hashElement); + */ + text = text.replace(/(\n[ ]{0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,hashElement); + + // Special case for standalone HTML comments: + + /* + text = text.replace(/ + ( // save in $1 + \n\n // Starting after a blank line + [ ]{0,3} // attacklab: g_tab_width - 1 + + [ \t]* + (?=\n{2,}) // followed by a blank line + ) + /g,hashElement); + */ + text = text.replace(/(\n\n[ ]{0,3}[ \t]*(?=\n{2,}))/g,hashElement); + + // PHP and ASP-style processor instructions ( and <%...%>) + + /* + text = text.replace(/ + (?: + \n\n // Starting after a blank line + ) + ( // save in $1 + [ ]{0,3} // attacklab: g_tab_width - 1 + (?: + <([?%]) // $2 + [^\r]*? + \2> + ) + [ \t]* + (?=\n{2,}) // followed by a blank line + ) + /g,hashElement); + */ + text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,hashElement); + + // attacklab: Undo double lines (see comment at top of this function) + text = text.replace(/\n\n/g,"\n"); + return text; +} + +var hashElement = function(wholeMatch,m1){ + var blockText = m1; + + // Undo double lines + blockText = blockText.replace(/\n\n/g,"\n"); + blockText = blockText.replace(/^\n/,""); + + // strip trailing blank lines + blockText = blockText.replace(/\n+$/g,""); + + // Replace the element text with a marker ("~KxK" where x is its key) + blockText = "\n\n~K" + (g_html_blocks.push(blockText)-1) + "K\n\n"; + + return blockText; +}; + +var _RunBlockGamut = function(text){ +// +// These are all the transformations that form block-level +// tags like paragraphs, headers, and list items. +// + text = _DoHeaders(text); + + // Do Horizontal Rules: + var key = hashBlock("
"); + text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm,key); + text = text.replace(/^[ ]{0,2}([ ]?\-[ ]?){3,}[ \t]*$/gm,key); + text = text.replace(/^[ ]{0,2}([ ]?\_[ ]?){3,}[ \t]*$/gm,key); + + text = _DoLists(text); + text = _DoCodeBlocks(text); + text = _DoBlockQuotes(text); + + // We already ran _HashHTMLBlocks() before, in Markdown(), but that + // was to escape raw HTML in the original Markdown source. This time, + // we're escaping the markup we've just created, so that we don't wrap + //
tags around block-level tags.
+ text = _HashHTMLBlocks(text);
+ text = _FormParagraphs(text);
+
+ return text;
+}
+
+
+var _RunSpanGamut = function(text){
+//
+// These are all the transformations that occur *within* block-level
+// tags like paragraphs, headers, and list items.
+//
+
+ text = _DoCodeSpans(text);
+ text = _EscapeSpecialCharsWithinTagAttributes(text);
+ text = _EncodeBackslashEscapes(text);
+
+ // Process anchor and image tags. Images must come first,
+ // because ![foo][f] looks like an anchor.
+ text = _DoImages(text);
+ text = _DoAnchors(text);
+
+ // Make links out of things like ` Just type tags
+//
+
+ // Strip leading and trailing lines:
+ text = text.replace(/^\n+/g,"");
+ text = text.replace(/\n+$/g,"");
+
+ var grafs = text.split(/\n{2,}/g);
+ var grafsOut = new Array();
+
+ //
+ // Wrap tags.
+ //
+ var end = grafs.length;
+ for (var i=0; i ");
+ str += " {description}
\n");
+
+ return text;
+}
+
+var _EscapeSpecialCharsWithinTagAttributes = function(text){
+//
+// Within tags -- meaning between < and > -- encode [\ ` * _] so they
+// don't conflict with their use in Markdown for code, italics and strong.
+//
+
+ // Build a regex to find HTML tags and comments. See Friedl's
+ // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
+ var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|)/gi;
+
+ text = text.replace(regex, function(wholeMatch){
+ var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g,"$1`");
+ tag = escapeCharacters(tag,"\\`*_");
+ return tag;
+ });
+
+ return text;
+}
+
+var _DoAnchors = function(text){
+//
+// Turn Markdown link shortcuts into XHTML tags.
+//
+ //
+ // First, handle reference-style links: [link text] [id]
+ //
+
+ /*
+ text = text.replace(/
+ ( // wrap whole match in $1
+ \[
+ (
+ (?:
+ \[[^\]]*\] // allow brackets nested one level
+ |
+ [^\[] // or anything else
+ )*
+ )
+ \]
+
+ [ ]? // one optional space
+ (?:\n[ ]*)? // one optional newline followed by spaces
+
+ \[
+ (.*?) // id = $3
+ \]
+ )()()()() // pad remaining backreferences
+ /g,_DoAnchors_callback);
+ */
+ text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeAnchorTag);
+
+ //
+ // Next, inline-style links: [link text](url "optional title")
+ //
+
+ /*
+ text = text.replace(/
+ ( // wrap whole match in $1
+ \[
+ (
+ (?:
+ \[[^\]]*\] // allow brackets nested one level
+ |
+ [^\[\]] // or anything else
+ )
+ )
+ \]
+ \( // literal paren
+ [ \t]*
+ () // no id, so leave $3 empty
+ ? // href = $4
+ [ \t]*
+ ( // $5
+ (['"]) // quote char = $6
+ (.*?) // Title = $7
+ \6 // matching quote
+ [ \t]* // ignore any spaces/tabs between closing quote and )
+ )? // title is optional
+ \)
+ )
+ /g,writeAnchorTag);
+ */
+ text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeAnchorTag);
+
+ //
+ // Last, handle reference-style shortcuts: [link text]
+ // These must come last in case you've also got [link test][1]
+ // or [link test](/foo)
+ //
+
+ /*
+ text = text.replace(/
+ ( // wrap whole match in $1
+ \[
+ ([^\[\]]+) // link text = $2; can't contain '[' or ']'
+ \]
+ )()()()()() // pad rest of backreferences
+ /g, writeAnchorTag);
+ */
+ text = text.replace(/(\[([^\[\]]+)\])()()()()()/g, writeAnchorTag);
+
+ return text;
+}
+
+var writeAnchorTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7){
+ if (m7 == undefined) m7 = "";
+ var whole_match = m1;
+ var link_text = m2;
+ var link_id = m3.toLowerCase();
+ var url = m4;
+ var title = m7;
+
+ if (url == ""){
+ if (link_id == ""){
+ // lower-case and turn embedded newlines into spaces
+ link_id = link_text.toLowerCase().replace(/ ?\n/g," ");
+ }
+ url = "#"+link_id;
+
+ if (g_urls[link_id] != undefined){
+ url = g_urls[link_id];
+ if (g_titles[link_id] != undefined){
+ title = g_titles[link_id];
+ }
+ }
+ else {
+ if (whole_match.search(/\(\s*\)$/m)>-1){
+ // Special case for explicit empty url
+ url = "";
+ } else {
+ return whole_match;
+ }
+ }
+ }
+
+ url = escapeCharacters(url,"*_");
+ var result = "";
+
+ return result;
+}
+
+
+var _DoImages = function(text){
+//
+// Turn Markdown image shortcuts into tags.
+//
+
+ //
+ // First, handle reference-style labeled images: ![alt text][id]
+ //
+
+ /*
+ text = text.replace(/
+ ( // wrap whole match in $1
+ !\[
+ (.*?) // alt text = $2
+ \]
+
+ [ ]? // one optional space
+ (?:\n[ ]*)? // one optional newline followed by spaces
+
+ \[
+ (.*?) // id = $3
+ \]
+ )()()()() // pad rest of backreferences
+ /g,writeImageTag);
+ */
+ text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeImageTag);
+
+ //
+ // Next, handle inline images: 
+ // Don't forget: encode * and _
+
+ /*
+ text = text.replace(/
+ ( // wrap whole match in $1
+ !\[
+ (.*?) // alt text = $2
+ \]
+ \s? // One optional whitespace character
+ \( // literal paren
+ [ \t]*
+ () // no id, so leave $3 empty
+ ? // src url = $4
+ [ \t]*
+ ( // $5
+ (['"]) // quote char = $6
+ (.*?) // title = $7
+ \6 // matching quote
+ [ \t]*
+ )? // title is optional
+ \)
+ )
+ /g,writeImageTag);
+ */
+ text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeImageTag);
+
+ return text;
+}
+
+var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7){
+ var whole_match = m1;
+ var alt_text = m2;
+ var link_id = m3.toLowerCase();
+ var url = m4;
+ var title = m7;
+
+ if (!title) title = "";
+
+ if (url == ""){
+ if (link_id == ""){
+ // lower-case and turn embedded newlines into spaces
+ link_id = alt_text.toLowerCase().replace(/ ?\n/g," ");
+ }
+ url = "#"+link_id;
+
+ if (g_urls[link_id] != undefined){
+ url = g_urls[link_id];
+ if (g_titles[link_id] != undefined){
+ title = g_titles[link_id];
+ }
+ }
+ else {
+ return whole_match;
+ }
+ }
+
+ alt_text = alt_text.replace(/"/g,""");
+ url = escapeCharacters(url,"*_");
+ var result = "
" + _RunSpanGamut(m1) + "");});
+
+ text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
+ function(matchFound,m1){return hashBlock("
" + _RunSpanGamut(m1) + "
");});
+
+ // atx-style headers:
+ // # Header 1
+ // ## Header 2
+ // ## Header 2 with closing hashes ##
+ // ...
+ // ###### Header 6
+ //
+
+ /*
+ text = text.replace(/
+ ^(\#{1,6}) // $1 = string of #'s
+ [ \t]*
+ (.+?) // $2 = Header text
+ [ \t]*
+ \#* // optional closing #'s (not counted)
+ \n+
+ /gm, function(){...});
+ */
+
+ text = text.replace(/^(\#{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
+ function(wholeMatch,m1,m2){
+ var h_level = m1.length;
+ return hashBlock("` blocks.
+//
+
+ /*
+ text = text.replace(text,
+ /(?:\n\n|^)
+ ( // $1 = the code block -- one or more lines, starting with a space/tab
+ (?:
+ (?:[ ]{4}|\t) // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
+ .*\n+
+ )+
+ )
+ (\n*[ ]{0,3}[^ \t\n]|(?=~0)) // attacklab: g_tab_width
+ /g,function(){...});
+ */
+
+ // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
+ text += "~0";
+
+ text = text.replace(/(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
+ function(wholeMatch,m1,m2){
+ var codeblock = m1;
+ var nextChar = m2;
+
+ codeblock = _EncodeCode( _Outdent(codeblock));
+ codeblock = _Detab(codeblock);
+ codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
+ codeblock = codeblock.replace(/\n+$/g,""); // trim trailing whitespace
+
+ codeblock = "
";
+
+ return hashBlock(codeblock) + nextChar;
+ }
+ );
+
+ // attacklab: strip sentinel
+ text = text.replace(/~0/,"");
+
+ return text;
+}
+
+var hashBlock = function(text){
+ text = text.replace(/(^\n+|\n+$)/g,"");
+ return "\n\n~K" + (g_html_blocks.push(text)-1) + "K\n\n";
+}
+
+
+var _DoCodeSpans = function(text){
+//
+// * Backtick quotes are used for " + codeblock + "\n spans.
+//
+// * You can use multiple backticks as the delimiters if you want to
+// include literal backticks in the code span. So, this input:
+//
+// Just type ``foo `bar` baz`` at the prompt.
+//
+// Will translate to:
+//
+// foo `bar` baz at the prompt.`bar` ...
+//
+
+ /*
+ text = text.replace(/
+ (^|[^\\]) // Character before opening ` can't be a backslash
+ (`+) // $2 = Opening run of `
+ ( // $3 = The code block
+ [^\r]*?
+ [^`] // attacklab: work around lack of lookbehind
+ )
+ \2 // Matching closer
+ (?!`)
+ /gm, function(){...});
+ */
+
+ text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
+ function(wholeMatch,m1,m2,m3,m4){
+ var c = m3;
+ c = c.replace(/^([ \t]*)/g,""); // leading whitespace
+ c = c.replace(/[ \t]*$/g,""); // trailing whitespace
+ c = _EncodeCode(c);
+ return m1+""+c+"";
+ });
+
+ return text;
+}
+
+
+var _EncodeCode = function(text){
+//
+// Encode/escape certain characters inside Markdown code runs.
+// The point is that in code, these characters are literals,
+// and lose their special Markdown meanings.
+//
+ // Encode all ampersands; HTML entities are not
+ // entities within a Markdown code span.
+ text = text.replace(/&/g,"&");
+
+ // Do the angle bracket song and dance:
+ text = text.replace(//g,">");
+
+ // Now, escape characters that are magic in Markdown:
+ text = escapeCharacters(text,"\*_{}[]\\",false);
+
+// jj the line above breaks this:
+//---
+
+//* Item
+
+// 1. Subitem
+
+// special char: *
+//---
+
+ return text;
+}
+
+
+var _DoItalicsAndBold = function(text){
+
+ // must go first:
+ text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[*_]*)\1/g,
+ "$2");
+
+ text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g,
+ "$2");
+
+ return text;
+}
+
+
+var _DoBlockQuotes = function(text){
+
+ /*
+ text = text.replace(/
+ ( // Wrap whole match in $1
+ (
+ ^[ \t]*>[ \t]? // '>' at the start of a line
+ .+\n // rest of the first line
+ (.+\n)* // subsequent consecutive lines
+ \n* // blanks
+ )+
+ )
+ /gm, function(){...});
+ */
+
+ text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
+ function(wholeMatch,m1){
+ var bq = m1;
+
+ // attacklab: hack around Konqueror 3.5.4 bug:
+ // "----------bug".replace(/^-/g,"") == "bug"
+
+ bq = bq.replace(/^[ \t]*>[ \t]?/gm,"~0"); // trim one level of quoting
+
+ // attacklab: clean up hack
+ bq = bq.replace(/~0/g,"");
+
+ bq = bq.replace(/^[ \t]+$/gm,""); // trim whitespace-only lines
+ bq = _RunBlockGamut(bq); // recurse
+
+ bq = bq.replace(/(^|\n)/g,"$1 ");
+ // These leading spaces screw with content, so we need to fix that:
+ bq = bq.replace(
+ /(\s*
[^\r]+?<\/pre>)/gm,
+ function(wholeMatch,m1){
+ var pre = m1;
+ // attacklab: hack around Konqueror 3.5.4 bug:
+ pre = pre.replace(/^ /mg,"~0");
+ pre = pre.replace(/~0/g,"");
+ return pre;
+ });
+
+ return hashBlock("\n" + bq + "\n
");
+ });
+ return text;
+}
+
+
+var _FormParagraphs = function(text){
+//
+// Params:
+// $text - string to process with html
+
+
+
+
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/assets/stickyWinHTML/top.gif b/assets/mootools-core/Tests/assets/stickyWinHTML/top.gif
new file mode 100644
index 00000000..815810cf
Binary files /dev/null and b/assets/mootools-core/Tests/assets/stickyWinHTML/top.gif differ
diff --git a/assets/mootools-core/Tests/assets/stickyWinHTML/top.png b/assets/mootools-core/Tests/assets/stickyWinHTML/top.png
new file mode 100644
index 00000000..d90882b2
Binary files /dev/null and b/assets/mootools-core/Tests/assets/stickyWinHTML/top.png differ
diff --git a/assets/mootools-core/Tests/assets/tests.css b/assets/mootools-core/Tests/assets/tests.css
new file mode 100644
index 00000000..56a5cf71
--- /dev/null
+++ b/assets/mootools-core/Tests/assets/tests.css
@@ -0,0 +1,219 @@
+/* -- Clear Fix -- */
+.clearfix:after {content: "."; display: block; height: 0; clear: both; visibility: hidden;}
+.clearfix {display: inline-table;}
+/* Hides from IE-mac \*/
+* html .clearfix {height: 1%;}
+.clearfix {display: block;}
+/* End hide from IE-mac */
+body {
+ font-family: verdana;
+ font-size: 10px;
+ font: 11px/1.5 Lucida Grande, Helvetica, Arial, sans-serif;
+ background: #F3F1F1;
+ color: #41464D;
+}
+dl {
+ position: relative;
+}
+
+#title {
+ width: 100%;
+ padding: 5px 0;
+ background: #aaa;
+ background: #41464D;
+ color: #F3F1F1;
+ height: 30px;
+}
+#title h1 {
+ font: 25px/1.1 Arial, sans-serif;
+ font-weight: bolder;
+ margin: 1px 0 2px 20px;
+ text-shadow: 0 2px 2px rgba(0,0,0,0.4);
+}
+
+#title h1 span {
+ color: #D2E0E6;
+}
+
+#title a {
+ color: #fff;
+ text-decoration: none;
+ font-size: 14px;
+ position: relative;
+ top: -2px;
+}
+
+#testBox {
+ width: 1100px;
+ text-align: left;
+ position: relative;
+}
+#testFrameContainer {
+ float: left;
+ width: 403px;
+ margin-left: 10px;
+}
+#testFrame {
+ border: 1px solid black;
+ width: 400px;
+ height: 450px;
+ margin-top: 5px;
+}
+#script {
+ width: 400px;
+ float: left;
+ height: 600px;
+ overflow: auto;
+ border-bottom: 1px solid #ddd;
+ color: #000;
+ margin-top: 5px;
+ border-left: none;
+}
+#testLoader {
+ width: 200px;
+ float: left;
+}
+#testLoader dl {
+ margin: 4px 12px 0px 0px;
+ height: 577px;
+ overflow: auto;
+ width: 200px;
+}
+#testLoader dl * {
+ width: 170px;
+}
+#testLoader h4 {
+ margin: 4px 0px;
+}
+#testLoader dt {
+ margin: 4px 0px 3px;
+ padding: 2px 2px 2px 4px;
+ cursor: pointer;
+ background: #D2E0E6;
+ color: #528CE0;
+ font-size: 12px;
+ font-weight: bold;
+}
+#testLoader dt:hover {
+ color: #41464D;
+}
+#testLoader dd {
+ margin: 2px 0px 2px 2px;
+ padding: 2px 2px 2px 7px;
+ background: #D0C8C8;
+ color: #8A7575;
+ font-size: 12px;
+ font-weight: bold;
+ cursor: pointer;
+}
+#testLoader dd.selected, #testLoader dt.selected {
+ background-color: #fdfbd0;
+ color: #9b9828;
+}
+#tests .selected {
+ background-color: #fdfbd0 !important;
+}
+#testLoader .exception {
+ color: #B33F3F !important;
+ background: #EE9A9A !important;
+}
+#testLoader .success {
+ background-color: #CFE773 !important;
+ color: #657528 !important;
+}
+#runTest {
+ position: absolute;
+ right: 0px;
+}
+#testTemplate {
+ display: none;
+}
+#tests {
+ width: 370px;
+ padding-left: 10px;
+}
+#tests dt {
+ padding: 2px 8px 4px;
+ border-bottom: 1px solid #d0d0d0;
+ position: relative;
+}
+#tests dt b {
+ cursor: pointer;
+}
+dt button {
+ position: absolute;
+ right: 8px;
+ top: -2px;
+}
+#tests dd {
+ margin: 0px 7px 0px;
+ overflow: hidden;
+}
+textarea {
+ width: 342px;
+ padding: 4px;
+ height: 25px;
+}
+#testFrameContainer textarea {
+ width: 391px;
+ height: 100px;
+}
+div.handle {
+ width: 353px;
+ height: 4px;
+ position: relative;
+ top: -1px;
+ left: -1px;
+ border-top: #fff 1px solid;
+ border-left: #fff 1px solid;
+ border-right: #999 1px solid;
+ border-bottom: #999 1px solid;
+ background: #ccc;
+ cursor: n-resize;
+}
+#testFrameContainer div.handle {
+ width: 402px;
+}
+
+div.handle:hover {
+ background: #fcfcfc;
+}
+#tests div.verify {
+ display: none;
+}
+#tests div.verify a.pass, #tests div.verify a.fail {
+ float: left;
+ display: block;
+ cursor: pointer;
+ padding: 2px 15px;
+ background: url(radio.unchecked.gif) 2px 1px no-repeat;
+}
+#tests div.passed div.verify a.pass, #tests div.failed div.verify a.fail {
+ background: url(radio.checked.gif) 2px 1px no-repeat;
+}
+#tests div.verify p {
+ margin-bottom: 0px;
+}
+#tests div.verify div.actions {
+ padding-left: 10px;
+}
+#tests div.testBlock {
+ border: 1px solid #d0d0d0;
+ background: #f5f5f5;
+ padding: 6px 0px 6px;
+ margin-bottom: 12px;
+}
+#tests div.passed {
+ background: #eafed8
+}
+#tests div.failed {
+ background: #feede7;
+}
+
+body.test_iframe {
+ background: #fff;
+}
+
+body.test_iframe h1 {
+ font-size: 14px;
+}
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/assets/waiter/waiter.gif b/assets/mootools-core/Tests/assets/waiter/waiter.gif
new file mode 100644
index 00000000..53dd589f
Binary files /dev/null and b/assets/mootools-core/Tests/assets/waiter/waiter.gif differ
diff --git a/assets/mootools-core/Tests/config.js b/assets/mootools-core/Tests/config.js
new file mode 100644
index 00000000..bcde0e00
--- /dev/null
+++ b/assets/mootools-core/Tests/config.js
@@ -0,0 +1,14 @@
+UnitTester.site = 'MooTools Core';
+UnitTester.title = 'Unit Tests';
+
+window.addEvent('load', function(){
+ var sources = {
+ mootoolsCore: '../'
+ };
+
+ new UnitTester(sources, {
+ 'mootools-core': 'UserTests/'
+ }, {
+ autoplay: true
+ });
+});
diff --git a/assets/mootools-core/Tests/index.html b/assets/mootools-core/Tests/index.html
new file mode 100644
index 00000000..a4ef7577
--- /dev/null
+++ b/assets/mootools-core/Tests/index.html
@@ -0,0 +1,70 @@
+
+
+
+
+ caption
+
+
+ Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi.
+
+
+
+
+
+
+
+ readme »
+
+
+
+
+
+
+ Load tests:
+
+
+
+
+
+
+ manual code entry:
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/readme.html b/assets/mootools-core/Tests/readme.html
new file mode 100644
index 00000000..9cacd85f
--- /dev/null
+++ b/assets/mootools-core/Tests/readme.html
@@ -0,0 +1,95 @@
+
+
+
+
+
+
+
diff --git a/assets/mootools-core/Tests/readme.md b/assets/mootools-core/Tests/readme.md
new file mode 100644
index 00000000..6d8828f7
--- /dev/null
+++ b/assets/mootools-core/Tests/readme.md
@@ -0,0 +1,169 @@
+The MooTools Unit Test Framework
+================================
+
+### Author & Contact
+
+Aaron Newton (aaron [ at ] iminta <dot> com)
+
+### Download
+
+This framework can be downloaded from Google's svn servers:
+
+[http://code.google.com/p/clientside-test-framework][]
+
+Overview
+--------
+
+### Purpose
+
+MooTools ships with a version of JSSpec ([http://jania.pe.kr/aw/moin.cgi/JSSpec][]) and a series of Specs tests. This test framework is excellent at verifying that code that immediately produces an output is working. It can test, for example, that 2+2 does equal 4.
+
+It is not, however, very good at evaluating any type of code that has a delay between the execution of a code block and the production of a result. This includes Ajax requests, animations and other transitions, or interfaces that require a user to interact with the test (such as Drag).
+
+### The Unit Test Framework
+
+The MooTools Unit Test Framework aims to create an environment where developers can utilize test driven development patterns to develop their code as well as use those tests to regress their changes. Tests are easy to write and easy to verify by non-coders. Users are given a simple task ("Drag the box around") and a question to answer ("Can you drag it around?"). Answering yes marks the test as having passed. Answering no marks it as having failed.
+
+
+### Environment
+
+The test framework itself is written with MooTools 1.2, but it can test any javascript code. It creates a "vanilla" iframe with only three javascript values defined: *dbug*, *$exec*, and *$LoadScript* (more on these in a bit).
+
+When a test is loaded, the dependencies for that test are loaded into the iframe synchronously along with the HTML portion of the test. This allows the developer to do several things:
+
+ * Test the dependency map of their code base. This uses the MooTools scripts.json to map dependencies; more than one scripts.json can be used (so long as the file names are all unique - so only one "Core.js" please).
+ * Test only the code needed to run the test. Rather than including a full build of all their code, they can include on the parts that, in theory, are needed to run the test.
+ * Quickly introduce changes and test again. Developers can edit their source files and run the test again without reloading their browsers.
+
+### Running Tests
+
+The framework comes with a Firebug-like interface (Moobugger) for testing with browsers that are not equipped with with Firebug. Tests produce output into the debugger to show the user that test are loading and are ready. Additionally, tests themselves can send output directly to the debugger for the user to inspect.
+
+### User Entry
+
+The test framework allows for users to run their own code in the iframe via a text area under the test frame. This facilitates debugging the current test environment. The author of individual tests can also choose to expose a portion of or all of an individual test as editable code that the user can alter at test time.
+
+Authoring Tests
+---------------
+
+### tests.json
+
+The test framework loads a menu of available tests based on a file called tests.json found in the UserTests subdirectory. This subdirectory should mirror the Source directory of your repository, though it does not have to have directories for every directory in the Source directory. In other words, if you wish to only test on script in a repository that has several directories (Core, Request, Element, etc) you can only have the one you need (say, Request).
+
+*tests.json* describes the tests that should be loaded.
+
+#### Example
+
+ {
+ "Foo":{
+ "Bar": ['a','b','c']
+ }
+ }
+
+#### File Mapping
+
+The above tests.json would load a menu with a "Foo" section and a test group called "Bar". Clicking on "Bar" would expand to show the tests for "a", "b", and "c". This would specifically test *Source/Foo/Bar.js* and load its dependencies as defined in *Source/scripts.json*.
+
+The actual javascript test file would therefore be located at *UserTests/Foo/Bar.a.js* and the HTML file for the test would be located at *UserTests/Foo/Bar.a.html*.
+
+### Single Tests vs. Break-outs
+
+Tests can be written as a single test file for a given script (as defined in Scripts.json) or as a series of tests. This is accomplished by naming conventions of the test files. If you give a test the name "all" then clicking the test name will not expand to show sub-tests but will instead just load the single test defined.
+
+#### Single Test in tests.json
+
+ {
+ "Foo":{
+ "Bar": ['all']
+ }
+ }
+
+This would load *Source/Foo/Bar.js* and its dependencies just as before, but it would load *UserTests/Foo/Bar.all.js* and *Bar.all.html* instead of expanding a list of sub-tests.
+
+### Test Files
+
+Test files come in pairs: the javascript which is used to load the test and the accompanying HTML (which can be empty if no HTML is required, but must exist).
+
+#### HTML and paths
+
+The HTML can be anything. Note that its source location is that of the iframe's, which is the same path as the test suite. So if your test is at http://foo/tests/ then the iframe's base url is also at that location. You can use relative locations to refer to other files on your system (such as ../../bar.jpg) though it is not recommended as it makes your tests less portable. It is recommended that any assets that accompany your tests be located along side your test files. So if your test needs to reference "x.jpg" that you put it in the same location as the test files and refer to it as *UserTests/Foo/x.jpg*.
+
+
+#### In-line JavaScript and domReady
+HTML parts can contain in-line JavaScript inside of <script> tags. This code will be evaluated *after* your HTML body and dependencies have loaded. Note that this means that you cannot refer to *onload* in your inline code, as the document will already be loaded when your code is evaluated. You should assume that your inline code will be evaluated after the document is ready. *domReady* is fired manually for those dependencies that load that refer to it, but your inline code need not use it.
+
+#### Test Javascript Files
+
+Each test comes with HTML and a JavaScript configuration file. These files look like this:
+
+ {
+ tests: [
+ {
+ title: "Your Test Title",
+ description: "A brief description of this test.",
+ verify: "Verification question to ask the user - did the test work?",
+ before: function(){
+ //code to execute when the user starts the test
+ },
+ body: "//User editable JavaScript run after *before* and before *post*",
+ post: function(){
+ //code to execute immediately after the *before* test above;
+ //if this returns a "falsy" value, the test will fail immediately
+ //before the user does anything else
+ }
+ }
+ ],
+ otherScripts: ["SomeOtherFileToLoad"]
+ }
+
+The *tests* array is an array of objects that contain test configurations. This allows you to pose more than one question to the user for a given test or to put more than one test in a given file.
+
+Each test has the following properties:
+
+ * title - (*string*) the title of the test; this is displayed to the user before they run the test.
+ * description - (*string*) a brief (one sentence is best) description of the test; this is also displayed
+ before the test is run.
+ * verify - (*string*) a question that the user must answer after they run the test. The question must be
+ a yes/no question and answering it *yes* signals that the test succeeded. This is only displayed after
+ the user starts the test.
+ * before - (*function*; optional) this code is run immediately when the test is started. If it throw an error, the
+ test will fail immediately.
+ * body - (*string*; optional) this code is evaluated when the user runs the test after the *before* method if it is defined. This is user-editable so this string is displayed to them for them to change if they like. If this code throws an error the test
+ will fail immediately.
+ * post - (*function*; optional) this code is run immediately after the *body* code is evaluated (if it's defined).
+ If this code throws an error or returns a 'falsy' value the test will fail immediately.
+
+In addition to the tests, the test author can define additional scripts that should be loaded. This will include any missing dependencies for that script as well. This is useful if you're testing something that, say, doesn't require *Selector.js*, but you want to use *Selectors* for your test. This property is an array of script names assigned to the property *otherScripts*.
+
+Configuration
+-------------
+
+The test framework must be configured for each environment in which it runs. All that is required is that the file *config.js* be altered for your environment. This amounts to initializing the *UnitTester* class with any options you choose to specify.
+
+ window.addEvent('load', function(){
+ new UnitTester(scripts, tests);
+ });
+
+### Arguments
+
+1. sources - (*object*) a set of name/value pairs for the locations of scripts.json files for dependency mapping
+2. tests - (*object*) a set of name/value pairs for the locations of tests.json files to load
+
+### Example
+
+ window.addEvent('load', function(){
+ new UnitTester({
+ mootoolsCore: '../svn/Mootools/mootools-core',
+ mootoolsMore: '../svn/Mootools/mootools-more'
+ },{
+ defaultTests: './UserTests/'
+ });
+ });
+
+Local Testing
+-------------
+
+The framework is designed to work from the desktop or from a server, but it definitely works better from a server. Some browsers (FF3 in particular) won't allow you to request local files due to security settings. Safari will allow it and IE will prompt you to allow it. It is possible to work around this in FF3, but it's better to serve the tests from a server when possible.
+
+[http://jania.pe.kr/aw/moin.cgi/JSSpec]: http://jania.pe.kr/aw/moin.cgi/JSSpec
+[http://code.google.com/p/clientside-test-framework]: http://code.google.com/p/clientside-test-framework
\ No newline at end of file
diff --git a/assets/mootools-core/Tests/test_frame.html b/assets/mootools-core/Tests/test_frame.html
new file mode 100644
index 00000000..167474b4
--- /dev/null
+++ b/assets/mootools-core/Tests/test_frame.html
@@ -0,0 +1,43 @@
+
+
+
+
+
+
+
+
+ run tests »
+
+ MooTools Unit Test Framework Documentation
+
+
+
+
+
+