rd-ast 0.0.1

Canonical, producer-agnostic AST for R's Rd (documentation) format
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

use super::*;

#[derive(Debug, Clone, PartialEq)]
pub struct RdEnc<'a> {
    path: RdPath,
    encoded: &'a [RdNode],
    ascii: &'a [RdNode],
}

impl<'a> RdEnc<'a> {
    pub fn path(&self) -> &RdPath {
        &self.path
    }
    /// Encoding-dependent Latex-mode markup; encoding-side selection is consumer policy.
    pub fn encoded(&self) -> &'a [RdNode] {
        self.encoded
    }
    /// Encoding-dependent Latex-mode markup; encoding-side selection is consumer policy.
    pub fn ascii(&self) -> &'a [RdNode] {
        self.ascii
    }
}

impl RdNode {
    pub fn enc(&self, base_path: &RdPath) -> Option<RdEnc<'_>> {
        self.inspect_enc(base_path).ok().flatten()
    }

    pub fn inspect_enc(&self, base_path: &RdPath) -> Result<Option<RdEnc<'_>>, RdShapeError> {
        let tagged = match self {
            RdNode::Tagged(tagged) => tagged,
            RdNode::Raw(raw) => {
                let Some(tag) = raw.tag().map(RdTag::from_rd_tag) else {
                    return Ok(None);
                };
                if tag != RdTag::Enc {
                    return Ok(None);
                }
                return Err(shape(
                    base_path.clone(),
                    Some(tag),
                    RdShapeErrorKind::UnexpectedNode {
                        expected: RdExpectedNode::Tagged,
                        actual: RdNodeKind::Raw,
                    },
                ));
            }
            _ => return Ok(None),
        };
        if tagged.tag() != &RdTag::Enc {
            return Ok(None);
        }
        if tagged.option().is_some() {
            return Err(shape(
                base_path.clone(),
                Some(tagged.tag().clone()),
                RdShapeErrorKind::UnexpectedOption,
            ));
        }
        let children = tagged.children();
        if children.len() != 2 {
            return Err(shape(
                base_path.clone(),
                Some(tagged.tag().clone()),
                RdShapeErrorKind::WrongArity {
                    expected: RdArity::Exactly(2),
                    actual: children.len(),
                },
            ));
        }
        for (index, child) in children.iter().enumerate() {
            if child.as_group().is_none() {
                return Err(shape(
                    base_path.with_child(index),
                    Some(tagged.tag().clone()),
                    RdShapeErrorKind::UnexpectedNode {
                        expected: RdExpectedNode::Group,
                        actual: RdNodeKind::of(child),
                    },
                ));
            }
        }
        Ok(Some(RdEnc {
            path: base_path.clone(),
            encoded: children[0].as_group().unwrap().children(),
            ascii: children[1].as_group().unwrap().children(),
        }))
    }
}