platforma/static/js/xslt.js

   1 /*
   2  *
   3  * XSLT STUFF
   4  *
   5  */
   6 function createXSLT(xsl) {
   7     var p = new XSLTProcessor();
   8     p.importStylesheet(xsl);
   9     return p;
  10 }
  11
  12 var xml2htmlStylesheet = null;
  13
  14 // Wykonuje block z załadowanymi arkuszami stylów
  15 function withStylesheets(code_block, onError)
  16 {
  17     if (!xml2htmlStylesheet) {
  18         $.blockUI({message: 'Ładowanie arkuszy stylów...'});
  19         $.ajax({
  20                 url: STATIC_URL + 'xsl/wl2html_client.xsl',
  21                 dataType: 'xml',
  22                 success: function(data) {
  23                 xml2htmlStylesheet = createXSLT(data);
  24                 $.unblockUI();
  25                                 code_block();
  26
  27             },
  28                         error: onError
  29         })
  30     }
  31         else {
  32                 code_block();
  33         }
  34 }
  35
  36
  37 function xml2html(options) {
  38     withStylesheets(function() {
  39         var xml = options.xml.replace(/\/\s+/g, '<br />');
  40         var parser = new DOMParser();
  41         var serializer = new XMLSerializer();
  42         var doc = parser.parseFromString(xml, 'text/xml');
  43         var error = $('parsererror', doc);
  44
  45         if (error.length == 0) {
  46             doc = xml2htmlStylesheet.transformToFragment(doc, document);
  47                         console.log(doc.firstChild);
  48
  49                         if(doc.firstChild === null) {
  50                                 options.error("Błąd w przetwarzaniu XML.");
  51                                 return;
  52                         }
  53
  54             error = $('parsererror', doc);
  55         }
  56
  57         if (error.length > 0 && options.error) {
  58             options.error(error.text());
  59         } else {
  60             options.success(doc.firstChild);
  61         }
  62     }, function() { options.error && options.error('Nie udało się załadować XSLT'); });
  63 }
  64
  65 /* USEFULL CONSTANTS */
  66 const ELEMENT_NODE                                       = 1;
  67 const ATTRIBUTE_NODE                 = 2;
  68 const TEXT_NODE                      = 3;
  69 const CDATA_SECTION_NODE             = 4;
  70 const ENTITY_REFERENCE_NODE          = 5;
  71 const ENTITY_NODE                    = 6;
  72 const PROCESSING_INSTRUCTION_NODE    = 7;
  73 const COMMENT_NODE                   = 8;
  74 const DOCUMENT_NODE                  = 9;
  75 const DOCUMENT_TYPE_NODE             = 10;
  76 const DOCUMENT_FRAGMENT_NODE         = 11;
  77 const NOTATION_NODE                  = 12;
  78 const XATTR_RE = /^x-attr-name-(.*)$/;
  79
  80 const ELEM_START = 1;
  81 const ELEM_END = 2;
  82 const NS_END = 3;
  83
  84 const NAMESPACES = {
  85         // namespaces not listed here will be assigned random names
  86         "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
  87         "http://purl.org/dc/elements/1.1/": "dc",
  88         "http://www.w3.org/XML/1998/namespace": "xml"
  89 };
  90
  91 /*
  92  * PADDING for pretty-printing
  93  */
  94 const PADDING = {
  95     dramat_wierszowany_l: 4,
  96     dramat_wierszowany_lp: 4,
  97     dramat_wspolczesny: 4,
  98     wywiad: 4,
  99     opowiadanie: 4,
 100     powiesc: 4,
 101     liryka_l: 4,
 102     liryka_lp: 4,
 103     naglowek_czesc: 4,
 104     naglowek_akt: 4,
 105     naglowek_rozdzial: 4,
 106     naglowek_osoba: 4,
 107     lista_osob: 4,
 108
 109     akap: 3,
 110     akap_cd: 3,
 111     akap_dialog: 3,
 112     strofa: 3,
 113     motto: 3,
 114     miejsce_czas: 3,
 115
 116     autor_utworu: 2,
 117     nazwa_utworu: 2,
 118     dzielo_nadrzedne: 2,
 119
 120     didaskalia: 2,
 121     motto_podpis: 2,
 122     naglowek_listy: 2,
 123     kwestia: 1,
 124     lista_osoba: 1,
 125
 126         "podpis": 1,
 127         "wers": 1,
 128         "wers_cd": 1,
 129         "wers_akap": 1,
 130         "wers_wciety": 1,
 131
 132         "rdf:RDF": 3,
 133         "rdf:Description": 1,
 134 };
 135
 136 function getPadding(name) {
 137
 138         if(name.match(/^dc:.*$/))
 139                 return -1;
 140
 141         if(PADDING[name])
 142                 return PADDING[name];
 143
 144         return 0;
 145 }
 146
 147 function HTMLSerializer() {
 148         // empty constructor
 149 }
 150
 151
 152
 153 HTMLSerializer.prototype._prepare = function() {
 154         this.stack = [];
 155
 156         // XML namespace is implicit
 157         this.nsMap = {"http://www.w3.org/XML/1998/namespace": "xml"};
 158
 159         this.result = "";
 160         this.nsCounter = 1;
 161 }
 162
 163 HTMLSerializer.prototype._pushElement = function(element) {
 164         this.stack.push({
 165                 "type": ELEM_START,
 166                 "node": element
 167         });
 168 }
 169
 170 HTMLSerializer.prototype._pushChildren = function(element) {
 171         for(var i = element.childNodes.length-1; i >= 0; i--)
 172                 this._pushElement(element.childNodes.item(i));
 173 }
 174
 175 HTMLSerializer.prototype._pushTagEnd = function(tagName) {
 176         this.stack.push({
 177                 "type": ELEM_END,
 178                 "tagName": tagName
 179         });
 180 }
 181
 182 HTMLSerializer.prototype._verseBefore = function(node) {
 183         var prev = node.previousSibling;
 184
 185         while(prev) {
 186                 if(prev.nodeType == ELEMENT_NODE && prev.hasAttribute('x-verse'))
 187                         return true;
 188         }
 189
 190         return false;
 191 }
 192
 193 HTMLSerializer.prototype.serialize = function(rootElement, stripOuter)
 194 {
 195         var self = this;
 196         self._prepare();
 197
 198         if(!stripOuter)
 199                 self._pushElement(rootElement);
 200         else
 201                 self._pushChildren(rootElement);
 202
 203         while(self.stack.length > 0) {
 204                 var token = self.stack.pop();
 205
 206                 if(token.type === ELEM_END) {
 207                         self.result += "</" + token.tagName + ">";
 208                         for(var padding = getPadding(token.tagName); padding > 0; padding--) {
 209                                 self.result += "\n";
 210                         }
 211                         continue;
 212                 };
 213
 214                 if(token.type === NS_END) {
 215                         self._unassignNamespace(token.namespace);
 216                         continue;
 217                 }
 218
 219
 220                 switch(token.node.nodeType) {
 221                         case ELEMENT_NODE:
 222                                 if(token.node.hasAttribute('x-pass-thru')) {
 223                                         self._pushChildren(token.node);
 224                                         break;
 225                                 }
 226
 227                                 if(!token.node.hasAttribute('x-node'))
 228                                         break;
 229
 230                                 var xnode = token.node.getAttribute('x-node');
 231
 232                                 if(xnode === 'wers') {
 233                                         /* push children */
 234                                         if(self._verseBefore(token.node))
 235                                                 self.result += '/\n';
 236                                         self._pushChildren(token.node);
 237                                         break;
 238                                 };
 239
 240                                 if(token.node.hasAttribute('x-verse') && self._verseBefore(token.node)) {
 241                                         self.result += '/\n';
 242                                 };
 243
 244                                 self._serializeElement(token.node);
 245                                 break;
 246                         case TEXT_NODE:
 247                                 self.result += token.node.nodeValue;
 248                                 break;
 249                 };
 250         };
 251
 252         return this.result;
 253 }
 254
 255 /*
 256  * TODO: this doesn't support prefix redefinitions
 257  */
 258 HTMLSerializer.prototype._unassignNamespace = function(nsData) {
 259         this.nsMap[nsData.uri] = undefined;
 260 };
 261
 262 HTMLSerializer.prototype._assignNamespace = function(uri) {
 263         if(uri === null) {
 264                 // default namespace
 265                 return ({"prefix": "", "uri": "", "fresh": false});
 266         }
 267
 268         if(this.nsMap[uri] === undefined) {
 269                 // this prefix hasn't been defined yet in current context
 270                 var prefix = NAMESPACES[uri];
 271
 272                 if (prefix === undefined) { // not predefined
 273                         prefix = "ns" + this.nsCounter;
 274                         this.nsCounter += 1;
 275                 }
 276
 277                 this.nsMap[uri] = prefix;
 278                 return ({
 279                         "prefix": prefix,
 280                         "uri": uri,
 281                         "fresh": true
 282                 });
 283         }
 284
 285         return ({"prefix": this.nsMap[uri], "uri": uri, "fresh": false});
 286 };
 287
 288 HTMLSerializer.prototype._join = function(prefix, name) {
 289         if(!!prefix)
 290                 return prefix + ":" + name;
 291         return name;
 292 };
 293
 294 HTMLSerializer.prototype._rjoin = function(prefix, name) {
 295         if(!!name)
 296                 return prefix + ":" + name;
 297         return prefix;
 298 };
 299
 300 HTMLSerializer.prototype._serializeElement = function(node) {
 301         var self = this;
 302
 303         var ns = node.getAttribute('x-ns');
 304         var nsPrefix = null;
 305         var newNamespaces = [];
 306
 307         var nsData = self._assignNamespace(node.getAttribute('x-ns'));
 308
 309         if(nsData.fresh) {
 310                 newNamespaces.push(nsData);
 311                 self.stack.push({
 312                         "type": NS_END,
 313                         "namespace": nsData
 314                 });
 315         }
 316
 317         var tagName = self._join(nsData.prefix, node.getAttribute('x-node'));
 318
 319         /* retrieve attributes */
 320         var attributeIDs = [];
 321         for (var i = 0; i < node.attributes.length; i++) {
 322                 var attr = node.attributes.item(i);
 323
 324                 // check if name starts with "x-attr-name"
 325                 var m = attr.name.match(XATTR_RE);
 326                 if (m !== null)
 327                         attributeIDs.push(m[1]);
 328         };
 329
 330         /* print out */
 331         if (getPadding(tagName))
 332                 self.result += '\n';
 333
 334         self.result += '<' + tagName;
 335
 336         $.each(attributeIDs, function() {
 337                 var nsData = self._assignNamespace(node.getAttribute('x-attr-ns-'+this));
 338
 339                 if(nsData.fresh) {
 340                         newNamespaces.push(nsData);
 341                         self.stack.push({
 342                                 "type": NS_END,
 343                                 "namespace": nsData
 344                         });
 345                 };
 346
 347                 self.result += ' ' + self._join(nsData.prefix, node.getAttribute('x-attr-name-'+this));
 348                 self.result += '="'+node.getAttribute('x-attr-value-'+this) +'"';
 349         });
 350
 351         /* print new namespace declarations */
 352         $.each(newNamespaces, function() {
 353                 self.result += " " + self._rjoin("xmlns", this.prefix);
 354                 self.result += '="' + this.uri + '"';
 355         });
 356
 357         if (node.childNodes.length > 0) {
 358                 self.result += ">";
 359                 self._pushTagEnd(tagName);
 360                 self._pushChildren(node);
 361         }
 362         else {
 363                 self.result += "/>";
 364         };
 365 };
 366
 367 function html2text(params) {
 368         try {
 369                 var s = new HTMLSerializer();
 370                 params.success( s.serialize(params.element, params.stripOuter) );
 371         } catch(e) {
 372                 params.error("Nie udało się zserializować tekstu:" + e)
 373         }
 374 }