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