Sarissa is a utility class. Provides static methods for DOMDocument and + * XMLHTTP objects, DOM Node serializatrion to XML strings and other goodies.
+ * @constructor + */ +function Sarissa(){}; +/** @private */ +Sarissa.PARSED_OK = "Document contains no parsing errors"; +/** + * Tells you whether transformNode and transformNodeToObject are available. This functionality + * is contained in sarissa_ieemu_xslt.js and is deprecated. If you want to control XSLT transformations + * use the XSLTProcessor + * @deprecated + * @type boolean + */ +Sarissa.IS_ENABLED_TRANSFORM_NODE = false; +/** + * tells you whether XMLHttpRequest (or equivalent) is available + * @type boolean + */ +Sarissa.IS_ENABLED_XMLHTTP = false; +/** + * Deprecated, will be removed in 0.9.6. Check for + *window.XSLTProcessor instead to see if
+ * XSLTProcessor is available.
+ * @type boolean
+ */
+Sarissa.IS_ENABLED_XSLTPROC = false;
+/**
+ * tells you whether selectNodes/selectSingleNode is available
+ * @type boolean
+ */
+Sarissa.IS_ENABLED_SELECT_NODES = false;
+var _sarissa_iNsCounter = 0;
+var _SARISSA_IEPREFIX4XSLPARAM = "";
+var _SARISSA_HAS_DOM_IMPLEMENTATION = document.implementation && true;
+var _SARISSA_HAS_DOM_CREATE_DOCUMENT = _SARISSA_HAS_DOM_IMPLEMENTATION && document.implementation.createDocument;
+var _SARISSA_HAS_DOM_FEATURE = _SARISSA_HAS_DOM_IMPLEMENTATION && document.implementation.hasFeature;
+/** Deprecated, will be removed in 0.9.6. @deprecated */
+var _SARISSA_IS_MOZ = _SARISSA_HAS_DOM_CREATE_DOCUMENT && _SARISSA_HAS_DOM_FEATURE;
+/** Deprecated, will be removed in 0.9.6. @deprecated */
+var _SARISSA_IS_IE = document.all && window.ActiveXObject && (navigator.userAgent.toLowerCase().indexOf("msie") > -1);
+//==========================================
+// Implement Node constants if not available
+//==========================================
+if(!window.Node || !window.Node.ELEMENT_NODE){
+ var Node = {ELEMENT_NODE: 1, ATTRIBUTE_NODE: 2, TEXT_NODE: 3, CDATA_SECTION_NODE: 4, ENTITY_REFERENCE_NODE: 5, ENTITY_NODE: 6, PROCESSING_INSTRUCTION_NODE: 7, COMMENT_NODE: 8, DOCUMENT_NODE: 9, DOCUMENT_TYPE_NODE: 10, DOCUMENT_FRAGMENT_NODE: 11, NOTATION_NODE: 12};
+};
+// IE initialization
+if(_SARISSA_IS_IE){
+ // for XSLT parameter names, prefix needed by IE
+ _SARISSA_IEPREFIX4XSLPARAM = "xsl:";
+ // used to store the most recent ProgID available out of the above
+ var _SARISSA_DOM_PROGID = "";
+ var _SARISSA_XMLHTTP_PROGID = "";
+ /**
+ * Called when the Sarissa_xx.js file is parsed, to pick most recent
+ * ProgIDs for IE, then gets destroyed.
+ * @param idList an array of MSXML PROGIDs from which the most recent will be picked for a given object
+ * @param enabledList an array of arrays where each array has two items; the index of the PROGID for which a certain feature is enabled
+ */
+ function pickRecentProgID(idList, enabledList){
+ // found progID flag
+ var bFound = false;
+ for(var i=0; i < idList.length && !bFound; i++){
+ try{
+ var oDoc = new ActiveXObject(idList[i]);
+ o2Store = idList[i];
+ bFound = true;
+ for(var j=0;jEmulate IE's onreadystatechange attribute
+ */ + XMLDocument.prototype.onreadystatechange = null; + /** + *Emulates IE's readyState property, which always gives an integer from 0 to 4:
+ *Emulate IE's parseError attribute
+ */ + XMLDocument.prototype.parseError = 0; + + // NOTE: setting async to false will only work with documents + // called over HTTP (meaning a server), not the local file system, + // unless you are using Moz 1.4+. + // BTW the try>catch block is for 1.4; I haven't found a way to check if + // the property is implemented without + // causing an error and I dont want to use user agent stuff for that... + var _SARISSA_SYNC_NON_IMPLEMENTED = false; + try{ + /** + *Emulates IE's async property for Moz versions prior to 1.4. + * It controls whether loading of remote XML files works + * synchronously or asynchronously.
+ */ + XMLDocument.prototype.async = true; + _SARISSA_SYNC_NON_IMPLEMENTED = true; + }catch(e){/* trap */}; + /** + *Keeps a handle to the original load() method. Internal use and only + * if Mozilla version is lower than 1.4
+ * @private + */ + XMLDocument.prototype._sarissa_load = XMLDocument.prototype.load; + + /** + *Overrides the original load method to provide synchronous loading for + * Mozilla versions prior to 1.4, using an XMLHttpRequest object (if + * async is set to false)
+ * @returns the DOM Object as it was before the load() call (may be empty) + */ + XMLDocument.prototype.load = function(sURI) { + var oDoc = document.implementation.createDocument("", "", null); + Sarissa.copyChildNodes(this, oDoc); + this.parseError = 0; + Sarissa.__setReadyState__(this, 1); + try { + if(this.async == false && _SARISSA_SYNC_NON_IMPLEMENTED) { + var tmp = new XMLHttpRequest(); + tmp.open("GET", sURI, false); + tmp.send(null); + Sarissa.__setReadyState__(this, 2); + Sarissa.copyChildNodes(tmp.responseXML, this); + Sarissa.__setReadyState__(this, 3); + } + else { + this._sarissa_load(sURI); + }; + } + catch (objException) { + this.parseError = -1; + } + finally { + if(this.async == false){ + Sarissa.__handleLoad__(this); + }; + }; + return oDoc; + }; + + if(window.DOMParser && !XMLDocument.loadXML){ + /** + *Parses the String given as parameter to build the document content + * for the object, exactly like IE's loadXML()
+ * @argument strXML The XML String to load as the Document's childNodes + * @returns the old Document structure serialized as an XML String + */ + XMLDocument.prototype.loadXML = function(strXML){ + Sarissa.__setReadyState__(this, 1); + var sOldXML = this.xml; + var oDoc = (new DOMParser()).parseFromString(strXML, "text/xml"); + Sarissa.__setReadyState__(this, 2); + Sarissa.copyChildNodes(oDoc, this); + Sarissa.__setReadyState__(this, 3); + Sarissa.__handleLoad__(this); + return sOldXML; + }; + };//if(window.DOMParser && !XMLDocument.loadXML) + };//if(window.XMLDocument) + + /** + *Ensures the document was loaded correctly, otherwise sets the + * parseError to -1 to indicate something went wrong. Internal use
+ * @private + */ + Sarissa.__handleLoad__ = function(oDoc){ + if (!oDoc.documentElement || oDoc.documentElement.tagName == "parsererror") + oDoc.parseError = -1; + Sarissa.__setReadyState__(oDoc, 4); + }; + /** + *Attached by an event handler to the load event. Internal use.
+ * @private + */ + function _sarissa_XMLDocument_onload() { + Sarissa.__handleLoad__(this); + }; + /** + *Sets the readyState property of the given DOM Document object. + * Internal use.
+ * @private + * @argument oDoc the DOM Document object to fire the + * readystatechange event + * @argument iReadyState the number to change the readystate property to + */ + Sarissa.__setReadyState__ = function(oDoc, iReadyState){ + oDoc.readyState = iReadyState; + if (oDoc.onreadystatechange != null && typeof oDoc.onreadystatechange == "function") + oDoc.onreadystatechange(); + }; + /** + *Factory method to obtain a new DOM Document object
+ * @argument sUri the namespace of the root node (if any) + * @argument sUri the local name of the root node (if any) + * @returns a new DOM Document + */ + Sarissa.getDomDocument = function(sUri, sName){ + var oDoc = document.implementation.createDocument(sUri?sUri:"", sName?sName:"", null); + oDoc.addEventListener("load", _sarissa_XMLDocument_onload, false); + return oDoc; + }; + };//if(_SARISSA_HAS_DOM_CREATE_DOCUMENT) +}; +//========================================== +// Common stuff +//========================================== +if(window.XMLHttpRequest){ + /** + *Deprecated, will be removed in 0.9.6. Factory method to obtain a new XMLHTTP Request object
+ * @returns a new XMLHTTP Request object + * @deprecated + */ + Sarissa.getXmlHttpRequest = function() { + return new XMLHttpRequest(); + }; + Sarissa.IS_ENABLED_XMLHTTP = true; +}; +if(!window.document.importNode){ + /** + * Implements importNode for the current window document in IE using innerHTML. + * Testing showed that DOM was multiple times slower than innerHTML for this, + * sorry folks. If you encounter trouble (who knows what IE does behind innerHTML) + * please gimme a call. + * @param oNode the Node to import + * @param bChildren whether to include the children of oNode + * @returns the imported node for further use + */ + window.document.importNode = function(oNode, bChildren){ + var importNode = document.createElement("div"); + if(bChildren) + importNode.innerHTML = Sarissa.serialize(oNode); + else + importNode.innerHTML = Sarissa.serialize(oNode.cloneNode(false)); + return importNode.firstChild; + }; +}; +if(!Sarissa.getParseErrorText){ + /** + *Returns a human readable description of the parsing error. Usefull + * for debugging. Tip: append the returned error string in a <pre> + * element if you want to render it.
+ *Many thanks to Christian Stocker for the initial patch.
+ * @argument oDoc The target DOM document + * @returns The parsing error description of the target Document in + * human readable form (preformated text) + */ + Sarissa.getParseErrorText = function (oDoc){ + var parseErrorText = Sarissa.PARSED_OK; + if(oDoc.parseError != 0){ + /*moz*/ + if(oDoc.documentElement.tagName == "parsererror"){ + parseErrorText = oDoc.documentElement.firstChild.data; + parseErrorText += "\n" + oDoc.documentElement.firstChild.nextSibling.firstChild.data; + }/*konq*/ + else if(oDoc.documentElement.tagName == "html"){ + parseErrorText = Sarissa.getText(oDoc.documentElement.getElementsByTagName("h1")[0], false) + "\n"; + parseErrorText += Sarissa.getText(oDoc.documentElement.getElementsByTagName("body")[0], false) + "\n"; + parseErrorText += Sarissa.getText(oDoc.documentElement.getElementsByTagName("pre")[0], false); + }; + }; + return parseErrorText; + }; +}; +Sarissa.getText = function(oNode, deep){ + var s = ""; + var nodes = oNode.childNodes; + for(var i=0; i < nodes.length; i++){ + var node = nodes[i]; + if(node.nodeType == Node.TEXT_NODE){ + s += node.data; + }else if(deep == true + && (node.nodeType == Node.ELEMENT_NODE + || node.nodeType == Node.DOCUMENT_NODE + || node.nodeType == Node.DOCUMENT_FRAGMENT_NODE)){ + + s += Sarissa.getText(node, true); + }; + }; + return s; +}; +if(window.XMLSerializer){ + /** + *Factory method to obtain the serialization of a DOM Node
+ * @returns the serialized Node as an XML string + */ + Sarissa.serialize = function(oDoc){ + return (new XMLSerializer()).serializeToString(oDoc); + }; +}else{ + if((Sarissa.getDomDocument("","foo", null)).xml){ + // see non-IE version + Sarissa.serialize = function(oDoc) { + // TODO: check for HTML document and return innerHTML instead + return oDoc.xml; + }; + /** + * Utility class to serialize DOM Node objects to XML strings + * @constructor + */ + XMLSerializer = function(){}; + /** + * Serialize the given DOM Node to an XML string + * @param oNode the DOM Node to serialize + */ + XMLSerializer.prototype.serializeToString = function(oNode) { + return oNode.xml; + }; + }; +}; +if(window.XSLTProcessor){ + Sarissa.IS_ENABLED_XSLTPROC = true; +}; +/** + * strips tags from a markup string + */ +Sarissa.stripTags = function (s) { + return s.replace(/<[^>]+>/g,""); +}; +/** + *Deletes all child nodes of the given node
+ * @argument oNode the Node to empty + */ +Sarissa.clearChildNodes = function(oNode) { + while(oNode.hasChildNodes()){ + oNode.removeChild(oNode.firstChild); + }; +}; +/** + *Replaces the childNodes of the toDoc object with the childNodes of + * the fromDoc object
+ *Note: The second object's original content is deleted before the copy operation
+ * @argument nodeFrom the Node to copy the childNodes from + * @argument nodeTo the Node to copy the childNodes to + */ +Sarissa.copyChildNodes = function(nodeFrom, nodeTo) { + Sarissa.clearChildNodes(nodeTo); + var ownerDoc = nodeTo.nodeType == Node.DOCUMENT_NODE ? nodeTo : nodeTo.ownerDocument; + var nodes = nodeFrom.childNodes; + if(typeof(ownerDoc.importNode) == "function"){ + for(var i=0;i < nodes.length;i++) { + nodeTo.appendChild(ownerDoc.importNode(nodes[i], true)); + }; + } + else{ + for(var i=0;i < nodes.length;i++) { + nodeTo.appendChild(nodes[i].cloneNode(true)); + }; + }; +}; + +/** + *Serialize any object to an XML string. All properties are serialized using the property name
+ * as the XML element name. Array elements are rendered as array-item elements,
+ * using their index/key as the value of the key attribute.