cdoc 0.5.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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use serde::{Deserialize, Serialize};
use std::fmt::{Display, Formatter};

use crate::ast::{Ast, AstVisitor, CodeAttributes};
use crate::document::Document;
use crate::notebook::CellOutput;
use crate::parsers::split::parse_code_string;
use crate::processors::{AstPreprocessor, AstPreprocessorConfig, Error, PreprocessorContext};

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ExercisesConfig;

#[typetag::serde(name = "exercises")]
impl AstPreprocessorConfig for ExercisesConfig {
    fn build(&self, _ctx: &PreprocessorContext) -> anyhow::Result<Box<dyn AstPreprocessor>> {
        Ok(Box::new(Exercises))
    }
}

// #[typetag::serde(name = "code_split")]
// impl EventPreprocessorConfig for ExercisesConfig {
//     fn build(&self, _ctx: &PreprocessorContext) -> anyhow::Result<Box<dyn EventPreprocessor>> {
//         Ok(Box::new(Exercises))
//     }
// }

#[derive(Debug)]
pub struct Exercises;

impl AstVisitor for Exercises {
    fn visit_code_block(
        &mut self,
        source: &mut String,
        _reference: &mut Option<String>,
        _attr: &mut CodeAttributes,
        _tags: &mut Option<Vec<String>>,
        _outputs: &mut Vec<CellOutput>,
    ) -> anyhow::Result<()> {
        let res = parse_code_string(source.clone().as_ref())?;
        let (pc, _) = res.split();
        *source = pc.strip_suffix('\n').unwrap_or(&pc).to_string();
        Ok(())
    }
}

impl AstPreprocessor for Exercises {
    fn name(&self) -> String {
        "Exercises".to_string()
    }

    fn process(&mut self, mut input: Document<Ast>) -> Result<Document<Ast>, Error> {
        self.walk_ast(&mut input.content)?;
        Ok(input)
    }
}

// impl EventPreprocessor for Exercises {
//     fn name(&self) -> String {
//         "Code split".to_string()
//     }
//
//     fn process(&self, input: Document<EventContent>) -> Result<Document<EventContent>, Error> {
//         let mut code_block = false;
//         let mut source = "".to_string();
//         let mut code_attr = String::new();
//
//         let content = input
//             .content
//             .into_iter()
//             .flat_map(|event| match &event {
//                 AEvent::Start(tag) => {
//                     if let ATag::CodeBlock(ACodeBlockKind::Fenced(attr)) = &tag {
//                         code_block = true;
//                         code_attr = attr.to_string();
//                     }
//                     vec![Ok(AEvent::Start(tag.clone()))]
//                 }
//                 AEvent::End(tag) => {
//                     if let ATag::CodeBlock(ACodeBlockKind::Fenced(_)) = tag {
//                         // TODO: Here
//                         let res = parse_code_string(source.clone().as_ref());
//                         code_block = false;
//                         source = String::new();
//                         match res {
//                             Ok(doc) => {
//                                 let (pc, _solution) = doc.split();
//                                 vec![
//                                     Ok(AEvent::Text(pc.trim().to_string())),
//                                     Ok(AEvent::End(tag.clone())),
//                                 ]
//                             }
//                             Err(e) => vec![Err(CodeParseError(human_errors(*e)))],
//                         }
//                     } else {
//                         vec![Ok(event)]
//                     }
//                 }
//                 AEvent::Text(txt) => {
//                     if code_block {
//                         source.push_str(txt.as_ref());
//                         vec![]
//                     } else {
//                         vec![Ok(AEvent::Text(txt.clone()))]
//                     }
//                 }
//                 _ => vec![Ok(event)],
//             })
//             .collect::<Result<Vec<AEvent>, Error>>()?;
//
//         Ok(Document {
//             metadata: input.metadata,
//             variables: input.variables,
//             content,
//         })
//     }
// }

impl Display for Exercises {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}