X-Git-Url: https://git.mdrn.pl/fnpeditor.git/blobdiff_plain/7ceaca87e48317ad610b946192e0783885696f0d..b9715b04ece107e8febac4105c4720461cf66c9c:/src/smartxml/smartxml.js?ds=inline diff --git a/src/smartxml/smartxml.js b/src/smartxml/smartxml.js index 1d9fdd0..749d4f4 100644 --- a/src/smartxml/smartxml.js +++ b/src/smartxml/smartxml.js @@ -2,25 +2,16 @@ define([ 'libs/jquery', 'libs/underscore', 'libs/backbone', - 'smartxml/events' -], function($, _, Backbone, events) { + 'smartxml/events', + 'smartxml/transformations', + 'smartxml/core', + 'smartxml/fragments' +], function($, _, Backbone, events, transformations, coreTransformations, fragments) { 'use strict'; +/* globals Node */ -var TEXT_NODE = Node.TEXT_NODE; - - -var INSERTION = function(implementation) { - var toret = function(node) { - var insertion = this.getNodeInsertion(node); - implementation.call(this, insertion.ofNode.nativeNode); - this.triggerChangeEvent(insertion.insertsNew ? 'nodeAdded' : 'nodeMoved', {node: insertion.ofNode}); - return insertion.ofNode; - }; - return toret; -}; - var DocumentNode = function(nativeNode, document) { if(!document) { throw new Error('undefined document for a node'); @@ -31,30 +22,79 @@ var DocumentNode = function(nativeNode, document) { }; $.extend(DocumentNode.prototype, { + + transform: function(Transformation, args) { + var transformation = new Transformation(this.document, this, args); + return this.document.transform(transformation); + }, + _setNativeNode: function(nativeNode) { this.nativeNode = nativeNode; this._$ = $(nativeNode); }, + clone: function() { + var clone = this._$.clone(true, true), + node = this; + clone.find('*').addBack().each(function() { + var el = this, + clonedData = $(this).data(); + + _.pairs(clonedData).forEach(function(pair) { + var key = pair[0], + value = pair[1]; + if(_.isFunction(value.clone)) { + clonedData[key] = value.clone(node.document.createDocumentNode(el)); + } + }); + }); + return this.document.createDocumentNode(clone[0]); + }, + + getPath: function(ancestor) { + if(!(this.document.containsNode(this))) { + return null; + } + + var nodePath = [this].concat(this.parents()), + toret, idx; + ancestor = ancestor || this.document.root; + + nodePath.some(function(node, i) { + if(node.sameNode(ancestor)) { + idx = i; + return true; + } + }); + + if(idx !== undefined) { + nodePath = nodePath.slice(0, idx); + } + toret = nodePath.map(function(node) {return node.getIndex(); }); + toret.reverse(); + return toret; + }, + isRoot: function() { return this.document.root.sameNode(this); }, - detach: function() { - var parent = this.parent(); - this._$.detach(); - this.triggerChangeEvent('nodeDetached', {parent: parent}); - return this; + isInDocument: function() { + return this.document.containsNode(this); + }, + + isSiblingOf: function(node) { + return node && this.parent().sameNode(node.parent()); }, sameNode: function(otherNode) { - return otherNode && this.nativeNode === otherNode.nativeNode; + return !!(otherNode) && this.nativeNode === otherNode.nativeNode; }, parent: function() { var parentNode = this.nativeNode.parentNode; if(parentNode && parentNode.nodeType === Node.ELEMENT_NODE) { - return this.document.createElementNode(parentNode); + return this.document.createDocumentNode(parentNode); } return null; }, @@ -82,56 +122,37 @@ $.extend(DocumentNode.prototype, { return myIdx < parentContents.length - 1 ? parentContents[myIdx+1] : null; }, - after: INSERTION(function(nativeNode) { - return this._$.after(nativeNode); - }), - - before: INSERTION(function(nativeNode) { - return this._$.before(nativeNode); - }), + isSurroundedByTextNodes: function() { + return this.isPrecededByTextNode() && this.isFollowedByTextNode(); + }, - wrapWith: function(node) { - var insertion = this.getNodeInsertion(node); - if(this.parent()) { - this.before(insertion.ofNode); - } - insertion.ofNode.append(this); - return insertion.ofNode; + isPrecededByTextNode: function() { + var prev = this.prev(); + return prev && prev.nodeType === Node.TEXT_NODE; }, - /** - * Removes parent of a node if node has no siblings. - */ - unwrap: function() { - if(this.isRoot()) { - return; - } - var parent = this.parent(), - grandParent; - if(parent.contents().length === 1) { - grandParent = parent.parent(); - parent.unwrapContent(); - return grandParent; - } + isFollowedByTextNode: function() { + var next = this.next(); + return next && next.nodeType === Node.TEXT_NODE; }, - triggerChangeEvent: function(type, metaData) { - var event = new events.ChangeEvent(type, $.extend({node: this}, metaData || {})); + triggerChangeEvent: function(type, metaData, origParent, nodeWasContained) { + var node = (metaData && metaData.node) ? metaData.node : this, + event = new events.ChangeEvent(type, $.extend({node: node}, metaData || {})); if(type === 'nodeDetached' || this.document.containsNode(event.meta.node)) { + if(type === 'nodeMoved') { + event.meta.parent = origParent; + } this.document.trigger('change', event); } + if((type === 'nodeAdded' || type === 'nodeMoved') && !this.document.containsNode(this) && nodeWasContained) { + event = new events.ChangeEvent('nodeDetached', {node: node, parent: origParent}); + this.document.trigger('change', event); + } }, getNodeInsertion: function(node) { - var insertion = {}; - if(node instanceof DocumentNode) { - insertion.ofNode = node; - insertion.insertsNew = !this.document.containsNode(node); - } else { - insertion.ofNode = this.document.createElementNode(node); - insertion.insertsNew = true; - } - return insertion; + return this.document.getNodeInsertion(node); }, getIndex: function() { @@ -139,9 +160,14 @@ $.extend(DocumentNode.prototype, { return 0; } return this.parent().indexOf(this); + }, + + getNearestElementNode: function() { + return this.nodeType === Node.ELEMENT_NODE ? this : this.parent(); } }); + var ElementNode = function(nativeNode, document) { DocumentNode.call(this, nativeNode, document); }; @@ -150,18 +176,6 @@ ElementNode.prototype = Object.create(DocumentNode.prototype); $.extend(ElementNode.prototype, { nodeType: Node.ELEMENT_NODE, - detach: function() { - var prev = this.prev(), - next = this.next(); - if(parent) { - if(prev && prev.nodeType === Node.TEXT_NODE && next && next.nodeType === Node.TEXT_NODE) { - prev.appendText(next.getText()); - next.detach(); - } - } - return DocumentNode.prototype.detach.call(this); - }, - setData: function(key, value) { if(value !== undefined) { this._$.data(key, value); @@ -182,17 +196,18 @@ $.extend(ElementNode.prototype, { return this.nativeNode.tagName.toLowerCase(); }, - contents: function() { + contents: function(selector) { var toret = [], document = this.document; - this._$.contents().each(function() { - if(this.nodeType === Node.ELEMENT_NODE) { - toret.push(document.createElementNode(this)); - } - else if(this.nodeType === Node.TEXT_NODE) { - toret.push(document.createTextNode(this)); - } - }); + if(selector) { + this._$.children(selector).each(function() { + toret.push(document.createDocumentNode(this)); + }); + } else { + this._$.contents().each(function() { + toret.push(document.createDocumentNode(this)); + }); + } return toret; }, @@ -200,37 +215,10 @@ $.extend(ElementNode.prototype, { return this._$.contents().index(node._$); }, - setTag: function(tagName) { - var node = this.document.createElementNode({tagName: tagName}), - oldTagName = this.getTagName(), - myContents = this._$.contents(); - - this.getAttrs().forEach(function(attribute) { - node.setAttr(attribute.name, attribute.value, true); - }); - node.setData(this.getData()); - - if(this.sameNode(this.document.root)) { - defineDocumentProperties(this.document, node._$); - } - this._$.replaceWith(node._$); - this._setNativeNode(node._$[0]); - this._$.append(myContents); - this.triggerChangeEvent('nodeTagChange', {oldTagName: oldTagName, newTagName: this.getTagName()}); - }, - getAttr: function(name) { return this._$.attr(name); }, - setAttr: function(name, value, silent) { - var oldVal = this.getAttr(name); - this._$.attr(name, value); - if(!silent) { - this.triggerChangeEvent('nodeAttrChange', {attr: name, oldVal: oldVal, newVal: value}); - } - }, - getAttrs: function() { var toret = []; for(var i = 0; i < this.nativeNode.attributes.length; i++) { @@ -239,65 +227,24 @@ $.extend(ElementNode.prototype, { return toret; }, - append: INSERTION(function(nativeNode) { - this._$.append(nativeNode); - }), - - prepend: INSERTION(function(nativeNode) { - this._$.prepend(nativeNode); - }), - - unwrapContent: function() { - var parent = this.parent(); - if(!parent) { - return; - } - - var myContents = this.contents(), - myIdx = parent.indexOf(this); - - - if(myContents.length === 0) { - return this.detach(); - } - - var prev = this.prev(), - next = this.next(), - moveLeftRange, moveRightRange, leftMerged; + containsNode: function(node) { + return node && (node.nativeNode === this.nativeNode || node._$.parents().index(this._$) !== -1); + }, - if(prev && (prev.nodeType === TEXT_NODE) && (myContents[0].nodeType === TEXT_NODE)) { - prev.appendText(myContents[0].getText()); - myContents[0].detach(); - moveLeftRange = true; - leftMerged = true; - } else { - leftMerged = false; - } + getLastTextNode: function() { + var contents = this.contents(), + toret; - if(!(leftMerged && myContents.length === 1)) { - var lastContents = _.last(myContents); - if(next && (next.nodeType === TEXT_NODE) && (lastContents.nodeType === TEXT_NODE)) { - next.prependText(lastContents.getText()); - lastContents.detach(); - moveRightRange = true; + contents.reverse().some(function(node) { + if(node.nodeType === Node.TEXT_NODE) { + toret = node; + return true; } - } - - var childrenLength = this.contents().length; - this.contents().forEach(function(child) { - this.before(child); - }.bind(this)); - - this.detach(); - - return { - element1: parent.contents()[myIdx + (moveLeftRange ? -1 : 0)], - element2: parent.contents()[myIdx + childrenLength-1 + (moveRightRange ? 1 : 0)] - }; - }, + toret = node.getLastTextNode(); + return !!toret; + }); - wrapText: function(params) { - return this.document._wrapText(_.extend({inside: this}, params)); + return toret; }, toXML: function() { @@ -311,6 +258,7 @@ $.extend(ElementNode.prototype, { } }); + var TextNode = function(nativeNode, document) { DocumentNode.call(this, nativeNode, document); }; @@ -323,33 +271,9 @@ $.extend(TextNode.prototype, { return this.nativeNode.data; }, - setText: function(text) { - this.nativeNode.data = text; - this.triggerTextChangeEvent(); - }, - appendText: function(text) { - this.nativeNode.data = this.nativeNode.data + text; - this.triggerTextChangeEvent(); - }, - - prependText: function(text) { - this.nativeNode.data = text + this.nativeNode.data; - this.triggerTextChangeEvent(); - }, - - wrapWith: function(desc) { - if(typeof desc.start === 'number' && typeof desc.end === 'number') { - return this.document._wrapText({ - inside: this.parent(), - textNodeIdx: this.parent().indexOf(this), - offsetStart: Math.min(desc.start, desc.end), - offsetEnd: Math.max(desc.start, desc.end), - _with: {tagName: desc.tagName, attrs: desc.attrs} - }); - } else { - return DocumentNode.prototype.wrapWith.call(this, desc); - } + containsNode: function() { + return false; }, triggerTextChangeEvent: function() { @@ -360,94 +284,126 @@ $.extend(TextNode.prototype, { var parseXML = function(xml) { - return $(xml)[0]; + var toret = $($.trim(xml)); + if(!toret.length) { + throw new Error('Unable to parse XML: ' + xml); + } + return toret[0]; + +}; + +var registerTransformation = function(desc, name, target) { + var Transformation = transformations.createContextTransformation(desc, name); + target[name] = function() { + var instance = this, + args = Array.prototype.slice.call(arguments, 0); + return instance.transform(Transformation, args); + }; }; -var Document = function(xml) { +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, { +$.extend(Document.prototype, Backbone.Events, fragments, { ElementNodeFactory: ElementNode, TextNodeFactory: TextNode, - createElementNode: function(from) { - if(!(from instanceof HTMLElement)) { - if(from.text) { - from = document.createTextNode(from.text); + createDocumentNode: function(from) { + if(!(from instanceof Node)) { + if(typeof from === 'string') { + from = parseXML(from); + this.normalizeXML(from); } else { - var node = $('<' + from.tagName + '>'); - - _.keys(from.attrs || {}).forEach(function(key) { - node.attr(key, from.attrs[key]); - }); - - from = node[0]; + 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; + 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; } - return new Factory(from, this); - }, + 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); + }); - createTextNode: function(nativeNode) { - return new this.TextNodeFactory(nativeNode, this); + return toret; }, loadXML: function(xml, options) { options = options || {}; - defineDocumentProperties(this, $(parseXML(xml))); + 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 && (node.nativeNode === this.root.nativeNode || node._$.parents().index(this.root._$) !== -1); - }, - - wrapNodes: function(params) { - if(!(params.element1.parent().sameNode(params.element2.parent()))) { - throw new Error('Wrapping non-sibling nodes not supported.'); - } - - var parent = params.element1.parent(), - parentContents = parent.contents(), - wrapper = this.createElementNode({ - tagName: params._with.tagName, - attrs: params._with.attrs}), - idx1 = parent.indexOf(params.element1), - idx2 = parent.indexOf(params.element2); - - if(idx1 > idx2) { - var tmp = idx1; - idx1 = idx2; - idx2 = tmp; - } - - var insertingMethod, insertingTarget; - if(idx1 === 0) { - insertingMethod = 'prepend'; - insertingTarget = parent; - } else { - insertingMethod = 'after'; - insertingTarget = parentContents[idx1-1]; - } - - for(var i = idx1; i <= idx2; i++) { - wrapper.append(parentContents[i].detach()); - } - - insertingTarget[insertingMethod](wrapper); - return wrapper; + return this.root && this.root.containsNode(node); }, getSiblingParents: function(params) { @@ -459,84 +415,291 @@ $.extend(Document.prototype, Backbone.Events, { return noSiblingParents; } - var i; - for(i = 0; i < Math.min(parents1.length, parents2.length); i++) { + 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]}; }, - _wrapText: function(params) { - params = _.extend({textNodeIdx: 0}, params); - if(typeof params.textNodeIdx === 'number') { - params.textNodeIdx = [params.textNodeIdx]; + 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); - var contentsInside = params.inside.contents(), - idx1 = Math.min.apply(Math, params.textNodeIdx), - idx2 = Math.max.apply(Math, params.textNodeIdx), - textNode1 = contentsInside[idx1], - textNode2 = contentsInside[idx2], - sameNode = textNode1.sameNode(textNode2), - prefixOutside = textNode1.getText().substr(0, params.offsetStart), - prefixInside = textNode1.getText().substr(params.offsetStart), - suffixInside = textNode2.getText().substr(0, params.offsetEnd), - suffixOutside = textNode2.getText().substr(params.offsetEnd) - ; - - if(!(textNode1.parent().sameNode(textNode2.parent()))) { - throw new Error('Wrapping text in non-sibling text nodes not supported.'); + if(hasChanged) { + if(documentChangedHandler) { + documentChangedHandler.call(context); + } + } else { + if(documentUnchangedHandler) { + documentUnchangedHandler.call(context); + } } - - var wrapperElement = this.createElementNode({tagName: params._with.tagName, attrs: params._with.attrs}); - textNode1.after(wrapperElement); - textNode1.detach(); - - if(prefixOutside.length > 0) { - wrapperElement.before({text:prefixOutside}); + }, + + transform: function(Transformation, args) { + var toret, transformation; + + if(!this._currentTransaction) { + return this.transaction(function() { + return this.transform(Transformation, args); + }, {context: this}); } - if(sameNode) { - var core = textNode1.getText().substr(params.offsetStart, params.offsetEnd - params.offsetStart); - wrapperElement.append({text: core}); + + if(typeof Transformation === 'function') { + transformation = new Transformation(this, this, args); } else { - textNode2.detach(); - if(prefixInside.length > 0) { - wrapperElement.append({text: prefixInside}); - } - for(var i = idx1 + 1; i < idx2; i++) { - wrapperElement.append(contentsInside[i]); + 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. + stopAt = undefined; + 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); + } } - if(suffixInside.length > 0) { - wrapperElement.append({text: suffixInside}); + + 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'); + + } + }, + + startTransaction: function(metadata) { + if(this._currentTransaction) { + throw new Error('Nested transactions not supported!'); + } + this._rollbackBackup = this.root.clone(); + this._currentTransaction = new Transaction([], metadata); + }, + + endTransaction: function() { + if(!this._currentTransaction) { + throw new Error('End of transaction requested, but there is no transaction in progress!'); + } + if(this._currentTransaction.hasTransformations()) { + this.undoStack.push(this._currentTransaction); + this.trigger('operationEnd'); + } + this._currentTransaction = null; + }, + + rollbackTransaction: function() { + if(!this._currentTransaction) { + throw new Error('Transaction rollback requested, but there is no transaction in progress!'); + } + this.replaceRoot(this._rollbackBackup); + this._rollbackBackup = null; + this._currentTransaction = null; + this._transformationLevel = 0; + }, + + transaction: function(callback, params) { + var toret; + params = params || {}; + this.startTransaction(params.metadata); + try { + toret = callback.call(params.context || this); + } catch(e) { + if(params.error) { + params.error(e); } + this.rollbackTransaction(); + return; } - if(suffixOutside.length > 0) { - wrapperElement.after({text: suffixOutside}); + this.endTransaction(); + if(params.success) { + params.success(toret); } - return wrapperElement; + return toret; }, - trigger: function() { - //console.log('trigger: ' + arguments[0] + (arguments[1] ? ', ' + arguments[1].type : '')); - Backbone.Events.trigger.apply(this, arguments); + getNodeByPath: function(path) { + var toret = this.root; + path.forEach(function(idx) { + toret = toret.contents()[idx]; + }); + return toret; + }, + + _defineDocumentProperties: function($document) { + var doc = this; + Object.defineProperty(doc, 'root', {get: function() { + if(!$document) { + return null; + } + return doc.createDocumentNode($document[0]); + }, configurable: true}); + Object.defineProperty(doc, 'dom', {get: function() { + if(!$document) { + return null; + } + return $document[0]; + }, configurable: true}); + }, + + createFragment: function(Type, params) { + if(!Type.prototype instanceof fragments.Fragment) { + throw new Error('Can\'t create a fragment: `Type` is not a valid Fragment'); + } + return new Type(this, params); } }); -var defineDocumentProperties = function(doc, $document) { - Object.defineProperty(doc, 'root', {get: function() { - return doc.createElementNode($document[0]); - }, configurable: true}); - Object.defineProperty(doc, 'dom', {get: function() { - return $document[0]; - }, configurable: true}); +var Transaction = function(transformations, metadata) { + this.transformations = transformations || []; + this.metadata = metadata; }; +$.extend(Transaction.prototype, { + pushTransformation: function(transformation) { + this.transformations.push(transformation); + }, + hasTransformations: function() { + return this.transformations.length > 0; + } +}); + return { documentFromXML: function(xml) { - return new Document(parseXML(xml)); + var doc = new Document(xml); + return doc; }, elementNodeFromXML: function(xml) { @@ -545,7 +708,8 @@ return { Document: Document, DocumentNode: DocumentNode, - ElementNode: ElementNode + ElementNode: ElementNode, + TextNode: TextNode }; }); \ No newline at end of file