92152879842045b4588c1b2de3b20e1ac5c59fe0
[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 Document = function(xml) {
579     this.loadXML(xml);
580     this.undoStack = [];
581     this.redoStack = [];
582     this._transformationLevel = 0;
583     this.transformations = new transformations.TransformationStorage();
584     
585     this._nodeMethods = {};
586     this._nodeTransformations = new transformations.TransformationStorage();
587 };
588
589 $.extend(Document.prototype, Backbone.Events, {
590     ElementNodeFactory: ElementNode,
591     TextNodeFactory: TextNode,
592
593     createDocumentNode: function(from) {
594         if(!(from instanceof Node)) {
595             if(from.text !== undefined) {
596                 /* globals document */
597                 from = document.createTextNode(from.text);
598             } else {
599                 var node = $('<' + from.tagName + '>');
600
601                 _.keys(from.attrs || {}).forEach(function(key) {
602                     node.attr(key, from.attrs[key]);
603                 });
604
605                 from = node[0];
606             }
607         }
608         var Factory;
609         if(from.nodeType === Node.TEXT_NODE) {
610             Factory = this.TextNodeFactory;
611         } else if(from.nodeType === Node.ELEMENT_NODE) {
612             Factory = this.ElementNodeFactory;
613         }
614         var toret = new Factory(from, this);
615         _.extend(toret, this._nodeMethods);
616         toret.transformations = this._nodeTransformations;
617         return toret;
618     },
619
620     loadXML: function(xml, options) {
621         options = options || {};
622         defineDocumentProperties(this, $(parseXML(xml)));
623         if(!options.silent) {
624             this.trigger('contentSet');
625         }
626     },
627
628     toXML: function() {
629         return this.root.toXML();
630     },
631
632     containsNode: function(node) {
633         return this.root && (node.nativeNode === this.root.nativeNode || node._$.parents().index(this.root._$) !== -1);
634     },
635
636     wrapNodes: function(params) {
637         if(!(params.node1.parent().sameNode(params.node2.parent()))) {
638             throw new Error('Wrapping non-sibling nodes not supported.');
639         }
640
641         var parent = params.node1.parent(),
642             parentContents = parent.contents(),
643             wrapper = this.createDocumentNode({
644                 tagName: params._with.tagName,
645                 attrs: params._with.attrs}),
646             idx1 = parent.indexOf(params.node1),
647             idx2 = parent.indexOf(params.node2);
648
649         if(idx1 > idx2) {
650             var tmp = idx1;
651             idx1 = idx2;
652             idx2 = tmp;
653         }
654
655         var insertingMethod, insertingTarget;
656         if(idx1 === 0) {
657             insertingMethod = 'prepend';
658             insertingTarget = parent;
659         } else {
660             insertingMethod = 'after';
661             insertingTarget = parentContents[idx1-1];
662         }
663
664         for(var i = idx1; i <= idx2; i++) {
665             wrapper.append(parentContents[i].detach());
666         }
667
668         insertingTarget[insertingMethod](wrapper);
669         return wrapper;
670     },
671
672     getSiblingParents: function(params) {
673         var parents1 = [params.node1].concat(params.node1.parents()).reverse(),
674             parents2 = [params.node2].concat(params.node2.parents()).reverse(),
675             noSiblingParents = null;
676
677         if(parents1.length === 0 || parents2.length === 0 || !(parents1[0].sameNode(parents2[0]))) {
678             return noSiblingParents;
679         }
680
681         var i;
682         for(i = 0; i < Math.min(parents1.length, parents2.length); i++) {
683             if(parents1[i].sameNode(parents2[i])) {
684                 continue;
685             }
686             break;
687         }
688         return {node1: parents1[i], node2: parents2[i]};
689     },
690
691     _wrapText: function(params) {
692         params = _.extend({textNodeIdx: 0}, params);
693         if(typeof params.textNodeIdx === 'number') {
694             params.textNodeIdx = [params.textNodeIdx];
695         }
696         
697         var contentsInside = params.inside.contents(),
698             idx1 = Math.min.apply(Math, params.textNodeIdx),
699             idx2 = Math.max.apply(Math, params.textNodeIdx),
700             textNode1 = contentsInside[idx1],
701             textNode2 = contentsInside[idx2],
702             sameNode = textNode1.sameNode(textNode2),
703             prefixOutside = textNode1.getText().substr(0, params.offsetStart),
704             prefixInside = textNode1.getText().substr(params.offsetStart),
705             suffixInside = textNode2.getText().substr(0, params.offsetEnd),
706             suffixOutside = textNode2.getText().substr(params.offsetEnd)
707         ;
708
709         if(!(textNode1.parent().sameNode(textNode2.parent()))) {
710             throw new Error('Wrapping text in non-sibling text nodes not supported.');
711         }
712         
713         var wrapperElement = this.createDocumentNode({tagName: params._with.tagName, attrs: params._with.attrs});
714         textNode1.after(wrapperElement);
715         textNode1.detach();
716         
717         if(prefixOutside.length > 0) {
718             wrapperElement.before({text:prefixOutside});
719         }
720         if(sameNode) {
721             var core = textNode1.getText().substr(params.offsetStart, params.offsetEnd - params.offsetStart);
722             wrapperElement.append({text: core});
723         } else {
724             textNode2.detach();
725             if(prefixInside.length > 0) {
726                 wrapperElement.append({text: prefixInside});
727             }
728             for(var i = idx1 + 1; i < idx2; i++) {
729                 wrapperElement.append(contentsInside[i]);
730             }
731             if(suffixInside.length > 0) {
732                 wrapperElement.append({text: suffixInside});
733             }
734         }
735         if(suffixOutside.length > 0) {
736             wrapperElement.after({text: suffixOutside});
737         }
738         return wrapperElement;
739     },
740
741     trigger: function() {
742         //console.log('trigger: ' + arguments[0] + (arguments[1] ? ', ' + arguments[1].type : ''));
743         Backbone.Events.trigger.apply(this, arguments);
744     },
745
746     getNodeInsertion: function(node) {
747         var insertion = {};
748         if(node instanceof DocumentNode) {
749             insertion.ofNode = node;
750             insertion.insertsNew = !this.containsNode(node);
751         } else {
752           insertion.ofNode = this.createDocumentNode(node);
753           insertion.insertsNew = true;
754         }
755         return insertion;
756     },
757
758     replaceRoot: function(node) {
759         var insertion = this.getNodeInsertion(node);
760         this.root.detach();
761         defineDocumentProperties(this, insertion.ofNode._$);
762         insertion.ofNode.triggerChangeEvent('nodeAdded');
763         return insertion.ofNode;
764     },
765
766     registerMethod: function(methodName, method) {
767         this[methodName] = method;
768     },
769
770     registerTransformation: function(Transformation) {
771         return this.transformations.register(Transformation);
772     },
773
774     registerNodeMethod: function(methodName, method) {
775         this._nodeMethods[methodName] = method;
776     },
777
778     registerNodeTransformation: function(Transformation) {
779         this._nodeTransformations.register(Transformation);
780     },
781
782     registerExtension: function(extension) {
783         //debugger;
784         var doc = this,
785             existingPropertyNames = _.values(this);
786
787         var getTrans = function(desc, methodName) {
788             if(typeof desc === 'function') {
789                 desc = {impl: desc};
790             }
791             if(!desc.impl) {
792                 throw new Error('Got transformation description without implementation.')
793             }
794             desc.name = desc.name || methodName;
795             return desc;
796         };
797
798         [
799             {source: extension.document, target: doc},
800             {source: extension.documentNode, target: [doc.ElementNodeFactory.prototype, doc.TextNodeFactory.prototype]},
801
802         ].forEach(function(mapping) {
803             if(mapping.source) {
804                 if(mapping.source.methods) {
805                     existingPropertyNames = _.values(mapping.target)
806                     _.pairs(mapping.source.methods).forEach(function(pair) {
807                         var methodName = pair[0],
808                             method = pair[1],
809                             targets = _.isArray(mapping.target) ? mapping.target : [mapping.target];
810                         if(_.contains(existingPropertyNames, methodName)) {
811                             throw new Error('Cannot extend {target} with method name {methodName}. Name already exists.'
812                                 .replace('{target}', mapping.target)
813                                 .replace('{methodName}', methodName)
814                             );
815                         }
816                         targets.forEach(function(target) {
817                             if(target === doc) {
818                                 target.registerMethod(methodName, method);
819                             } else {
820                                 doc.registerNodeMethod(methodName, method);
821                             }
822
823                         });
824                     });
825                 }
826
827                 if(mapping.source.transformations) {
828                     _.pairs(mapping.source.transformations).forEach(function(pair) {
829                         var transformation = getTrans(pair[1], pair[0]),
830                             targets = _.isArray(mapping.target) ? mapping.target : [mapping.target];
831                         targets.forEach(function(target) {
832                             if(target === doc) {
833                                 target.registerTransformation(transformations.createContextTransformation(transformation));    
834                             } else {
835                                 doc.registerNodeTransformation(transformations.createContextTransformation(transformation));
836                             }
837
838                             
839                         });
840                     });
841                 }
842             }
843         });
844     },
845
846     transform: function(transformation, args) {
847         //console.log('transform');
848         var Transformation, toret;
849         if(typeof transformation === 'string') {
850             Transformation = this.transformations.get(transformation);
851             if(Transformation) {
852                 transformation = new Transformation(this, this, args);
853             }
854         } 
855         if(transformation) {
856             this._transformationLevel++;
857             toret = transformation.run();
858             if(this._transformationLevel === 1) {
859                 this.undoStack.push(transformation);
860             }
861             this._transformationLevel--;
862             //console.log('clearing redo stack');
863             this.redoStack = [];
864             return toret;
865         } else {
866             throw new Error('Transformation ' + transformation + ' doesn\'t exist!');
867         }
868     },
869     undo: function() {
870         var transformation = this.undoStack.pop();
871         if(transformation) {
872             transformation.undo();
873             this.redoStack.push(transformation);
874         }
875     },
876     redo: function() {
877         var transformation = this.redoStack.pop();
878         if(transformation) {
879             transformation.run();
880             this.undoStack.push(transformation);
881         }
882     },
883
884     getNodeByPath: function(path) {
885         var toret = this.root;
886         path.forEach(function(idx) {
887             toret = toret.contents()[idx];
888         });
889         return toret;
890     }
891 });
892
893 var defineDocumentProperties = function(doc, $document) {
894     Object.defineProperty(doc, 'root', {get: function() {
895         return doc.createDocumentNode($document[0]);
896     }, configurable: true});
897     Object.defineProperty(doc, 'dom', {get: function() {
898         return $document[0];
899     }, configurable: true});
900 };
901
902 // Document.prototype.transformations.register(transformations.createContextTransformation({
903 //     name: 'smartxml.wrapNodes',
904 //     // init: function() {
905
906 //     // },
907 //     // getChangeRoot: function() {
908 //     //     return this.context;
909 //     // },
910 //     impl: function(args) {
911 //         this.wrapNodes(args);
912 //     },
913
914 // }));
915
916
917 return {
918     documentFromXML: function(xml) {
919         return new Document(xml);
920     },
921
922     elementNodeFromXML: function(xml) {
923         return this.documentFromXML(xml).root;
924     },
925
926     Document: Document,
927     DocumentNode: DocumentNode,
928     ElementNode: ElementNode,
929     TextNode: TextNode
930 };
931
932 });