The Tor Browser / file comparison

comparison: testing/mochitest/tests/MochiKit-1.4.2/MochiKit/Selector.js

testing/mochitest/tests/MochiKit-1.4.2/MochiKit/Selector.js

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:4926a17d77c1
1 /***
2
3 MochiKit.Selector 1.4.2
4
5 See <http://mochikit.com/> for documentation, downloads, license, etc.
6
7 (c) 2005 Bob Ippolito and others. All rights Reserved.
8
9 ***/
10
11 MochiKit.Base._deps('Selector', ['Base', 'DOM', 'Iter']);
12
13 MochiKit.Selector.NAME = "MochiKit.Selector";
14 MochiKit.Selector.VERSION = "1.4.2";
15
16 MochiKit.Selector.__repr__ = function () {
17 return "[" + this.NAME + " " + this.VERSION + "]";
18 };
19
20 MochiKit.Selector.toString = function () {
21 return this.__repr__();
22 };
23
24 MochiKit.Selector.EXPORT = [
25 "Selector",
26 "findChildElements",
27 "findDocElements",
28 "$$"
29 ];
30
31 MochiKit.Selector.EXPORT_OK = [
32 ];
33
34 MochiKit.Selector.Selector = function (expression) {
35 this.params = {classNames: [], pseudoClassNames: []};
36 this.expression = expression.toString().replace(/(^\s+|\s+$)/g, '');
37 this.parseExpression();
38 this.compileMatcher();
39 };
40
41 MochiKit.Selector.Selector.prototype = {
42 /***
43
44 Selector class: convenient object to make CSS selections.
45
46 ***/
47 __class__: MochiKit.Selector.Selector,
48
49 /** @id MochiKit.Selector.Selector.prototype.parseExpression */
50 parseExpression: function () {
51 function abort(message) {
52 throw 'Parse error in selector: ' + message;
53 }
54
55 if (this.expression == '') {
56 abort('empty expression');
57 }
58
59 var repr = MochiKit.Base.repr;
60 var params = this.params;
61 var expr = this.expression;
62 var match, modifier, clause, rest;
63 while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!^$*]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
64 params.attributes = params.attributes || [];
65 params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
66 expr = match[1];
67 }
68
69 if (expr == '*') {
70 return this.params.wildcard = true;
71 }
72
73 while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+(?:\([^)]*\))?)(.*)/i)) {
74 modifier = match[1];
75 clause = match[2];
76 rest = match[3];
77 switch (modifier) {
78 case '#':
79 params.id = clause;
80 break;
81 case '.':
82 params.classNames.push(clause);
83 break;
84 case ':':
85 params.pseudoClassNames.push(clause);
86 break;
87 case '':
88 case undefined:
89 params.tagName = clause.toUpperCase();
90 break;
91 default:
92 abort(repr(expr));
93 }
94 expr = rest;
95 }
96
97 if (expr.length > 0) {
98 abort(repr(expr));
99 }
100 },
101
102 /** @id MochiKit.Selector.Selector.prototype.buildMatchExpression */
103 buildMatchExpression: function () {
104 var repr = MochiKit.Base.repr;
105 var params = this.params;
106 var conditions = [];
107 var clause, i;
108
109 function childElements(element) {
110 return "MochiKit.Base.filter(function (node) { return node.nodeType == 1; }, " + element + ".childNodes)";
111 }
112
113 if (params.wildcard) {
114 conditions.push('true');
115 }
116 if (clause = params.id) {
117 conditions.push('element.id == ' + repr(clause));
118 }
119 if (clause = params.tagName) {
120 conditions.push('element.tagName.toUpperCase() == ' + repr(clause));
121 }
122 if ((clause = params.classNames).length > 0) {
123 for (i = 0; i < clause.length; i++) {
124 conditions.push('MochiKit.DOM.hasElementClass(element, ' + repr(clause[i]) + ')');
125 }
126 }
127 if ((clause = params.pseudoClassNames).length > 0) {
128 for (i = 0; i < clause.length; i++) {
129 var match = clause[i].match(/^([^(]+)(?:\((.*)\))?$/);
130 var pseudoClass = match[1];
131 var pseudoClassArgument = match[2];
132 switch (pseudoClass) {
133 case 'root':
134 conditions.push('element.nodeType == 9 || element === element.ownerDocument.documentElement'); break;
135 case 'nth-child':
136 case 'nth-last-child':
137 case 'nth-of-type':
138 case 'nth-last-of-type':
139 match = pseudoClassArgument.match(/^((?:(\d+)n\+)?(\d+)|odd|even)$/);
140 if (!match) {
141 throw "Invalid argument to pseudo element nth-child: " + pseudoClassArgument;
142 }
143 var a, b;
144 if (match[0] == 'odd') {
145 a = 2;
146 b = 1;
147 } else if (match[0] == 'even') {
148 a = 2;
149 b = 0;
150 } else {
151 a = match[2] && parseInt(match) || null;
152 b = parseInt(match[3]);
153 }
154 conditions.push('this.nthChild(element,' + a + ',' + b
155 + ',' + !!pseudoClass.match('^nth-last') // Reverse
156 + ',' + !!pseudoClass.match('of-type$') // Restrict to same tagName
157 + ')');
158 break;
159 case 'first-child':
160 conditions.push('this.nthChild(element, null, 1)');
161 break;
162 case 'last-child':
163 conditions.push('this.nthChild(element, null, 1, true)');
164 break;
165 case 'first-of-type':
166 conditions.push('this.nthChild(element, null, 1, false, true)');
167 break;
168 case 'last-of-type':
169 conditions.push('this.nthChild(element, null, 1, true, true)');
170 break;
171 case 'only-child':
172 conditions.push(childElements('element.parentNode') + '.length == 1');
173 break;
174 case 'only-of-type':
175 conditions.push('MochiKit.Base.filter(function (node) { return node.tagName == element.tagName; }, ' + childElements('element.parentNode') + ').length == 1');
176 break;
177 case 'empty':
178 conditions.push('element.childNodes.length == 0');
179 break;
180 case 'enabled':
181 conditions.push('(this.isUIElement(element) && element.disabled === false)');
182 break;
183 case 'disabled':
184 conditions.push('(this.isUIElement(element) && element.disabled === true)');
185 break;
186 case 'checked':
187 conditions.push('(this.isUIElement(element) && element.checked === true)');
188 break;
189 case 'not':
190 var subselector = new MochiKit.Selector.Selector(pseudoClassArgument);
191 conditions.push('!( ' + subselector.buildMatchExpression() + ')')
192 break;
193 }
194 }
195 }
196 if (clause = params.attributes) {
197 MochiKit.Base.map(function (attribute) {
198 var value = 'MochiKit.DOM.getNodeAttribute(element, ' + repr(attribute.name) + ')';
199 var splitValueBy = function (delimiter) {
200 return value + '.split(' + repr(delimiter) + ')';
201 }
202 conditions.push(value + ' != null');
203 switch (attribute.operator) {
204 case '=':
205 conditions.push(value + ' == ' + repr(attribute.value));
206 break;
207 case '~=':
208 conditions.push('MochiKit.Base.findValue(' + splitValueBy(' ') + ', ' + repr(attribute.value) + ') > -1');
209 break;
210 case '^=':
211 conditions.push(value + '.substring(0, ' + attribute.value.length + ') == ' + repr(attribute.value));
212 break;
213 case '$=':
214 conditions.push(value + '.substring(' + value + '.length - ' + attribute.value.length + ') == ' + repr(attribute.value));
215 break;
216 case '*=':
217 conditions.push(value + '.match(' + repr(attribute.value) + ')');
218 break;
219 case '|=':
220 conditions.push(splitValueBy('-') + '[0].toUpperCase() == ' + repr(attribute.value.toUpperCase()));
221 break;
222 case '!=':
223 conditions.push(value + ' != ' + repr(attribute.value));
224 break;
225 case '':
226 case undefined:
227 // Condition already added above
228 break;
229 default:
230 throw 'Unknown operator ' + attribute.operator + ' in selector';
231 }
232 }, clause);
233 }
234
235 return conditions.join(' && ');
236 },
237
238 /** @id MochiKit.Selector.Selector.prototype.compileMatcher */
239 compileMatcher: function () {
240 var code = 'return (!element.tagName) ? false : ' +
241 this.buildMatchExpression() + ';';
242 this.match = new Function('element', code);
243 },
244
245 /** @id MochiKit.Selector.Selector.prototype.nthChild */
246 nthChild: function (element, a, b, reverse, sametag){
247 var siblings = MochiKit.Base.filter(function (node) {
248 return node.nodeType == 1;
249 }, element.parentNode.childNodes);
250 if (sametag) {
251 siblings = MochiKit.Base.filter(function (node) {
252 return node.tagName == element.tagName;
253 }, siblings);
254 }
255 if (reverse) {
256 siblings = MochiKit.Iter.reversed(siblings);
257 }
258 if (a) {
259 var actualIndex = MochiKit.Base.findIdentical(siblings, element);
260 return ((actualIndex + 1 - b) / a) % 1 == 0;
261 } else {
262 return b == MochiKit.Base.findIdentical(siblings, element) + 1;
263 }
264 },
265
266 /** @id MochiKit.Selector.Selector.prototype.isUIElement */
267 isUIElement: function (element) {
268 return MochiKit.Base.findValue(['input', 'button', 'select', 'option', 'textarea', 'object'],
269 element.tagName.toLowerCase()) > -1;
270 },
271
272 /** @id MochiKit.Selector.Selector.prototype.findElements */
273 findElements: function (scope, axis) {
274 var element;
275
276 if (axis == undefined) {
277 axis = "";
278 }
279
280 function inScope(element, scope) {
281 if (axis == "") {
282 return MochiKit.DOM.isChildNode(element, scope);
283 } else if (axis == ">") {
284 return element.parentNode === scope;
285 } else if (axis == "+") {
286 return element === nextSiblingElement(scope);
287 } else if (axis == "~") {
288 var sibling = scope;
289 while (sibling = nextSiblingElement(sibling)) {
290 if (element === sibling) {
291 return true;
292 }
293 }
294 return false;
295 } else {
296 throw "Invalid axis: " + axis;
297 }
298 }
299
300 if (element = MochiKit.DOM.getElement(this.params.id)) {
301 if (this.match(element)) {
302 if (!scope || inScope(element, scope)) {
303 return [element];
304 }
305 }
306 }
307
308 function nextSiblingElement(node) {
309 node = node.nextSibling;
310 while (node && node.nodeType != 1) {
311 node = node.nextSibling;
312 }
313 return node;
314 }
315
316 if (axis == "") {
317 scope = (scope || MochiKit.DOM.currentDocument()).getElementsByTagName(this.params.tagName || '*');
318 } else if (axis == ">") {
319 if (!scope) {
320 throw "> combinator not allowed without preceding expression";
321 }
322 scope = MochiKit.Base.filter(function (node) {
323 return node.nodeType == 1;
324 }, scope.childNodes);
325 } else if (axis == "+") {
326 if (!scope) {
327 throw "+ combinator not allowed without preceding expression";
328 }
329 scope = nextSiblingElement(scope) && [nextSiblingElement(scope)];
330 } else if (axis == "~") {
331 if (!scope) {
332 throw "~ combinator not allowed without preceding expression";
333 }
334 var newscope = [];
335 while (nextSiblingElement(scope)) {
336 scope = nextSiblingElement(scope);
337 newscope.push(scope);
338 }
339 scope = newscope;
340 }
341
342 if (!scope) {
343 return [];
344 }
345
346 var results = MochiKit.Base.filter(MochiKit.Base.bind(function (scopeElt) {
347 return this.match(scopeElt);
348 }, this), scope);
349
350 return results;
351 },
352
353 /** @id MochiKit.Selector.Selector.prototype.repr */
354 repr: function () {
355 return 'Selector(' + this.expression + ')';
356 },
357
358 toString: MochiKit.Base.forwardCall("repr")
359 };
360
361 MochiKit.Base.update(MochiKit.Selector, {
362
363 /** @id MochiKit.Selector.findChildElements */
364 findChildElements: function (element, expressions) {
365 var uniq = function(arr) {
366 var res = [];
367 for (var i = 0; i < arr.length; i++) {
368 if (MochiKit.Base.findIdentical(res, arr[i]) < 0) {
369 res.push(arr[i]);
370 }
371 }
372 return res;
373 };
374 return MochiKit.Base.flattenArray(MochiKit.Base.map(function (expression) {
375 var nextScope = "";
376 var reducer = function (results, expr) {
377 if (match = expr.match(/^[>+~]$/)) {
378 nextScope = match[0];
379 return results;
380 } else {
381 var selector = new MochiKit.Selector.Selector(expr);
382 var elements = MochiKit.Iter.reduce(function (elements, result) {
383 return MochiKit.Base.extend(elements, selector.findElements(result || element, nextScope));
384 }, results, []);
385 nextScope = "";
386 return elements;
387 }
388 };
389 var exprs = expression.replace(/(^\s+|\s+$)/g, '').split(/\s+/);
390 return uniq(MochiKit.Iter.reduce(reducer, exprs, [null]));
391 }, expressions));
392 },
393
394 findDocElements: function () {
395 return MochiKit.Selector.findChildElements(MochiKit.DOM.currentDocument(), arguments);
396 },
397
398 __new__: function () {
399 var m = MochiKit.Base;
400
401 this.$$ = this.findDocElements;
402
403 this.EXPORT_TAGS = {
404 ":common": this.EXPORT,
405 ":all": m.concat(this.EXPORT, this.EXPORT_OK)
406 };
407
408 m.nameFunctions(this);
409 }
410 });
411
412 MochiKit.Selector.__new__();
413
414 MochiKit.Base._exportSymbols(this, MochiKit.Selector);
415

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial