git.roojs.org Git - roojs1/blob - Roo/htmleditor/TidySerializer.js

   1   define('tinymce/html/Serializer', ['tinymce/html/Writer', 'tinymce/html/Schema'], function(Writer, Schema) {
   2         /**
   3          * Constructs a new Serializer instance.
   4          *
   5          * @constructor
   6          * @method Serializer
   7          * @param {Object} settings Name/value settings object.
   8          * @param {tinymce.html.Schema} schema Schema instance to use.
   9          */
  10         return function(settings, schema) {
  11             var self = this,
  12                 writer = new Writer(settings);
  13             settings = settings || {};
  14             settings.validate = !('validate' in settings) || settings.validate;
  15             self.schema = schema = schema || new Schema();
  16             self.writer = writer;
  17             /**
  18              * Serializes the specified node into a string.
  19              *
  20              * @example
  21              * new tinymce.html.Serializer().serialize(new tinymce.html.DomParser().parse('<p>text</p>'));
  22              * @method serialize
  23              * @param {tinymce.html.Node} node Node instance to serialize.
  24              * @return {String} String with HTML based on DOM tree.
  25              */
  26             self.serialize = function(node) {
  27                 var handlers, validate;
  28                 validate = settings.validate;
  29                 handlers = {
  30                     // #text
  31                     3: function(node) {
  32                         writer.text(node.value, node.raw);
  33                     },
  34                     // #comment
  35                     8: function(node) {
  36                         writer.comment(node.value);
  37                     },
  38                     // Processing instruction
  39                     7: function(node) {
  40                         writer.pi(node.name, node.value);
  41                     },
  42                     // Doctype
  43                     10: function(node) {
  44                         writer.doctype(node.value);
  45                     },
  46                     // CDATA
  47                     4: function(node) {
  48                         writer.cdata(node.value);
  49                     },
  50                     // Document fragment
  51                     11: function(node) {
  52                         if (node = node.firstChild) {
  53                             do {
  54                                 walk(node);
  55                             } while (node = node.next);
  56                         }
  57                     }
  58                 };
  59                 writer.reset();
  60
  61                 function walk(node) {
  62                     var name, isEmpty, attrs, attrName, attrValue, sortedAttrs, i, l, elementRule, handler = handlers[node.type];
  63                     if (handler) {
  64                         handler(node);
  65                     } else {
  66                         name = node.name;
  67                         isEmpty = node.shortEnded;
  68                         attrs = node.attributes;
  69                         // Sort attributes
  70                         if (validate && attrs && attrs.length > 1) {
  71                             sortedAttrs = [];
  72                             sortedAttrs.map = {};
  73                             elementRule = schema.getElementRule(node.name);
  74                             if (elementRule) {
  75                                 for (i = 0, l = elementRule.attributesOrder.length; i < l; i++) {
  76                                     attrName = elementRule.attributesOrder[i];
  77                                     if (attrName in attrs.map) {
  78                                         attrValue = attrs.map[attrName];
  79                                         sortedAttrs.map[attrName] = attrValue;
  80                                         sortedAttrs.push({
  81                                             name: attrName,
  82                                             value: attrValue
  83                                         });
  84                                     }
  85                                 }
  86                                 for (i = 0, l = attrs.length; i < l; i++) {
  87                                     attrName = attrs[i].name;
  88                                     if (!(attrName in sortedAttrs.map)) {
  89                                         attrValue = attrs.map[attrName];
  90                                         sortedAttrs.map[attrName] = attrValue;
  91                                         sortedAttrs.push({
  92                                             name: attrName,
  93                                             value: attrValue
  94                                         });
  95                                     }
  96                                 }
  97                                 attrs = sortedAttrs;
  98                             }
  99                         }
 100                         writer.start(node.name, attrs, isEmpty);
 101                         if (!isEmpty) {
 102                             if (node = node.firstChild) {
 103                                 do {
 104                                     walk(node);
 105                                 } while (node = node.next);
 106                             }
 107                             writer.end(name);
 108                         }
 109                     }
 110                 }
 111                 // Serialize element and treat all non elements as fragments
 112                 1 != node.type || settings.inner ? handlers[11](node) : walk(node);
 113                 return writer.getContent();
 114             };
 115         };
 116
 117