X-Git-Url: https://git.mdrn.pl/fnpeditor.git/blobdiff_plain/2d0b2293c1110c3fab4e804be31bc233a4159bcb..8464a511c74dff643095ce419659df60b0580b7a:/src/smartxml/smartxml.js diff --git a/src/smartxml/smartxml.js b/src/smartxml/smartxml.js index 9862fab..712c0ad 100644 --- a/src/smartxml/smartxml.js +++ b/src/smartxml/smartxml.js @@ -1,48 +1,243 @@ define([ - 'libs/jquery' -], function($) { + 'libs/jquery', + 'libs/underscore', + 'libs/backbone', + 'smartxml/events', + 'smartxml/transformations' +], function($, _, Backbone, events, transformations) { 'use strict'; +/* globals Node */ +var TEXT_NODE = Node.TEXT_NODE; -var TEXT_NODE = Node.TEXT_NODE, ELEMENT_NODE = Node.ELEMENT_NODE; +var INSERTION = function(implementation) { + var toret = function(node) { + var insertion = this.getNodeInsertion(node), + nodeParent; + if(!(this.document.containsNode(this))) { + nodeParent = insertion.ofNode.parent(); + } + implementation.call(this, insertion.ofNode.nativeNode); + this.triggerChangeEvent(insertion.insertsNew ? 'nodeAdded' : 'nodeMoved', {node: insertion.ofNode}, nodeParent); + return insertion.ofNode; + }; + return toret; +}; var DocumentNode = function(nativeNode, document) { + if(!document) { + throw new Error('undefined document for a node'); + } this.document = document; - this.nativeNode = nativeNode; - this._$ = $(nativeNode); + this._setNativeNode(nativeNode); + }; $.extend(DocumentNode.prototype, { - detach: function() { this._$.detach(); }, + + transformations: new transformations.TransformationStorage(), + + transform: function(name, args) { + var Transformation = this.transformations.get(name), + transformation; + if(Transformation) { + 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); + // clone.find('*').addBack().each(function() { + // var n = $(this); + // if(n.data('canvasElement')) { + // n.data('canvasElement', $.extend(true, {}, n.data('canvasElement'))); + // n.data('canvasElement').$element = n.data('canvasElement').$element.clone(true, true); + // } + // }); + return this.document.createDocumentNode(clone[0]); + }, + + getPath: function(ancestor) { + 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; + }, + + replaceWith: function(node) { + var toret; + if(this.isRoot()) { + return this.document.replaceRoot(node); + } + toret = this.after(node); + this.detach(); + return toret; + }, sameNode: function(otherNode) { - return this.nativeNode === otherNode.nativeNode; + return !!(otherNode) && this.nativeNode === otherNode.nativeNode; }, parent: function() { - return this.nativeNode.parentNode ? this.document.createElementNode(this.nativeNode.parentNode) : null; + var parentNode = this.nativeNode.parentNode; + if(parentNode && parentNode.nodeType === Node.ELEMENT_NODE) { + return this.document.createDocumentNode(parentNode); + } + return null; + }, + + parents: function() { + var parent = this.parent(), + parents = parent ? parent.parents() : []; + if(parent) { + parents.unshift(parent); + } + return parents; + }, + + prev: function() { + var myIdx = this.getIndex(); + return myIdx > 0 ? this.parent().contents()[myIdx-1] : null; + }, + + next: function() { + if(this.isRoot()) { + return null; + } + var myIdx = this.getIndex(), + parentContents = this.parent().contents(); + return myIdx < parentContents.length - 1 ? parentContents[myIdx+1] : null; }, - before: function(node) { - this._$.before(node.nativeNode); + isSurroundedByTextElements: function() { + var prev = this.prev(), + next = this.next(); + return prev && (prev.nodeType === Node.TEXT_NODE) && next && (next.nodeType === Node.TEXT_NODE); }, + after: INSERTION(function(nativeNode) { + return this._$.after(nativeNode); + }), + + before: INSERTION(function(nativeNode) { + return this._$.before(nativeNode); + }), + wrapWith: function(node) { - if(this.parent()) - this.before(node); - node.append(this); + var insertion = this.getNodeInsertion(node); + if(this.parent()) { + this.before(insertion.ofNode); + } + insertion.ofNode.append(this); + return insertion.ofNode; }, + + /** + * 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; + } + }, + + triggerChangeEvent: function(type, metaData, origParent) { + 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)) { + this.document.trigger('change', event); + } + if((type === 'nodeAdded' || type === 'nodeMoved') && !(this.document.containsNode(this))) { + event = new events.ChangeEvent('nodeDetached', {node: node, parent: origParent}); + this.document.trigger('change', event); + } + }, + + getNodeInsertion: function(node) { + return this.document.getNodeInsertion(node); + }, + + getIndex: function() { + if(this.isRoot()) { + return 0; + } + return this.parent().indexOf(this); + } }); -var ElementNode = function(nativeNode) { - DocumentNode.apply(this, arguments); +var ElementNode = function(nativeNode, document) { + DocumentNode.call(this, nativeNode, document); }; +ElementNode.prototype = Object.create(DocumentNode.prototype); -$.extend(ElementNode.prototype, DocumentNode.prototype, { +$.extend(ElementNode.prototype, { nodeType: Node.ELEMENT_NODE, + detach: function() { + var next; + if(this.parent() && this.isSurroundedByTextElements()) { + next = this.next(); + this.prev().appendText(next.getText()); + next.detach(); + } + return DocumentNode.prototype.detach.call(this); + }, + + setData: function(key, value) { + if(value !== undefined) { + this._$.data(key, value); + } else { + this._$.removeData(_.keys(this._$.data())); + this._$.data(key); + } + }, + + getData: function(key) { + if(key) { + return this._$.data(key); + } + return this._$.data(); + }, + getTagName: function() { return this.nativeNode.tagName.toLowerCase(); }, @@ -51,10 +246,7 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { 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)); + toret.push(document.createDocumentNode(this)); }); return toret; }, @@ -63,34 +255,82 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { return this._$.contents().index(node._$); }, + setTag: function(tagName) { + var node = this.document.createDocumentNode({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) { + 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}); + } }, - append: function(documentNode) { - this._$.append(documentNode.nativeNode); + getAttrs: function() { + var toret = []; + for(var i = 0; i < this.nativeNode.attributes.length; i++) { + toret.push(this.nativeNode.attributes[i]); + } + return toret; + }, + + append: INSERTION(function(nativeNode) { + this._$.append(nativeNode); + }), + + prepend: INSERTION(function(nativeNode) { + this._$.prepend(nativeNode); + }), + + insertAtIndex: function(nativeNode, index) { + var contents = this.contents(); + if(index < contents.length) { + return contents[index].before(nativeNode); + } else if(index === contents.length) { + return this.append(nativeNode); + } }, unwrapContent: function() { var parent = this.parent(); - if(!parent) + if(!parent) { return; + } - var parentContents = parent.contents(), - myContents = this.contents(), + var myContents = this.contents(), myIdx = parent.indexOf(this); - if(myContents.length === 0) + + if(myContents.length === 0) { return this.detach(); + } - var moveLeftRange, moveRightRange, leftMerged; + var prev = this.prev(), + next = this.next(), + moveLeftRange, moveRightRange, leftMerged; - if(myIdx > 0 && (parentContents[myIdx-1].nodeType === TEXT_NODE) && (myContents[0].nodeType === TEXT_NODE)) { - parentContents[myIdx-1].appendText(myContents[0].getText()); + if(prev && (prev.nodeType === TEXT_NODE) && (myContents[0].nodeType === TEXT_NODE)) { + prev.appendText(myContents[0].getText()); myContents[0].detach(); moveLeftRange = true; leftMerged = true; @@ -99,9 +339,10 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { } if(!(leftMerged && myContents.length === 1)) { - if(myIdx < parentContents.length - 1 && (parentContents[myIdx+1].nodeType === TEXT_NODE) && (myContents[myContents.length-1].nodeType === TEXT_NODE)) { - parentContents[myIdx+1].prependText(myContents[myContents.length-1].getText()); - myContents[myContents.length-1].detach(); + var lastContents = _.last(myContents); + if(next && (next.nodeType === TEXT_NODE) && (lastContents.nodeType === TEXT_NODE)) { + next.prependText(lastContents.getText()); + lastContents.detach(); moveRightRange = true; } } @@ -117,60 +358,454 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { element1: parent.contents()[myIdx + (moveLeftRange ? -1 : 0)], element2: parent.contents()[myIdx + childrenLength-1 + (moveRightRange ? 1 : 0)] }; - } + }, + wrapText: function(params) { + return this.document._wrapText(_.extend({inside: this}, params)); + }, + + toXML: function() { + var wrapper = $('
'); + wrapper.append(this._getXMLDOMToDump()); + return wrapper.html(); + }, + + _getXMLDOMToDump: function() { + return this._$; + } }); -var TextNode = function(nativeNode) { - DocumentNode.apply(this, arguments); +// trans + +// todo - split+append + +ElementNode.prototype.transformations.register(transformations.createContextTransformation({ + name: 'smartxml.setAttr', + impl: function(args) { + this.setAttr(args.name, args.value); + }, + getChangeRoot: function() { + return this.context; + } +})); + +DocumentNode.prototype.transformations.register(transformations.createContextTransformation({ + name: 'smartxml.wrapWith', + getChangeRoot: function() { + return this.context.parent(); + }, + impl: function(args) { + return this.wrapWith(args); + } +})); + +DocumentNode.prototype.transformations.register(transformations.createContextTransformation({ + name: 'smartxml.wrapText', + getChangeRoot: function() { + return this.context; + }, + impl: function(args) { + return this.wrapText(args); + } +})); + +DocumentNode.prototype.transformations.register(transformations.createContextTransformation({ + name: 'smartxml.detach', + getChangeRoot: function() { + return this.context.parent(); + }, + impl: function(args) { + return this.detach(); + } +})); + +/// + +var TextNode = function(nativeNode, document) { + DocumentNode.call(this, nativeNode, document); }; +TextNode.prototype = Object.create(DocumentNode.prototype); -$.extend(TextNode.prototype, DocumentNode.prototype, { +$.extend(TextNode.prototype, { nodeType: Node.TEXT_NODE, getText: function() { return this.nativeNode.data; }, + setText: function(text) { + console.log('smartxml: ' + 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); + } + }, + + split: function(params) { + var parentElement = this.parent(), + passed = false, + succeedingChildren = [], + prefix = this.getText().substr(0, params.offset), + suffix = this.getText().substr(params.offset); + + parentElement.contents().forEach(function(child) { + if(passed) { + succeedingChildren.push(child); + } + if(child.sameNode(this)) { + passed = true; + } + }.bind(this)); + + if(prefix.length > 0) { + this.setText(prefix); + } + else { + this.detach(); + } + + var attrs = {}; + parentElement.getAttrs().forEach(function(attr) {attrs[attr.name] = attr.value; }); + var newElement = this.document.createDocumentNode({tagName: parentElement.getTagName(), attrs: attrs}); + parentElement.after(newElement); + + if(suffix.length > 0) { + newElement.append({text: suffix}); + } + succeedingChildren.forEach(function(child) { + newElement.append(child); + }); + + return {first: parentElement, second: newElement}; + }, + + triggerTextChangeEvent: function() { + var event = new events.ChangeEvent('nodeTextChange', {node: this}); + this.document.trigger('change', event); } }); +TextNode.prototype.transformations.register(transformations.createContextTransformation({ + name: 'rng.breakContent', + // impl: function(args) { + // var node = this.context, + // newNodes, emptyNode, emptyText; + // newNodes = node.transform('smartxml.split', {offset: args.offset}); + // [newNodes.first, newNodes.second].some(function(newNode) { + // if(!(newNode.contents().length)) { + // newNode.transform('smartxml.append', {text: ''}); + // return true; // break + // } + // }); + // return _.extend(newNodes, {emptyText: emptyText}); + // }, + impl: function(args) { + var node = this, + newNodes, emptyNode, emptyText; + newNodes = node.split({offset: args.offset}); + [newNodes.first, newNodes.second].some(function(newNode) { + if(!(newNode.contents().length)) { + newNode.append({text: ''}); + return true; // break + } + }); + return _.extend(newNodes, {emptyText: emptyText}); + }, + getChangeRoot: function() { + return this.context.parent().parent(); + } +})); + + +ElementNode.prototype.transformations.register(transformations.createContextTransformation({ + name: 'smartxml.setText', + impl: function(args) { + this.setText(args.text); + }, + getChangeRoot: function() { + return this.context; + } +})); + + var parseXML = function(xml) { - return $(xml)[0]; + return $($.trim(xml))[0]; }; var Document = function(xml) { - var $document = $(parseXML(xml)); - - var doc = this; - Object.defineProperty(this, 'root', {get: function() { - return doc.createElementNode($document[0]); - }}); + this.loadXML(xml); + this.undoStack = []; + this.redoStack = []; }; -$.extend(Document.prototype, { + +$.extend(Document.prototype, Backbone.Events, { ElementNodeFactory: ElementNode, TextNodeFactory: TextNode, + transformations: new transformations.TransformationStorage(), + + createDocumentNode: function(from) { + if(!(from instanceof Node)) { + if(from.text !== undefined) { + /* globals document */ + from = document.createTextNode(from.text); + } else { + var node = $('<' + from.tagName + '>'); + + _.keys(from.attrs || {}).forEach(function(key) { + node.attr(key, from.attrs[key]); + }); + + from = node[0]; + } + } + var Factory; + if(from.nodeType === Node.TEXT_NODE) { + Factory = this.TextNodeFactory; + } else if(from.nodeType === Node.ELEMENT_NODE) { + Factory = this.ElementNodeFactory; + } + return new Factory(from, this); + }, + + loadXML: function(xml, options) { + options = options || {}; + defineDocumentProperties(this, $(parseXML(xml))); + if(!options.silent) { + this.trigger('contentSet'); + } + }, + + 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.node1.parent().sameNode(params.node2.parent()))) { + throw new Error('Wrapping non-sibling nodes not supported.'); + } + + var parent = params.node1.parent(), + parentContents = parent.contents(), + wrapper = this.createDocumentNode({ + tagName: params._with.tagName, + attrs: params._with.attrs}), + idx1 = parent.indexOf(params.node1), + idx2 = parent.indexOf(params.node2); + + 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; + }, + + 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; + } - createElementNode: function(nativeNode) { - return new this.ElementNodeFactory(nativeNode, this); + var i; + for(i = 0; i < Math.min(parents1.length, parents2.length); i++) { + if(parents1[i].sameNode(parents2[i])) { + continue; + } + break; + } + return {node1: parents1[i], node2: parents2[i]}; + }, + + _wrapText: function(params) { + params = _.extend({textNodeIdx: 0}, params); + if(typeof params.textNodeIdx === 'number') { + params.textNodeIdx = [params.textNodeIdx]; + } + + 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.'); + } + + var wrapperElement = this.createDocumentNode({tagName: params._with.tagName, attrs: params._with.attrs}); + textNode1.after(wrapperElement); + textNode1.detach(); + + if(prefixOutside.length > 0) { + wrapperElement.before({text:prefixOutside}); + } + if(sameNode) { + var core = textNode1.getText().substr(params.offsetStart, params.offsetEnd - params.offsetStart); + wrapperElement.append({text: core}); + } else { + textNode2.detach(); + if(prefixInside.length > 0) { + wrapperElement.append({text: prefixInside}); + } + for(var i = idx1 + 1; i < idx2; i++) { + wrapperElement.append(contentsInside[i]); + } + if(suffixInside.length > 0) { + wrapperElement.append({text: suffixInside}); + } + } + if(suffixOutside.length > 0) { + wrapperElement.after({text: suffixOutside}); + } + return wrapperElement; }, - createTextNode: function(nativeNode) { - return new this.TextNodeFactory(nativeNode, this); + trigger: function() { + //console.log('trigger: ' + arguments[0] + (arguments[1] ? ', ' + arguments[1].type : '')); + 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; + }, + + replaceRoot: function(node) { + var insertion = this.getNodeInsertion(node); + this.root.detach(); + defineDocumentProperties(this, insertion.ofNode._$); + insertion.ofNode.triggerChangeEvent('nodeAdded'); + return insertion.ofNode; + }, + + transform: function(transformation, args) { + console.log('transform'); + var Transformation, toret; + if(typeof transformation === 'string') { + Transformation = this.transformations.get(transformation); + if(Transformation) { + transformation = new Transformation(this, this, args); + } + } + if(transformation) { + toret = transformation.run(); + this.undoStack.push(transformation); + console.log('clearing redo stack'); + this.redoStack = []; + return toret; + } else { + throw new Error('Transformation ' + transformation + ' doesn\'t exist!'); + } + }, + undo: function() { + var transformation = this.undoStack.pop(); + if(transformation) { + transformation.undo(); + this.redoStack.push(transformation); + } + }, + redo: function() { + var transformation = this.redoStack.pop(); + if(transformation) { + transformation.run(); + this.undoStack.push(transformation); + } + }, + + getNodeByPath: function(path) { + var toret = this.root; + path.forEach(function(idx) { + toret = toret.contents()[idx]; + }); + return toret; } }); +var defineDocumentProperties = function(doc, $document) { + Object.defineProperty(doc, 'root', {get: function() { + return doc.createDocumentNode($document[0]); + }, configurable: true}); + Object.defineProperty(doc, 'dom', {get: function() { + return $document[0]; + }, configurable: true}); +}; + +Document.prototype.transformations.register(transformations.createContextTransformation({ + name: 'smartxml.wrapNodes', + // init: function() { + + // }, + // getChangeRoot: function() { + // return this.context; + // }, + impl: function(args) { + this.wrapNodes(args); + }, + +})); + return { documentFromXML: function(xml) { - return new Document(parseXML(xml)); + return new Document(xml); }, elementNodeFromXML: function(xml) {