Subversion Repositories munaweb

/**
 * XMLWriter - XML generator for Javascript, based on .NET's XMLTextWriter.
 * Copyright (c) 2008-2014 Ariel Flesler - aflesler [a] gmail [d] com | http://flesler.blogspot.com
 * Licensed under BSD (https://raw2.github.com/flesler/XMLWriter/master/LICENSE)
 * @version 1.0.2
 * @author Ariel Flesler
 * http://flesler.blogspot.com/2008/03/xmlwriter-for-javascript.html
 */
 
function XMLWriter( encoding, version ){
        if( encoding )
                this.encoding = encoding;
        if( version )
                this.version = version;
};
(function(){
        
var proto = XMLWriter.prototype = {
        /* These are the defaults, you don't need to change them on the original code */
        encoding:'UTF-8',// what is the encoding
        version:'1.0', //what xml version to use
        formatting: 'indented', //how to format the output (indented/none)  ?
        indentChar:'\t', //char to use for indent
        indentation: 1, //how many indentChar to add per level
        newLine: '\n', //character to separate nodes when formatting
        /* */
        //start a new document, cleanup if we are reusing
        writeStartDocument:function( standalone ){
                this.close();//cleanup
                this.stack = [ ];
                this.standalone = standalone;
        },
        //get back to the root
        writeEndDocument:function(){
                this.active = this.root;
                this.stack = [ ];
        },
        //set the text of the doctype
        writeDocType:function( dt ){
                this.doctype = dt;
        },
        //start a new node with this name, and an optional namespace
        writeStartElement:function( name, ns ){
                if( ns )//namespace
                        name = ns + ':' + name;
                
                var node = { n:name, a:{ }, c: [ ] };//(n)ame, (a)ttributes, (c)hildren
                
                if( this.active ){
                        this.active.c.push(node);
                        this.stack.push(this.active);
                }else
                        this.root = node;
                this.active = node;
        },
        //go up one node, if we are in the root, ignore it
        writeEndElement:function(){
                this.active = this.stack.pop() || this.root;
        },
        //add an attribute to the active node
        writeAttributeString:function( name, value ){
                if( this.active )
                        this.active.a[name] = value;
        },
        //add a text node to the active node
        writeString:function( text ){
                if( this.active )
                        this.active.c.push(text);
        },
        //add plain xml content to the active node without any further checks and escaping
        writeXML:function( text ){
                if( this.active )
                        this.active.c.push(text);
        },
        //shortcut, open an element, write the text and close
        writeElementString:function( name, text, ns ){
                this.writeStartElement( name, ns ) //take advantage of the chaining
                        .writeString( text )
                        .writeEndElement();
        },
        //add a text node wrapped with CDATA
        writeCDATA:function( text ){
                // keep nested CDATA
                text = text.replace(/>>]/g, "]]><![CDATA[>");
                this.writeString( '<![CDATA[' + text + ']]>' );
        },
        //add a text node wrapped in a comment
        writeComment:function( text ){
                this.writeString('<!-- ' + text + ' -->');
        },
        //generate the xml string, you can skip closing the last nodes
        flush:function(){               
                this.writeEndDocument();//ensure it's closed
                
                var 
                        chr = '', num = this.indentation,
                        formatting = this.formatting.toLowerCase() == 'indented',
                        buffer = ['<?xml version="'+this.version+'" encoding="'+this.encoding+'"'];
                        
                if( this.standalone !== undefined )
                        buffer[0] += ' standalone="'+!!this.standalone+'"';
                
                buffer[0] += ' ?>';
                
                if( this.doctype && this.root )
                        buffer.push('<!DOCTYPE '+ this.root.n + ' ' + this.doctype+'>'); 
                
                if( formatting ){
                        while( num-- )
                                chr += this.indentChar;
                }
                
                if( this.root )//skip if no element was added
                        format( this.root, '', chr, buffer );
                
                return buffer.join( formatting ? this.newLine : '' );
        },
        //cleanup, don't use again without calling startDocument
        close:function(){
                if( this.root )
                        clean( this.root );
                this.active = this.root = this.stack = null;
        },
        getDocument: window.ActiveXObject 
                ? function(){ //MSIE
                        var doc = new ActiveXObject('Microsoft.XMLDOM');
                        doc.async = false;
                        doc.loadXML(this.flush());
                        return doc;
                }
                : function(){//W3C
                        return (new DOMParser()).parseFromString(this.flush(),'text/xml');
        }
};

//utility, you don't need it
function clean( node ){
        var l = node.c.length;
        while( l-- ){
                if( typeof node.c[l] == 'object' )
                        clean( node.c[l] );
        }
        node.n = node.a = node.c = null;        
};

//utility, you don't need it
function format( node, indent, chr, buffer ){
        var 
                xml = indent + '<' + node.n,
                nc = node.c.length,
                attr, child, i = 0;
                
        for( attr in node.a )
                xml += ' ' + attr + '="' + node.a[attr] + '"';
        
        xml += nc ? '>' : ' />';

        buffer.push( xml );
                
        if( nc ){
                do{
                        child = node.c[i++];
                        if( typeof child == 'string' ){
                                if( nc == 1 )//single text node
                                        return buffer.push( buffer.pop() + child + '</'+node.n+'>' );                                   
                                else //regular text node
                                        buffer.push( indent+chr+child );
                        }else if( typeof child == 'object' ) //element node
                                format(child, indent+chr, chr, buffer);
                }while( i < nc );
                buffer.push( indent + '</'+node.n+'>' );
        }
};

//add chaining! :)
for( var method in proto ){
        if( typeof proto[method] == 'function' && !/flush|getDocument/.test(method) ){
                var original = proto[method];
                proto[method] = function(){
                        arguments.callee._o_.apply(this,arguments);
                        return this;
                };
                proto[method]._o_ = original;
        }
}

})();