+var registerMethod = function(methodName, method, target) {
+ if(target[methodName]) {
+ throw new Error('Cannot extend {target} with method name {methodName}. Name already exists.'
+ .replace('{target}', target)
+ .replace('{methodName}', methodName)
+ );
+ }
+ target[methodName] = method;
+};
+
+
+var Document = function(xml, extensions) {
+ this.undoStack = [];
+ this.redoStack = [];
+ this._currentTransaction = null;
+ this._transformationLevel = 0;
+
+ this._nodeMethods = {};
+ this._textNodeMethods = {};
+ this._elementNodeMethods = {};
+ this._nodeTransformations = {};
+ this._textNodeTransformations = {};
+ this._elementNodeTransformations = {};
+
+ this.registerExtension(coreTransformations);
+
+ (extensions || []).forEach(function(extension) {
+ this.registerExtension(extension);
+ }.bind(this));
+ this.loadXML(xml);
+};
+
+$.extend(Document.prototype, Backbone.Events, fragments, {
+ ElementNodeFactory: ElementNode,
+ TextNodeFactory: TextNode,
+
+ createDocumentNode: function(from) {
+ var cached;
+
+ if(from instanceof Node) {
+ /* globals Text */
+ cached = from instanceof Text ? from.__smartxmlTextNodeInstance : ($(from).data(privateKey) || {}).node;
+ if(cached instanceof DocumentNode) {
+ return cached;
+ }
+ } else {
+ if(typeof from === 'string') {
+ from = parseXML(from);
+ this.normalizeXML(from);
+ } else {
+ if(from.text !== undefined) {
+ /* globals document */
+ from = document.createTextNode(from.text);
+ } else {
+ if(!from.tagName) {
+ throw new Error('tagName missing');
+ }
+ var node = $('<' + from.tagName + '>');
+
+ _.keys(from.attrs || {}).forEach(function(key) {
+ node.attr(key, from.attrs[key]);
+ });
+
+ from = node[0];
+ }
+ }
+ }
+ var Factory, typeMethods, typeTransformations;
+ if(from.nodeType === Node.TEXT_NODE) {
+ Factory = this.TextNodeFactory;
+ typeMethods = this._textNodeMethods;
+ typeTransformations = this._textNodeTransformations;
+ } else if(from.nodeType === Node.ELEMENT_NODE) {
+ Factory = this.ElementNodeFactory;
+ typeMethods = this._elementNodeMethods;
+ typeTransformations = this._elementNodeTransformations;
+ }
+ var toret = new Factory(from, this);
+ _.extend(toret, this._nodeMethods);
+ _.extend(toret, typeMethods);
+
+ _.extend(toret, this._nodeTransformations);
+ _.extend(toret, typeTransformations);
+
+ toret.__super__ = _.extend({}, this._nodeMethods, this._nodeTransformations);
+ _.keys(toret.__super__).forEach(function(key) {
+ toret.__super__[key] = _.bind(toret.__super__[key], toret);
+ });
+
+ return toret;
+ },
+
+ loadXML: function(xml, options) {
+ options = options || {};
+ this._defineDocumentProperties($(parseXML(xml)));
+ this.normalizeXML(this.dom);
+ if(!options.silent) {
+ this.trigger('contentSet');
+ }
+ },
+
+ normalizeXML: function(nativeNode) {
+ void(nativeNode); // noop
+ },
+
+ toXML: function() {
+ return this.root.toXML();
+ },
+
+ containsNode: function(node) {
+ return this.root && this.root.containsNode(node);
+ },
+
+ getSiblingParents: function(params) {
+ var parents1 = [params.node1].concat(params.node1.parents()).reverse(),
+ parents2 = [params.node2].concat(params.node2.parents()).reverse(),
+ noSiblingParents = null;
+
+ if(parents1.length === 0 || parents2.length === 0 || !(parents1[0].sameNode(parents2[0]))) {
+ return noSiblingParents;
+ }
+
+ var stop = Math.min(parents1.length, parents2.length),
+ i;
+ for(i = 0; i < stop; i++) {
+ if(parents1[i].sameNode(parents2[i])) {
+ continue;
+ }
+ break;
+ }
+ if(i === stop) {
+ i--;
+ }
+ return {node1: parents1[i], node2: parents2[i]};
+ },
+
+ trigger: function() {
+ Backbone.Events.trigger.apply(this, arguments);
+ },
+
+ getNodeInsertion: function(node) {
+ var insertion = {};
+ if(node instanceof DocumentNode) {
+ insertion.ofNode = node;
+ insertion.insertsNew = !this.containsNode(node);
+ } else {
+ insertion.ofNode = this.createDocumentNode(node);
+ insertion.insertsNew = true;
+ }
+ return insertion;
+ },
+
+ registerMethod: function(methodName, method, dstName) {
+ var doc = this;
+ var destination = {
+ document: doc,
+ documentNode: doc._nodeMethods,
+ textNode: doc._textNodeMethods,
+ elementNode: doc._elementNodeMethods
+ }[dstName];
+ registerMethod(methodName, method, destination);
+ },
+
+ registerTransformation: function(desc, name, dstName) {
+ var doc = this;
+ var destination = {
+ document: doc,
+ documentNode: doc._nodeTransformations,
+ textNode: doc._textNodeTransformations,
+ elementNode: doc._elementNodeTransformations
+ }[dstName];
+ registerTransformation(desc, name, destination);
+ },
+
+ registerExtension: function(extension) {
+ var doc = this;
+
+ ['document', 'documentNode', 'elementNode', 'textNode'].forEach(function(dstName) {
+ var dstExtension = extension[dstName];
+ if(dstExtension) {
+ if(dstExtension.methods) {
+ _.pairs(dstExtension.methods).forEach(function(pair) {
+ var methodName = pair[0],
+ method = pair[1];
+
+ doc.registerMethod(methodName, method, dstName);
+
+ });
+ }
+
+ if(dstExtension.transformations) {
+ _.pairs(dstExtension.transformations).forEach(function(pair) {
+ var name = pair[0],
+ desc = pair[1];
+ doc.registerTransformation(desc, name, dstName);
+ });
+ }
+ }
+ });
+ },
+
+ ifChanged: function(context, action, documentChangedHandler, documentUnchangedHandler) {
+ var hasChanged = false,
+ changeMonitor = function() {
+ hasChanged = true;
+ };
+
+ this.on('change', changeMonitor);
+ action.call(context);
+ this.off('change', changeMonitor);
+
+ if(hasChanged) {
+ if(documentChangedHandler) {
+ documentChangedHandler.call(context);
+ }
+ } else {
+ if(documentUnchangedHandler) {
+ documentUnchangedHandler.call(context);
+ }
+ }
+ },
+
+ transform: function(Transformation, args) {
+ var toret, transformation;
+
+ if(!this._currentTransaction) {
+ return this.transaction(function() {
+ return this.transform(Transformation, args);
+ }, {context: this});
+ }
+
+ if(typeof Transformation === 'function') {
+ transformation = new Transformation(this, this, args);
+ } else {
+ transformation = Transformation;
+ }
+ if(transformation) {
+ this._transformationLevel++;
+
+ this.ifChanged(
+ this,
+ function() {
+ toret = transformation.run({beUndoable:this._transformationLevel === 1});
+ },
+ function() {
+ if(this._transformationLevel === 1 && !this._undoInProgress) {
+ this._currentTransaction.pushTransformation(transformation);
+ this.redoStack = [];
+ }
+ }
+ );
+
+ this._transformationLevel--;
+ return toret;
+ } else {
+ throw new Error('Transformation ' + transformation + ' doesn\'t exist!');
+ }
+ },
+ undo: function() {
+ var transaction = this.undoStack.pop(),
+ doc = this,
+ transformations, stopAt;
+
+ if(transaction) {
+ this._undoInProgress = true;
+
+ // We will modify this array in a minute so make sure we work on a copy.
+ transformations = transaction.transformations.slice(0);
+
+ if(transformations.length > 1) {
+ // In case of real transactions we don't want to run undo on all of transformations if we don't have to.
+ transformations.some(function(t, idx) {
+ if(!t.undo && t.getChangeRoot().sameNode(doc.root)) {
+ stopAt = idx;
+ return true; //break
+ }
+ });
+ if(stopAt !== undefined) {
+ // We will get away with undoing only this transformations as the one at stopAt reverses the whole document.
+ transformations = transformations.slice(0, stopAt+1);
+ }
+ }
+
+ transformations.reverse();
+ transformations.forEach(function(t) {
+ t.undo();
+ });
+
+ this._undoInProgress = false;
+ this.redoStack.push(transaction);
+ this.trigger('operationEnd');
+ }
+ },
+ redo: function() {
+ var transaction = this.redoStack.pop();
+ if(transaction) {
+ this._transformationLevel++;
+ transaction.transformations.forEach(function(t) {
+ t.run({beUndoable: true});
+ });
+ this._transformationLevel--;
+ this.undoStack.push(transaction);
+ this.trigger('operationEnd');
+
+ }
fnp / fnpeditor.git / blobdiff