include/javascript/tiny_mce/classes/html/Serializer.js

   1 /**
   2  * Serializer.js
   3  *
   4  * Copyright 2010, Moxiecode Systems AB
   5  * Released under LGPL License.
   6  *
   7  * License: http://tinymce.moxiecode.com/license
   8  * Contributing: http://tinymce.moxiecode.com/contributing
   9  */
  10
  11 (function(tinymce) {
  12         /**
  13          * This class is used to serialize down the DOM tree into a string using a Writer instance.
  14          *
  15          *
  16          * @example
  17          * new tinymce.html.Serializer().serialize(new tinymce.html.DomParser().parse('<p>text</p>'));
  18          * @class tinymce.html.Serializer
  19          * @version 3.4
  20          */
  21
  22         /**
  23          * Constructs a new Serializer instance.
  24          *
  25          * @constructor
  26          * @method Serializer
  27          * @param {Object} settings Name/value settings object.
  28          * @param {tinymce.html.Schema} schema Schema instance to use.
  29          */
  30         tinymce.html.Serializer = function(settings, schema) {
  31                 var self = this, writer = new tinymce.html.Writer(settings);
  32
  33                 settings = settings || {};
  34                 settings.validate = "validate" in settings ? settings.validate : true;
  35
  36                 self.schema = schema = schema || new tinymce.html.Schema();
  37                 self.writer = writer;
  38
  39                 /**
  40                  * Serializes the specified node into a string.
  41                  *
  42                  * @example
  43                  * new tinymce.html.Serializer().serialize(new tinymce.html.DomParser().parse('<p>text</p>'));
  44                  * @method serialize
  45                  * @param {tinymce.html.Node} node Node instance to serialize.
  46                  * @return {String} String with HTML based on DOM tree.
  47                  */
  48                 self.serialize = function(node) {
  49                         var handlers, validate;
  50
  51                         validate = settings.validate;
  52
  53                         handlers = {
  54                                 // #text
  55                                 3: function(node, raw) {
  56                                         writer.text(node.value, node.raw);
  57                                 },
  58
  59                                 // #comment
  60                                 8: function(node) {
  61                                         writer.comment(node.value);
  62                                 },
  63
  64                                 // Processing instruction
  65                                 7: function(node) {
  66                                         writer.pi(node.name, node.value);
  67                                 },
  68
  69                                 // Doctype
  70                                 10: function(node) {
  71                                         writer.doctype(node.value);
  72                                 },
  73
  74                                 // CDATA
  75                                 4: function(node) {
  76                                         writer.cdata(node.value);
  77                                 },
  78
  79                                 // Document fragment
  80                                 11: function(node) {
  81                                         if ((node = node.firstChild)) {
  82                                                 do {
  83                                                         walk(node);
  84                                                 } while (node = node.next);
  85                                         }
  86                                 }
  87                         };
  88
  89                         writer.reset();
  90
  91                         function walk(node) {
  92                                 var handler = handlers[node.type], name, isEmpty, attrs, attrName, attrValue, sortedAttrs, i, l, elementRule;
  93
  94                                 if (!handler) {
  95                                         name = node.name;
  96                                         isEmpty = node.shortEnded;
  97                                         attrs = node.attributes;
  98
  99                                         // Sort attributes
 100                                         if (validate && attrs && attrs.length > 1) {
 101                                                 sortedAttrs = [];
 102                                                 sortedAttrs.map = {};
 103
 104                                                 elementRule = schema.getElementRule(node.name);
 105                                                 for (i = 0, l = elementRule.attributesOrder.length; i < l; i++) {
 106                                                         attrName = elementRule.attributesOrder[i];
 107
 108                                                         if (attrName in attrs.map) {
 109                                                                 attrValue = attrs.map[attrName];
 110                                                                 sortedAttrs.map[attrName] = attrValue;
 111                                                                 sortedAttrs.push({name: attrName, value: attrValue});
 112                                                         }
 113                                                 }
 114
 115                                                 for (i = 0, l = attrs.length; i < l; i++) {
 116                                                         attrName = attrs[i].name;
 117
 118                                                         if (!(attrName in sortedAttrs.map)) {
 119                                                                 attrValue = attrs.map[attrName];
 120                                                                 sortedAttrs.map[attrName] = attrValue;
 121                                                                 sortedAttrs.push({name: attrName, value: attrValue});
 122                                                         }
 123                                                 }
 124
 125                                                 attrs = sortedAttrs;
 126                                         }
 127
 128                                         writer.start(node.name, attrs, isEmpty);
 129
 130                                         if (!isEmpty) {
 131                                                 if ((node = node.firstChild)) {
 132                                                         do {
 133                                                                 walk(node);
 134                                                         } while (node = node.next);
 135                                                 }
 136
 137                                                 writer.end(name);
 138                                         }
 139                                 } else
 140                                         handler(node);
 141                         }
 142
 143                         // Serialize element and treat all non elements as fragments
 144                         if (node.type == 1 && !settings.inner)
 145                                 walk(node);
 146                         else
 147                                 handlers[11](node);
 148
 149                         return writer.getContent();
 150                 };
 151         }
 152 })(tinymce);