smartxml: wrapping sibling nodes

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

diff --git a/src/smartxml/smartxml.test.js b/src/smartxml/smartxml.test.js
index e58e754..0826458 100644 (file)
--- a/src/smartxml/smartxml.test.js
+++ b/src/smartxml/smartxml.test.js
@@ -1,7 +1,8 @@
 define([
     'libs/chai',
 define([
     'libs/chai',

+    'libs/sinon',

     './smartxml.js'
     './smartxml.js'

-], function(chai, smartxml) {
+], function(chai, sinon, smartxml) {

     
 'use strict';
 /*jshint expr:true */
     
 'use strict';
 /*jshint expr:true */


@@ -84,6 +85,19 @@ describe('smartxml', function() {
                 expect(node.getTagName()).to.equal('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
             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


@@ -111,19 +125,150 @@ describe('smartxml', function() {
                     doc.root.setTag('span');
                     expect(doc.root.getTagName()).to.equal('span');
                 });
                     doc.root.setTag('span');
                     expect(doc.root.getTagName()).to.equal('span');
                 });

+
+                it('keeps contents', function() {
+                    var node = elementNodeFromXML('<div><div></div></div>');
+                    node.setTag('header');
+                    expect(node.contents()).to.have.length(1);
+                });
+            });
+
+        describe('Setting node attributes', function() {
+            it('can set node attribute', function() {
+                var node = elementNodeFromXML('<div></div>');
+
+                node.setAttr('key', 'value');
+                expect(node.getAttr('key')).to.equal('value');
+            });
+            it('emits nodeAttrChange event', function() {
+                var node = elementNodeFromXML('<div key="value1"></div>'),
+                    spy = sinon.spy();
+
+                node.document.on('change', spy);
+                node.setAttr('key', 'value2');
+                var event = spy.args[0][0];
+
+                expect(event.type).to.equal('nodeAttrChange');
+                expect(event.meta.node.sameNode(node)).to.be.true;
+                expect(event.meta.attr).to.equal('key');
+                expect(event.meta.oldVal).to.equal('value1');
+            });
+        });
+
+        });
+    });
+
+    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() {


@@ -134,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];


@@ -156,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() {


@@ -170,6 +380,19 @@ describe('smartxml', function() {
             
             expect(input.isEqualNode(output)).to.be.true;
         });
             
             expect(input.isEqualNode(output)).to.be.true;
         });

+
+        it('keeps entities intact', function() {
+            var xmlIn = '<section>&lt; &gt;</section>',
+                doc = getDocumentFromXML(xmlIn),
+                xmlOut = doc.toXML();
+            expect(xmlOut).to.equal(xmlIn);
+        });
+        it('keeps entities intact when they form html/xml', function() {
+            var xmlIn = '<section>&lt;abc&gt;</section>',
+                doc = getDocumentFromXML(xmlIn),
+                xmlOut = doc.toXML();
+            expect(xmlOut).to.equal(xmlIn);
+        });

     });
 
 });
     });
 
 });