5e461eea91d75fa09bbc8a3e1efb160cb4f52f92
[fnpeditor.git] / src / smartxml / transformations.js
1 define(function(require) {
2     
3 'use strict';
4
5 var _ = require('libs/underscore'),
6     toret = {};
7
8 var getTransDesc = function(desc, name) {
9     if(typeof desc === 'function') {
10         desc = {impl: desc};
11     }
12     if(!desc.impl) {
13         throw new Error('Got transformation description without implementation.')
14     }
15     return desc;
16 };
17
18 toret.createGenericTransformation = function(desc, name) {
19     desc = getTransDesc(desc);
20     
21     var GenericTransformation = function(document, args) {
22         this.args = args || [];
23
24         var transformation = this;
25         // _.keys(this.args).forEach(function(key) {
26         //     if(transformation.args[key].nodeType) { //@@ change to instanceof check, fix circular dependency
27         //         var value = transformation.args[key],
28         //             path = value.getPath();
29         //         Object.defineProperty(transformation.args, key, {
30         //             get: function() {
31         //                 if(transformation.hasRun) {
32         //                     //console.log('returning via path');
33         //                     return transformation.document.getNodeByPath(path);
34         //                 } else {
35         //                     //console.log('returning original arg');
36         //                     return value;
37
38         //                 }
39         //             }
40         //         });
41         //     }
42         // });
43
44         // potem spr na dotychczasowych undo/redo tests;
45         
46
47         this.args.forEach(function(arg, idx, args) {
48             var path;
49             if(arg) {
50                 if(arg.nodeType) { // ~
51                     path = arg.getPath();
52                     Object.defineProperty(args, idx, {
53                         get: function() {
54                             if(transformation.hasRun && path) {
55                                 return transformation.document.getNodeByPath(path);
56                             } else {
57                                 return arg;
58                             }
59                         }
60                     });
61                 } else if(_.isObject(arg)) {
62                     _.keys(arg).forEach(function(key) {
63                         var value = arg[key],
64                             path;
65                         if(value && value.nodeType) {
66                             path = value.getPath();
67                             Object.defineProperty(arg, key, {
68                                 get: function() {
69                                     if(transformation.hasRun && path) {
70                                         return transformation.document.getNodeByPath(path);
71                                     } else {
72                                         return value;
73                                     }
74                                 }
75                             });   
76                         }
77                     });
78                 }
79             }
80         });
81
82         this.document = document;
83         this.hasRun = false;
84         if(desc.init) {
85             desc.init.call(this);
86         }
87     };
88     _.extend(GenericTransformation.prototype, {
89         name: name,
90         run: function(options) {
91             var changeRoot;
92             if(!desc.undo && options.beUndoable) {
93                 changeRoot = desc.getChangeRoot ? desc.getChangeRoot.call(this) : this.document.root;
94                 this.snapshot = changeRoot.clone();
95                 this.changeRootPath = changeRoot.getPath();
96             }
97             //var toret = desc.impl.call(this.context, this.args); // a argumenty do metody?
98             var toret = desc.impl.apply(this.context, this.args);
99             this.hasRun = true;
100             return toret;
101         },
102         undo: function() {
103             if(desc.undo) {
104                 desc.undo.call(this.context);
105             } else {
106                 this.document.getNodeByPath(this.changeRootPath).replaceWith(this.snapshot);
107             }
108         },
109     });
110
111     return GenericTransformation;
112 };
113 // var T = createGenericTransformation({impl: function() {}});
114 // var t = T(doc, {a:1,b:2,c3:3});
115
116
117 toret.createContextTransformation = function(desc, name) {
118     // mozna sie pozbyc przez przeniesienie object/context na koniec argumentow konstruktora generic transformation
119     var GenericTransformation = toret.createGenericTransformation(desc, name);
120
121     var ContextTransformation = function(document, object, args) {
122         GenericTransformation.call(this, document, args);
123
124         if(document === object) {
125             this.context = document;
126         } else {      
127             var contextPath = object.getPath(),
128                 transformation = this;
129             Object.defineProperty(this, 'context', {
130                 get: function() {
131                     // todo: to jakos inaczej, bo np. this.context w undo transformacji before to juz nie ten sam obiekt
132                     // moze transformacja powinna zwracac zmodyfikowana sciezke do obiektu po dzialaniu run?
133                     
134                     if(transformation.hasRun) {
135                         //console.log('returning via path');
136                         return transformation.document.getNodeByPath(contextPath);
137                     } else {
138                         //console.log('returning original arg');
139                         return object;
140
141                     }
142                 }
143             });
144         }
145     }
146     ContextTransformation.prototype = Object.create(GenericTransformation.prototype);
147     return ContextTransformation;
148 }
149 // var T = createContextTransformation({impl: function() {}});
150 // var t = T(doc, node, {a:1,b:2,c3:3});
151 ///
152
153
154
155 toret.TransformationStorage = function() {
156     this._transformations = {};
157 };
158
159 _.extend(toret.TransformationStorage.prototype, {
160     
161     register: function(Transformation) {
162         var list = (this._transformations[Transformation.prototype.name] = this._transformations[Transformation.prototype.name] || []);
163         list.push(Transformation);
164     },
165
166     get: function(name) {
167         var transformations = this._transformations[name];
168         if(!transformations) {
169             throw new Error('Transformation "' + name + '" not found!');
170         }
171         // na razie zwraca pierwsza
172         return transformations[0];
173     }
174 });
175
176
177
178 // var registerTransformationFromMethod = (object, methodName, desc) {
179 //         if(!object[methodName]) {
180 //             throw new Exeption('Cannot register transformation from unknown method ' + methodName + ' on ' + object);
181 //         }
182 //         desc.impl = object[name];
183 //         Transformation = createContextTransformation(desc);
184 //         object.prototype.registerContextTransformation(name, createContextTransformation(method));
185 // };
186
187
188 // registerTransformationFromMethod(ElementNode, 'setAttr', {
189 //     impl: function(args) {
190 //         this.setAttr(args.name, args.value);
191 //     },
192 //     getChangeRoot: function() {
193 //         return this.context;
194 //     }
195
196 // });
197
198 return toret;
199
200 });