chrome/test/data/dromaeo/lib/yui-selector.js

   1 /*
   2 Copyright (c) 2008, Yahoo! Inc. All rights reserved.
   3 Code licensed under the BSD License:
   4 http://developer.yahoo.net/yui/license.txt
   5 version: 2.6.0
   6 */
   7 /**
   8  * The selector module provides helper methods allowing CSS3 Selectors to be used with DOM elements.
   9  * @module selector
  10  * @title Selector Utility
  11  * @namespace YAHOO.util
  12  * @requires yahoo, dom
  13  */
  14
  15 (function() {
  16 /**
  17  * Provides helper methods for collecting and filtering DOM elements.
  18  * @namespace YAHOO.util
  19  * @class Selector
  20  * @static
  21  */
  22 var Selector = function() {};
  23
  24 var Y = YAHOO.util;
  25
  26 var reNth = /^(?:([-]?\d*)(n){1}|(odd|even)$)*([-+]?\d*)$/;
  27
  28 Selector.prototype = {
  29     /**
  30      * Default document for use queries
  31      * @property document
  32      * @type object
  33      * @default window.document
  34      */
  35     document: window.document,
  36     /**
  37      * Mapping of attributes to aliases, normally to work around HTMLAttributes
  38      * that conflict with JS reserved words.
  39      * @property attrAliases
  40      * @type object
  41      */
  42     attrAliases: {
  43     },
  44
  45     /**
  46      * Mapping of shorthand tokens to corresponding attribute selector
  47      * @property shorthand
  48      * @type object
  49      */
  50     shorthand: {
  51         //'(?:(?:[^\\)\\]\\s*>+~,]+)(?:-?[_a-z]+[-\\w]))+#(-?[_a-z]+[-\\w]*)': '[id=$1]',
  52         '\\#(-?[_a-z]+[-\\w]*)': '[id=$1]',
  53         '\\.(-?[_a-z]+[-\\w]*)': '[class~=$1]'
  54     },
  55
  56     /**
  57      * List of operators and corresponding boolean functions.
  58      * These functions are passed the attribute and the current node's value of the attribute.
  59      * @property operators
  60      * @type object
  61      */
  62     operators: {
  63         '=': function(attr, val) { return attr === val; }, // Equality
  64         '!=': function(attr, val) { return attr !== val; }, // Inequality
  65         '~=': function(attr, val) { // Match one of space seperated words
  66             var s = ' ';
  67             return (s + attr + s).indexOf((s + val + s)) > -1;
  68         },
  69         '|=': function(attr, val) { return getRegExp('^' + val + '[-]?').test(attr); }, // Match start with value followed by optional hyphen
  70         '^=': function(attr, val) { return attr.indexOf(val) === 0; }, // Match starts with value
  71         '$=': function(attr, val) { return attr.lastIndexOf(val) === attr.length - val.length; }, // Match ends with value
  72         '*=': function(attr, val) { return attr.indexOf(val) > -1; }, // Match contains value as substring
  73         '': function(attr, val) { return attr; } // Just test for existence of attribute
  74     },
  75
  76     /**
  77      * List of pseudo-classes and corresponding boolean functions.
  78      * These functions are called with the current node, and any value that was parsed with the pseudo regex.
  79      * @property pseudos
  80      * @type object
  81      */
  82     pseudos: {
  83         'root': function(node) {
  84             return node === node.ownerDocument.documentElement;
  85         },
  86
  87         'nth-child': function(node, val) {
  88             return getNth(node, val);
  89         },
  90
  91         'nth-last-child': function(node, val) {
  92             return getNth(node, val, null, true);
  93         },
  94
  95         'nth-of-type': function(node, val) {
  96             return getNth(node, val, node.tagName);
  97         },
  98
  99         'nth-last-of-type': function(node, val) {
 100             return getNth(node, val, node.tagName, true);
 101         },
 102
 103         'first-child': function(node) {
 104             return getChildren(node.parentNode)[0] === node;
 105         },
 106
 107         'last-child': function(node) {
 108             var children = getChildren(node.parentNode);
 109             return children[children.length - 1] === node;
 110         },
 111
 112         'first-of-type': function(node, val) {
 113             return getChildren(node.parentNode, node.tagName.toLowerCase())[0];
 114         },
 115
 116         'last-of-type': function(node, val) {
 117             var children = getChildren(node.parentNode, node.tagName.toLowerCase());
 118             return children[children.length - 1];
 119         },
 120
 121         'only-child': function(node) {
 122             var children = getChildren(node.parentNode);
 123             return children.length === 1 && children[0] === node;
 124         },
 125
 126         'only-of-type': function(node) {
 127             return getChildren(node.parentNode, node.tagName.toLowerCase()).length === 1;
 128         },
 129
 130         'empty': function(node) {
 131             return node.childNodes.length === 0;
 132         },
 133
 134         'not': function(node, simple) {
 135             return !Selector.test(node, simple);
 136         },
 137
 138         'contains': function(node, str) {
 139             var text = node.innerText || node.textContent || '';
 140             return text.indexOf(str) > -1;
 141         },
 142         'checked': function(node) {
 143             return node.checked === true;
 144         }
 145     },
 146
 147     /**
 148      * Test if the supplied node matches the supplied selector.
 149      * @method test
 150      *
 151      * @param {HTMLElement | String} node An id or node reference to the HTMLElement being tested.
 152      * @param {string} selector The CSS Selector to test the node against.
 153      * @return{boolean} Whether or not the node matches the selector.
 154      * @static
 155
 156      */
 157     test: function(node, selector) {
 158         node = Selector.document.getElementById(node) || node;
 159
 160         if (!node) {
 161             return false;
 162         }
 163
 164         var groups = selector ? selector.split(',') : [];
 165         if (groups.length) {
 166             for (var i = 0, len = groups.length; i < len; ++i) {
 167                 if ( rTestNode(node, groups[i]) ) { // passes if ANY group matches
 168                     return true;
 169                 }
 170             }
 171             return false;
 172         }
 173         return rTestNode(node, selector);
 174     },
 175
 176     /**
 177      * Filters a set of nodes based on a given CSS selector.
 178      * @method filter
 179      *
 180      * @param {array} nodes A set of nodes/ids to filter.
 181      * @param {string} selector The selector used to test each node.
 182      * @return{array} An array of nodes from the supplied array that match the given selector.
 183      * @static
 184      */
 185     filter: function(nodes, selector) {
 186         nodes = nodes || [];
 187
 188         var node,
 189             result = [],
 190             tokens = tokenize(selector);
 191
 192         if (!nodes.item) { // if not HTMLCollection, handle arrays of ids and/or nodes
 193             for (var i = 0, len = nodes.length; i < len; ++i) {
 194                 if (!nodes[i].tagName) { // tagName limits to HTMLElements
 195                     node = Selector.document.getElementById(nodes[i]);
 196                     if (node) { // skip IDs that return null
 197                         nodes[i] = node;
 198                     } else {
 199                     }
 200                 }
 201             }
 202         }
 203         result = rFilter(nodes, tokenize(selector)[0]);
 204         clearParentCache();
 205         return result;
 206     },
 207
 208     /**
 209      * Retrieves a set of nodes based on a given CSS selector.
 210      * @method query
 211      *
 212      * @param {string} selector The CSS Selector to test the node against.
 213      * @param {HTMLElement | String} root optional An id or HTMLElement to start the query from. Defaults to Selector.document.
 214      * @param {Boolean} firstOnly optional Whether or not to return only the first match.
 215      * @return {Array} An array of nodes that match the given selector.
 216      * @static
 217      */
 218     query: function(selector, root, firstOnly) {
 219         var result = query(selector, root, firstOnly);
 220         return result;
 221     }
 222 };
 223
 224 var query = function(selector, root, firstOnly, deDupe) {
 225     var result =  (firstOnly) ? null : [];
 226     if (!selector) {
 227         return result;
 228     }
 229
 230     var groups = selector.split(','); // TODO: handle comma in attribute/pseudo
 231
 232     if (groups.length > 1) {
 233         var found;
 234         for (var i = 0, len = groups.length; i < len; ++i) {
 235             found = arguments.callee(groups[i], root, firstOnly, true);
 236             result = firstOnly ? found : result.concat(found);
 237         }
 238         clearFoundCache();
 239         return result;
 240     }
 241
 242     if (root && !root.nodeName) { // assume ID
 243         root = Selector.document.getElementById(root);
 244         if (!root) {
 245             return result;
 246         }
 247     }
 248
 249     root = root || Selector.document;
 250     var tokens = tokenize(selector);
 251     var idToken = tokens[getIdTokenIndex(tokens)],
 252         nodes = [],
 253         node,
 254         id,
 255         token = tokens.pop() || {};
 256
 257     if (idToken) {
 258         id = getId(idToken.attributes);
 259     }
 260
 261     // use id shortcut when possible
 262     if (id) {
 263         node = Selector.document.getElementById(id);
 264
 265         if (node && (root.nodeName == '#document' || contains(node, root))) {
 266             if ( rTestNode(node, null, idToken) ) {
 267                 if (idToken === token) {
 268                     nodes = [node]; // simple selector
 269                 } else {
 270                     root = node; // start from here
 271                 }
 272             }
 273         } else {
 274             return result;
 275         }
 276     }
 277
 278     if (root && !nodes.length) {
 279         nodes = root.getElementsByTagName(token.tag);
 280     }
 281
 282     if (nodes.length) {
 283         result = rFilter(nodes, token, firstOnly, deDupe);
 284     }
 285
 286     clearParentCache();
 287     return result;
 288 };
 289
 290 var contains = function() {
 291     if (document.documentElement.contains && !YAHOO.env.ua.webkit < 422)  { // IE & Opera, Safari < 3 contains is broken
 292         return function(needle, haystack) {
 293             return haystack.contains(needle);
 294         };
 295     } else if ( document.documentElement.compareDocumentPosition ) { // gecko
 296         return function(needle, haystack) {
 297             return !!(haystack.compareDocumentPosition(needle) & 16);
 298         };
 299     } else  { // Safari < 3
 300         return function(needle, haystack) {
 301             var parent = needle.parentNode;
 302             while (parent) {
 303                 if (needle === parent) {
 304                     return true;
 305                 }
 306                 parent = parent.parentNode;
 307             }
 308             return false;
 309         };
 310     }
 311 }();
 312
 313 var rFilter = function(nodes, token, firstOnly, deDupe) {
 314     var result = firstOnly ? null : [];
 315
 316     for (var i = 0, len = nodes.length; i < len; i++) {
 317         if (! rTestNode(nodes[i], '', token, deDupe)) {
 318             continue;
 319         }
 320
 321         if (firstOnly) {
 322             return nodes[i];
 323         }
 324         if (deDupe) {
 325             if (nodes[i]._found) {
 326                 continue;
 327             }
 328             nodes[i]._found = true;
 329             foundCache[foundCache.length] = nodes[i];
 330         }
 331
 332         result[result.length] = nodes[i];
 333     }
 334
 335     return result;
 336 };
 337
 338 var rTestNode = function(node, selector, token, deDupe) {
 339     token = token || tokenize(selector).pop() || {};
 340
 341     if (!node.tagName ||
 342         (token.tag !== '*' && node.tagName.toUpperCase() !== token.tag) ||
 343         (deDupe && node._found) ) {
 344         return false;
 345     }
 346
 347     if (token.attributes.length) {
 348         var attribute;
 349         for (var i = 0, len = token.attributes.length; i < len; ++i) {
 350             attribute = node.getAttribute(token.attributes[i][0], 2);
 351             if (attribute === null || attribute === undefined) {
 352                 return false;
 353             }
 354             if ( Selector.operators[token.attributes[i][1]] &&
 355                     !Selector.operators[token.attributes[i][1]](attribute, token.attributes[i][2])) {
 356                 return false;
 357             }
 358         }
 359     }
 360
 361     if (token.pseudos.length) {
 362         for (var i = 0, len = token.pseudos.length; i < len; ++i) {
 363             if (Selector.pseudos[token.pseudos[i][0]] &&
 364                     !Selector.pseudos[token.pseudos[i][0]](node, token.pseudos[i][1])) {
 365                 return false;
 366             }
 367         }
 368     }
 369
 370     return (token.previous && token.previous.combinator !== ',') ?
 371             combinators[token.previous.combinator](node, token) :
 372             true;
 373 };
 374
 375
 376 var foundCache = [];
 377 var parentCache = [];
 378 var regexCache = {};
 379
 380 var clearFoundCache = function() {
 381     for (var i = 0, len = foundCache.length; i < len; ++i) {
 382         try { // IE no like delete
 383             delete foundCache[i]._found;
 384         } catch(e) {
 385             foundCache[i].removeAttribute('_found');
 386         }
 387     }
 388     foundCache = [];
 389 };
 390
 391 var clearParentCache = function() {
 392     if (!document.documentElement.children) { // caching children lookups for gecko
 393         return function() {
 394             for (var i = 0, len = parentCache.length; i < len; ++i) {
 395                 delete parentCache[i]._children;
 396             }
 397             parentCache = [];
 398         };
 399     } else return function() {}; // do nothing
 400 }();
 401
 402 var getRegExp = function(str, flags) {
 403     flags = flags || '';
 404     if (!regexCache[str + flags]) {
 405         regexCache[str + flags] = new RegExp(str, flags);
 406     }
 407     return regexCache[str + flags];
 408 };
 409
 410 var combinators = {
 411     ' ': function(node, token) {
 412         while (node = node.parentNode) {
 413             if (rTestNode(node, '', token.previous)) {
 414                 return true;
 415             }
 416         }
 417         return false;
 418     },
 419
 420     '>': function(node, token) {
 421         return rTestNode(node.parentNode, null, token.previous);
 422     },
 423
 424     '+': function(node, token) {
 425         var sib = node.previousSibling;
 426         while (sib && sib.nodeType !== 1) {
 427             sib = sib.previousSibling;
 428         }
 429
 430         if (sib && rTestNode(sib, null, token.previous)) {
 431             return true;
 432         }
 433         return false;
 434     },
 435
 436     '~': function(node, token) {
 437         var sib = node.previousSibling;
 438         while (sib) {
 439             if (sib.nodeType === 1 && rTestNode(sib, null, token.previous)) {
 440                 return true;
 441             }
 442             sib = sib.previousSibling;
 443         }
 444
 445         return false;
 446     }
 447 };
 448
 449 var getChildren = function() {
 450     if (document.documentElement.children) { // document for capability test
 451         return function(node, tag) {
 452             return (tag) ? node.children.tags(tag) : node.children || [];
 453         };
 454     } else {
 455         return function(node, tag) {
 456             if (node._children) {
 457                 return node._children;
 458             }
 459             var children = [],
 460                 childNodes = node.childNodes;
 461
 462             for (var i = 0, len = childNodes.length; i < len; ++i) {
 463                 if (childNodes[i].tagName) {
 464                     if (!tag || childNodes[i].tagName.toLowerCase() === tag) {
 465                         children[children.length] = childNodes[i];
 466                     }
 467                 }
 468             }
 469             node._children = children;
 470             parentCache[parentCache.length] = node;
 471             return children;
 472         };
 473     }
 474 }();
 475
 476 /*
 477     an+b = get every _a_th node starting at the _b_th
 478     0n+b = no repeat ("0" and "n" may both be omitted (together) , e.g. "0n+1" or "1", not "0+1"), return only the _b_th element
 479     1n+b =  get every element starting from b ("1" may may be omitted, e.g. "1n+0" or "n+0" or "n")
 480     an+0 = get every _a_th element, "0" may be omitted
 481 */
 482 var getNth = function(node, expr, tag, reverse) {
 483     if (tag) tag = tag.toLowerCase();
 484     reNth.test(expr);
 485     var a = parseInt(RegExp.$1, 10), // include every _a_ elements (zero means no repeat, just first _a_)
 486         n = RegExp.$2, // "n"
 487         oddeven = RegExp.$3, // "odd" or "even"
 488         b = parseInt(RegExp.$4, 10) || 0, // start scan from element _b_
 489         result = [];
 490
 491     var siblings = getChildren(node.parentNode, tag);
 492
 493     if (oddeven) {
 494         a = 2; // always every other
 495         op = '+';
 496         n = 'n';
 497         b = (oddeven === 'odd') ? 1 : 0;
 498     } else if ( isNaN(a) ) {
 499         a = (n) ? 1 : 0; // start from the first or no repeat
 500     }
 501
 502     if (a === 0) { // just the first
 503         if (reverse) {
 504             b = siblings.length - b + 1;
 505         }
 506
 507         if (siblings[b - 1] === node) {
 508             return true;
 509         } else {
 510             return false;
 511         }
 512
 513     } else if (a < 0) {
 514         reverse = !!reverse;
 515         a = Math.abs(a);
 516     }
 517
 518     if (!reverse) {
 519         for (var i = b - 1, len = siblings.length; i < len; i += a) {
 520             if ( i >= 0 && siblings[i] === node ) {
 521                 return true;
 522             }
 523         }
 524     } else {
 525         for (var i = siblings.length - b, len = siblings.length; i >= 0; i -= a) {
 526             if ( i < len && siblings[i] === node ) {
 527                 return true;
 528             }
 529         }
 530     }
 531     return false;
 532 };
 533
 534 var getId = function(attr) {
 535     for (var i = 0, len = attr.length; i < len; ++i) {
 536         if (attr[i][0] == 'id' && attr[i][1] === '=') {
 537             return attr[i][2];
 538         }
 539     }
 540 };
 541
 542 var getIdTokenIndex = function(tokens) {
 543     for (var i = 0, len = tokens.length; i < len; ++i) {
 544         if (getId(tokens[i].attributes)) {
 545             return i;
 546         }
 547     }
 548     return -1;
 549 };
 550
 551 var patterns = {
 552     tag: /^((?:-?[_a-z]+[\w-]*)|\*)/i,
 553     attributes: /^\[([a-z]+\w*)+([~\|\^\$\*!=]=?)?['"]?([^\]]*?)['"]?\]/i,
 554     //attributes: /^\[([a-z]+\w*)+([~\|\^\$\*!=]=?)?['"]?([^'"\]]*)['"]?\]*/i,
 555     pseudos: /^:([-\w]+)(?:\(['"]?(.+)['"]?\))*/i,
 556     combinator: /^\s*([>+~]|\s)\s*/
 557 };
 558
 559 /**
 560     Break selector into token units per simple selector.
 561     Combinator is attached to left-hand selector.
 562  */
 563 var tokenize = function(selector) {
 564     var token = {},     // one token per simple selector (left selector holds combinator)
 565         tokens = [],    // array of tokens
 566         id,             // unique id for the simple selector (if found)
 567         found = false,  // whether or not any matches were found this pass
 568         match;          // the regex match
 569
 570     selector = replaceShorthand(selector); // convert ID and CLASS shortcuts to attributes
 571
 572     /*
 573         Search for selector patterns, store, and strip them from the selector string
 574         until no patterns match (invalid selector) or we run out of chars.
 575
 576         Multiple attributes and pseudos are allowed, in any order.
 577         for example:
 578             'form:first-child[type=button]:not(button)[lang|=en]'
 579     */
 580     do {
 581         found = false; // reset after full pass
 582         for (var re in patterns) {
 583                 if (!YAHOO.lang.hasOwnProperty(patterns, re)) {
 584                     continue;
 585                 }
 586                 if (re != 'tag' && re != 'combinator') { // only one allowed
 587                     token[re] = token[re] || [];
 588                 }
 589             if (match = patterns[re].exec(selector)) { // note assignment
 590                 found = true;
 591                 if (re != 'tag' && re != 'combinator') { // only one allowed
 592                     //token[re] = token[re] || [];
 593
 594                     // capture ID for fast path to element
 595                     if (re === 'attributes' && match[1] === 'id') {
 596                         token.id = match[3];
 597                     }
 598
 599                     token[re].push(match.slice(1));
 600                 } else { // single selector (tag, combinator)
 601                     token[re] = match[1];
 602                 }
 603                 selector = selector.replace(match[0], ''); // strip current match from selector
 604                 if (re === 'combinator' || !selector.length) { // next token or done
 605                     token.attributes = fixAttributes(token.attributes);
 606                     token.pseudos = token.pseudos || [];
 607                     token.tag = token.tag ? token.tag.toUpperCase() : '*';
 608                     tokens.push(token);
 609
 610                     token = { // prep next token
 611                         previous: token
 612                     };
 613                 }
 614             }
 615         }
 616     } while (found);
 617
 618     return tokens;
 619 };
 620
 621 var fixAttributes = function(attr) {
 622     var aliases = Selector.attrAliases;
 623     attr = attr || [];
 624     for (var i = 0, len = attr.length; i < len; ++i) {
 625         if (aliases[attr[i][0]]) { // convert reserved words, etc
 626             attr[i][0] = aliases[attr[i][0]];
 627         }
 628         if (!attr[i][1]) { // use exists operator
 629             attr[i][1] = '';
 630         }
 631     }
 632     return attr;
 633 };
 634
 635 var replaceShorthand = function(selector) {
 636     var shorthand = Selector.shorthand;
 637     var attrs = selector.match(patterns.attributes); // pull attributes to avoid false pos on "." and "#"
 638     if (attrs) {
 639         selector = selector.replace(patterns.attributes, 'REPLACED_ATTRIBUTE');
 640     }
 641     for (var re in shorthand) {
 642         if (!YAHOO.lang.hasOwnProperty(shorthand, re)) {
 643             continue;
 644         }
 645         selector = selector.replace(getRegExp(re, 'gi'), shorthand[re]);
 646     }
 647
 648     if (attrs) {
 649         for (var i = 0, len = attrs.length; i < len; ++i) {
 650             selector = selector.replace('REPLACED_ATTRIBUTE', attrs[i]);
 651         }
 652     }
 653     return selector;
 654 };
 655
 656 Selector = new Selector();
 657 Selector.patterns = patterns;
 658 Y.Selector = Selector;
 659
 660 if (YAHOO.env.ua.ie) { // rewrite class for IE (others use getAttribute('class')
 661     Y.Selector.attrAliases['class'] = 'className';
 662     Y.Selector.attrAliases['for'] = 'htmlFor';
 663 }
 664
 665 })();
 666 YAHOO.register("selector", YAHOO.util.Selector, {version: "2.6.0", build: "1321"});