Adding functionality

.github/dependabot.yml

@@ -0,0 +1,7 @@
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/" # Location of package manifests
+ schedule:
+ interval: "weekly"

src/LinkTree.jl

@@ -9,9 +9,9 @@ newempty(::Type{Data}) where {Data} = Data()
 
 A branch type that connects LinkNodes in a LinkTree
 """
-struct LinkBranch{RT, NL, Data, LenUnits} <: AbstractBranch{RT, NL}
+mutable struct LinkBranch{RT, NL, Data, LenUnits} <: AbstractBranch{RT, NL}
  name::Int
- inout::Tuple{AbstractNode{RT, NL}, AbstractNode{RT, NL}}
+ inout::Tuple{<:AbstractNode{RT, NL}, <:AbstractNode{RT, NL}}
  length::Union{Missing, LenUnits}
  data::Data
 end

src/Phylo.jl

@@ -213,6 +213,63 @@ include("metrics.jl")
 export mrca, nodeheights
 export distance, distances, heighttoroot, heightstoroot
 
+"""
+ sort!(::AbstractTree; uselength = [if available], rev = false)
+
+Sorts the branches descending from each node by total number of descendants
+(or branch length is `uselength = true`). This creates a clearer tree for
+plotting. The process is also called "ladderizing" the tree. Use `rev = true`
+to reverse the sorting order.
+"""
+function Base.sort!(tree::T;
+ uselength = all(haslength.(Ref(tree), getbranches(tree))),
+ rev = false) where
+ {T <: AbstractTree{OneTree, <:Rooted}}
+ function loc!(clade::String)
+ if isleaf(tree, clade)
+ return uselength ?
+ zero(nonmissingtype(typeof(getlength(tree,
+ getinbound(tree,
+ clade))))) :
+ 1.0
+ end
+
+ sizes = uselength ?
+ [getlength(tree, child) +
+ loc!(getnodename(tree, dst(tree, child)))
+ for child in getoutbounds(tree, clade)] :
+ map(loc!, getchildren(tree, clade))
+ node = getnode(tree, clade)
+ if T <: LinkTree
+ node.other .= node.other[sortperm(sizes, rev = rev)]
+ elseif T <: RecursiveTree
+ node.conns .= node.conns[sortperm(sizes, rev = rev)]
+ end
+ if uselength
+ return maximum(sizes)
+ else
+ return sum(sizes) + 1.0
+ end
+ end
+
+ for root in getroots(tree)
+ loc!(getnodename(tree, root))
+ end
+
+ return tree
+end
+
+"""
+ sort(::AbstractTree; uselength = [if available], rev = false)
+
+Copies a tree and sorts its branches. See `sort!` for further details.
+"""
+function Base.sort(tree::AbstractTree;
+ uselength = all(haslength.(Ref(tree), getbranches(tree))),
+ rev = false)
+ return sort!(deepcopy(tree), uselength = uselength, rev = rev)
+end
+
 # Path into package
 path(path...; dir::String = "test") = joinpath(@__DIR__, "..", dir, path...)
 

src/RecursiveTree.jl

@@ -121,11 +121,7 @@ function RecursiveTree{RT, NL, NodeData, BranchData, BT, LenUnits, TD}(leafinfos
 end
 
 import Phylo.API: _prefernodeobjects, _preferbranchobjects
-_prefernodeobjects(::Type{<:RecursiveTree}) = true
-_prefernodeobjects(::Type{<:RecursiveNode}) = true
 _prefernodeobjects(::Type{<:RecursiveElt}) = true
-_preferbranchobjects(::Type{<:RecursiveTree}) = true
-_preferbranchobjects(::Type{<:RecursiveBranch}) = true
 _preferbranchobjects(::Type{<:RecursiveElt}) = true
 
 import Phylo.API: _validate!

src/plot.jl

@@ -220,41 +220,6 @@ function _extend(tmp, x)
  return ret
 end
 
-"""
- sort!(::AbstractTree; rev = false)
-
-Sorts the branches descending from each node by total number of
-descendants. This creates a clearer tree for plotting. The
-process is also called "ladderizing" the tree. Use `rev=true` to
-reverse the sorting order.
-"""
-function Base.sort!(tree::T; rev = false) where {T <: AbstractTree}
- function loc!(clade::String)
- if isleaf(tree, clade)
- return 1
- end
-
- sizes = map(loc!, getchildren(tree, clade))
- node = getnode(tree, clade)
- if T <: LinkTree
- node.other .= node.other[sortperm(sizes, rev = rev)]
- elseif T <: RecursiveTree
- node.conns .= node.conns[sortperm(sizes, rev = rev)]
- end
- return sum(sizes) + 1
- end
-
- loc!(first(nodenamefilter(isroot, tree)))
- return tree
-end
-
-"""
- sort(::AbstractTree; rev = false)
-
-Copies a tree and sorts its branches. See `sort!` for further details.
-"""
-Base.sort(tree::AbstractTree; rev = false) = sort!(copy(tree))
-
 function _nodedepths(tree::Phylo.AbstractTree)
  function finddepths!(clade::String)
  if !in(clade, keys(depth))

test/test_Phylo.jl

@@ -2,6 +2,7 @@ module TestPhylo
 using Test
 
 using Phylo
+using Random
 
 @testset "Deprecations" begin
  t = NamedTree()
@@ -16,4 +17,18 @@ using Phylo
  @test_deprecated treenameiter(t)
 end
 
+@testset "Sort $TreeType" for TreeType in [RootedTree, Phylo.LTD{OneRoot, Float64}]
+ tree = rand(Nonultrametric{TreeType}(100))
+ @test validate!(deepcopy(tree))
+ t2 = sort(tree)
+ leaves = getleaves(t2, inorder)
+ @test maximum(getheight.(Ref(t2), leaves)) == getheight(t2, leaves[end])
+ t3 = sort(tree, uselength = false, rev = true)
+ leaves = getleaves(t3, inorder)
+ for b in getbranches(t3)
+ b.length = one(b.length)
+ end
+ @test maximum(getheight.(Ref(t3), leaves)) == getheight(t3, first(leaves))
+end
+
 end