boundries → boundaries
[fnpeditor.git] / src / smartxml / transformations.js
1 define(function(require) {
2     
3 'use strict';
4
5 var _ = require('libs/underscore'),
6     toret = {};
7
8
9 var getTransDesc = function(desc) {
10     if(typeof desc === 'function') {
11         desc = {impl: desc};
12     }
13     if(!desc.impl) {
14         throw new Error('Got transformation description without implementation.');
15     }
16     return desc;
17 };
18
19 toret.createGenericTransformation = function(desc, name) {
20     desc = getTransDesc(desc);
21     
22     var GenericTransformation = function(document, args) {
23         this.args = args || [];
24         var transformation = this;
25         
26         var patchObject = function(obj, depth) {
27             depth = _.isNumber(depth) ? depth : 1;
28             if(depth > 3) {
29                 return;
30             }
31             _.keys(obj).forEach(function(key) {
32                 var value = obj[key];
33                 if(value) {
34                     if(value.nodeType) {
35                         transformation.wrapNodeProperty(obj, key);
36                     } else if(_.isObject(value)) {
37                         patchObject(value, depth+1);
38                     }
39                 }
40             });
41         };
42
43         this.args.forEach(function(arg, idx, args) {
44             if(arg) {
45                 if(arg.nodeType) { // ~
46                     transformation.wrapNodeProperty(args, idx);
47                 } else if(_.isObject(arg)) {
48                     patchObject(arg);
49                 }
50             }
51         });
52
53         this.document = document;
54         this.runCount = 0;
55         if(desc.init) {
56             desc.init.call(this);
57         }
58     };
59     _.extend(GenericTransformation.prototype, {
60         name: name,
61         run: function(options) {
62             var changeRoot;
63             if(!desc.undo && options.beUndoable) {
64                 changeRoot = this.getChangeRoot();
65                 if(!changeRoot) {
66                      throw new Error(
67                          'Transformation {name} returned invalid change root value'
68                          .replace('{name}', name)
69                      );
70                 }
71                 this.changeRootPath = changeRoot.getPath();
72                 this.snapshot = changeRoot.clone();
73             }
74             var argsToPass = desc.undo ? [this].concat(this.args) : this.args;
75             var toret = desc.impl.apply(this.context, argsToPass);
76             this.runCount++;
77             return toret;
78         },
79         undo: function() {
80             if(desc.undo) {
81                 desc.undo.call(this.context, this);
82                 this.runCount++;
83             } else {
84                 this.document.getNodeByPath(this.changeRootPath).replaceWith(this.snapshot);
85             }
86         },
87         getChangeRoot: desc.getChangeRoot || function() {
88             return this.document.root;
89         },
90         wrapNodeProperty: function(object, propName, value) {
91             var transformation = this,
92                 lastRunNumber = 0,
93                 path;
94             
95             value = value || object[propName];
96             if(value && value.nodeType) {
97                 path = value.getPath();
98                 Object.defineProperty(object, propName, {
99                     get: function() {
100                         if((lastRunNumber !== transformation.runCount) && path) {
101                             value = transformation.document.getNodeByPath(path);
102                             lastRunNumber = transformation.runCount;
103                         }
104                         return value;
105                     }
106                 });
107             }
108         }
109     });
110
111     return GenericTransformation;
112 };
113
114 toret.createContextTransformation = function(desc, name) {
115     var GenericTransformation = toret.createGenericTransformation(desc, name);
116
117     var ContextTransformation = function(document, object, args) {
118         GenericTransformation.call(this, document, args);
119
120         if(document === object) {
121             this.context = document;
122         } else {
123             this.wrapNodeProperty(this, 'context', object);
124         }
125     };
126     ContextTransformation.prototype = Object.create(GenericTransformation.prototype);
127     return ContextTransformation;
128 };
129
130 return toret;
131
132 });