smartxml: fix detaching element node with adjacent text nodes

[fnpeditor.git] / src / smartxml / smartxml.test.js

diff --git a/src/smartxml/smartxml.test.js b/src/smartxml/smartxml.test.js
index 4c9b860..67ada78 100644 (file)
--- a/src/smartxml/smartxml.test.js
+++ b/src/smartxml/smartxml.test.js
@@ -40,6 +40,17 @@ describe('smartxml', function() {
             doc.loadXML('<header></header>');
             expect(doc.root.getTagName()).to.equal('header');
         });
+
+        it('knows if it contains an ElementNode in its tree', function() {
+            var doc = getDocumentFromXML('<root><a></a>text</root>'),
+                root = doc.root,
+                a = root.contents()[0],
+                text = root.contents()[1];
+
+            expect(doc.containsNode(root)).to.equal(true, 'contains its root');
+            expect(doc.containsNode(a)).to.equal(true, 'contains Element Node');
+            expect(doc.containsNode(text)).to.equal(true, 'contains Text Node');
+        });
     });
 
     describe('Basic ElementNode properties', function() {
@@ -251,6 +262,17 @@ describe('smartxml', function() {
 
     describe('Manipulations', function() {
 
+        it('merges adjacent text nodes resulting from detaching an element node in between', function() {
+            var doc = getDocumentFromXML('<div>Alice <span>has</span>a cat</div>'),
+                span = doc.root.contents()[1];
+
+            span.detach();
+
+            var rootContents = doc.root.contents();
+            expect(rootContents).to.have.length(1, 'one child left');
+            expect(rootContents[0].getText()).to.equal('Alice a cat');
+        });
+
         it('appends element node to another element node', function() {
             var node1 = elementNodeFromParams({tag: 'div'}),
                 node2 = elementNodeFromParams({tag: 'a'}),
@@ -291,11 +313,24 @@ describe('smartxml', function() {
             expect(node.contents()[2].getText()).to.equal(' a cat!');
         });
 
+        it('unwrap single node from its parent', function() {
+            var doc = getDocumentFromXML('<div><a><b></b></a></div>'),
+                div = doc.root,
+                a = div.contents()[0],
+                b = a.contents()[0];
+
+            var parent = b.unwrap();
+
+            expect(parent.sameNode(div)).to.equal(true, 'returns new parent');
+            expect(div.contents()).to.have.length(1, 'root contains only one node');
+            expect(div.contents()[0].sameNode(b)).to.equal(true, 'node got unwrapped');
+        });
+
         describe('Wrapping text', function() {
             it('wraps text spanning multiple sibling TextNodes', function() {
                 var section = elementNodeFromXML('<section>Alice has a <span>small</span> cat</section>'),
                     wrapper = section.wrapText({
-                        _with: {tag: 'span', attrs: {'attr1': 'value1'}},
+                        _with: {tagName: 'span', attrs: {'attr1': 'value1'}},
                         offsetStart: 6,
                         offsetEnd: 4,
                         textNodeIdx: [0,2]
@@ -307,6 +342,7 @@ describe('smartxml', function() {
 
                 var wrapper2 = section.contents()[1];
                 expect(wrapper2.sameNode(wrapper)).to.be.true;
+                expect(wrapper.getTagName()).to.equal('span');
 
                 var wrapperContents = wrapper.contents();
                 expect(wrapperContents.length).to.equal(3);
@@ -369,6 +405,20 @@ describe('smartxml', function() {
     });
 
     describe('Events', function() {
+        it('emits nodeDetached event on node detach', function() {
+            var node = elementNodeFromXML('<div><div></div></div>'),
+                innerNode = node.contents()[0],
+                spy = sinon.spy();
+            node.document.on('change', spy);
+            
+            var detached = innerNode.detach(),
+                event = spy.args[0][0];
+
+            expect(event.type).to.equal('nodeDetached');
+            expect(event.meta.node.sameNode(detached, 'detached node in event meta'));
+            expect(event.meta.parent.sameNode(node), 'original parent node in event meta');
+        }),
+
         it('emits nodeAdded event when appending new node', function() {
             var node = elementNodeFromXML('<div></div>'),
                 spy = sinon.spy();
@@ -471,6 +521,54 @@ describe('smartxml', function() {
         });
     });
 
+    describe('Traversing', function() {
+        describe('Basic', function() {
+            it('can access node parent', function() {
+                var doc = getDocumentFromXML('<a><b></b></a>'),
+                    a = doc.root,
+                    b = a.contents()[0];
+
+                expect(a.parent()).to.equal(null, 'parent of a root is null');
+                expect(b.parent().sameNode(a)).to.be.true;
+            });
+            it('can access node parents', function() {
+                var doc = getDocumentFromXML('<a><b><c></c></b></a>'),
+                    a = doc.root,
+                    b = a.contents()[0],
+                    c = b.contents()[0];
+
+                var parents = c.parents();
+                expect(parents).to.eql([b,a]);
+            });
+        });
+
+        describe('finding sibling parents of two elements', function() {
+            it('returns elements themself if they have direct common parent', function() {
+                var doc = getDocumentFromXML('<section><div><div>A</div><div>B</div></div></section>'),
+                    wrappingDiv = doc.root.contents()[0],
+                    divA = wrappingDiv.contents()[0],
+                    divB = wrappingDiv.contents()[1];
+
+                var siblingParents = doc.getSiblingParents({node1: divA, node2: divB});
+
+                expect(siblingParents.node1.sameNode(divA)).to.equal(true, 'divA');
+                expect(siblingParents.node2.sameNode(divB)).to.equal(true, 'divB');
+            });
+
+            it('returns sibling parents - example 1', function() {
+                var doc = getDocumentFromXML('<section>Alice <span>has a cat</span></section>'),
+                    aliceText = doc.root.contents()[0],
+                    span = doc.root.contents()[1],
+                    spanText = span.contents()[0];
+
+                var siblingParents = doc.getSiblingParents({node1: aliceText, node2: spanText});
+
+                expect(siblingParents.node1.sameNode(aliceText)).to.equal(true, 'aliceText');
+                expect(siblingParents.node2.sameNode(span)).to.equal(true, 'span');
+            });
+        });
+    });
+
     describe('Serializing document to WLXML', function() {
         it('keeps document intact when no changes have been made', function() {
             var xmlIn = '<section>Alice<div>has</div>a <span class="uri" meta-uri="http://cat.com">cat</span>!</section>',