smartxml: wrapping sibling nodes
[fnpeditor.git] / src / smartxml / smartxml.test.js
index 2ccfa6d..0826458 100644 (file)
@@ -158,13 +158,117 @@ describe('smartxml', function() {
         });
     });
 
         });
     });
 
+    describe('Basic TextNode properties', function() {
+        it('can have its text set', function() {
+            var node = elementNodeFromXML('<div>Alice</div>'),
+                textNode = node.contents()[0];
+
+            textNode.setText('Cat');
+            expect(textNode.getText()).to.equal('Cat');
+        });
+
+        it('emits nodeTextChange', function() {
+            var node = elementNodeFromXML('<div>Alice</div>'),
+                textNode = node.contents()[0],
+                spy = sinon.spy();
+
+            textNode.document.on('change', spy);
+            textNode.setText('Cat');
+
+            var event = spy.args[0][0];
+            expect(event.type).to.equal('nodeTextChange');
+        });
+
+        it('puts NodeElement after itself', function() {
+            var node = elementNodeFromXML('<div>Alice</div>'),
+                textNode = node.contents()[0],
+                returned = textNode.after({tagName:'div'});
+            expect(returned.sameNode(node.contents()[1])).to.be.true;
+        });
+
+        it('puts NodeElement before itself', function() {
+            var node = elementNodeFromXML('<div>Alice</div>'),
+                textNode = node.contents()[0],
+                returned = textNode.before({tagName:'div'});
+            expect(returned.sameNode(node.contents()[0])).to.be.true;
+        });
+
+        describe('Wrapping TextNode contents', function() {
+
+            it('wraps DocumentTextElement', function() {
+                var node = elementNodeFromXML('<section>Alice</section>'),
+                    textNode = node.contents()[0];
+                
+                var returned = textNode.wrapWith({tagName: 'header'}),
+                    parent = textNode.parent(),
+                    parent2 = node.contents()[0];
+
+                expect(returned.sameNode(parent)).to.be.equal(true, 'wrapper is a parent');
+                expect(returned.sameNode(parent2)).to.be.equal(true, 'wrapper has a correct parent');
+                expect(returned.getTagName()).to.equal('header');
+            });
+
+            describe('wrapping part of DocumentTextElement', function() {
+                [{start: 5, end: 12}, {start: 12, end: 5}].forEach(function(offsets) {
+                    it('wraps in the middle ' + offsets.start + '/' + offsets.end, function() {
+                        var node = elementNodeFromXML('<section>Alice has a cat</section>'),
+                            textNode = node.contents()[0];
+                        
+                        var returned = textNode.wrapWith({tagName: 'header', attrs: {'attr1': 'value1'}, start: offsets.start, end: offsets.end}),
+                            contents = node.contents();
+
+                        expect(contents.length).to.equal(3);
+                        
+                        expect(contents[0].nodeType).to.be.equal(Node.TEXT_NODE, 'first node is text node');
+                        expect(contents[0].getText()).to.equal('Alice');
+
+                        expect(contents[1].sameNode(returned)).to.be.true;
+                        expect(returned.getTagName()).to.equal('header');
+                        expect(returned.getAttr('attr1')).to.equal('value1');
+                        expect(contents[1].contents().length).to.equal(1, 'wrapper has one node inside');
+                        expect(contents[1].contents()[0].getText()).to.equal(' has a ');
+
+                        expect(contents[2].nodeType).to.be.equal(Node.TEXT_NODE, 'third node is text node');
+                        expect(contents[2].getText()).to.equal('cat');
+                    });
+                });
+
+                it('wraps whole text inside DocumentTextElement if offsets span entire content', function() {
+                    var node = elementNodeFromXML('<section>Alice has a cat</section>'),
+                         textNode = node.contents()[0];
+                     
+                    textNode.wrapWith({tagName: 'header', start: 0, end: 15});
+                    
+                    var contents = node.contents();
+                    expect(contents.length).to.equal(1);
+                    expect(contents[0].getTagName()).to.equal('header');
+                    expect(contents[0].contents()[0].getText()).to.equal('Alice has a cat');
+                });
+            });
+        });
+
+    });
+
     describe('Manipulations', function() {
 
         it('appends element node to another element node', function() {
             var node1 = elementNodeFromParams({tag: 'div'}),
     describe('Manipulations', function() {
 
         it('appends element node to another element node', function() {
             var node1 = elementNodeFromParams({tag: 'div'}),
-                node2 = elementNodeFromParams({tag: 'a'});
+                node2 = elementNodeFromParams({tag: 'a'}),
+                node3 = elementNodeFromParams({tag: 'p'});
             node1.append(node2);
             node1.append(node2);
+            node1.append(node3);
             expect(node1.contents()[0].sameNode(node2)).to.be.true;
             expect(node1.contents()[0].sameNode(node2)).to.be.true;
+            expect(node1.contents()[1].sameNode(node3)).to.be.true;
+        });
+
+        it('prepends element node to another element node', function() {
+            var node1 = elementNodeFromParams({tag: 'div'}),
+                node2 = elementNodeFromParams({tag: 'a'}),
+                node3 = elementNodeFromParams({tag: 'p'});
+            node1.prepend(node2);
+            node1.prepend(node3);
+            expect(node1.contents()[0].sameNode(node3)).to.be.true;
+            expect(node1.contents()[1].sameNode(node2)).to.be.true;
         });
 
         it('wraps element node with another element node', function() {
         });
 
         it('wraps element node with another element node', function() {
@@ -175,16 +279,6 @@ describe('smartxml', function() {
             expect(node.parent().sameNode(wrapper)).to.be.true;
         });
 
             expect(node.parent().sameNode(wrapper)).to.be.true;
         });
 
-        it('wraps text node with element node', function() {
-            var node = elementNodeFromXML('<div>Alice</div>'),
-                textNode = node.contents()[0],
-                wrapper = elementNodeFromXML('<wrapper></wrapper>');
-
-            textNode.wrapWith(wrapper);
-            expect(textNode.parent().sameNode(wrapper)).to.be.true;
-            expect(node.contents()).to.have.length(1);
-        });
-
         it('unwraps element node contents', function() {
             var node = elementNodeFromXML('<div>Alice <div>has <span>propably</span> a cat</div>!</div>'),
                 outerDiv = node.contents()[1];
         it('unwraps element node contents', function() {
             var node = elementNodeFromXML('<div>Alice <div>has <span>propably</span> a cat</div>!</div>'),
                 outerDiv = node.contents()[1];
@@ -197,6 +291,81 @@ describe('smartxml', function() {
             expect(node.contents()[2].getText()).to.equal(' a cat!');
         });
 
             expect(node.contents()[2].getText()).to.equal(' a cat!');
         });
 
+        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'}},
+                        offsetStart: 6,
+                        offsetEnd: 4,
+                        textNodeIdx: [0,2]
+                    });
+
+                expect(section.contents().length).to.equal(2);
+                expect(section.contents()[0].nodeType).to.equal(Node.TEXT_NODE);
+                expect(section.contents()[0].getText()).to.equal('Alice ');
+
+                var wrapper2 = section.contents()[1];
+                expect(wrapper2.sameNode(wrapper)).to.be.true;
+
+                var wrapperContents = wrapper.contents();
+                expect(wrapperContents.length).to.equal(3);
+                expect(wrapperContents[0].getText()).to.equal('has a ');
+
+                expect(wrapperContents[1].nodeType).to.equal(Node.ELEMENT_NODE);
+                expect(wrapperContents[1].contents().length).to.equal(1);
+                expect(wrapperContents[1].contents()[0].getText()).to.equal('small');
+            });
+        });
+
+        describe('Wrapping Nodes', function() {
+            it('wraps multiple sibling nodes', function() {
+                var section = elementNodeFromXML('<section>Alice<div>has</div><div>a cat</div></section>'),
+                    aliceText = section.contents()[0],
+                    firstDiv = section.contents()[1],
+                    lastDiv = section.contents()[section.contents().length -1];
+
+                var returned = section.document.wrapNodes({
+                        element1: aliceText,
+                        element2: lastDiv,
+                        _with: {tagName: 'header'}
+                    });
+
+                var sectionContents = section.contents(),
+                    header = sectionContents[0],
+                    headerContents = header.contents();
+
+                expect(sectionContents).to.have.length(1);
+                expect(header.sameNode(returned)).to.equal(true, 'wrapper returned');
+                expect(header.parent().sameNode(section)).to.be.true;
+                expect(headerContents).to.have.length(3);
+                expect(headerContents[0].sameNode(aliceText)).to.equal(true, 'first node wrapped');
+                expect(headerContents[1].sameNode(firstDiv)).to.equal(true, 'second node wrapped');
+                expect(headerContents[2].sameNode(lastDiv)).to.equal(true, 'third node wrapped');
+            });
+
+            it('wraps multiple sibling Elements - middle case', function() {
+                var section = elementNodeFromXML('<section><div></div><div></div><div></div><div></div></section>'),
+                    div2 = section.contents()[1],
+                    div3 = section.contents()[2];
+
+                section.document.wrapNodes({
+                        element1: div2,
+                        element2: div3,
+                        _with: {tagName: 'header'}
+                    });
+
+                var sectionContents = section.contents(),
+                    header = sectionContents[1],
+                    headerChildren = header.contents();
+
+                expect(sectionContents).to.have.length(3);
+                expect(headerChildren).to.have.length(2);
+                expect(headerChildren[0].sameNode(div2)).to.equal(true, 'first node wrapped');
+                expect(headerChildren[1].sameNode(div3)).to.equal(true, 'second node wrapped');
+            });
+        });
+
     });
 
     describe('Serializing document to WLXML', function() {
     });
 
     describe('Serializing document to WLXML', function() {