Replace deprecated functions by the new functions

Author: VEZY

docs/src/the_mtg/our_implementation.md

@@ -36,7 +36,7 @@ Here is a simple description of each field:
 - `attributes`: node values (for example length, diameter, color, 3D position).
 - `traversal_cache`: saved traversal results used to speed up repeated operations.
 
-The values of these fields are accessed with helper functions such as [`node_id`](@ref), [`parent`](@ref), [`children`](@ref), [`node_mtg`](@ref), and [`node_attributes`](@ref).
+The values of these fields are accessed with helper functions such as [`node_id`](@ref), [`parent`](@ref), [`children`](@ref), [`node_mtg`](@ref), [`attribute`](@ref), and [`attributes`](@ref).
 
 The MTG field of a node describes how the node is positioned in the graph: link with parent (`/`, `<`, `+`), symbol, index, and scale (see [Node MTG and attributes](@ref) and [The MTG section](@ref) for more details). It is stored as [`NodeMTG`](@ref) or [`MutableNodeMTG`](@ref). These types have four fields:
 
@@ -112,7 +112,7 @@ node_mtg(mtg)
 ```
 
 ```@example usepkg
-node_attributes(mtg)
+attributes(mtg, format=:dict)
 ```
 
 The package also provide helper functions to access the MTG encoding of the node directly:

docs/src/tutorials/2.descendants_ancestors_filters.md

@@ -58,10 +58,10 @@ descendants(mtg, :Length, symbol=:Leaf, ignore_nothing=true)
 !!! tip
     If you call the same traversal many times in a simulation loop, look at [Performance Considerations](@ref), especially in-place methods (`descendants!`, `ancestors!`).
 
-You can get all the attributes of a node using the [`node_attributes`](@ref) function:
+You can get all the attributes of a node as a dictionary snapshot using [`attributes`](@ref):
 
 ```@example usepkg
-node_attributes(mtg)
+attributes(mtg, format=:dict)
 ```
 
 !!! note
@@ -89,13 +89,13 @@ node_5.Length
 
 This one even has autocompletion! It means that you can type `node_5.` and then press `TAB` to see all the available attributes, and when you start typing the name of an attribute, it will suggest the completion of the name.
 
-The previous notations are both equivalent to:
+The previous notations are equivalent to:
 
 ```@example usepkg
-node_attributes(node_5)[:Length]
+attribute(node_5, :Length)
 ```
 
-`node_attributes(node_5)` gives access to all attributes of this node.
+Use [`attributes`](@ref) when you want all values from one node at once.
 
 For day-to-day use, the simpler APIs are usually clearer:
 
@@ -151,10 +151,10 @@ The function can also help get the nodes directly if we don't pass any attribute
 descendants(mtg)
 ```
 
-This is useful to get more information about the nodes, like their scale, symbol, index, or link to their parent. Of course you can still get their attributes using the `node_attributes` function, *e.g.*:
+This is useful to get more information about the nodes, like their scale, symbol, index, or link to their parent. You can still get attributes for each returned node, for example:
 
 ```@example usepkg
-node_attributes.(descendants(mtg))
+[attributes(node, format=:dict) for node in descendants(mtg)]
 ```
 
 ## Ancestors

docs/src/tutorials/3.transform_mtg.md

@@ -274,7 +274,7 @@ end
 
 ## Mutate an MTG
 
-For users coming from R, we also provide the `@mutate_mtg!` macro that is similar to [`transform!`](@ref) but uses a more `tidyverse`-alike syntax. All values coming from the MTG node must be preceded by a `node.`, as with the `.data$` in the `tidyverse`. The names of the attributes are shortened to just `node.attr_name` instead of `node_attributes(node).attr_name` though. Here's an example usage:
+For users coming from R, we also provide the `@mutate_mtg!` macro that is similar to [`transform!`](@ref) but uses a more `tidyverse`-alike syntax. All values coming from the MTG node must be preceded by `node.`, as with `.data$` in the `tidyverse`. Attribute names are therefore written as `node.attr_name`. Here's an example usage:
 
 ```@example usepkg
 @mutate_mtg!(mtg, volume = π * 2 * node.Length, symbol = :I)

docs/src/tutorials/6.add_remove_nodes.md

@@ -132,13 +132,7 @@ The MTG encoding field of the newly-created root node (`node_mtg(mtg_2)`) used s
 #### Node attributes
 
 We can also provide attributes for the new node using the `attr_fun` argument. `attr_fun` expects a function that computes new attributes based on the input node. This function must return
-attribute values of the same type as the one used for other nodes attributes in the MTG (*e.g.* `Dict` or `NamedTuple`).
-
-To know what is the type used for the attributes of your MTG, you can use `typeof` as follows:
-
-```@example usepkg
-typeof(node_attributes(mtg))
-```
+attribute values (*e.g.* a `Dict{Symbol,Any}` or a `NamedTuple`).
 
 If you just need to pass attributes values to a node, you can do as follows:
 
@@ -148,10 +142,10 @@ mtg_2 = deepcopy(mtg)
 insert_child!(
     mtg_2,
     NodeMTG(:/, :Axis, 0, 2),
-    node -> Dict{Symbol, Any}(:length => 2, :area =>  0.1)
+node -> Dict{Symbol, Any}(:length => 2, :area =>  0.1)
 )
 
-node_attributes(mtg_2[1])
+attributes(mtg_2[1], format=:dict)
 ```
 
 But we can also compute our attributes based on other nodes data:
@@ -162,10 +156,10 @@ mtg_2 = deepcopy(mtg)
 insert_child!(
     mtg_2,
     NodeMTG(:/, :Axis, 0, 2),
-    node -> Dict{Symbol, Any}(:total_length => sum(descendants(node, :length, ignore_nothing = true)))
+node -> Dict{Symbol, Any}(:total_length => sum(descendants(node, :length, ignore_nothing = true)))
 )
 
-node_attributes(mtg_2[1])
+attributes(mtg_2[1], format=:dict)
 ```
 
 We use `mtg_2[1]` here to get the first child of the root node.
@@ -324,10 +318,7 @@ insert_siblings!(
 ```
 
 !!! danger
-    The function used to compute the attributes must return data using the same structure as the one used for the other nodes attributes. In our example it returns a `Dict{Symbol, Any}`, but it can be different depending on your MTG. To know which structure you should use, use this command:
-    ```julia
-    typeof(node_attributes(mtg))
-    ```
+    The function used to compute attributes should return either a `Dict{Symbol,Any}` or a `NamedTuple`.
 
 Let's see the results for the area of our leaves: