expect(node.contents()[0].getText()).to.equal('Alice');
expect(node.contents()[1].getTagName()).to.equal('b');
});
+
+ describe('Retrieving node by path', function() {
+ it('passes smoke tests', function() {
+ var doc = getDocumentFromXML('<root><a><b>c</b></a>');
+ expect(doc.getNodeByPath([0]).sameNode(doc.root.contents()[0])).to.be.true;
+ expect(doc.getNodeByPath([0,0]).sameNode(doc.root.contents()[0].contents()[0])).to.be.true;
+ });
+ it('treats empty path as a root path', function() {
+ var doc = getDocumentFromXML('<root></root>');
+ expect(doc.getNodeByPath([]).sameNode(doc.root)).to.be.true;
+ });
+ it('returns undefined for non existing paths', function() {
+ var doc = getDocumentFromXML('<root><a></a></root>');
+ expect(doc.getNodeByPath([1])).to.be.undefined;
+ expect(doc.getNodeByPath([0,1])).to.be.undefined;
+ expect(doc.getNodeByPath([10,1])).to.be.undefined;
+ });
+ });
});
describe('DocumentNode', function() {
});
it('can be cloned with its contents and its contents data', function() {
- var doc = getDocumentFromXML('<root><div></div></root>'),
+ var doc = getDocumentFromXML('<root><div>text</div></root>'),
root = doc.root,
- div = root.contents()[0];
+ div = root.contents()[0],
+ text = div.contents()[0];
var ClonableObject = function(arg) {
this.arg = arg;
div.setData('key', 'value');
div.setData('clonableObject', new ClonableObject('test'));
+ text.setData('key', 'value');
var rootClone = root.clone(),
divClone = rootClone.contents()[0],
+ textClone = divClone.contents()[0],
stringClone = divClone.getData('key'),
objClone = divClone.getData('clonableObject');
expect(stringClone).to.equal('value');
expect(objClone.arg).to.equal('test', 'clonable object got copied');
expect(objClone !== div.getData('clonableObject')).to.be.equal(true, 'copy of the clonable object is a new object');
+
+ expect(textClone.getData('key')).to.be.equal(undefined, 'cloning text node data is not supported yet');
});
it('knows its path in the document tree', function() {
node.setData({key1: 'value1', key2: 'value2'});
expect(node.getData()).to.eql({key1: 'value1', key2: 'value2'});
});
+
+ it('can remove specific data', function() {
+ node.setData('key', 'value');
+ node.setData('key', undefined);
+ expect(node.getData('key')).to.be.undefined;
+ });
});
describe('Changing node tag', function() {
it('can change tag name', function() {
var node = elementNodeFromXML('<div></div>');
- node.setTag('span');
+ node = node.setTag('span');
expect(node.getTagName()).to.equal('span');
});
- it('emits nodeTagChange event', function() {
- var node = elementNodeFromXML('<div></div>'),
- spy = sinon.spy();
-
- node.document.on('change', spy);
- node.setTag('span');
- var event = spy.args[0][0];
-
- expect(event.type).to.equal('nodeTagChange');
- expect(event.meta.node.sameNode(node)).to.be.true;
- expect(event.meta.oldTagName).to.equal('div');
- });
-
describe('Implementation specific expectations', function() {
- // DOM specifies ElementNode tag as a read-only property, so
- // changing it in a seamless way is a little bit tricky. For this reason
- // the folowing expectations are required, despite the fact that they actually are
- // motivated by implemetation details.
-
- it('keeps node in the document', function() {
- var doc = getDocumentFromXML('<div><header></header></div>'),
- header = doc.root.contents()[0];
- header.setTag('span');
- expect(header.parent().sameNode(doc.root)).to.be.true;
- });
it('keeps custom data', function() {
var node = elementNodeFromXML('<div></div>');
node.setData('key', 'value');
- node.setTag('header');
+ node = node.setTag('header');
expect(node.getTagName()).to.equal('header');
expect(node.getData()).to.eql({key: 'value'});
expect(doc.root.getTagName()).to.equal('span');
});
- it('keeps contents', function() {
+ it('keeps node contents', function() {
var node = elementNodeFromXML('<div><div></div></div>');
- node.setTag('header');
+ node = node.setTag('header');
expect(node.contents()).to.have.length(1);
});
});
expect(event.meta.oldVal).to.equal('value1');
});
});
+
+ describe('Searching for the last child text node', function() {
+ [
+ '<div>xxx<div></div>last</div>',
+ '<div><div>last</div></div>',
+ '<div>xxx<div>last</div><div></div></div>'
+ ].forEach(function(xml, i) {
+ var example = 'example ' + i;
+ it('returns last child text node ' + example + ')', function() {
+ var doc = getDocumentFromXML(xml),
+ lastTextNode = doc.root.getLastTextNode();
+ expect(lastTextNode.getText()).to.equal('last', example);
+ });
+ });
+ });
+
+ describe('Putting nodes around', function() {
+ it('will not allow to put node before or after root node', function() {
+ var doc = getDocumentFromXML('<root></root>'),
+ spy = sinon.spy(),
+ root = doc.root,
+ result;
+
+ doc.on('change', spy);
+
+ result = doc.root.before({tagName: 'test'});
+
+ expect(spy.callCount).to.equal(0);
+ expect(result).to.undefined;
+
+ result = doc.root.after({tagName: 'test'});
+
+ expect(spy.callCount).to.equal(0);
+ expect(result).to.undefined;
+
+ expect(doc.root.sameNode(root));
+ });
+ });
});
describe('Basic TextNode properties', function() {
expect(rootContents[0].getText()).to.equal('Alice a cat');
});
+ it('merges adjacent text nodes resulting from moving an element node in between', function() {
+ var doc = getDocumentFromXML('<div><a></a>Alice <span>has</span>a cat</div>'),
+ span = doc.root.contents()[2],
+ a = doc.root.contents()[0];
+
+ a.append(span);
+
+ var rootContents = doc.root.contents();
+ expect(rootContents).to.have.length(2, 'one child left');
+ expect(rootContents[1].getText()).to.equal('Alice a cat');
+ });
+
it('inserts node at index', function() {
var doc = getDocumentFromXML('<div><a></a><b></b><c></c></div>'),
b = doc.root.contents()[1];
expect(node.contents()[2].getText()).to.equal(' a cat!');
});
+ it('removes parent-describing sibling nodes of unwrapped node', function() {
+ var doc = getDocumentFromXML('<root><div><a></a><x></x><a></a></div></root>');
+
+ doc.registerExtension({documentNode: {methods: {
+ object: {
+ describesParent: function() {
+ return this.getTagName() === 'x';
+ }
+ }
+ }}});
+
+ var div = doc.root.contents()[0],
+ x = div.contents()[1];
+
+ div.unwrapContent();
+ expect(doc.root.contents().length).to.equal(2);
+ expect(x.isInDocument()).to.be.false;
+ });
+
it('unwrap single element node from its parent', function() {
var doc = getDocumentFromXML('<div><a><b></b></a></div>'),
div = doc.root,
expect(wrapperContents[1].contents().length).to.equal(1);
expect(wrapperContents[1].contents()[0].getText()).to.equal('small');
});
+
+ it('keeps parent-describing nodes in place', function() {
+ var doc = getDocumentFromXML('<root>Alice <x></x> probably <y></y> has a cat</root>');
+
+ doc.registerExtension({documentNode: {methods: {
+ object: {
+ describesParent: function() {
+ /* globals Node */
+ return this.nodeType === Node.ELEMENT_NODE && this.getTagName() === 'x';
+ }
+ }
+ }}});
+
+ var root = doc.root,
+ x = root.contents()[1],
+ y = root.contents()[3];
+
+ root.wrapText({
+ _with: {tagName: 'span', attrs: {'attr1': 'value1'}},
+ offsetStart: 1,
+ offsetEnd: 4,
+ textNodeIdx: [0,4]
+ });
+
+ expect(x.parent().sameNode(root)).to.be.true;
+ expect(y.parent().getTagName()).to.equal('span');
+ });
});
describe('Wrapping Nodes', function() {
expect(headerChildren[0].sameNode(div2)).to.equal(true, 'first node wrapped');
expect(headerChildren[1].sameNode(div3)).to.equal(true, 'second node wrapped');
});
+
+ it('keeps parent-describing nodes in place', function() {
+ var section = elementNodeFromXML('<section>Alice<x></x><div>a cat</div></section>');
+
+ section.document.registerExtension({documentNode: {methods: {
+ object: {
+ describesParent: function() {
+ return this.nodeType === Node.ELEMENT_NODE && this.getTagName() === 'x';
+ }
+ }
+ }}});
+
+ var aliceText = section.contents()[0],
+ x = section.contents()[1],
+ lastDiv = section.contents()[2];
+
+ section.document.wrapNodes({
+ node1: aliceText,
+ node2: lastDiv,
+ _with: {tagName: 'header'}
+ });
+
+ expect(x.parent().sameNode(section)).to.be.true;
+ expect(aliceText.parent().getTagName()).to.equal('header');
+ expect(lastDiv.parent().getTagName()).to.equal('header');
+ });
});
});
expect(contents[1].contents().length).to.equal(1);
expect(contents[1].contents()[0].getText()).to.equal('b');
});
+ it('removes across elements - 6', function() {
+ var doc = getDocumentFromXML('<root><div>aaa<span>bbb</span>ccc</div><div>ddd</div></root>');
+ doc.deleteText({
+ from: {
+ node: getTextNode('aaa', doc),
+ offset: 1
+ },
+ to: {
+ node: getTextNode('ddd', doc),
+ offset: 1
+ }
+ }, {
+ error: function(e) {throw e;}
+ });
+
+ var contents = doc.root.contents();
+ expect(contents.length).to.equal(2);
+ expect(contents[0].contents().length).to.equal(1);
+ expect(contents[0].contents()[0].getText()).to.equal('a');
+ expect(contents[1].contents().length).to.equal(1);
+ expect(contents[1].contents()[0].getText()).to.equal('dd');
+ });
});
describe('Splitting text', function() {
expect(event.meta.node.sameNode(appended)).to.be.true;
});
- it('emits nodeMoved when appending aready existing node', function() {
+ it('emits nodeDetached/nodeAdded events with `move` flag when appending aready existing node', function() {
var node = elementNodeFromXML('<div><a></a><b></b></div>'),
a = node.contents()[0],
b = node.contents()[1],
node.document.on('change', spy);
var appended = a.append(b),
- event = spy.args[0][0];
+ detachedEvent = spy.args[0][0],
+ addedEvent = spy.args[1][0];
+
+ expect(spy.callCount).to.equal(2);
+ expect(detachedEvent.type).to.equal('nodeDetached');
+ expect(detachedEvent.meta.node.sameNode(appended)).to.be.true;
+ expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
+ expect(addedEvent.type).to.equal('nodeAdded');
+ expect(addedEvent.meta.node.sameNode(appended)).to.be.true;
+ expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
- expect(spy.callCount).to.equal(1);
- expect(event.type).to.equal('nodeMoved');
- expect(event.meta.node.sameNode(appended)).to.be.true;
- expect(node.document.root.sameNode(event.meta.parent)).to.equal(true, 'previous parent attached to event meta');
});
it('emits nodeAdded event when prepending new node', function() {
expect(event.meta.node.sameNode(prepended)).to.be.true;
});
- it('emits nodeMoved when prepending aready existing node', function() {
+ it('emits nodeDetached/nodeAdded events with `move` flag when prepending aready existing node', function() {
var node = elementNodeFromXML('<div><a></a><b></b></div>'),
a = node.contents()[0],
b = node.contents()[1],
spy = sinon.spy();
node.document.on('change', spy);
-
+
var prepended = a.prepend(b),
- event = spy.args[0][0];
- expect(spy.callCount).to.equal(1);
- expect(event.type).to.equal('nodeMoved');
- expect(event.meta.node.sameNode(prepended)).to.be.true;
+ detachedEvent = spy.args[0][0],
+ addedEvent = spy.args[1][0];
+
+ expect(spy.callCount).to.equal(2);
+ expect(detachedEvent.type).to.equal('nodeDetached');
+ expect(detachedEvent.meta.node.sameNode(prepended)).to.be.true;
+ expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
+ expect(addedEvent.type).to.equal('nodeAdded');
+ expect(addedEvent.meta.node.sameNode(prepended)).to.be.true;
+ expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
});
it('emits nodeAdded event when inserting node after another', function() {
expect(event.meta.node.sameNode(inserted)).to.be.true;
});
- it('emits nodeMoved when inserting aready existing node after another', function() {
+ it('emits nodeDetached/nodeAdded events with `move` flag when inserting aready existing node after another', function() {
var node = elementNodeFromXML('<div><a></a><b></b></div>'),
a = node.contents()[0],
b = node.contents()[1],
spy = sinon.spy();
node.document.on('change', spy);
var inserted = b.after(a),
- event = spy.args[0][0];
+ detachedEvent = spy.args[0][0],
+ addedEvent = spy.args[1][0];
- expect(spy.callCount).to.equal(1);
- expect(event.type).to.equal('nodeMoved');
- expect(event.meta.node.sameNode(inserted)).to.be.true;
+ expect(spy.callCount).to.equal(2);
+ expect(detachedEvent.type).to.equal('nodeDetached');
+ expect(detachedEvent.meta.node.sameNode(inserted)).to.be.true;
+ expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
+ expect(addedEvent.type).to.equal('nodeAdded');
+ expect(addedEvent.meta.node.sameNode(inserted)).to.be.true;
+ expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
});
it('emits nodeAdded event when inserting node before another', function() {
expect(event.meta.node.sameNode(inserted)).to.be.true;
});
- it('emits nodeAdded when inserting aready existing node before another', function() {
+ it('emits nodeDetached/nodeAdded events with `move` flag when inserting aready existing node before another', function() {
var node = elementNodeFromXML('<div><a></a><b></b></div>'),
a = node.contents()[0],
b = node.contents()[1],
spy = sinon.spy();
node.document.on('change', spy);
var inserted = a.before(b),
- event = spy.args[0][0];
+ detachedEvent = spy.args[0][0],
+ addedEvent = spy.args[1][0];
- expect(spy.callCount).to.equal(1);
- expect(event.type).to.equal('nodeMoved');
- expect(event.meta.node.sameNode(inserted)).to.be.true;
+ expect(spy.callCount).to.equal(2);
+ expect(detachedEvent.type).to.equal('nodeDetached');
+ expect(detachedEvent.meta.node.sameNode(inserted)).to.be.true;
+ expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
+ expect(addedEvent.type).to.equal('nodeAdded');
+ expect(addedEvent.meta.node.sameNode(inserted)).to.be.true;
+ expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
});
it('emits nodeDetached and nodeAdded when replacing root node with another', function() {
beforeEach(function() {
doc = getDocumentFromXML('<section>Alice<div class="test_class"></div></section>');
- elementNode = doc.root;
- textNode = doc.root.contents()[0];
- extension = {};
-
- expect(elementNode.testTransformation).to.be.undefined;
- expect(textNode.testTransformation).to.be.undefined;
- expect(doc.testTransformation).to.be.undefined;
-
- expect(doc.testMethod).to.be.undefined;
- expect(elementNode.testMethod).to.be.undefined;
- expect(textNode.testMethod).to.be.undefined;
- expect(elementNode.elementTestMethod).to.be.undefined;
- expect(textNode.textTestMethod).to.be.undefined;
});
it('allows adding method to a document', function() {
doc.registerExtension(extension);
- /* refresh */
elementNode = doc.root;
textNode = doc.root.contents()[0];
doc.registerExtension(extension);
- /* refresh */
elementNode = doc.root;
textNode = doc.root.contents()[0];
expect(doc.undoStack.length).to.equal(0, 'nothing to undo');
expect(doc.root.contents().length).to.equal(0);
});
+
+ it('rollbacks and calls error handleor if error gets thrown', function() {
+ var doc = getDocumentFromXML('<root></root>'),
+ err = new Error(),
+ spy = sinon.spy();
+
+ doc.transaction(function() {
+ doc.root.append({tagName: 'div'});
+ throw err;
+ }, {error: spy});
+
+ expect(spy.args[0][0]).to.equal(err);
+ expect(doc.root.contents().length).to.equal(0);
+ expect(doc.undoStack.length).to.equal(0);
+ });
});
describe('Regression tests', function() {
doc.redo();
expect(doc.root.getAttr('t')).to.equal('1');
});
+ it('can perform undo of an operation performed after automatic transaction rollback', function() {
+ var doc = getDocumentFromXML('<section></section>'),
+ extension = {document: {transformations: {
+ throwingTransformation: function() { throw new Error(); }
+ }}};
+
+ doc.registerExtension(extension);
+
+ doc.throwingTransformation();
+
+ doc.transaction(function() {
+ doc.root.setAttr('x', '2');
+ });
+
+ expect(doc.undoStack.length).to.equal(1);
+ expect(doc.root.getAttr('x')).to.equal('2');
+
+ doc.undo();
+
+ expect(doc.undoStack.length).to.equal(0);
+ expect(doc.root.getAttr('x')).to.be.undefined;
+
+ });
});
});
fnp / fnpeditor.git / blobdiff