ruSTLa 0.38.0

A reStructuredText → LarST ⊂ LaTeX transpiler.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

/*!
A submodule for doctree walker functions.

Copyright © 2020 Santtu Söderholm
*/

use super::*;

use crate::common::TraversalType;

/// ---------
///  Walkers
/// ---------
///
/// Functions for walking to differents parts of the contained `TreeZipper`.
/// These include ID-based searches, as well as criteria related to the
/// contained data variant.
impl DocTree {

    /// Walks to the root of the contained tree zipper.
    pub fn walk_to_root(mut self) -> Self {
        self.tree = self.tree.walk_to_root();
        self
    }

    /// The mother of all walkers. Performs a tree walk based on given `TraversalType`.
    /// These include walking to a specific node id, but a reference to a `TreeNodeType`
    /// might also be used in determining when to stop walking.
    pub fn walk(mut self, traversal_type: TraversalType) -> Self {
        // Always walk to tree root before starting the search/walk.
        self.tree = self.tree.walk_to_root();

        match traversal_type {
            TraversalType::ID(id) => self.walk_to_node_with_id(id),
        }
    }

    /// Walks to a `TreeNode` with a specific given ID.
    /// Naively walks to the tree root before beginning the actual search,
    /// in order to ensure that all nodes are traversed.
    ///
    /// Panic!s if a node with the given id is not found.
    fn walk_to_node_with_id(mut self, id: NodeId) -> Self {
        if id > self.node_count() {
            panic!("No node with given ID. Computer says no...")
        }

        self.tree = match self.tree.walk_to_node_with_id(id) {
            Ok(zipper) => zipper,
            Err(zipper) => zipper,
        };

        self
    }

    /// Walks to a node with a given ID and the back again.
    /// Panic!s, if the given target node id has not been entered into the tree.
    fn walk_to_and_fro(self, to_id: NodeId, current_id: NodeId) -> Self {
        if to_id > self.node_count() {
            panic!("No node with given ID. Computer says no...")
        }

        todo!()
    }
}

/// ---------
///  Walkers
/// ---------
impl TreeZipper {

    /// Walks to a specific node based on a given id,
    /// using the NLR (pre-order) strategy.
    pub fn walk_to_node_with_id(mut self, id: NodeId) -> Result<Self, Self> {
        if self.node_id() == id {
            return Ok(self);
        }

        let n_of_children = if let Some(children) = self.shared_node().shared_children() {
            self.n_of_children()
        } else {
            match self.focus_on_parent() {
                Ok(zipper) | Err(zipper) => return Err(zipper),
            }
        };

        for ind in 0..n_of_children {
            self = if let Ok(child) = self.focus_on_child(ind) {
                child
            } else {
                unreachable!("This should not happen with enumerated children...")
            };
            match self.walk_to_node_with_id(id) {
                Ok(zipper) => return Ok(zipper),
                Err(zipper) => {
                    self = zipper;
                    continue;
                }
            }
        }

        self = match self.focus_on_parent() {
            Ok(zipper) | Err(zipper) => zipper,
        };
        Err(self)
    }
}