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
123
|
use failure::{Error,bail};
use pest::iterators::Pair;
use crate::document_tree::{
Element,HasChildren,ExtraAttributes,
elements as e,
element_categories as c,
attribute_types::ID,
extra_attributes as a,
};
use crate::parser::{
pest_rst::Rule,
pair_ext_parse::PairExt,
};
use super::ConversionError;
pub fn convert_ssubel(pair: Pair<Rule>) -> Result<Option<c::StructuralSubElement>, Error> {
// TODO: This is just a proof of concep. Keep closely to DTD in final version!
Ok(Some(match pair.as_rule() {
Rule::title => convert_title(pair).into(),
Rule::paragraph => e::Paragraph::with_children(vec![pair.as_str().into()]).into(),
Rule::target => convert_target(pair)?.into(),
Rule::substitution_def => convert_substitution_def(pair)?.into(),
Rule::admonition_gen => convert_admonition_gen(pair)?.into(),
Rule::image => convert_image::<e::Image>(pair)?.into(),
Rule::EOI => return Ok(None),
rule => return Err(ConversionError::UnknownRuleError { rule }.into()),
}))
}
fn convert_title(pair: Pair<Rule>) -> e::Title {
let mut title: Option<&str> = None;
let mut _adornment_char: Option<char> = None;
for p in pair.into_inner() {
match p.as_rule() {
Rule::line => title = Some(p.as_str()),
Rule::adornments => _adornment_char = Some(p.as_str().chars().next().expect("Empty adornment?")),
rule => panic!("Unexpected rule in title: {:?}", rule),
};
}
// TODO adornment char
e::Title::with_children(vec![
title.expect("No text in title").into()
])
}
fn convert_target(pair: Pair<Rule>) -> Result<e::Target, Error> {
let mut attrs = a::Target {
anonymous: false,
..Default::default()
};
for p in pair.into_inner() {
match p.as_rule() {
// TODO: or is it refnames?
Rule::target_name_uq | Rule::target_name_qu => attrs.refid = Some(ID(p.as_str().to_owned())),
Rule::link_target => attrs.refuri = Some(p.parse()?),
rule => panic!("Unexpected rule in target: {:?}", rule),
}
}
Ok(e::Target::new(Default::default(), attrs))
}
fn convert_substitution_def(pair: Pair<Rule>) -> Result<e::SubstitutionDefinition, Error> {
let mut pairs = pair.into_inner();
let name = pairs.next().unwrap().as_str(); // Rule::substitution_name
let inner_pair = pairs.next().unwrap();
let inner: c::TextOrInlineElement = match inner_pair.as_rule() {
Rule::image => convert_image::<e::ImageInline>(inner_pair)?.into(),
rule => panic!("Unknown substitution rule {:?}", rule),
};
let mut subst_def = e::SubstitutionDefinition::with_children(vec![inner.into()]);
subst_def.names_mut().push(name.to_owned());
Ok(subst_def)
}
fn convert_image<I>(pair: Pair<Rule>) -> Result<I, Error> where I: Element + ExtraAttributes<a::Image> {
let mut pairs = pair.into_inner();
let mut image = I::with_extra(a::Image::new(
pairs.next().unwrap().parse()?, // line
));
if let Some(opt_block) = pairs.next() { // image_opt_block
let options = opt_block.into_inner();
for opt in options {
let mut opt_iter = opt.into_inner();
let opt_name = opt_iter.next().unwrap();
let opt_val = opt_iter.next().unwrap();
match opt_name.as_str() {
"class" => image.classes_mut().push(opt_val.as_str().to_owned()),
"name" => image.names_mut().push(opt_val.as_str().to_owned()),
"alt" => image.extra_mut().alt = Some(opt_val.as_str().to_owned()),
"height" => image.extra_mut().height = Some(opt_val.parse()?),
"width" => image.extra_mut().width = Some(opt_val.parse()?),
"scale" => image.extra_mut().scale = Some(opt_val.parse()?), // TODO: can end with %
"align" => image.extra_mut().align = Some(opt_val.parse()?),
"target" => image.extra_mut().target = Some(opt_val.parse()?),
name => bail!("Unknown Image option {}", name),
}
}
}
Ok(image)
}
fn convert_admonition_gen(pair: Pair<Rule>) -> Result<c::BodyElement, Error> {
let mut iter = pair.into_inner();
let typ = iter.next().unwrap().as_str();
// TODO: in reality it contains body elements.
let children: Vec<c::BodyElement> = iter.map(|p| e::Paragraph::with_children(vec![p.as_str().into()]).into()).collect();
Ok(match typ {
"attention" => e::Attention::with_children(children).into(),
"hint" => e::Hint::with_children(children).into(),
"note" => e::Note::with_children(children).into(),
"caution" => e::Caution::with_children(children).into(),
"danger" => e::Danger::with_children(children).into(),
"error" => e::Error::with_children(children).into(),
"important" => e::Important::with_children(children).into(),
"tip" => e::Tip::with_children(children).into(),
"warning" => e::Warning::with_children(children).into(),
typ => panic!("Unknown admontion type {}!", typ),
})
}
|
