API changed for consistency

Author: AleMorales

docs/src/index.md

@@ -71,7 +71,7 @@ has_parent(c::Context)
 ```
 
 ```@docs
-isroot(c::Context)
+is_root
 ```
 
 ```@docs
@@ -87,23 +87,27 @@ ancestor(c::Context; condition = x -> true, maxlevel::Int = typemax(Int))
 ```
 
 ```@docs
-haschildren(c::Context)
+get_root
 ```
 
 ```@docs
-isleaf(c::Context)
+has_children(c::Context)
 ```
 
 ```@docs
-hasdescendant(c::Context; condition = x -> true, maxlevel::Int = typemax(Int))
+is_leaf(c::Context)
+```
+
+```@docs
+has_descendant(c::Context; condition = x -> true, maxlevel::Int = typemax(Int))
 ```
 
 ```@docs
 children(c::Context)
 ```
 
 ```@docs
-getdescendant(c::Context; condition = x -> true, maxlevel::Int = typemax(Int))
+get_descendant
 ```
 
 # Traversal algorithms
@@ -113,11 +117,11 @@ traverse(g::Graph; fun = () -> nothing)
 ```
 
 ```@docs
-traversedfs(g::Graph; fun = () -> nothing, ID = root_id(g))
+traverse_dfs(g::Graph; fun = () -> nothing, ID = root_id(g))
 ```
 
 ```@docs
-traversebfs(g::Graph; fun = () -> nothing, ID = root_id(g))
+traverse_bfs(g::Graph; fun = () -> nothing, ID = root_id(g))
 ```
 
 ## Graph visualization

src/Algorithms.jl

@@ -21,7 +21,7 @@ applied to each node.
 This traveral happens in the order in which the nodes are stored in the graph.
 This order is arbitrary and may vary across executions of the code (it does not
 correspond to the order in which nodes are created). For algorithms that require
-a particular traveral order of the graph, see `traversedfs` and `traversebfs`.
+a particular traveral order of the graph, see `traverse_dfs` and `traverse_bfs`.
 
 This function does not store any results generated by `fun`. Hence, if the user
 wants to keep track of such results, they should be stored indirectly (e.g., via
@@ -71,15 +71,15 @@ function traverse(g::StaticGraph; fun = () -> nothing, order = "any", ID = root_
             fun(data(val))
         end
     elseif order == "dfs"
-        traversedfs(g::Graph; fun = fun, ID = ID)
+        traverse_dfs(g::Graph; fun = fun, ID = ID)
     elseif order == "bfs"
-        traversebfs(g::Graph; fun = fun, ID = ID)
+        traverse_bfs(g::Graph; fun = fun, ID = ID)
     end
     return nothing
 end
 
 """
-    traversedfs(g::Graph; fun = () -> nothing, ID = root_id(g))
+    traverse_dfs(g::Graph; fun = () -> nothing, ID = root_id(g))
 
 Iterates over all the nodes in the graph (depth-first order, starting at a any
 node) and execute for the function `fun` on each node
@@ -98,7 +98,7 @@ This traveral happens in a depth-first order. That is, all nodes in a branch of
 the graph are visited until reach a leaf node, then moving to the next branch.
 Hence, this algorithm should always generate the same result when applied to the
 same graph (assuming the user-defined function is not stochastic). For a version
-of this function that us breadth-first order see `traversebfs`.
+of this function that us breadth-first order see `traverse_bfs`.
 
 This function does not store any results generated by `fun`. Hence, if the user
 wants to keep track of such results, they should be stored indirectly (e.g., via
@@ -129,7 +129,7 @@ julia> let
            f = Foo(Int[])
            axiom = A1(2) + (B1(1) + A1(3), B1(4))
                g = Graph(axiom = axiom)
-           traversedfs(g, fun = f)
+           traverse_dfs(g, fun = f)
            f.vals
        end
 4-element Vector{Int64}:
@@ -139,11 +139,11 @@ julia> let
  3
 ```
 """
-function traversedfs(g::Graph; fun = () -> nothing, ID = root_id(g))
-    traversedfs(static_graph(g), fun, ID)
+function traverse_dfs(g::Graph; fun = () -> nothing, ID = root_id(g))
+    traverse_dfs(static_graph(g), fun, ID)
 end
 
-function traversedfs(g::StaticGraph, fun, ID)
+function traverse_dfs(g::StaticGraph, fun, ID)
     # Use LIFO stack to keep track of nodes in traversal
     node_stack = Int[]
     push!(node_stack, ID)
@@ -161,7 +161,7 @@ function traversedfs(g::StaticGraph, fun, ID)
 end
 
 """
-    traversebfs(g::Graph; fun = () -> nothing, ID = root_id(g))
+    traverse_bfs(g::Graph; fun = () -> nothing, ID = root_id(g))
 
 Iterates over all the nodes in the graph (breadth-first order, starting at a any
 node) and execute for the function `fun` on each node
@@ -180,7 +180,7 @@ This traveral happens in a breadth-first order. That is, all nodes at a given
 depth of the the graph are visited first, then moving on to the next level.
 Hence, this algorithm should always generate the same result when applied to the
 same graph (assuming the user-defined function is not stochastic). For a version
-of this function that us depth-first order see `traversedfs`.
+of this function that us depth-first order see `traverse_dfs`.
 
 This function does not store any results generated by `fun`. Hence, if the user
 wants to keep track of such results, they should be stored indirectly (e.g., via
@@ -211,7 +211,7 @@ julia> let
            f = Foo(Int[])
                axiom = A1(2) + (B1(1) + A1(3), B1(4))
                    g = Graph(axiom = axiom)
-           traversebfs(g, fun = f)
+           traverse_bfs(g, fun = f)
            f.vals
        end
 4-element Vector{Int64}:
@@ -221,11 +221,11 @@ julia> let
  3
 ```
 """
-function traversebfs(g::Graph; fun = () -> nothing, ID = root_id(g))
-    traversebfs(static_graph(g), fun, ID)
+function traverse_bfs(g::Graph; fun = () -> nothing, ID = root_id(g))
+    traverse_bfs(static_graph(g), fun, ID)
 end
 
-function traversebfs(g::StaticGraph, fun, ID)
+function traverse_bfs(g::StaticGraph, fun, ID)
     # Use LIFO stack to keep track of nodes in traversal
     node_stack = Int[]
     prepend!(node_stack, ID)

src/Context.jl

@@ -39,13 +39,18 @@ within a rule or query.
 """
 has_parent(c::Context) = has_parent(node(c))
 
+isroot(c::Context) = !has_parent(c)
+
 """
-    isroot(c::Context)
+    is_root(c::Context)
+
 
 Check if a node is the root of the graph (i.e., has no parent) and return `true` or
 `false`. Intended to be used within a rule or query.
+
+`isroot` is an alias for `is_root` for compatibility with AbstractTrees.jl
 """
-isroot(c::Context) = !has_parent(c)
+const is_root = isroot
 
 """
     has_ancestor(c::Context; condition = x -> true, max_level::Int = typemax(Int))
@@ -107,23 +112,23 @@ function has_ancestor(c::Context; condition = x -> true, max_level::Int = typema
 end
 
 """
-    haschildren(c::Context)
+    has_children(c::Context)
 
 Check if a node has at least one child and return `true` or `false`. Intended to be used
 within a rule or query.
 """
-haschildren(c::Context) = haschildren(node(c))
+has_children(c::Context) = has_children(node(c))
 
 """
-    isleaf(c::Context)
+    is_leaf(c::Context)
 
 Check if a node is a leaf in the graph (i.e., has no children) and return `true` or
 `false`. Intended to be used within a rule or query.
 """
-isleaf(c::Context) = !haschildren(c)
+is_leaf(c::Context) = !has_children(c)
 
 """
-    hasdescendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
+    has_descendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
 
 Check if a node has a descendant that matches the optional condition. Intended to be used
 within a rule or query.
@@ -143,7 +148,7 @@ leaves of the graph until a node is found for which `condition` returns `true`.
 If no node meets the condition, then it will return `false`. The defaults values
 for this function are such that the algorithm always returns `true`
 after one step (unless it is applied to a leaf node) in which case it is
-equivalent to calling `haschildren` on the node.
+equivalent to calling `has_children` on the node.
 
 The number of levels that the algorithm is allowed to traverse is capped by
 `max_level` (mostly to avoid excessive computation, though the user may want to
@@ -165,7 +170,7 @@ julia> let
            axiom = A1(2) + (B1(1) + A1(3), B1(4))
            g = Graph(axiom = axiom)
                function qfun(n)
-               hasdescendant(n, condition = x -> data(x).val == 1)[1]
+               has_descendant(n, condition = x -> data(x).val == 1)[1]
            end
            Q1 = Query(A1, condition = qfun)
            R1 = apply(g, Q1)
@@ -176,8 +181,8 @@ julia> let
 (A1[A1(2)], B1[])
 ```
 """
-function hasdescendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
-    out = hasdescendant(node(c), graph(c), condition, max_level, 1)
+function has_descendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
+    out = has_descendant(node(c), graph(c), condition, max_level, 1)
     return out
 end
 
@@ -296,12 +301,21 @@ function children(c::Context)
     return out
 end
 
+function getdescendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
+    desc = getdescendant(node(c), graph(c), condition, max_level, 1)
+    ismissing(desc) && return missing
+    out = Context(graph(c), desc)
+    return out
+end
+
 """
-    getdescendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
+    get_descendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
 
 Returns the first descendant of a node that matches the `condition`. Intended to
 be used within a rule or query.
 
+`getdescendant` is an alias for `get_descendant` for compatibility with AbstractTrees.jl
+
 ## Arguments
 - `c::Context`: Context associated to a node in a dynamic graph.
 
@@ -312,8 +326,8 @@ and returns `true` or `false`.
 traversing the graph.
 
 ## Details
-If `hasdescendant()` returns `false` for the same node and `condition`,
-`getdescendant()` will return `missing`, otherwise it returns the `Context`
+If `has_descendant()` returns `false` for the same node and `condition`,
+`get_descendant()` will return `missing`, otherwise it returns the `Context`
 associated to the matching node.
 
 ## Return
@@ -327,7 +341,7 @@ julia> let
            axiom = A1(1) + (B1(1) + A1(3), B1(4))
            g = Graph(axiom = axiom)
                function qfun(n)
-               na = getdescendant(n, condition = x -> (data(x).val == 1))
+               na = get_descendant(n, condition = x -> (data(x).val == 1))
                if !ismissing(na)
                    data(na) isa B1
                else
@@ -343,9 +357,4 @@ julia> let
 (A1[A1(1)], B1[])
 ```
 """
-function getdescendant(c::Context; condition = x -> true, max_level::Int = typemax(Int))
-    desc = getdescendant(node(c), graph(c), condition, max_level, 1)
-    ismissing(desc) && return missing
-    out = Context(graph(c), desc)
-    return out
-end
+const get_descendant = getdescendant

src/Graph.jl

@@ -151,7 +151,7 @@ end
 @forwardgraph length
 @forwardgraph nodetypes
 @forwardgraph root_id
-@forwardgraph getroot
+@forwardgraph get_root
 @forwardgraph insertion_id
 @forwardgraph insertion
 @forwardgraph nodes

src/GraphNode.jl

@@ -57,17 +57,17 @@ end
  Check if GraphNode has a child or a descendant that fits a condition with optional
  recursive search (with maximum depth)
 =#
-haschildren(n::GraphNode) = !isempty(n.children_id)
-isleaf(n::GraphNode) = !haschildren(n)
+has_children(n::GraphNode) = !isempty(n.children_id)
+is_leaf(n::GraphNode) = !has_children(n)
 
-function hasdescendant(node::GraphNode, g::Graph, condition, maxlevel::Int,
+function has_descendant(node::GraphNode, g::Graph, condition, maxlevel::Int,
     level::Int = 1)
     for child in children(node, g)
         if condition(Context(g, child))
             return true, level
         else
             if level <= maxlevel
-                if hasdescendant(child, g, condition, maxlevel, level + 1)[1]
+                if has_descendant(child, g, condition, maxlevel, level + 1)[1]
                     return true, level + 1
                 end
             end

src/PlantGraphs.jl

@@ -3,8 +3,8 @@ module PlantGraphs
 # Public API of PlantGraph
 export Node, Graph, Rule, Query, rewrite!, apply, data, rules, graph,
     static_graph, data, graph_data, parent,
-    has_parent, has_ancestor, ancestor, isroot, getroot, haschildren, hasdescendant,
-    children, getdescendant, isleaf, traverse, traversedfs, traversebfs, draw,
+    has_parent, has_ancestor, ancestor, is_root, get_root, has_children, has_descendant,
+    children, get_descendant, is_leaf, traverse, traverse_dfs, traverse_bfs, draw,
     calculate_resolution, node_label
 
 # API for VPL-style graphs

src/StaticGraph.jl

@@ -1,4 +1,4 @@
-### This file does not contain public API ###
+### This file contains public API ###
 
 #=
  Generate unique IDs for Nodes in graphs to avoid ID clashes when merging graphs
@@ -64,6 +64,16 @@ root_id(g::StaticGraph) = g.root
 update_root!(g::StaticGraph, ID) = g.root = ID
 getroot(g::StaticGraph) = g[root_id(g)]
 
+"""
+    get_root(g::Graph)
+
+
+Extract the root node of a graph.
+
+`getroot` is an alias for `get_root` for compatibility with AbstractTrees.jl
+"""
+const get_root = getroot
+
 #=
 Insertion
 =#

test/api/test_graph_2.jl

@@ -30,7 +30,7 @@ let
 
     # Cell transfer bottom to top
     function transferUp(context)
-        if haschildren(context)
+        if has_children(context)
             child = first(children(context))
             return (true, (child,))
         else

test/api/test_graph_3.jl

@@ -46,12 +46,12 @@ let
 
     # Extract states from the organism using breadth-first traversal
     states = Rational{Int}[]
-    traversebfs(organism, fun = x -> push!(states, x.state))
+    traverse_bfs(organism, fun = x -> push!(states, x.state))
     @test states == [10 // 1 * 5 // 4 * 1 // 3, 10 // 1 * 5 // 4 * 2 // 3]
 
     # Extract states from the organism using depth-first traversal
     states = Rational{Int}[]
-    traversedfs(organism, fun = x -> push!(states, x.state))
+    traverse_dfs(organism, fun = x -> push!(states, x.state))
     @test states == [10 // 1 * 5 // 4 * 1 // 3, 10 // 1 * 5 // 4 * 2 // 3]
 
     # Extract organism using traversal with arbitrary order
@@ -64,12 +64,12 @@ let
 
     # Extract states from the organism using breadth-first traversal
     states = Rational{Int}[]
-    traversebfs(organism, fun = x -> push!(states, x.state))
+    traverse_bfs(organism, fun = x -> push!(states, x.state))
     @test states == [125 // 72, 125 // 36, 125 // 36, 125 // 18]
 
     # Extract states from the organism using depth-first traversal
     states = Rational{Int}[]
-    traversedfs(organism, fun = x -> push!(states, x.state))
+    traverse_dfs(organism, fun = x -> push!(states, x.state))
     @test sort(states) == [125 // 72, 125 // 36, 125 // 36, 125 // 18]
 
     ### Growth & death models ###