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