ltk_ritobin 0.8.1

Ritobin text format parser and writer for League Toolkit
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

use crate::ast::{
    node::{NodeRef, SubNodeRef},
    Ast,
};

/// Iterator of every [`Node`] on the way to a given offset, from the top level.
///
/// Use [`Ast::coarse_path_to`] to construct this iterator.
#[derive(Clone)]
pub struct AstPathIter<'a> {
    next: Option<NodeRef<'a>>,
    offset: u32,
}

impl<'a> AstPathIter<'a> {
    pub(crate) fn from_ast(ast: &'a Ast, offset: u32) -> Self {
        Self {
            next: ast
                .root_entries()
                .find(|o| o.span().contains_inclusive(offset))
                .map(NodeRef::RootEntry),
            offset,
        }
    }
    pub(crate) fn from_node(node: NodeRef<'a>, offset: u32) -> Self {
        Self {
            next: node.span().contains_inclusive(offset).then_some(node),
            offset,
        }
    }
}

impl<'a> Iterator for AstPathIter<'a> {
    type Item = NodeRef<'a>;

    fn next(&mut self) -> Option<NodeRef<'a>> {
        let current = self.next.take()?;
        self.next = current
            .children()
            .find(|c| c.span().contains_inclusive(self.offset));
        Some(current)
    }
}

/// Iterator of every [`Node`] on the way to a given offset, from the top level.
///
/// Use [`Ast::fine_path_to`] to construct this iterator.
#[derive(Clone)]
pub struct AstFinePathIter<'a> {
    next: Option<SubNodeRef<'a>>,
    offset: u32,
}
impl<'a> AstFinePathIter<'a> {
    pub(crate) fn from_ast(ast: &'a Ast, offset: u32) -> Self {
        Self {
            next: ast
                .roots
                .iter()
                .find(|r| r.span().contains_inclusive(offset))
                .map(|r| SubNodeRef::Root(r, crate::ast::query::AstRootDetail::Node)),
            offset,
        }
    }
    // pub(crate) fn from_node(node: Node<'a>, offset: u32) -> Self {
    //     Self {
    //         next: node.span().contains(offset).then_some(node),
    //         offset,
    //     }
    // }
}

impl<'a> Iterator for AstFinePathIter<'a> {
    type Item = SubNodeRef<'a>;

    fn next(&mut self) -> Option<SubNodeRef<'a>> {
        let current = self.next.take()?;

        // only recurse on nodes with detail = Node, since that means we have more resolution
        if current.detail().is_node() {
            self.next = match current {
                SubNodeRef::Root(v, _) => v
                    .detailed_children()
                    .find(|c| c.span().contains_inclusive(self.offset)),
                SubNodeRef::RootEntry(v, _) => v
                    .detailed_children()
                    .find(|c| c.span().contains_inclusive(self.offset)),
                SubNodeRef::Object(v, _) => v
                    .detailed_children()
                    .find(|c| c.span().contains_inclusive(self.offset)),
                SubNodeRef::Property(v, _) => v
                    .detailed_children()
                    .find(|c| c.span().contains_inclusive(self.offset)),
                SubNodeRef::Value(v) => v
                    .children()
                    .find(|c| c.span().contains_inclusive(self.offset))
                    .map(|c| c.into()),
            };
        }

        Some(current)
    }
}