phyloio 2.1.1 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phyloio",
-  "version": "2.1.1",
+  "version": "2.2.2",
   "description": "JS library for visualising and comparing phylogenetic trees",
   "scripts": {
     "test": "npm run-script build-jest; jest --silent=false",

package/rerooting.test.js

@@ -0,0 +1,297 @@
+/**
+ * @jest-environment jsdom
+ */
+
+
+const PhyloIO = require("./dist-jest/phylo.js").PhyloIO;
+const utils = require('./src/utils.js')
+
+var data = '((C,D)1,(A,(B,X)3)2,E);'
+
+// get string made of concatenation  of leaves name from node.leaves
+const getSortedLeaves = (node) => {
+    return node.leaves.map(leaf => leaf.name).sort();
+}
+
+const verify_boostrap_default = (node, children) =>  {
+
+    var con_leaves = getSortedLeaves(node)
+
+    if ( con_leaves.length <= 1) {
+        return;
+    }
+
+    var str_leaves = JSON.stringify(con_leaves);
+
+    switch (str_leaves){
+        case JSON.stringify(['A', 'B', 'X']):
+            expect(node.extended_informations.Data).toBe("2");
+            break;
+        case JSON.stringify(['B', 'X']):
+            expect(node.extended_informations.Data).toBe("3");
+            break;
+        case JSON.stringify(['C', 'D']):
+            expect(node.extended_informations.Data).toBe("1");
+            break;
+        case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+            expect(node.extended_informations.Data).toBeUndefined();
+            break;
+        default:
+            expect(true).toBe(false);
+            break
+    }
+}
+
+test('test reroot on X' , () => {
+
+    const phylo = PhyloIO.init();
+
+    // >>>  test with  internal label for branches
+    var m1 = phylo._create_model(data, {'data_type' : 'nhx'})
+    m1.settings.edge_related_data.push('Data');
+    m1.traverse(m1.data,verify_boostrap_default);
+
+    // reroot on X
+    var x_node = m1.data.leaves.find(leaf => leaf.name === 'X');
+    m1.reroot(x_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBeUndefined();
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+    // >>> test without internal label for branches
+    var m2 = phylo._create_model(data, {'data_type' : 'nhx'})
+    m2.traverse(m2.data,verify_boostrap_default);
+
+    // reroot on X
+    var x_node2 = m2.data.leaves.find(leaf => leaf.name === 'X');
+    m2.reroot(x_node2);
+    m2.traverse(m2.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBeUndefined()
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeUndefined();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+})
+
+test('test reroot on B/X > C/D > B/X ' , () => {
+
+    const phylo = PhyloIO.init();
+
+    // >>>  test with  internal label for branches
+    var m1 = phylo._create_model(data, {'data_type' : 'nhx'})
+    m1.settings.edge_related_data.push('Data');
+    m1.traverse(m1.data,verify_boostrap_default);
+
+    // reroot on BX
+    var bx_node = null;
+    m1.traverse(m1.data, function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        if (str_leaves === JSON.stringify(['B', 'X'])) {
+            bx_node = node;
+        }
+    });
+    m1.reroot(bx_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            case JSON.stringify(['B', 'X']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+    // reroot on CD
+    var cd_node = null;
+    m1.traverse(m1.data, function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        if (str_leaves === JSON.stringify(['C', 'D'])) {
+            cd_node = node;
+        }
+    });
+    m1.reroot(cd_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['A', 'B', 'X']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'B', 'E', 'X']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['B', 'X']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+    // reroot on BX
+    var bx2_node = null;
+    m1.traverse(m1.data, function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        console.log(str_leaves)
+
+        if (str_leaves === JSON.stringify(['B', 'X'])) {
+
+            bx2_node = node;
+        }
+    });
+    m1.reroot(bx2_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            case JSON.stringify(['B', 'X']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+
+})
+
+
+
+
+
+
+

package/src/model.js

@@ -794,10 +794,6 @@ export default class Model {
         parent.branch_length = old_distance /2
         parent.extended_informations['Length'] = old_distance/2
 
-
-
-        //                      ((C,D)1,(A,(B,X)3)2,E); to test
-
         // Until we reach the old root reverse child/parent order
         var child = root
         var stack = []
@@ -812,29 +808,26 @@ export default class Model {
             parent.values_before_reverse = {}
             parent.branch_length_before_reverse = parent.branch_length
 
-            for (var key of this.settings.edge_related_data) {
-
-                var value = key;
+            for (var value of this.settings.edge_related_data) {
 
                 parent.values_before_reverse[value] = parent.extended_informations[value]
 
+                if (value=== 'Length'){
+                    parent.branch_length = child.branch_length_before_reverse || child.branch_length;
+                    parent.extended_informations['Length'] = parent.branch_length;
 
-                    if (value=== 'Length'){
-                        parent.branch_length = child.branch_length_before_reverse || child.branch_length;
-                        parent.extended_informations['Length'] = parent.branch_length;
-
+                }
+                else{
+                    if ( child.values_before_reverse && value in child.values_before_reverse){
+                        parent.extended_informations[value] = child.values_before_reverse[value]
                     }
                     else{
-                        if ( child.values_before_reverse && value in child.values_before_reverse){
-                            parent.extended_informations[value] = child.values_before_reverse[value]
-                        }
-                        else{
-                            parent.extended_informations[value] = child.extended_informations[value]
-                            child.extended_informations[value] = null
-                        }
-
+                        parent.extended_informations[value] = child.extended_informations[value]
+                        child.extended_informations[value] = null
                     }
 
+                }
+
 
 
             }
@@ -890,7 +883,6 @@ export default class Model {
 
             for (var childy of root.children) {
 
-                console.log(childy, childy.extended_informations[key], root.extended_informations[key] )
                 childy.extended_informations[key] =  root.extended_informations[key]
 
             }
@@ -909,6 +901,8 @@ export default class Model {
 
         this.traverse(root, function(n,c){
             n.leaves = this.get_leaves(n)
+            n.values_before_reverse = {}
+            n.branch_length_before_reverse = undefined
         })