cdoc 0.8.1

A markdown-based document parser and processor
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

use cdoc_parser::code_ast::types::CodeContent;
use cdoc_parser::document::CodeOutput;
use cowstr::CowStr;

use cdoc_parser::Span;

use rhai::serde::{from_dynamic, to_dynamic};
use rhai::{CustomType, Dynamic, TypeBuilder};

#[derive(Clone)]
pub(crate) struct ScriptCodeBlock {
    source: CodeContent,
    attributes: Vec<CowStr>,
    outputs: Dynamic,
    display_cell: bool,
    global_idx: usize,
    #[allow(unused)]
    span: Span,
}

impl ScriptCodeBlock {
    pub fn new(
        source: &CodeContent,
        attributes: &[CowStr],
        outputs: &Option<&mut CodeOutput>,
        display_cell: bool,
        global_idx: usize,
        pos: &Span,
    ) -> Self {
        ScriptCodeBlock {
            source: source.clone(),
            attributes: attributes.to_vec(),
            outputs: to_dynamic(outputs).unwrap(),
            display_cell,
            global_idx,
            span: pos.clone(),
        }
    }

    pub fn apply_changes(
        self,
        source: &mut CodeContent,
        tags: &mut Vec<CowStr>,
        outputs: Option<&mut CodeOutput>,
        display_cell: &mut bool,
        global_idx: &mut usize,
    ) -> anyhow::Result<()> {
        *source = self.source;

        *tags = self.attributes;
        *display_cell = self.display_cell;
        *global_idx = self.global_idx;

        if let Some(out) = outputs {
            *out = from_dynamic(&self.outputs)?;
        }

        Ok(())
    }
}

impl CustomType for ScriptCodeBlock {
    fn build(mut builder: TypeBuilder<Self>) {
        builder
            .with_name("CodeBlock")
            .with_get_set(
                "source",
                |s: &mut Self| s.source.clone(),
                |s: &mut Self, v: CodeContent| s.source = v,
            )
            .with_get_set(
                "tags",
                |s: &mut Self| s.attributes.clone(),
                |s: &mut Self, v: Vec<CowStr>| s.attributes = v,
            )
            .with_get_set(
                "outputs",
                |s: &mut Self| s.outputs.clone(),
                |s: &mut Self, v: Dynamic| s.outputs = v,
            )
            .with_get_set(
                "display_cell",
                |s: &mut Self| s.display_cell,
                |s: &mut Self, v: bool| s.display_cell = v,
            )
            .with_get_set(
                "global_idx",
                |s: &mut Self| s.global_idx,
                |s: &mut Self, v: usize| s.global_idx = v,
            );
    }
}