fnp / fnpeditor.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Update jshint
[fnpeditor.git] / src / smartxml / smartxml.test.js
diff --git a/src/smartxml/smartxml.test.js b/src/smartxml/smartxml.test.js
index 8f7deb6..ce0d98a 100644 (file)
--- a/src/smartxml/smartxml.test.js
+++ b/src/smartxml/smartxml.test.js
@@ -163,46 +163,28 @@ describe('smartxml', function() {
                 node.setData({key1: 'value1', key2: 'value2'});
                 expect(node.getData()).to.eql({key1: 'value1', key2: 'value2'});
             });
                 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>');
         });
 
         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');
             });
 
                 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() {
             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');
                 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(node.getTagName()).to.equal('header');
                     expect(node.getData()).to.eql({key: 'value'});
@@ -214,9 +196,9 @@ describe('smartxml', function() {
                     expect(doc.root.getTagName()).to.equal('span');
                 });
 
                     expect(doc.root.getTagName()).to.equal('span');
                 });
 
-                it('keeps contents', function() {
+                it('keeps node contents', function() {
                     var node = elementNodeFromXML('<div><div></div></div>');
                     var node = elementNodeFromXML('<div><div></div></div>');
-                    node.setTag('header');
+                    node = node.setTag('header');
                     expect(node.contents()).to.have.length(1);
                 });
             });
                     expect(node.contents()).to.have.length(1);
                 });
             });
@@ -243,6 +225,44 @@ describe('smartxml', function() {
                 expect(event.meta.oldVal).to.equal('value1');
             });
         });
                 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() {
     });
 
     describe('Basic TextNode properties', function() {
@@ -425,6 +445,18 @@ describe('smartxml', function() {
             expect(rootContents[0].getText()).to.equal('Alice a cat');
         });
 
             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];
         it('inserts node at index', function() {
             var doc = getDocumentFromXML('<div><a></a><b></b><c></c></div>'),
                 b = doc.root.contents()[1];
@@ -569,6 +601,24 @@ describe('smartxml', function() {
             expect(node.contents()[2].getText()).to.equal(' a cat!');
         });
 
             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>'),
+                div = doc.root.contents()[0],
+                x = div.contents()[1];
+
+            doc.registerExtension({documentNode: {methods: {
+                object: {
+                    describesParent: function() {
+                        return this.getTagName() === 'x';
+                    }
+                }
+            }}});
+
+            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,
         it('unwrap single element node from its parent', function() {
             var doc = getDocumentFromXML('<div><a><b></b></a></div>'),
                 div = doc.root,
@@ -621,6 +671,32 @@ describe('smartxml', function() {
                 expect(wrapperContents[1].contents().length).to.equal(1);
                 expect(wrapperContents[1].contents()[0].getText()).to.equal('small');
             });
                 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>'),
+                    root = doc.root,
+                    x = root.contents()[1],
+                    y = root.contents()[3];
+
+                doc.registerExtension({documentNode: {methods: {
+                    object: {
+                        describesParent: function() {
+                            /* globals Node */
+                            return this.nodeType === Node.ELEMENT_NODE && this.getTagName() === 'x';
+                        }
+                    }
+                }}});
+
+                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() {
         });
 
         describe('Wrapping Nodes', function() {
@@ -669,6 +745,31 @@ 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');
             });
                 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>'),
+                    aliceText = section.contents()[0],
+                    x = section.contents()[1],
+                    lastDiv = section.contents()[2];
+
+                section.document.registerExtension({documentNode: {methods: {
+                    object: {
+                        describesParent: function() {
+                            return this.nodeType === Node.ELEMENT_NODE && this.getTagName() === 'x';
+                        }
+                    }
+                }}});
+
+                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');
+            });
         });
 
     });
         });
 
     });
@@ -841,6 +942,28 @@ describe('smartxml', function() {
             expect(contents[1].contents().length).to.equal(1);
             expect(contents[1].contents()[0].getText()).to.equal('b');
         });
             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() {
     });
 
     describe('Splitting text', function() {
@@ -948,7 +1071,7 @@ describe('smartxml', function() {
             expect(event.meta.node.sameNode(appended)).to.be.true;
         });
         
             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],
             var node = elementNodeFromXML('<div><a></a><b></b></div>'),
                 a = node.contents()[0],
                 b = node.contents()[1],
@@ -956,12 +1079,17 @@ describe('smartxml', function() {
             node.document.on('change', spy);
             
             var appended = a.append(b),
             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() {
         });
         
         it('emits nodeAdded event when prepending new node', function() {
@@ -975,18 +1103,24 @@ describe('smartxml', function() {
             expect(event.meta.node.sameNode(prepended)).to.be.true;
         });
         
             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 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),
             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() {
         });
         
         it('emits nodeAdded event when inserting node after another', function() {
@@ -1000,18 +1134,23 @@ describe('smartxml', function() {
             expect(event.meta.node.sameNode(inserted)).to.be.true;
         });
         
             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),
             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() {
         });
 
         it('emits nodeAdded event when inserting node before another', function() {
@@ -1025,18 +1164,23 @@ describe('smartxml', function() {
             expect(event.meta.node.sameNode(inserted)).to.be.true;
         });
         
             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),
             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() {
         });
 
         it('emits nodeDetached and nodeAdded when replacing root node with another', function() {
@@ -1649,6 +1793,32 @@ describe('smartxml', function() {
                 var transaction = doc.undoStack[0];
                 expect(transaction.metadata).to.equal(metadata);
             });
                 var transaction = doc.undoStack[0];
                 expect(transaction.metadata).to.equal(metadata);
             });
+
+            it('can be rolled back', function() {
+                var doc = getDocumentFromXML('<root></root>');
+
+                doc.startTransaction();
+                doc.root.append({tagName: 'div'});
+                doc.rollbackTransaction();
+
+                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() {
         });
 
         describe('Regression tests', function() {
@@ -1677,6 +1847,29 @@ describe('smartxml', function() {
                 doc.redo();
                 expect(doc.root.getAttr('t')).to.equal('1');
             });
                 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;
+
+            });
         });
     });
 
         });
     });