Ticket #330: trac-diff-display-switcher-r4282-for-0.10.3.patch

a/htdocs/css/diff.css

@@ -69 +69 @@
- margin: 0 auto;
- padding: .1em 0 .25em .5em;
-}
+.diff h2 .switch { color: #999; float: right; font-size: 75%;
+  line-height: 1.6;
+}
+.diff h2 .switch span { border-left: 1px solid #ccc; cursor: pointer;
+  padding: 0 1em;
+}
+.diff h2 .switch span:first-child { border: none; }
+.diff h2 .switch span.active { color: #333; cursor: default; }
-
-/* Styles for the actual diff tables (side-by-side and inline) */
-.diff table {
@@ -161 +169 @@
-.diff table.sidebyside tbody.mod del, .diff table.sidebyside tbody.mod ins {
- background: #fc0; 
-}
+
+/* Styles for the plain-text diff view */
+.diff pre { background: #fff; border: 1px solid #ddd; font-size: 85%;
+  margin: 0;
+}

/dev/null

@@ +1 @@
+function escapeHTML(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function convertDiff(name, table) {
+  var ths = table.tHead.rows[0].cells;
+  var lines = [
+    "Index: " + name,
+    "===================================================================",
+    "--- " + ths[0].title.substr(5),
+    "+++ " + ths[1].title.substr(5),
+  ];
+  var sepIndex = 0;
+  var oldOffset = 0, oldLength = 0, newOffset = 0, newLength = 0;
+
+  for (var i = 0; i < table.tBodies.length; i++) {
+    var tBody = table.tBodies[i];
+    if (i == 0 || tBody.className == "skipped") {
+      if (i > 0) {
+        if (!oldOffset && oldLength) oldOffset = 1
+        if (!newOffset && newLength) newOffset = 1
+        lines[sepIndex] = lines[sepIndex]
+          .replace("{1}", oldOffset).replace("{2}", oldLength)
+          .replace("{3}", newOffset).replace("{4}", newLength);
+      }
+      sepIndex = lines.length;
+      lines.push("@@ -{1},{2}, +{3},{4} @@");
+      oldOffset = 0, oldLength = 0, newOffset = 0, newLength = 0;
+      if (tBody.className == "skipped") continue;
+    }
+    for (var j = 0; j < tBody.rows.length; j++) {
+      var cells = tBody.rows[j].cells;
+      var oldLineNo = parseInt($(cells[0]).text());
+      var newLineNo = parseInt($(cells[1]).text());
+      var line = $(cells[2]).text();
+      if (isNaN(oldLineNo)) {
+        lines.push("+ " + escapeHTML(line));
+        newLength += 1;
+      } else if (isNaN(newLineNo)) {
+        lines.push("- " + escapeHTML(line));
+        oldLength += 1;
+      } else {
+        lines.push("  " + escapeHTML(line));
+        oldLength += 1;
+        newLength += 1;
+        if (!oldOffset) oldOffset = oldLineNo;
+        if (!newOffset) newOffset = newLineNo;
+      }
+    }
+  }
+
+  if (!oldOffset && oldLength) oldOffset = 1
+  if (!newOffset && newLength) newOffset = 1
+  lines[sepIndex] = lines[sepIndex]
+    .replace("{1}", oldOffset).replace("{2}", oldLength)
+    .replace("{3}", newOffset).replace("{4}", newLength);
+
+  return lines.join("<br />");
+}
+
+$(document).ready(function() {
+  $("div.diff h2").each(function() {
+    var switcher = $("<span class='switch'></span>").prependTo(this);
+    var name = $.trim($(this).text());
+    var table = $(this).next().get(0);
+    var pre = $("<pre></pre>").hide().insertAfter(table);
+    $("<span>Tabular</span>").click(function() {
+      $(pre).hide();
+      $(table).show();
+      $(this).addClass("active").siblings("span").removeClass("active");
+      return false;
+    }).addClass("active").appendTo(switcher);
+    $("<span>Unified</span>").click(function() {
+      $(table).hide();
+      if (!pre.get(0).firstChild) pre.html(convertDiff(name, table));
+      $(pre).fadeIn("fast")
+      $(this).addClass("active").siblings("span").removeClass("active");
+      return false;
+    }).appendTo(switcher);
+  });
+});

/dev/null

@@ +1 @@
+/* prevent execution of jQuery if included more then once */
+if(typeof window.jQuery == "undefined") {
+/*
+ * jQuery 1.0.4 - New Wave Javascript
+ *
+ * Copyright (c) 2006 John Resig (jquery.com)
+ * Dual licensed under the MIT (MIT-LICENSE.txt)
+ * and GPL (GPL-LICENSE.txt) licenses.
+ *
+ * $Date: 2006-12-12 15:33:10 -0500 (Tue, 12 Dec 2006) $
+ * $Rev: 696 $
+ */
+
+// Global undefined variable
+window.undefined = window.undefined;
+
+var jQuery = function(a,c) {
+
+        // Shortcut for document ready
+        if ( a && typeof a == "function" && jQuery.fn.ready && !a.nodeType && a[0] == undefined ) // Safari reports typeof on DOM NodeLists as a function
+                return jQuery(document).ready(a);
+
+        // Make sure that a selection was provided
+        a = a || document;
+
+        // Watch for when a jQuery object is passed as the selector
+        if ( a.jquery )
+                return jQuery( jQuery.merge( a, [] ) );
+
+        // Watch for when a jQuery object is passed at the context
+        if ( c && c.jquery )
+                return jQuery( c ).find(a);
+
+        // If the context is global, return a new object
+        if ( window == this )
+                return new jQuery(a,c);
+
+        // Handle HTML strings
+        if ( typeof a  == "string" ) {
+                var m = /^[^<]*(<.+>)[^>]*$/.exec(a);
+                if ( m ) a = jQuery.clean( [ m[1] ] );
+        }
+
+        // Watch for when an array is passed in
+        this.set( a.constructor == Array || a.length && a != window && !a.nodeType && a[0] != undefined && a[0].nodeType ?
+                // Assume that it is an array of DOM Elements
+                jQuery.merge( a, [] ) :
+
+                // Find the matching elements and save them for later
+                jQuery.find( a, c ) );
+
+        // See if an extra function was provided
+        var fn = arguments[ arguments.length - 1 ];
+
+        // If so, execute it in context
+        if ( fn && typeof fn == "function" )
+                this.each(fn);
+
+        return this;
+};
+
+// Map over the $ in case of overwrite
+if ( typeof $ != "undefined" )
+        jQuery._$ = $;
+        
+// Map the jQuery namespace to the '$' one
+var $ = jQuery;
+
+
+
+jQuery.fn = jQuery.prototype = {
+
+        jquery: "1.0.4",
+
+
+        size: function() {
+                return this.length;
+        },
+
+
+        get: function( num ) {
+                return num == undefined ?
+
+                        // Return a 'clean' array
+                        jQuery.merge( this, [] ) :
+
+                        // Return just the object
+                        this[num];
+        },
+
+        set: function( array ) {
+                // Use a tricky hack to make the jQuery object
+                // look and feel like an array
+                this.length = 0;
+                [].push.apply( this, array );
+                return this;
+        },
+
+        each: function( fn, args ) {
+                return jQuery.each( this, fn, args );
+        },
+
+        index: function( obj ) {
+                var pos = -1;
+                this.each(function(i){
+                        if ( this == obj ) pos = i;
+                });
+                return pos;
+        },
+
+
+        attr: function( key, value, type ) {
+                // Check to see if we're setting style values
+                return key.constructor != String || value != undefined ?
+                        this.each(function(){
+                                // See if we're setting a hash of styles
+                                if ( value == undefined )
+                                        // Set all the styles
+                                        for ( var prop in key )
+                                                jQuery.attr(
+                                                        type ? this.style : this,
+                                                        prop, key[prop]
+                                                );
+
+                                // See if we're setting a single key/value style
+                                else
+                                        jQuery.attr(
+                                                type ? this.style : this,
+                                                key, value
+                                        );
+                        }) :
+
+                        // Look for the case where we're accessing a style value
+                        jQuery[ type || "attr" ]( this[0], key );
+        },
+
+
+        css: function( key, value ) {
+                return this.attr( key, value, "curCSS" );
+        },
+
+        text: function(e) {
+                e = e || this;
+                var t = "";
+                for ( var j = 0; j < e.length; j++ ) {
+                        var r = e[j].childNodes;
+                        for ( var i = 0; i < r.length; i++ )
+                                if ( r[i].nodeType != 8 )
+                                        t += r[i].nodeType != 1 ?
+                                                r[i].nodeValue : jQuery.fn.text([ r[i] ]);
+                }
+                return t;
+        },
+
+
+        wrap: function() {
+                // The elements to wrap the target around
+                var a = jQuery.clean(arguments);
+
+                // Wrap each of the matched elements individually
+                return this.each(function(){
+                        // Clone the structure that we're using to wrap
+                        var b = a[0].cloneNode(true);
+
+                        // Insert it before the element to be wrapped
+                        this.parentNode.insertBefore( b, this );
+
+                        // Find the deepest point in the wrap structure
+                        while ( b.firstChild )
+                                b = b.firstChild;
+
+                        // Move the matched element to within the wrap structure
+                        b.appendChild( this );
+                });
+        },
+
+
+        append: function() {
+                return this.domManip(arguments, true, 1, function(a){
+                        this.appendChild( a );
+                });
+        },
+
+
+        prepend: function() {
+                return this.domManip(arguments, true, -1, function(a){
+                        this.insertBefore( a, this.firstChild );
+                });
+        },
+
+
+        before: function() {
+                return this.domManip(arguments, false, 1, function(a){
+                        this.parentNode.insertBefore( a, this );
+                });
+        },
+
+
+        after: function() {
+                return this.domManip(arguments, false, -1, function(a){
+                        this.parentNode.insertBefore( a, this.nextSibling );
+                });
+        },
+
+        end: function() {
+                if( !(this.stack && this.stack.length) )
+                        return this;
+                return this.set( this.stack.pop() );
+        },
+
+        find: function(t) {
+                return this.pushStack( jQuery.map( this, function(a){
+                        return jQuery.find(t,a);
+                }), arguments );
+        },
+
+        clone: function(deep) {
+                return this.pushStack( jQuery.map( this, function(a){
+                        return a.cloneNode( deep != undefined ? deep : true );
+                }), arguments );
+        },
+
+
+        filter: function(t) {
+                return this.pushStack(
+                        t.constructor == Array &&
+                        jQuery.map(this,function(a){
+                                for ( var i = 0; i < t.length; i++ )
+                                        if ( jQuery.filter(t[i],[a]).r.length )
+                                                return a;
+                                return null;
+                        }) ||
+
+                        t.constructor == Boolean &&
+                        ( t ? this.get() : [] ) ||
+
+                        typeof t == "function" &&
+                        jQuery.grep( this, t ) ||
+
+                        jQuery.filter(t,this).r, arguments );
+        },
+
+
+        not: function(t) {
+                return this.pushStack( typeof t == "string" ?
+                        jQuery.filter(t,this,false).r :
+                        jQuery.grep(this,function(a){ return a != t; }), arguments );
+        },
+
+
+        add: function(t) {
+                return this.pushStack( jQuery.merge( this, typeof t == "string" ?
+                        jQuery.find(t) : t.constructor == Array ? t : [t] ), arguments );
+        },
+
+        is: function(expr) {
+                return expr ? jQuery.filter(expr,this).r.length > 0 : false;
+        },
+
+        domManip: function(args, table, dir, fn){
+                var clone = this.size() > 1;
+                var a = jQuery.clean(args);
+
+                return this.each(function(){
+                        var obj = this;
+
+                        if ( table && this.nodeName.toUpperCase() == "TABLE" && a[0].nodeName.toUpperCase() != "THEAD" ) {
+                                var tbody = this.getElementsByTagName("tbody");
+
+                                if ( !tbody.length ) {
+                                        obj = document.createElement("tbody");
+                                        this.appendChild( obj );
+                                } else
+                                        obj = tbody[0];
+                        }
+
+                        for ( var i = ( dir < 0 ? a.length - 1 : 0 );
+                                i != ( dir < 0 ? dir : a.length ); i += dir ) {
+                                        fn.apply( obj, [ clone ? a[i].cloneNode(true) : a[i] ] );
+                        }
+                });
+        },
+
+        pushStack: function(a,args) {
+                var fn = args && args[args.length-1];
+                var fn2 = args && args[args.length-2];
+                
+                if ( fn && fn.constructor != Function ) fn = null;
+                if ( fn2 && fn2.constructor != Function ) fn2 = null;
+
+                if ( !fn ) {
+                        if ( !this.stack ) this.stack = [];
+                        this.stack.push( this.get() );
+                        this.set( a );
+                } else {
+                        var old = this.get();
+                        this.set( a );
+
+                        if ( fn2 && a.length || !fn2 )
+                                this.each( fn2 || fn ).set( old );
+                        else
+                                this.set( old ).each( fn );
+                }
+
+                return this;
+        }
+};
+
+
+jQuery.extend = jQuery.fn.extend = function() {
+        // copy reference to target object
+        var target = arguments[0],
+                a = 1;
+
+        // extend jQuery itself if only one argument is passed
+        if ( arguments.length == 1 ) {
+                target = this;
+                a = 0;
+        }
+        var prop;
+        while (prop = arguments[a++])
+                // Extend the base object
+                for ( var i in prop ) target[i] = prop[i];
+
+        // Return the modified object
+        return target;
+};
+
+jQuery.extend({
+
+        init: function(){
+                jQuery.initDone = true;
+
+                jQuery.each( jQuery.macros.axis, function(i,n){
+                        jQuery.fn[ i ] = function(a) {
+                                var ret = jQuery.map(this,n);
+                                if ( a && typeof a == "string" )
+                                        ret = jQuery.filter(a,ret).r;
+                                return this.pushStack( ret, arguments );
+                        };
+                });
+
+                jQuery.each( jQuery.macros.to, function(i,n){
+                        jQuery.fn[ i ] = function(){
+                                var a = arguments;
+                                return this.each(function(){
+                                        for ( var j = 0; j < a.length; j++ )
+                                                jQuery(a[j])[n]( this );
+                                });
+                        };
+                });
+
+                jQuery.each( jQuery.macros.each, function(i,n){
+                        jQuery.fn[ i ] = function() {
+                                return this.each( n, arguments );
+                        };
+                });
+
+                jQuery.each( jQuery.macros.filter, function(i,n){
+                        jQuery.fn[ n ] = function(num,fn) {
+                                return this.filter( ":" + n + "(" + num + ")", fn );
+                        };
+                });
+
+                jQuery.each( jQuery.macros.attr, function(i,n){
+                        n = n || i;
+                        jQuery.fn[ i ] = function(h) {
+                                return h == undefined ?
+                                        this.length ? this[0][n] : null :
+                                        this.attr( n, h );
+                        };
+                });
+
+                jQuery.each( jQuery.macros.css, function(i,n){
+                        jQuery.fn[ n ] = function(h) {
+                                return h == undefined ?
+                                        ( this.length ? jQuery.css( this[0], n ) : null ) :
+                                        this.css( n, h );
+                        };
+                });
+
+        },
+
+        // args is for internal usage only
+        each: function( obj, fn, args ) {
+                if ( obj.length == undefined )
+                        for ( var i in obj )
+                                fn.apply( obj[i], args || [i, obj[i]] );
+                else
+                        for ( var i = 0; i < obj.length; i++ )
+                                if ( fn.apply( obj[i], args || [i, obj[i]] ) === false ) break;
+                return obj;
+        },
+
+        className: {
+                add: function(o,c){
+                        if (jQuery.className.has(o,c)) return;
+                        o.className += ( o.className ? " " : "" ) + c;
+                },
+                remove: function(o,c){
+                        if( !c ) {
+                                o.className = "";
+                        } else {
+                                var classes = o.className.split(" ");
+                                for(var i=0; i<classes.length; i++) {
+                                        if(classes[i] == c) {
+                                                classes.splice(i, 1);
+                                                break;
+                                        }
+                                }
+                                o.className = classes.join(' ');
+                        }
+                },
+                has: function(e,a) {
+                        if ( e.className != undefined )
+                                e = e.className;
+                        return new RegExp("(^|\\s)" + a + "(\\s|$)").test(e);
+                }
+        },
+
+        swap: function(e,o,f) {
+                for ( var i in o ) {
+                        e.style["old"+i] = e.style[i];
+                        e.style[i] = o[i];
+                }
+                f.apply( e, [] );
+                for ( var i in o )
+                        e.style[i] = e.style["old"+i];
+        },
+
+        css: function(e,p) {
+                if ( p == "height" || p == "width" ) {
+                        var old = {}, oHeight, oWidth, d = ["Top","Bottom","Right","Left"];
+
+                        for ( var i=0; i<d.length; i++ ) {
+                                old["padding" + d[i]] = 0;
+                                old["border" + d[i] + "Width"] = 0;
+                        }
+
+                        jQuery.swap( e, old, function() {
+                                if (jQuery.css(e,"display") != "none") {
+                                        oHeight = e.offsetHeight;
+                                        oWidth = e.offsetWidth;
+                                } else {
+                                        e = jQuery(e.cloneNode(true))
+                                                .find(":radio").removeAttr("checked").end()
+                                                .css({
+                                                        visibility: "hidden", position: "absolute", display: "block", right: "0", left: "0"
+                                                }).appendTo(e.parentNode)[0];
+
+                                        var parPos = jQuery.css(e.parentNode,"position");
+                                        if ( parPos == "" || parPos == "static" )
+                                                e.parentNode.style.position = "relative";
+
+                                        oHeight = e.clientHeight;
+                                        oWidth = e.clientWidth;
+
+                                        if ( parPos == "" || parPos == "static" )
+                                                e.parentNode.style.position = "static";
+
+                                        e.parentNode.removeChild(e);
+                                }
+                        });
+
+                        return p == "height" ? oHeight : oWidth;
+                }
+
+                return jQuery.curCSS( e, p );
+        },
+
+        curCSS: function(elem, prop, force) {
+                var ret;
+                
+                if (prop == 'opacity' && jQuery.browser.msie)
+                        return jQuery.attr(elem.style, 'opacity');
+                        
+                if (prop == "float" || prop == "cssFloat")
+                    prop = jQuery.browser.msie ? "styleFloat" : "cssFloat";
+
+                if (!force && elem.style[prop]) {
+
+                        ret = elem.style[prop];
+
+                } else if (document.defaultView && document.defaultView.getComputedStyle) {
+
+                        if (prop == "cssFloat" || prop == "styleFloat")
+                                prop = "float";
+
+                        prop = prop.replace(/([A-Z])/g,"-$1").toLowerCase();
+                        var cur = document.defaultView.getComputedStyle(elem, null);
+
+                        if ( cur )
+                                ret = cur.getPropertyValue(prop);
+                        else if ( prop == 'display' )
+                                ret = 'none';
+                        else
+                                jQuery.swap(elem, { display: 'block' }, function() {
+                                    var c = document.defaultView.getComputedStyle(this, '');
+                                    ret = c && c.getPropertyValue(prop) || '';
+                                });
+
+                } else if (elem.currentStyle) {
+
+                        var newProp = prop.replace(/\-(\w)/g,function(m,c){return c.toUpperCase();});
+                        ret = elem.currentStyle[prop] || elem.currentStyle[newProp];
+                        
+                }
+
+                return ret;
+        },
+        
+        clean: function(a) {
+                var r = [];
+                for ( var i = 0; i < a.length; i++ ) {
+                        var arg = a[i];
+                        if ( typeof arg == "string" ) { // Convert html string into DOM nodes
+                                // Trim whitespace, otherwise indexOf won't work as expected
+                                var s = jQuery.trim(arg), div = document.createElement("div"), wrap = [0,"",""];
+
+                                if ( !s.indexOf("<opt") ) // option or optgroup
+                                        wrap = [1, "<select>", "</select>"];
+                                else if ( !s.indexOf("<thead") || !s.indexOf("<tbody") )
+                                        wrap = [1, "<table>", "</table>"];
+                                else if ( !s.indexOf("<tr") )
+                                        wrap = [2, "<table>", "</table>"];      // tbody auto-inserted
+                                else if ( !s.indexOf("<td") || !s.indexOf("<th") )
+                                        wrap = [3, "<table><tbody><tr>", "</tr></tbody></table>"];
+
+                                // Go to html and back, then peel off extra wrappers
+                                div.innerHTML = wrap[1] + s + wrap[2];
+                                while ( wrap[0]-- ) div = div.firstChild;
+                                arg = div.childNodes;
+                        } 
+                        
+                        
+                        if ( arg.length != undefined && ( (jQuery.browser.safari && typeof arg == 'function') || !arg.nodeType ) ) // Safari reports typeof on a DOM NodeList to be a function
+                                for ( var n = 0; n < arg.length; n++ ) // Handles Array, jQuery, DOM NodeList collections
+                                        r.push(arg[n]);
+                        else
+                                r.push( arg.nodeType ? arg : document.createTextNode(arg.toString()) );
+                }
+
+                return r;
+        },
+
+        expr: {
+                "": "m[2]== '*'||a.nodeName.toUpperCase()==m[2].toUpperCase()",
+                "#": "a.getAttribute('id')&&a.getAttribute('id')==m[2]",
+                ":": {
+                        // Position Checks
+                        lt: "i<m[3]-0",
+                        gt: "i>m[3]-0",
+                        nth: "m[3]-0==i",
+                        eq: "m[3]-0==i",
+                        first: "i==0",
+                        last: "i==r.length-1",
+                        even: "i%2==0",
+                        odd: "i%2",
+
+                        // Child Checks
+                        "nth-child": "jQuery.sibling(a,m[3]).cur",
+                        "first-child": "jQuery.sibling(a,0).cur",
+                        "last-child": "jQuery.sibling(a,0).last",
+                        "only-child": "jQuery.sibling(a).length==1",
+
+                        // Parent Checks
+                        parent: "a.childNodes.length",
+                        empty: "!a.childNodes.length",
+
+                        // Text Check
+                        contains: "jQuery.fn.text.apply([a]).indexOf(m[3])>=0",
+
+                        // Visibility
+                        visible: "a.type!='hidden'&&jQuery.css(a,'display')!='none'&&jQuery.css(a,'visibility')!='hidden'",
+                        hidden: "a.type=='hidden'||jQuery.css(a,'display')=='none'||jQuery.css(a,'visibility')=='hidden'",
+
+                        // Form attributes
+                        enabled: "!a.disabled",
+                        disabled: "a.disabled",
+                        checked: "a.checked",
+                        selected: "a.selected || jQuery.attr(a, 'selected')",
+
+                        // Form elements
+                        text: "a.type=='text'",
+                        radio: "a.type=='radio'",
+                        checkbox: "a.type=='checkbox'",
+                        file: "a.type=='file'",
+                        password: "a.type=='password'",
+                        submit: "a.type=='submit'",
+                        image: "a.type=='image'",
+                        reset: "a.type=='reset'",
+                        button: "a.type=='button'",
+                        input: "/input|select|textarea|button/i.test(a.nodeName)"
+                },
+                ".": "jQuery.className.has(a,m[2])",
+                "@": {
+                        "=": "z==m[4]",
+                        "!=": "z!=m[4]",
+                        "^=": "z && !z.indexOf(m[4])",
+                        "$=": "z && z.substr(z.length - m[4].length,m[4].length)==m[4]",
+                        "*=": "z && z.indexOf(m[4])>=0",
+                        "": "z"
+                },
+                "[": "jQuery.find(m[2],a).length"
+        },
+
+        token: [
+                "\\.\\.|/\\.\\.", "a.parentNode",
+                ">|/", "jQuery.sibling(a.firstChild)",
+                "\\+", "jQuery.sibling(a).next",
+                "~", function(a){
+                        var s = jQuery.sibling(a);
+                        return s.n >= 0 ? s.slice(s.n+1) : [];
+                }
+        ],
+
+        find: function( t, context ) {
+                // Make sure that the context is a DOM Element
+                if ( context && context.nodeType == undefined )
+                        context = null;
+
+                // Set the correct context (if none is provided)
+                context = context || document;
+
+                if ( t.constructor != String ) return [t];
+
+                if ( !t.indexOf("//") ) {
+                        context = context.documentElement;
+                        t = t.substr(2,t.length);
+                } else if ( !t.indexOf("/") ) {
+                        context = context.documentElement;
+                        t = t.substr(1,t.length);
+                        // FIX Assume the root element is right :(
+                        if ( t.indexOf("/") >= 1 )
+                                t = t.substr(t.indexOf("/"),t.length);
+                }
+
+                var ret = [context];
+                var done = [];
+                var last = null;
+
+                while ( t.length > 0 && last != t ) {
+                        var r = [];
+                        last = t;
+
+                        t = jQuery.trim(t).replace( /^\/\//i, "" );
+
+                        var foundToken = false;
+
+                        for ( var i = 0; i < jQuery.token.length; i += 2 ) {
+                                if ( foundToken ) continue;
+
+                                var re = new RegExp("^(" + jQuery.token[i] + ")");
+                                var m = re.exec(t);
+
+                                if ( m ) {
+                                        r = ret = jQuery.map( ret, jQuery.token[i+1] );
+                                        t = jQuery.trim( t.replace( re, "" ) );
+                                        foundToken = true;
+                                }
+                        }
+
+                        if ( !foundToken ) {
+                                if ( !t.indexOf(",") || !t.indexOf("|") ) {
+                                        if ( ret[0] == context ) ret.shift();
+                                        done = jQuery.merge( done, ret );
+                                        r = ret = [context];
+                                        t = " " + t.substr(1,t.length);
+                                } else {
+                                        var re2 = /^([#.]?)([a-z0-9\\*_-]*)/i;
+                                        var m = re2.exec(t);
+
+                                        if ( m[1] == "#" ) {
+                                                // Ummm, should make this work in all XML docs
+                                                var oid = document.getElementById(m[2]);
+                                                r = ret = oid ? [oid] : [];
+                                                t = t.replace( re2, "" );
+                                        } else {
+                                                if ( !m[2] || m[1] == "." ) m[2] = "*";
+
+                                                for ( var i = 0; i < ret.length; i++ )
+                                                        r = jQuery.merge( r,
+                                                                m[2] == "*" ?
+                                                                        jQuery.getAll(ret[i]) :
+                                                                        ret[i].getElementsByTagName(m[2])
+                                                        );
+                                        }
+                                }
+
+                        }
+
+                        if ( t ) {
+                                var val = jQuery.filter(t,r);
+                                ret = r = val.r;
+                                t = jQuery.trim(val.t);
+                        }
+                }
+
+                if ( ret && ret[0] == context ) ret.shift();
+                done = jQuery.merge( done, ret );
+
+                return done;
+        },
+
+        getAll: function(o,r) {
+                r = r || [];
+                var s = o.childNodes;
+                for ( var i = 0; i < s.length; i++ )
+                        if ( s[i].nodeType == 1 ) {
+                                r.push( s[i] );
+                                jQuery.getAll( s[i], r );
+  &nb