ba612b4b341b86324233550e732ab9a08a6b3461
[fnpeditor.git] / src / smartxml / core.js
1 define(function(require) {
2     
3 'use strict';
4 /* globals Node */
5
6 var _ = require('libs/underscore');
7
8
9 var INSERTION = function(implementation) {
10     var toret = function(node, options) {
11         var insertion = this.getNodeInsertion(node),
12             nodeWasContained = this.document.containsNode(insertion.ofNode),
13             nodeParent,
14             returned;
15         options = options || {};
16         if(!(this.document.containsNode(this)) || !insertion.isNew) {
17             nodeParent = insertion.ofNode.parent();
18         }
19         returned = implementation.call(this, insertion.ofNode);
20         if(!options.silent && returned.sameNode(insertion.ofNode)) {
21             this.triggerChangeEvent(insertion.insertsNew ? 'nodeAdded' : 'nodeMoved', {node: insertion.ofNode}, nodeParent, nodeWasContained);
22         }
23         return returned;
24     };
25     return toret;
26 };
27
28 var documentNodeTransformations = {
29     detach: function() {
30         var parent = this.parent(),
31             existed = this.document.containsNode(this);
32         this._$.detach();
33         if(existed) {
34             this.triggerChangeEvent('nodeDetached', {parent: parent});
35             if(!parent) {
36                 // This was the root of the document
37                 this.document._defineDocumentProperties(null);
38             }
39         }
40         return this;
41     },
42
43     replaceWith: function(node) {
44         var toret;
45         if(this.isRoot()) {
46             return this.document.replaceRoot(node);
47         }
48         if(this.parent()) {
49             toret = this.after(node);
50             this.detach();
51             return toret;
52         }
53         throw new Error('Cannot replace node without a parent.');
54     },
55
56     after: INSERTION(function(node) {
57         var next = this.next();
58         if(next && next.nodeType === Node.TEXT_NODE && node.nodeType === Node.TEXT_NODE) {
59             next.setText(node.getText() + next.getText());
60             node.detach();
61             return next;
62         }
63         this._$.after(node.nativeNode);
64         return node;
65     }),
66
67     before: INSERTION(function(node) {
68         var prev = this.prev();
69         if(prev && prev.nodeType === Node.TEXT_NODE && node.nodeType === Node.TEXT_NODE) {
70             prev.setText(prev.getText() + node.getText());
71             node.detach();
72             return prev;
73         }
74         this._$.before(node.nativeNode);
75         return node;
76     }),
77
78     wrapWith: function(node) {
79         var insertion = this.getNodeInsertion(node);
80         if(this.parent()) {
81             this.before(insertion.ofNode);
82         }
83         insertion.ofNode.append(this);
84         return insertion.ofNode;
85     },
86
87     /**
88     * Removes parent of a node if node has no siblings.
89     */
90     unwrap: function() {
91         if(this.isRoot()) {
92             return;
93         }
94         var parent = this.parent(),
95             grandParent;
96         if(parent.contents().length === 1) {
97             grandParent = parent.parent();
98             parent.unwrapContent();
99             return grandParent;
100         }
101     }
102 };
103
104 var elementNodeTransformations = {
105
106     detach: function() {
107         var next;
108         if(this.parent() && this.isSurroundedByTextElements()) {
109             next = this.next();
110             this.prev().appendText(next.getText());
111             next.detach();
112         }
113         return this.__super__.detach();
114     },
115
116     setTag: function(tagName) {
117         var node = this.document.createDocumentNode({tagName: tagName}),
118             oldTagName = this.getTagName(),
119             myContents = this._$.contents();
120
121         this.getAttrs().forEach(function(attribute) {
122             node.setAttr(attribute.name, attribute.value, true);
123         });
124         node.setData(this.getData());
125
126         if(this.sameNode(this.document.root)) {
127             this.document._defineDocumentProperties(node._$);
128         }
129
130         /* TODO: This invalidates old references to this node. Caching instances on nodes would fix this. */
131         this._$.replaceWith(node._$);
132         this._setNativeNode(node._$[0]);
133         this._$.append(myContents);
134         this.triggerChangeEvent('nodeTagChange', {oldTagName: oldTagName, newTagName: this.getTagName()});
135     },
136
137
138     setAttr: function(name, value, silent) {
139         var oldVal = this.getAttr(name);
140         this._$.attr(name, value);
141         if(!silent) {
142             this.triggerChangeEvent('nodeAttrChange', {attr: name, oldVal: oldVal, newVal: value});
143         }
144     },
145
146     append: INSERTION(function(node) {
147         var last = _.last(this.contents());
148         if(last && last.nodeType === Node.TEXT_NODE && node.nodeType === Node.TEXT_NODE) {
149             last.setText(last.getText() + node.getText());
150             node.detach();
151             return last;
152         } else {
153             this._$.append(node.nativeNode);
154             return node;
155         }
156     }),
157
158     prepend: INSERTION(function(node) {
159         var first = this.contents()[0];
160         if(first && first.nodeType === Node.TEXT_NODE && node.nodeType === Node.TEXT_NODE) {
161             first.setText(node.getText() + first.getText());
162             node.detach();
163             return first;
164         } else {
165             this._$.prepend(node.nativeNode);
166             return node;
167         }
168     }),
169
170     insertAtIndex: function(nativeNode, index) {
171         var contents = this.contents();
172         if(index < contents.length) {
173             return contents[index].before(nativeNode);
174         } else if(index === contents.length) {
175             return this.append(nativeNode);
176         }
177     },
178
179     unwrapContent: function() {
180         var parent = this.parent();
181         if(!parent) {
182             return;
183         }
184
185         var myContents = this.contents(),
186             myIdx = parent.indexOf(this);
187
188
189         if(myContents.length === 0) {
190             return this.detach();
191         }
192
193
194         var childrenLength = this.contents().length,
195             first = true,
196             shiftRange = false;
197         this.contents().forEach(function(child) {
198             var returned = this.before(child);
199             if(first && !(returned.sameNode(child))) {
200                 shiftRange = true;
201                 first = false;
202             }
203         }.bind(this));
204
205         this.detach();
206
207         return {
208             element1: parent.contents()[myIdx + (shiftRange ? -1 : 0)],
209             element2: parent.contents()[myIdx + childrenLength-1 + (shiftRange ? -1 : 0)]
210         };
211     },
212
213     wrapText: function(params) {
214         return this.document._wrapText(_.extend({inside: this}, params));
215     }
216 };
217
218 var textNodeTransformations = {
219     setText: {
220         impl: function(t, text) {
221             t.oldText = this.getText();
222             this.nativeNode.data = text;
223             this.triggerTextChangeEvent();
224         },
225         undo: function(t) {
226             this.setText(t.oldText);
227         }
228     },
229
230     before: INSERTION(function(node) {
231         if(node.nodeType === Node.TEXT_NODE) {
232             this.prependText(node.getText());
233             node.detach();
234             return this;
235         } else {
236             return this.__super__.before(node, {silent:true});
237         }
238     }),
239
240     after: INSERTION(function(node) {
241         if(node.nodeType === Node.TEXT_NODE) {
242             this.appendText(node.getText());
243             node.detach();
244             return this;
245         } else {
246             return this.__super__.after(node, {silent:true});
247         }
248     }),
249
250     append: function(node) {
251         if(node.nodeType === Node.TEXT_NODE) {
252             this.appendText(node.getText());
253             node.detach();
254             return this;
255         }
256     },
257     prepend: function(node) {
258         if(node.nodeType === Node.TEXT_NODE) {
259             this.prependText(node.getText());
260             node.detach();
261             return this;
262         }
263     },
264
265     appendText: function(text) {
266         this.nativeNode.data = this.nativeNode.data + text;
267         this.triggerTextChangeEvent();
268     },
269
270     prependText: function(text) {
271         this.nativeNode.data = text + this.nativeNode.data;
272         this.triggerTextChangeEvent();
273     },
274
275     wrapWith: function(desc) {
276         if(typeof desc.start === 'number' && typeof desc.end === 'number') {
277             return this.document._wrapText({
278                 inside: this.parent(),
279                 textNodeIdx: this.parent().indexOf(this),
280                 offsetStart: Math.min(desc.start, desc.end),
281                 offsetEnd: Math.max(desc.start, desc.end),
282                 _with: {tagName: desc.tagName, attrs: desc.attrs}
283             });
284         } else {
285             return this.__super__.wrapWith.call(this, desc);
286         }
287     },
288
289     split: function(params) {
290         var parentElement = this.parent(),
291             passed = false,
292             succeedingChildren = [],
293             prefix = this.getText().substr(0, params.offset),
294             suffix = this.getText().substr(params.offset);
295
296         parentElement.contents().forEach(function(child) {
297             if(passed) {
298                 succeedingChildren.push(child);
299             }
300             if(child.sameNode(this)) {
301                 passed = true;
302             }
303         }.bind(this));
304
305         if(prefix.length > 0) {
306             this.setText(prefix);
307         }
308         else {
309             this.detach();
310         }
311
312         var attrs = {};
313         parentElement.getAttrs().forEach(function(attr) {attrs[attr.name] = attr.value; });
314         var newElement = this.document.createDocumentNode({tagName: parentElement.getTagName(), attrs: attrs});
315         parentElement.after(newElement);
316
317         if(suffix.length > 0) {
318             newElement.append({text: suffix});
319         }
320         succeedingChildren.forEach(function(child) {
321             newElement.append(child);
322         });
323
324         return {first: parentElement, second: newElement};
325     },
326
327     divideWithElementNode: function(node, params) {
328         var insertion = this.getNodeInsertion(node),
329             myText = this.getText();
330
331         if(params.offset === myText.length) {
332             return this.after(node);
333         }
334         if(params.offset === 0) {
335             return this.before(node);
336         }
337
338         var lhsText = myText.substr(0, params.offset),
339             rhsText = myText.substr(params.offset),
340             rhsTextNode = this.document.createDocumentNode({text: rhsText});
341
342         this.setText(lhsText);
343         this.after(insertion.ofNode);
344         insertion.ofNode.after(rhsTextNode);
345         return insertion.ofNode;
346     }
347 };
348
349 var documentTransformations = {
350     wrapNodes: function(params) {
351         if(!(params.node1.parent().sameNode(params.node2.parent()))) {
352             throw new Error('Wrapping non-sibling nodes not supported.');
353         }
354
355         var parent = params.node1.parent(),
356             parentContents = parent.contents(),
357             wrapper = this.createDocumentNode({
358                 tagName: params._with.tagName,
359                 attrs: params._with.attrs}),
360             idx1 = parent.indexOf(params.node1),
361             idx2 = parent.indexOf(params.node2);
362
363         if(idx1 > idx2) {
364             var tmp = idx1;
365             idx1 = idx2;
366             idx2 = tmp;
367         }
368
369         var insertingMethod, insertingTarget;
370         if(idx1 === 0) {
371             insertingMethod = 'prepend';
372             insertingTarget = parent;
373         } else {
374             insertingMethod = 'after';
375             insertingTarget = parentContents[idx1-1];
376         }
377
378         for(var i = idx1; i <= idx2; i++) {
379             wrapper.append(parentContents[i].detach());
380         }
381
382         insertingTarget[insertingMethod](wrapper);
383         return wrapper;
384     },
385
386     _wrapText: function(params) {
387         params = _.extend({textNodeIdx: 0}, params);
388         if(typeof params.textNodeIdx === 'number') {
389             params.textNodeIdx = [params.textNodeIdx];
390         }
391         
392         var contentsInside = params.inside.contents(),
393             idx1 = Math.min.apply(Math, params.textNodeIdx),
394             idx2 = Math.max.apply(Math, params.textNodeIdx),
395             textNode1 = contentsInside[idx1],
396             textNode2 = contentsInside[idx2],
397             sameNode = textNode1.sameNode(textNode2),
398             prefixOutside = textNode1.getText().substr(0, params.offsetStart),
399             prefixInside = textNode1.getText().substr(params.offsetStart),
400             suffixInside = textNode2.getText().substr(0, params.offsetEnd),
401             suffixOutside = textNode2.getText().substr(params.offsetEnd)
402         ;
403
404         if(!(textNode1.parent().sameNode(textNode2.parent()))) {
405             throw new Error('Wrapping text in non-sibling text nodes not supported.');
406         }
407         
408         var wrapperElement = this.createDocumentNode({tagName: params._with.tagName, attrs: params._with.attrs});
409         textNode1.after(wrapperElement);
410         textNode1.detach();
411         
412         if(prefixOutside.length > 0) {
413             wrapperElement.before({text:prefixOutside});
414         }
415         if(sameNode) {
416             var core = textNode1.getText().substr(params.offsetStart, params.offsetEnd - params.offsetStart);
417             wrapperElement.append({text: core});
418         } else {
419             textNode2.detach();
420             if(prefixInside.length > 0) {
421                 wrapperElement.append({text: prefixInside});
422             }
423             for(var i = idx1 + 1; i < idx2; i++) {
424                 wrapperElement.append(contentsInside[i]);
425             }
426             if(suffixInside.length > 0) {
427                 wrapperElement.append({text: suffixInside});
428             }
429         }
430         if(suffixOutside.length > 0) {
431             wrapperElement.after({text: suffixOutside});
432         }
433         return wrapperElement;
434     },
435     replaceRoot: function(node) {
436         var insertion = this.getNodeInsertion(node);
437         this.root.detach();
438         this._defineDocumentProperties(insertion.ofNode._$);
439         insertion.ofNode.triggerChangeEvent('nodeAdded');
440         return insertion.ofNode;
441     },
442     deleteText: function(params) {
443         var ptr, next, toDetach, middle, text;
444
445         if(params.from.node.sameNode(params.to.node)) {
446             ptr = params.from.node;
447             text = ptr.getText();
448             ptr.setText(text.substr(0, params.from.offset) + text.substr(params.to.offset));
449             return;
450         }
451
452         // Both edge text nodes need to be edited before anything else happen in case that
453         // they get merged when detaching content between them.
454         params.from.node.setText(params.from.node.getText().substr(0, params.from.offset));
455         params.to.node.setText(params.to.node.getText().substr(params.to.offset));
456
457         ptr = params.from.node;
458         next = ptr.next();
459
460         while(next || ptr.parent()) {
461             if(next) {
462                 if(next.sameNode(params.to.node)) {
463                     return;
464                 }
465                 else if(next.nodeType === Node.ELEMENT_NODE && next.containsNode(params.to.node)) {
466                     middle = next;
467                     break;
468                 } else {
469                     toDetach = next;
470                     next = next.next();
471                     toDetach.detach();
472                 }
473             } else {
474                 ptr = ptr.parent();
475                 next = ptr.next();
476             }
477         }
478
479         if(!this.containsNode(params.to.node)) {
480             // The end node was merged during detaching nodes above - there is nothing more left to do.
481             return;
482         }
483
484         ptr = middle.contents()[0];
485         while(ptr && !ptr.sameNode(params.to.node)) {
486             if(ptr.nodeType === Node.ELEMENT_NODE && ptr.containsNode(params.to.node)) {
487                 ptr = ptr.contents()[0];
488                 continue;
489             } else {
490                 ptr = ptr.next();
491                 ptr.prev().detach();
492             }
493         }
494     }
495 };
496
497 return {
498     document: {
499         transformations: documentTransformations
500     },
501     documentNode: {
502         transformations: documentNodeTransformations
503     },
504     elementNode: {
505         transformations: elementNodeTransformations
506     },
507     textNode: {
508         transformations: textNodeTransformations
509     }
510 };
511
512 });