3ff9df7826f925c5ea07cbc9055abd9deb82448f
[fnpeditor.git] / src / smartxml / smartxml.js
1 define([
2     'libs/jquery',
3     'libs/underscore',
4     'libs/backbone',
5     'smartxml/events',
6     'smartxml/transformations'
7 ], function($, _, Backbone, events, transformations) {
8     
9 'use strict';
10 /* globals Node */
11
12 var TEXT_NODE = Node.TEXT_NODE;
13
14
15 var INSERTION = function(implementation) {
16     var toret = function(node) {
17         var insertion = this.getNodeInsertion(node),
18             nodeWasContained = this.document.containsNode(insertion.ofNode),
19             nodeParent;
20         if(!(this.document.containsNode(this))) {
21             nodeParent = insertion.ofNode.parent();
22         }
23         implementation.call(this, insertion.ofNode.nativeNode);
24         this.triggerChangeEvent(insertion.insertsNew ? 'nodeAdded' : 'nodeMoved', {node: insertion.ofNode}, nodeParent, nodeWasContained);
25         return insertion.ofNode;
26     };
27     return toret;
28 };
29
30 var DocumentNode = function(nativeNode, document) {
31     if(!document) {
32         throw new Error('undefined document for a node');
33     }
34     this.document = document;
35     this._setNativeNode(nativeNode);
36
37 };
38
39 $.extend(DocumentNode.prototype, {
40
41     transform: function(name, args) {
42         var Transformation = this.transformations.get(name),
43             transformation;
44         if(Transformation) {
45             transformation = new Transformation(this.document, this, args);
46         }
47         return this.document.transform(transformation);
48     },
49
50     _setNativeNode: function(nativeNode) {
51         this.nativeNode = nativeNode;
52         this._$ = $(nativeNode);
53     },
54
55     clone: function() {
56         var clone = this._$.clone(true, true);
57         // clone.find('*').addBack().each(function() {
58         //     var n = $(this);
59         //     if(n.data('canvasElement')) {
60         //         n.data('canvasElement', $.extend(true, {}, n.data('canvasElement')));
61         //         n.data('canvasElement').$element = n.data('canvasElement').$element.clone(true, true);
62         //     }
63         // });
64         return this.document.createDocumentNode(clone[0]);
65     },
66
67     getPath: function(ancestor) {
68         var nodePath = [this].concat(this.parents()),
69             toret, idx;
70         ancestor = ancestor || this.document.root;
71
72         nodePath.some(function(node, i) {
73             if(node.sameNode(ancestor)) {
74                 idx = i;
75                 return true;
76             }
77         });
78
79         if(idx !== 'undefined') {
80             nodePath = nodePath.slice(0, idx);
81         }
82         toret = nodePath.map(function(node) {return node.getIndex(); });
83         toret.reverse();
84         return toret;
85     },
86
87     isRoot: function() {
88         return this.document.root.sameNode(this);
89     },
90
91     detach: function() {
92         var parent = this.parent();
93         this._$.detach();
94         this.triggerChangeEvent('nodeDetached', {parent: parent});
95         return this;
96     },
97
98     replaceWith: function(node) {
99         var toret;
100         if(this.isRoot()) {
101             return this.document.replaceRoot(node);
102         }
103         toret = this.after(node);
104         this.detach();
105         return toret;
106     },
107
108     sameNode: function(otherNode) {
109         return !!(otherNode) && this.nativeNode === otherNode.nativeNode;
110     },
111
112     parent: function() {
113         var parentNode = this.nativeNode.parentNode;
114         if(parentNode && parentNode.nodeType === Node.ELEMENT_NODE) {
115             return this.document.createDocumentNode(parentNode);
116         }
117         return null;
118     },
119
120     parents: function() {
121         var parent = this.parent(),
122             parents = parent ? parent.parents() : [];
123         if(parent) {
124             parents.unshift(parent);
125         }
126         return parents;
127     },
128
129     prev: function() {
130         var myIdx = this.getIndex();
131         return myIdx > 0 ? this.parent().contents()[myIdx-1] : null;
132     },
133
134     next: function() {
135         if(this.isRoot()) {
136             return null;
137         }
138         var myIdx = this.getIndex(),
139             parentContents = this.parent().contents();
140         return myIdx < parentContents.length - 1 ? parentContents[myIdx+1] : null;
141     },
142
143     isSurroundedByTextElements: function() {
144         var prev = this.prev(),
145             next = this.next();
146         return prev && (prev.nodeType === Node.TEXT_NODE) && next && (next.nodeType === Node.TEXT_NODE);
147     },
148
149     after: INSERTION(function(nativeNode) {
150         return this._$.after(nativeNode);
151     }),
152
153     before: INSERTION(function(nativeNode) {
154         return this._$.before(nativeNode);
155     }),
156
157     wrapWith: function(node) {
158         var insertion = this.getNodeInsertion(node);
159         if(this.parent()) {
160             this.before(insertion.ofNode);
161         }
162         insertion.ofNode.append(this);
163         return insertion.ofNode;
164     },
165
166     /**
167     * Removes parent of a node if node has no siblings.
168     */
169     unwrap: function() {
170         if(this.isRoot()) {
171             return;
172         }
173         var parent = this.parent(),
174             grandParent;
175         if(parent.contents().length === 1) {
176             grandParent = parent.parent();
177             parent.unwrapContent();
178             return grandParent;
179         }
180     },
181
182     triggerChangeEvent: function(type, metaData, origParent, nodeWasContained) {
183         var node = (metaData && metaData.node) ? metaData.node : this,
184             event = new events.ChangeEvent(type, $.extend({node: node}, metaData || {}));
185         if(type === 'nodeDetached' || this.document.containsNode(event.meta.node)) {
186             this.document.trigger('change', event);
187         }
188         if((type === 'nodeAdded' || type === 'nodeMoved') && !this.document.containsNode(this) && nodeWasContained) {
189              event = new events.ChangeEvent('nodeDetached', {node: node, parent: origParent});
190              this.document.trigger('change', event);
191         }
192     },
193     
194     getNodeInsertion: function(node) {
195         return this.document.getNodeInsertion(node);
196     },
197
198     getIndex: function() {
199         if(this.isRoot()) {
200             return 0;
201         }
202         return this.parent().indexOf(this);
203     }
204 });
205
206 var ElementNode = function(nativeNode, document) {
207     DocumentNode.call(this, nativeNode, document);
208 };
209 ElementNode.prototype = Object.create(DocumentNode.prototype);
210
211 $.extend(ElementNode.prototype, {
212     nodeType: Node.ELEMENT_NODE,
213
214     detach: function() {
215         var next;
216         if(this.parent() && this.isSurroundedByTextElements()) {
217             next = this.next();
218             this.prev().appendText(next.getText());
219             next.detach();
220         }
221         return DocumentNode.prototype.detach.call(this);
222     },
223
224     setData: function(key, value) {
225         if(value !== undefined) {
226             this._$.data(key, value);
227         } else {
228             this._$.removeData(_.keys(this._$.data()));
229             this._$.data(key);
230         }
231     },
232
233     getData: function(key) {
234         if(key) {
235             return this._$.data(key);
236         }
237         return this._$.data();
238     },
239
240     getTagName: function() {
241         return this.nativeNode.tagName.toLowerCase();
242     },
243
244     contents: function(selector) {
245         var toret = [],
246             document = this.document;
247         if(selector) {
248             this._$.children(selector).each(function() {
249                 toret.push(document.createDocumentNode(this));
250             });
251         } else {
252             this._$.contents().each(function() {
253                 toret.push(document.createDocumentNode(this));
254             });
255         }
256         return toret;
257     },
258
259     indexOf: function(node) {
260         return this._$.contents().index(node._$);
261     },
262
263     setTag: function(tagName) {
264         var node = this.document.createDocumentNode({tagName: tagName}),
265             oldTagName = this.getTagName(),
266             myContents = this._$.contents();
267
268         this.getAttrs().forEach(function(attribute) {
269             node.setAttr(attribute.name, attribute.value, true);
270         });
271         node.setData(this.getData());
272
273         if(this.sameNode(this.document.root)) {
274             defineDocumentProperties(this.document, node._$);
275         }
276         this._$.replaceWith(node._$);
277         this._setNativeNode(node._$[0]);
278         this._$.append(myContents);
279         this.triggerChangeEvent('nodeTagChange', {oldTagName: oldTagName, newTagName: this.getTagName()});
280     },
281
282     getAttr: function(name) {
283         return this._$.attr(name);
284     },
285
286     setAttr: function(name, value, silent) {
287         var oldVal = this.getAttr(name);
288         this._$.attr(name, value);
289         if(!silent) {
290             this.triggerChangeEvent('nodeAttrChange', {attr: name, oldVal: oldVal, newVal: value});
291         }
292     },
293
294     getAttrs: function() {
295         var toret = [];
296         for(var i = 0; i < this.nativeNode.attributes.length; i++) {
297             toret.push(this.nativeNode.attributes[i]);
298         }
299         return toret;
300     },
301
302     append: INSERTION(function(nativeNode) {
303         this._$.append(nativeNode);
304     }),
305
306     prepend: INSERTION(function(nativeNode) {
307         this._$.prepend(nativeNode);
308     }),
309
310     insertAtIndex: function(nativeNode, index) {
311         var contents = this.contents();
312         if(index < contents.length) {
313             return contents[index].before(nativeNode);
314         } else if(index === contents.length) {
315             return this.append(nativeNode);
316         }
317     },
318
319     unwrapContent: function() {
320         var parent = this.parent();
321         if(!parent) {
322             return;
323         }
324
325         var myContents = this.contents(),
326             myIdx = parent.indexOf(this);
327
328
329         if(myContents.length === 0) {
330             return this.detach();
331         }
332
333         var prev = this.prev(),
334             next = this.next(),
335             moveLeftRange, moveRightRange, leftMerged;
336
337         if(prev && (prev.nodeType === TEXT_NODE) && (myContents[0].nodeType === TEXT_NODE)) {
338             prev.appendText(myContents[0].getText());
339             myContents[0].detach();
340             moveLeftRange = true;
341             leftMerged = true;
342         } else {
343             leftMerged = false;
344         }
345
346         if(!(leftMerged && myContents.length === 1)) {
347             var lastContents = _.last(myContents);
348             if(next && (next.nodeType === TEXT_NODE) && (lastContents.nodeType === TEXT_NODE)) {
349                 next.prependText(lastContents.getText());
350                 lastContents.detach();
351                 moveRightRange = true;
352             }
353         }
354
355         var childrenLength = this.contents().length;
356         this.contents().forEach(function(child) {
357             this.before(child);
358         }.bind(this));
359
360         this.detach();
361
362         return {
363             element1: parent.contents()[myIdx + (moveLeftRange ? -1 : 0)],
364             element2: parent.contents()[myIdx + childrenLength-1 + (moveRightRange ? 1 : 0)]
365         };
366     },
367
368     wrapText: function(params) {
369         return this.document._wrapText(_.extend({inside: this}, params));
370     },
371
372     toXML: function() {
373         var wrapper = $('<div>');
374         wrapper.append(this._getXMLDOMToDump());
375         return wrapper.html();
376     },
377     
378     _getXMLDOMToDump: function() {
379         return this._$;
380     }
381 });
382
383 // trans
384
385 // todo - split+append
386
387 // ElementNode.prototype.transformations.register(transformations.createContextTransformation({
388 //     name: 'smartxml.setAttr',
389 //     impl: function(args) {
390 //         this.setAttr(args.name, args.value);
391 //     },
392 //     getChangeRoot: function() {
393 //         return this.context;
394 //     }
395 // }));
396
397 // ElementNode.prototype.transformations.register(transformations.createContextTransformation({
398 //     name: 'smartxml.setAttr2',
399 //     impl: function(args) {
400 //         this.prevAttr = this.getAttr(args.name);
401 //         this.setAttr(args.name, args.value);
402 //     },
403 //     undo: function(args) {
404 //         this.setAttr(args.name, this.prevAttr);
405 //     }
406 // }));
407
408 // DocumentNode.prototype.transformations.register(transformations.createContextTransformation({
409 //     name: 'smartxml.wrapWith',
410 //     getChangeRoot: function() {
411 //         return this.context.parent();
412 //     },
413 //     impl: function(args) {
414 //         return this.wrapWith(args);
415 //     }
416 // }));
417
418 // DocumentNode.prototype.transformations.register(transformations.createContextTransformation({
419 //     name: 'smartxml.wrapText',
420 //     getChangeRoot: function() {
421 //         return this.context;
422 //     },
423 //     impl: function(args) {
424 //         return this.wrapText(args);
425 //     }
426 // }));
427
428 // DocumentNode.prototype.transformations.register(transformations.createContextTransformation({
429 //     name: 'smartxml.detach',
430 //     getChangeRoot: function() {
431 //         return this.context.parent();
432 //     },
433 //     impl: function(args) {
434 //         return this.detach();
435 //     }
436 // }));
437
438 ///
439
440 var TextNode = function(nativeNode, document) {
441     DocumentNode.call(this, nativeNode, document);
442 };
443 TextNode.prototype = Object.create(DocumentNode.prototype);
444
445 $.extend(TextNode.prototype, {
446     nodeType: Node.TEXT_NODE,
447
448     getText: function() {
449         return this.nativeNode.data;
450     },
451
452     setText: function(text) {
453         //console.log('smartxml: ' + text);
454         this.nativeNode.data = text;
455         this.triggerTextChangeEvent();
456     },
457
458     appendText: function(text) {
459         this.nativeNode.data = this.nativeNode.data + text;
460         this.triggerTextChangeEvent();
461     },
462
463     prependText: function(text) {
464         this.nativeNode.data = text + this.nativeNode.data;
465         this.triggerTextChangeEvent();
466     },
467
468     wrapWith: function(desc) {
469         if(typeof desc.start === 'number' && typeof desc.end === 'number') {
470             return this.document._wrapText({
471                 inside: this.parent(),
472                 textNodeIdx: this.parent().indexOf(this),
473                 offsetStart: Math.min(desc.start, desc.end),
474                 offsetEnd: Math.max(desc.start, desc.end),
475                 _with: {tagName: desc.tagName, attrs: desc.attrs}
476             });
477         } else {
478             return DocumentNode.prototype.wrapWith.call(this, desc);
479         }
480     },
481
482     split: function(params) {
483         var parentElement = this.parent(),
484             passed = false,
485             succeedingChildren = [],
486             prefix = this.getText().substr(0, params.offset),
487             suffix = this.getText().substr(params.offset);
488
489         parentElement.contents().forEach(function(child) {
490             if(passed) {
491                 succeedingChildren.push(child);
492             }
493             if(child.sameNode(this)) {
494                 passed = true;
495             }
496         }.bind(this));
497
498         if(prefix.length > 0) {
499             this.setText(prefix);
500         }
501         else {
502             this.detach();
503         }
504
505         var attrs = {};
506         parentElement.getAttrs().forEach(function(attr) {attrs[attr.name] = attr.value; });
507         var newElement = this.document.createDocumentNode({tagName: parentElement.getTagName(), attrs: attrs});
508         parentElement.after(newElement);
509
510         if(suffix.length > 0) {
511             newElement.append({text: suffix});
512         }
513         succeedingChildren.forEach(function(child) {
514             newElement.append(child);
515         });
516
517         return {first: parentElement, second: newElement};
518     },
519
520     triggerTextChangeEvent: function() {
521         var event = new events.ChangeEvent('nodeTextChange', {node: this});
522         this.document.trigger('change', event);
523     }
524 });
525
526
527 // TextNode.prototype.transformations.register(transformations.createContextTransformation({
528 //     name: 'rng.breakContent',
529 //     // impl: function(args) {
530 //     //     var node = this.context,
531 //     //         newNodes, emptyNode, emptyText;
532 //     //     newNodes = node.transform('smartxml.split', {offset: args.offset});
533 //     //     [newNodes.first, newNodes.second].some(function(newNode) {
534 //     //         if(!(newNode.contents().length)) {
535 //     //             newNode.transform('smartxml.append', {text: ''});
536 //     //             return true; // break
537 //     //         }
538 //     //     });
539 //     //     return _.extend(newNodes, {emptyText: emptyText});
540 //     // },
541 //     impl: function(args) {
542 //         var node = this,
543 //             newNodes, emptyNode, emptyText;
544 //         newNodes = node.split({offset: args.offset});
545 //         [newNodes.first, newNodes.second].some(function(newNode) {
546 //             if(!(newNode.contents().length)) {
547 //                 newNode.append({text: ''});
548 //                 return true; // break
549 //             }
550 //         });
551 //         return _.extend(newNodes, {emptyText: emptyText});
552 //     },
553 //     getChangeRoot: function() {
554 //         return this.context.parent().parent();
555 //     },
556 //     isAllowed: function(args) {
557 //         var parent = this.parent();
558 //         return !!(parent && parent.parent());
559 //     }
560 // }));
561
562
563 // ElementNode.prototype.transformations.register(transformations.createContextTransformation({
564 //     name: 'smartxml.setText',
565 //     impl: function(args) {
566 //         this.setText(args.text);
567 //     },
568 //     getChangeRoot: function() {
569 //         return this.context;
570 //     }
571 // }));
572
573
574 var parseXML = function(xml) {
575     return $($.trim(xml))[0];
576 };
577
578 var registerTransformation = function(desc, name, target) {
579     var Transformation = transformations.createContextTransformation(desc, name);
580     target.register(Transformation);
581 };
582
583
584 var Document = function(xml) {
585     this.loadXML(xml);
586     this.undoStack = [];
587     this.redoStack = [];
588     this._transformationLevel = 0;
589     this.transformations = new transformations.TransformationStorage();
590     
591     this._nodeMethods = {};
592     this._nodeTransformations = new transformations.TransformationStorage();
593 };
594
595 $.extend(Document.prototype, Backbone.Events, {
596     ElementNodeFactory: ElementNode,
597     TextNodeFactory: TextNode,
598
599     createDocumentNode: function(from) {
600         if(!(from instanceof Node)) {
601             if(from.text !== undefined) {
602                 /* globals document */
603                 from = document.createTextNode(from.text);
604             } else {
605                 var node = $('<' + from.tagName + '>');
606
607                 _.keys(from.attrs || {}).forEach(function(key) {
608                     node.attr(key, from.attrs[key]);
609                 });
610
611                 from = node[0];
612             }
613         }
614         var Factory;
615         if(from.nodeType === Node.TEXT_NODE) {
616             Factory = this.TextNodeFactory;
617         } else if(from.nodeType === Node.ELEMENT_NODE) {
618             Factory = this.ElementNodeFactory;
619         }
620         var toret = new Factory(from, this);
621         _.extend(toret, this._nodeMethods);
622         toret.transformations = this._nodeTransformations;
623         return toret;
624     },
625
626     loadXML: function(xml, options) {
627         options = options || {};
628         defineDocumentProperties(this, $(parseXML(xml)));
629         if(!options.silent) {
630             this.trigger('contentSet');
631         }
632     },
633
634     toXML: function() {
635         return this.root.toXML();
636     },
637
638     containsNode: function(node) {
639         return this.root && (node.nativeNode === this.root.nativeNode || node._$.parents().index(this.root._$) !== -1);
640     },
641
642     wrapNodes: function(params) {
643         if(!(params.node1.parent().sameNode(params.node2.parent()))) {
644             throw new Error('Wrapping non-sibling nodes not supported.');
645         }
646
647         var parent = params.node1.parent(),
648             parentContents = parent.contents(),
649             wrapper = this.createDocumentNode({
650                 tagName: params._with.tagName,
651                 attrs: params._with.attrs}),
652             idx1 = parent.indexOf(params.node1),
653             idx2 = parent.indexOf(params.node2);
654
655         if(idx1 > idx2) {
656             var tmp = idx1;
657             idx1 = idx2;
658             idx2 = tmp;
659         }
660
661         var insertingMethod, insertingTarget;
662         if(idx1 === 0) {
663             insertingMethod = 'prepend';
664             insertingTarget = parent;
665         } else {
666             insertingMethod = 'after';
667             insertingTarget = parentContents[idx1-1];
668         }
669
670         for(var i = idx1; i <= idx2; i++) {
671             wrapper.append(parentContents[i].detach());
672         }
673
674         insertingTarget[insertingMethod](wrapper);
675         return wrapper;
676     },
677
678     getSiblingParents: function(params) {
679         var parents1 = [params.node1].concat(params.node1.parents()).reverse(),
680             parents2 = [params.node2].concat(params.node2.parents()).reverse(),
681             noSiblingParents = null;
682
683         if(parents1.length === 0 || parents2.length === 0 || !(parents1[0].sameNode(parents2[0]))) {
684             return noSiblingParents;
685         }
686
687         var i;
688         for(i = 0; i < Math.min(parents1.length, parents2.length); i++) {
689             if(parents1[i].sameNode(parents2[i])) {
690                 continue;
691             }
692             break;
693         }
694         return {node1: parents1[i], node2: parents2[i]};
695     },
696
697     _wrapText: function(params) {
698         params = _.extend({textNodeIdx: 0}, params);
699         if(typeof params.textNodeIdx === 'number') {
700             params.textNodeIdx = [params.textNodeIdx];
701         }
702         
703         var contentsInside = params.inside.contents(),
704             idx1 = Math.min.apply(Math, params.textNodeIdx),
705             idx2 = Math.max.apply(Math, params.textNodeIdx),
706             textNode1 = contentsInside[idx1],
707             textNode2 = contentsInside[idx2],
708             sameNode = textNode1.sameNode(textNode2),
709             prefixOutside = textNode1.getText().substr(0, params.offsetStart),
710             prefixInside = textNode1.getText().substr(params.offsetStart),
711             suffixInside = textNode2.getText().substr(0, params.offsetEnd),
712             suffixOutside = textNode2.getText().substr(params.offsetEnd)
713         ;
714
715         if(!(textNode1.parent().sameNode(textNode2.parent()))) {
716             throw new Error('Wrapping text in non-sibling text nodes not supported.');
717         }
718         
719         var wrapperElement = this.createDocumentNode({tagName: params._with.tagName, attrs: params._with.attrs});
720         textNode1.after(wrapperElement);
721         textNode1.detach();
722         
723         if(prefixOutside.length > 0) {
724             wrapperElement.before({text:prefixOutside});
725         }
726         if(sameNode) {
727             var core = textNode1.getText().substr(params.offsetStart, params.offsetEnd - params.offsetStart);
728             wrapperElement.append({text: core});
729         } else {
730             textNode2.detach();
731             if(prefixInside.length > 0) {
732                 wrapperElement.append({text: prefixInside});
733             }
734             for(var i = idx1 + 1; i < idx2; i++) {
735                 wrapperElement.append(contentsInside[i]);
736             }
737             if(suffixInside.length > 0) {
738                 wrapperElement.append({text: suffixInside});
739             }
740         }
741         if(suffixOutside.length > 0) {
742             wrapperElement.after({text: suffixOutside});
743         }
744         return wrapperElement;
745     },
746
747     trigger: function() {
748         //console.log('trigger: ' + arguments[0] + (arguments[1] ? ', ' + arguments[1].type : ''));
749         Backbone.Events.trigger.apply(this, arguments);
750     },
751
752     getNodeInsertion: function(node) {
753         var insertion = {};
754         if(node instanceof DocumentNode) {
755             insertion.ofNode = node;
756             insertion.insertsNew = !this.containsNode(node);
757         } else {
758           insertion.ofNode = this.createDocumentNode(node);
759           insertion.insertsNew = true;
760         }
761         return insertion;
762     },
763
764     replaceRoot: function(node) {
765         var insertion = this.getNodeInsertion(node);
766         this.root.detach();
767         defineDocumentProperties(this, insertion.ofNode._$);
768         insertion.ofNode.triggerChangeEvent('nodeAdded');
769         return insertion.ofNode;
770     },
771
772     registerMethod: function(methodName, method) {
773         if(this[methodName]) {
774             throw new Error('Cannot extend document with method name {methodName}. Name already exists.'
775                 .replace('{methodName}', methodName)
776             );
777         }
778         this[methodName] = method;
779     },
780
781     registerNodeMethod: function(methodName, method) {
782         if(this._nodeMethods[methodName]) {
783             throw new Error('Cannot extend document with method name {methodName}. Name already exists.'
784                 .replace('{methodName}', methodName)
785             );
786         }
787         this._nodeMethods[methodName] = method;
788     },
789
790     registerDocumentTransformation: function(desc, name) {
791         registerTransformation(desc, name, this.transformations);
792     },
793
794     registerNodeTransformation: function(desc, name) {
795         registerTransformation(desc, name, this._nodeTransformations);
796     },
797
798     registerExtension: function(extension) {
799         //debugger;
800         var doc = this,
801             existingPropertyNames = _.values(this);
802
803         ['document', 'documentNode'].forEach(function(dstName) {
804             var dstExtension = extension[dstName];
805             if(dstExtension) {
806                 if(dstExtension.methods) {
807                     _.pairs(dstExtension.methods).forEach(function(pair) {
808                         var methodName = pair[0],
809                             method = pair[1],
810                             operation;
811                         operation = {document: 'registerMethod', documentNode: 'registerNodeMethod'}[dstName];
812                         doc[operation](methodName, method);
813
814                     });
815                 }
816
817                 if(dstExtension.transformations) {
818                     _.pairs(dstExtension.transformations).forEach(function(pair) {
819                         var name = pair[0],
820                             desc = pair[1],
821                             operation;
822                         operation = {document: 'registerDocumentTransformation', documentNode: 'registerNodeTransformation'}[dstName];
823                         doc[operation](desc, name);
824                     });
825                 }
826             }
827         });
828     },
829
830     transform: function(transformation, args) {
831         //console.log('transform');
832         var Transformation, toret;
833         if(typeof transformation === 'string') {
834             Transformation = this.transformations.get(transformation);
835             if(Transformation) {
836                 transformation = new Transformation(this, this, args);
837             }
838         } 
839         if(transformation) {
840             this._transformationLevel++;
841             toret = transformation.run();
842             if(this._transformationLevel === 1) {
843                 this.undoStack.push(transformation);
844             }
845             this._transformationLevel--;
846             //console.log('clearing redo stack');
847             this.redoStack = [];
848             return toret;
849         } else {
850             throw new Error('Transformation ' + transformation + ' doesn\'t exist!');
851         }
852     },
853     undo: function() {
854         var transformation = this.undoStack.pop();
855         if(transformation) {
856             transformation.undo();
857             this.redoStack.push(transformation);
858         }
859     },
860     redo: function() {
861         var transformation = this.redoStack.pop();
862         if(transformation) {
863             transformation.run();
864             this.undoStack.push(transformation);
865         }
866     },
867
868     getNodeByPath: function(path) {
869         var toret = this.root;
870         path.forEach(function(idx) {
871             toret = toret.contents()[idx];
872         });
873         return toret;
874     }
875 });
876
877 var defineDocumentProperties = function(doc, $document) {
878     Object.defineProperty(doc, 'root', {get: function() {
879         return doc.createDocumentNode($document[0]);
880     }, configurable: true});
881     Object.defineProperty(doc, 'dom', {get: function() {
882         return $document[0];
883     }, configurable: true});
884 };
885
886 // Document.prototype.transformations.register(transformations.createContextTransformation({
887 //     name: 'smartxml.wrapNodes',
888 //     // init: function() {
889
890 //     // },
891 //     // getChangeRoot: function() {
892 //     //     return this.context;
893 //     // },
894 //     impl: function(args) {
895 //         this.wrapNodes(args);
896 //     },
897
898 // }));
899
900
901 return {
902     documentFromXML: function(xml) {
903         return new Document(xml);
904     },
905
906     elementNodeFromXML: function(xml) {
907         return this.documentFromXML(xml).root;
908     },
909
910     Document: Document,
911     DocumentNode: DocumentNode,
912     ElementNode: ElementNode,
913     TextNode: TextNode
914 };
915
916 });