Fix
[redakcja.git] / redakcja / static / js / lib / jquery / jquery.xmlns.js
1 //
2 //  jquery.xmlns.js:  xml-namespace selector support for jQuery
3 //
4 //  This plugin modifies the jQuery tag and attribute selectors to
5 //  support optional namespace specifiers as defined in CSS 3:
6 //
7 //    $("elem")      - matches 'elem' nodes in the default namespace
8 //    $("|elem")     - matches 'elem' nodes that don't have a namespace
9 //    $("NS|elem")   - matches 'elem' nodes in declared namespace 'NS'
10 //    $("*|elem")    - matches 'elem' nodes in any namespace
11 //    $("NS|*")      - matches any nodes in declared namespace 'NS'
12 //
13 //  A similar synax is also supported for attribute selectors, but note
14 //  that the default namespace does *not* apply to attributes - a missing
15 //  or empty namespace selector selects only attributes with no namespace.
16 //
17 //  In a slight break from the W3C standards, and with a nod to ease of
18 //  implementation, the empty namespace URI is treated as equivalent to
19 //  an unspecified namespace.  Plenty of browsers seem to make the same
20 //  assumption...
21 //
22 //  Namespace declarations live in the $.xmlns object, which is a simple
23 //  mapping from namespace ids to namespace URIs.  The default namespace
24 //  is determined by the value associated with the empty string.
25 //
26 //    $.xmlns.D = "DAV:"
27 //    $.xmlns.FOO = "http://www.foo.com/xmlns/foobar"
28 //    $.xmlns[""] = "http://www.example.com/new/default/namespace/"
29 //
30 //  Unfortunately this is a global setting - I can't find a way to do
31 //  query-object-specific namespaces since the jQuery selector machinery
32 //  is stateless.  However, you can use the 'xmlns' function to push and
33 //  pop namespace delcarations with ease:
34 //
35 //    $().xmlns({D:"DAV:"})     // pushes the DAV: namespace
36 //    $().xmlns("DAV:")         // makes DAV: the default namespace
37 //    $().xmlns(false)          // pops the namespace we just pushed
38 //    $().xmlns(false)          // pops again, returning to defaults
39 //
40 //  To execute this as a kind of "transaction", pass a function as the
41 //  second argument.  It will be executed in the context of the current
42 //  jQuery object:
43 //
44 //    $().xmlns("DAV:",function() {
45 //      //  The default namespace is DAV: within this function,
46 //      //  but it is reset to the previous value on exit.
47 //      return this.find("response").each(...);
48 //    }).find("div")
49 //
50 //  If you pass a string as a function, it will be executed against the
51 //  current jQuery object using find(); i.e. the following will find all
52 //  "href" elements in the "DAV:" namespace:
53 //
54 //    $().xmlns("DAV:","href")
55 //
56 // 
57 //  And finally, the legal stuff:
58 //
59 //    Copyright (c) 2009, Ryan Kelly.
60 //    TAG and ATTR functions derived from jQuery's selector.js.
61 //    Dual licensed under the MIT and GPL licenses.
62 //    http://docs.jquery.com/License
63 //
64
65 (function($) {
66
67 //  Some common default namespaces, that are treated specially by browsers.
68 //
69 var default_xmlns = {
70     "xml": "http://www.w3.org/XML/1998/namespace",
71     "xmlns": "http://www.w3.org/2000/xmlns/",
72     "html": "http://www.w3.org/1999/xhtml/"
73 };
74  
75
76 //  A reverse mapping for common namespace prefixes.
77 //
78 var default_xmlns_rev = {}
79 for(var k in default_xmlns) {
80     default_xmlns_rev[default_xmlns[k]] = k;
81 }
82
83
84 //  $.xmlns is a mapping from namespace identifiers to namespace URIs.
85 //  The default default-namespace is "*", and we provide some additional
86 //  defaults that are specified in the XML Namespaces standard.
87 //
88 $.extend({xmlns: $.extend({},default_xmlns,{"":"*"})});
89
90
91 //  jQuery method to push/pop namespace declarations.
92 //
93 //  If a single argument is specified:
94 //    * if it's a mapping, push those namespaces onto the stack
95 //    * if it's a string, push that as the default namespace
96 //    * if it evaluates to false, pop the latest namespace
97 //
98 //  If two arguments are specified, the second is executed "transactionally"
99 //  using the namespace declarations found in the first.  It can be either a
100 //  a selector string (in which case it is passed to this.find()) or a function
101 //  (in which case it is called in the context of the current jQuery object).
102 //  The given namespace mapping is automatically pushed before executing and
103 //  popped afterwards.
104 //
105 var xmlns_stack = [];
106 $.fn.extend({xmlns: function(nsmap,func) {
107     if(typeof nsmap == "string") {
108         nsmap = {"":nsmap};
109     }
110     if(nsmap) {
111         xmlns_stack.push($.xmlns);
112         $.xmlns = $.extend({},$.xmlns,nsmap);
113         if(func !== undefined) {
114             if(typeof func == "string") {
115                 return this.find(func).xmlns(undefined)
116             } else {
117                 var self = this;
118                 try {
119                     self = func.call(this);
120                     if(!self) {
121                         self = this;
122                     }
123                 } finally {
124                     self.xmlns(undefined);
125                 }
126                 return self
127             }
128         } else {
129             return this;
130         }
131     } else {
132         $.xmlns = (xmlns_stack ? xmlns_stack.pop() : {});
133         return this;
134     }
135 }});
136
137
138 //  Convert a namespace prefix into a namespace URI, based
139 //  on the delcarations made in $.xmlns.
140 //
141 var getNamespaceURI = function(id) {
142     // No namespace id, use the default.
143     if(!id) {
144         return $.xmlns[""];
145     }
146     // Strip the pipe character from the specifier
147     id = id.substr(0,id.length-1);
148     // Certain special namespaces aren't mapped to a URI
149     if(id == "" || id == "*") {
150         return id;
151     }
152     var ns = $.xmlns[id];
153     if(typeof(ns) == "undefined") {
154         throw "Syntax error, undefined namespace prefix '" + id + "'";
155     }
156     return ns;
157 };
158
159
160 //  Update the regex used by $.expr to parse selector components for a
161 //  particular type of selector (e.g. "TAG" or "ATTR").
162 //
163 //  This logic is taken straight from the jQuery/Sizzle sources.
164 //
165 var setExprMatchRegex = function(type,regex) {
166   $.expr.match[type] = new RegExp(regex.source + /(?![^\[]*\])(?![^\(]*\))/.source);
167   if($.expr.leftMatch) {
168       $.expr.leftMatch[type] = new RegExp(/(^(?:.|\r|\n)*?)/.source + $.expr.match[type].source.replace(/\\(\d+)/g, function(all, num){
169           return "\\" + (num - 0 + 1);
170       }));
171   }
172 }
173
174
175
176 //  Modify the TAG match regexp to include optional namespace selector.
177 //  This is basically (namespace|)?(tagname).
178 //
179 setExprMatchRegex("TAG",/^((?:((?:[\w\u00c0-\uFFFF\*_-]*\|)?)((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)))/);
180
181
182 //  Perform some capability-testing.
183 //
184 var div = document.createElement("div");
185
186 //  Sometimes getElementsByTagName("*") will return comment nodes,
187 //  which we will have to remove from the results.
188 //
189 var gebtn_yields_comments = false;
190 div.appendChild(document.createComment(""));
191 if(div.getElementsByTagName("*").length > 0) {
192     gebtn_yields_comments = true;
193 }
194
195 //  Some browsers return node.localName in upper case, some in lower case.
196 //
197 var localname_is_uppercase = true;
198 if(div.localName && div.localName == "div") {
199     localname_is_uppercase = false;
200 }
201
202 //  Allow the testing div to be garbage-collected.
203 //
204 div = null;
205
206
207 //  Modify the TAG find function to account for a namespace selector.
208 //
209 $.expr.find.TAG = function(match,context,isXML) {
210     var ns = getNamespaceURI(match[2]);
211     var ln = match[3];
212     var res;
213     if(typeof context.getElementsByTagNameNS != "undefined") {
214         //  Easy case - we have getElementsByTagNameNS
215         res = context.getElementsByTagNameNS(ns,ln);
216     } else if(typeof context.selectNodes != "undefined") {
217         //  Use xpath if possible (not available on HTML DOM nodes in IE)
218         if(context.ownerDocument) {
219             context.ownerDocument.setProperty("SelectionLanguage","XPath");
220         } else {
221             context.setProperty("SelectionLanguage","XPath");
222         }
223         var predicate = "";
224         if(ns != "*") {
225             if(ln != "*") {
226                 predicate="namespace-uri()='"+ns+"' and local-name()='"+ln+"'";
227             } else {
228                 predicate="namespace-uri()='"+ns+"'";
229             }
230         } else {
231             if(ln != "*") {
232                 predicate="local-name()='"+ln+"'";
233             }
234         }
235         if(predicate) {
236             res = context.selectNodes("descendant-or-self::*["+predicate+"]");
237         } else {
238             res = context.selectNodes("descendant-or-self::*");
239         }
240     } else {
241         //  Otherwise, we need to simulate using getElementsByTagName
242         res = context.getElementsByTagName(ln); 
243         if(gebtn_yields_comments && ln == "*") {
244             var tmp = [];
245             for(var i=0; res[i]; i++) {
246                 if(res[i].nodeType == 1) {
247                     tmp.push(res[i]);
248                 }
249             }
250             res = tmp;
251         }
252         if(res && ns != "*") {
253             var tmp = [];
254             for(var i=0; res[i]; i++) {
255                if(res[i].namespaceURI == ns || res[i].tagUrn == ns) {
256                    tmp.push(res[i]);
257                }
258             }
259             res = tmp;
260         }
261     }
262     return res;
263 };
264
265
266 //  Check whether a node is part of an XML document.
267 //  Copied verbatim from jQuery sources, needed in TAG preFilter below.
268 //
269 var isXML = function(elem){
270     return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
271             !!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";
272 };
273
274
275 //  Modify the TAG preFilter function to work with modified match regexp.
276 //  This normalises case of the tag name if we're in a HTML document.
277 //
278 $.expr.preFilter.TAG = function(match, curLoop, inplace, result, not, isXML) {
279   var ln = match[3];
280   if(!isXML) {
281       if(localname_is_uppercase) {
282           ln = ln.toUpperCase();
283       } else {
284           ln = ln.toLowerCase();
285       }
286   }
287   return [match[0],getNamespaceURI(match[2]),ln];
288 };
289
290
291 //  Modify the TAG filter function to account for a namespace selector.
292 //
293 $.expr.filter.TAG = function(elem,match) {
294     var ns = match[1];
295     var ln = match[2];
296     var e_ns = elem.namespaceURI ? elem.namespaceURI : elem.tagUrn;
297     var e_ln = elem.localName ? elem.localName : elem.tagName;
298     if(ns == "*" || e_ns == ns || (ns == "" && !e_ns)) {
299         return ((ln == "*" && elem.nodeType == 1)  || e_ln == ln);
300     }
301     return false;
302 };
303
304
305 //  Modify the ATTR match regexp to extract a namespace selector.
306 //  This is basically ([namespace|])(attrname)(op)(quote)(pattern)(quote)
307 //
308 setExprMatchRegex("ATTR",/\[\s*((?:((?:[\w\u00c0-\uFFFF\*_-]*\|)?)((?:[\w\u00c0-\uFFFF_-]|\\.)+)))\s*(?:(\S?=)\s*(['"]*)(.*?)\5|)\s*\]/);
309
310
311 //  Modify the ATTR preFilter function to account for new regexp match groups,
312 //  and normalise the namespace URI.
313 //
314 $.expr.preFilter.ATTR = function(match, curLoop, inplace, result, not, isXML) {
315     var name = match[3].replace(/\\/g, "");
316     if(!isXML && $.expr.attrMap[name]) {
317         match[3] = $.expr.attrMap[name];
318     }
319     if( match[4] == "~=" ) {
320         match[6] = " " + match[6] + " ";
321     }
322     if(!match[2] || match[2] == "|") {
323         match[2] = "";
324     } else {
325         match[2] = getNamespaceURI(match[2]);
326     }
327     return match;
328 };
329
330
331 //  Modify the ATTR filter function to account for namespace selector.
332 //  Unfortunately this means factoring out the attribute-checking code
333 //  into a separate function, since it might be called multiple times.
334 //
335 var filter_attr = function(result,type,check) {
336     var value = result + "";
337     return result == null ?
338                 type === "!=" :
339                 type === "=" ?
340                 value === check :
341                 type === "*=" ?
342                 value.indexOf(check) >= 0 :
343                 type === "~=" ?
344                 (" " + value + " ").indexOf(check) >= 0 :
345                 !check ?
346                 value && result !== false :
347                 type === "!=" ?
348                 value != check :
349                 type === "^=" ?
350                 value.indexOf(check) === 0 :
351                 type === "$=" ?
352                 value.substr(value.length - check.length) === check :
353                 type === "|=" ?
354                 value === check || value.substr(0,check.length+1)===check+"-" :
355                 false;
356 }
357
358
359 $.expr.filter.ATTR = function(elem, match) {
360     var ns = match[2];
361     var name = match[3];
362     var type = match[4];
363     var check = match[6];
364     var result;
365     //  No namespace, just use ordinary attribute lookup.
366     if(ns == "") {
367         result = $.expr.attrHandle[name] ?
368                      $.expr.attrHandle[name](elem) :
369                      elem[name] != null ?
370                          elem[name] :
371                          elem.getAttribute(name);
372         return filter_attr(result,type,check);
373     }
374     //  Directly use getAttributeNS if applicable and available
375     if(ns != "*" && typeof elem.getAttributeNS != "undefined") {
376         return filter_attr(elem.getAttributeNS(ns,name),type,check);
377     }
378     //  Need to iterate over all attributes, either because we couldn't
379     //  look it up or because we need to match all namespaces.
380     var attrs = elem.attributes;
381     for(var i=0; attrs[i]; i++) {
382         var ln = attrs[i].localName;
383         if(!ln) {
384             ln = attrs[i].nodeName
385             var idx = ln.indexOf(":");
386             if(idx >= 0) {
387                 ln = ln.substr(idx+1);
388             }
389         }
390         if(ln == name) {
391             result = attrs[i].nodeValue;
392             if(ns == "*" || attrs[i].namespaceURI == ns) {
393                 if(filter_attr(result,type,check)) {
394                     return true;
395                 }
396             }
397             if(attrs[i].namespaceURI === "" && attrs[i].prefix) {
398                 if(attrs[i].prefix == default_xmlns_rev[ns]) {
399                     if(filter_attr(result,type,check)) {
400                         return true;
401                     }
402                 }
403             }
404         }
405     }
406     return false;
407 };
408
409
410 })(jQuery);
411