X-Git-Url: https://git.mdrn.pl/fnpeditor.git/blobdiff_plain/f63769e206281f306f6c2cb937358837da450185..9abc2f052e1503f396f118e9508b14cb8b276e39:/src/smartxml/smartxml.test.js

diff --git a/src/smartxml/smartxml.test.js b/src/smartxml/smartxml.test.js
index 5d1ca3e..f506f09 100644
--- a/src/smartxml/smartxml.test.js
+++ b/src/smartxml/smartxml.test.js
@@ -69,6 +69,24 @@ describe('smartxml', function() {
             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() {
@@ -87,9 +105,10 @@ describe('smartxml', 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;
@@ -100,15 +119,19 @@ describe('smartxml', function() {
 
             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() {
@@ -163,6 +186,12 @@ describe('smartxml', 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() {
@@ -219,6 +248,44 @@ describe('smartxml', function() {
                 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() {
@@ -401,6 +468,18 @@ describe('smartxml', 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];
@@ -545,6 +624,25 @@ describe('smartxml', function() {
             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,
@@ -597,6 +695,33 @@ describe('smartxml', function() {
                 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() {
@@ -645,6 +770,32 @@ describe('smartxml', 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');
+            });
         });
 
     });
@@ -817,6 +968,28 @@ describe('smartxml', function() {
             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() {
@@ -924,7 +1097,7 @@ describe('smartxml', 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],
@@ -932,12 +1105,17 @@ describe('smartxml', function() {
             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() {
@@ -951,18 +1129,24 @@ describe('smartxml', 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() {
@@ -976,18 +1160,23 @@ describe('smartxml', 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() {
@@ -1001,18 +1190,23 @@ describe('smartxml', 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() {
@@ -1162,19 +1356,6 @@ describe('smartxml', 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() {
@@ -1218,7 +1399,6 @@ describe('smartxml', function() {
 
             doc.registerExtension(extension);
 
-            /* refresh */
             elementNode = doc.root;
             textNode = doc.root.contents()[0];
 
@@ -1254,7 +1434,6 @@ describe('smartxml', function() {
             
             doc.registerExtension(extension);
 
-            /* refresh */
             elementNode = doc.root;
             textNode = doc.root.contents()[0];