X-Git-Url: https://git.mdrn.pl/fnpeditor.git/blobdiff_plain/0f5cbf957bc0bbdcff93bdb33c227f78041e332b..90a4709555ba28d2175c7a359d538e7775f9bf64:/src/smartxml/smartxml.test.js?ds=inline

diff --git a/src/smartxml/smartxml.test.js b/src/smartxml/smartxml.test.js
index a15f833..08598aa 100644
--- a/src/smartxml/smartxml.test.js
+++ b/src/smartxml/smartxml.test.js
@@ -769,7 +769,9 @@ describe('smartxml', function() {
                     c = b.contents()[0];
 
                 var parents = c.parents();
-                expect(parents).to.eql([b,a]);
+                // @@
+                expect(parents[0].sameNode(b)).to.be.true;
+                expect(parents[1].sameNode(a)).to.be.true;
             });
         });
 
@@ -836,18 +838,15 @@ describe('smartxml', function() {
             textNode = doc.root.contents()[0];
             extension = {};
             
-            expect(function() {
-                elementNode.transform('testTransformation');
-            }).to.throw(Error);
-            expect(function() {
-                textNode.transform('testTransformation');
-            }).to.throw(Error);
-            expect(function() {
-                doc.transform('testTransformation');
-            }).to.throw(Error);
+            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() {
@@ -866,14 +865,28 @@ describe('smartxml', function() {
             }}};
 
             doc.registerExtension(extension);
-            expect(doc.transform('testTransformation')).to.equal(doc, 'context is set to a document instance');
-            expect(doc.transform('testTransformation2')).to.equal(doc, 'context is set to a document instance');
+            expect(doc.testTransformation()).to.equal(doc, 'context is set to a document instance');
+            expect(doc.testTransformation2()).to.equal(doc, 'context is set to a document instance');
         });
 
         it('allows adding method to a DocumentNode instance', function() {
-            extension = {documentNode: {methods: {
-                testMethod: function() { return this; }    
-            }}};
+            extension = {
+                documentNode: {
+                    methods: {
+                        testMethod: function() { return this; }
+                    }
+                },
+                textNode: {
+                    methods: {
+                        textTestMethod: function() { return this; }
+                    }
+                },
+                elementNode: {
+                    methods: {
+                        elementTestMethod: function() { return this; }
+                    }
+                }
+            };
 
             doc.registerExtension(extension);
 
@@ -883,20 +896,101 @@ describe('smartxml', function() {
 
             expect(elementNode.testMethod().sameNode(elementNode)).to.equal(true, 'context is set to a node instance');
             expect(textNode.testMethod().sameNode(textNode)).to.equal(true, 'context is set to a node instance');
+
+            expect(elementNode.elementTestMethod().sameNode(elementNode)).to.be.true;
+            expect(elementNode.textTestMethod).to.be.undefined;
+        
+            expect(textNode.textTestMethod().sameNode(textNode)).to.be.true;
+            expect(textNode.elementTestMethod).to.be.undefined;
         });
 
         it('allows adding transformation to a DocumentNode', function() {
-            extension = {documentNode: {transformations: {
-                testTransformation: function() { return this; },
-                testTransformation2: {impl: function() { return this;}}
-            }}};
+            extension = {
+                documentNode: {
+                    transformations: {
+                        testTransformation: function() { return this; },
+                        testTransformation2: {impl: function() { return this;}}
+                    }
+                },
+                textNode: {
+                    transformations: {
+                        textTestTransformation: function() { return this; }
+                    }
+                },
+                elementNode: {
+                    transformations: {
+                        elementTestTransformation: function() { return this; }
+                    }
+                }
+            };
             
             doc.registerExtension(extension);
 
-            expect(elementNode.transform('testTransformation').sameNode(elementNode)).to.equal(true, '1');
-            expect(elementNode.transform('testTransformation2').sameNode(elementNode)).to.equal(true, '2');
-            expect(textNode.transform('testTransformation').sameNode(textNode)).to.equal(true, '3');
-            expect(textNode.transform('testTransformation2').sameNode(textNode)).to.equal(true, '4');
+            /* refresh */
+            elementNode = doc.root;
+            textNode = doc.root.contents()[0];
+            
+            expect(elementNode.testTransformation().sameNode(elementNode)).to.equal(true, '1');
+            expect(elementNode.testTransformation2().sameNode(elementNode)).to.equal(true, '2');
+            expect(textNode.testTransformation().sameNode(textNode)).to.equal(true, '3');
+            expect(textNode.testTransformation2().sameNode(textNode)).to.equal(true, '4');
+
+            expect(elementNode.elementTestTransformation().sameNode(elementNode)).to.be.true;
+            expect(elementNode.textTestTransformation).to.be.undefined;
+        
+            expect(textNode.textTestTransformation().sameNode(textNode)).to.be.true;
+            expect(textNode.elementTestTransfomation).to.be.undefined; 
+        });
+
+        it('allows text/element node methods and transformations to access node and transormations on document node', function() {
+
+            var doc = getDocumentFromXML('<div>text</div>');
+
+            doc.registerExtension({
+                documentNode: {
+                    methods: {
+                        test: function() {
+                            return 'super';
+                        }
+                    },
+                    transformations: {
+                        testT: function() {
+                            return 'super_trans';
+                        }
+                    }
+                },
+                elementNode: {
+                    methods: {
+                        test: function() {
+                            return 'element_sub_' + this.__super__.test();
+                        }
+                    },
+                    transformations: {
+                        testT: function() {
+                            return 'element_trans_sub_' + this.__super__.testT();
+                        }
+                    }
+                },
+                textNode: {
+                    methods: {
+                        test: function() {
+                            return 'text_sub_' + this.__super__.test();
+                        }
+                    },
+                    transformations: {
+                        testT: function() {
+                            return 'text_trans_sub_' + this.__super__.testT();
+                        }
+                    }
+                }
+            });
+
+            var textNode = doc.root.contents()[0];
+
+            expect(doc.root.test()).to.equal('element_sub_super');
+            expect(textNode.test()).to.equal('text_sub_super');
+            expect(doc.root.testT()).to.equal('element_trans_sub_super_trans');
+            expect(textNode.testT()).to.equal('text_trans_sub_super_trans');
         });
     });