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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
//! Dynamic typesetting functions.
use std::any::Any;
use std::collections::HashMap;
use std::fmt::{self, Debug, Formatter};
use crate::layout::{layout, Layout, LayoutContext, LayoutResult};
use crate::layout::flex::FlexLayout;
use crate::parsing::{parse, ParseContext, ParseError, ParseResult};
use crate::syntax::{SyntaxTree, FuncHeader};
/// Typesetting function types.
///
/// These types have to be able to parse tokens into themselves and store the relevant information
/// from the parsing to do their role in typesetting later.
///
/// The trait `FunctionBounds` is automatically implemented for types which can be used as
/// functions, that is they fulfill the bounds `Debug + PartialEq + 'static`.
pub trait Function: FunctionBounds {
/// Parse the header and body into this function given a context.
fn parse(header: &FuncHeader, body: Option<&str>, ctx: &ParseContext)
-> ParseResult<Self> where Self: Sized;
/// Layout this function given a context.
///
/// Returns optionally the resulting layout and a new context if changes to the context should
/// be made.
fn layout(&self, ctx: &LayoutContext) -> LayoutResult<Option<Layout>>;
}
impl PartialEq for dyn Function {
fn eq(&self, other: &dyn Function) -> bool {
self.help_eq(other)
}
}
/// A helper trait that describes requirements for types that can implement [`Function`].
///
/// Automatically implemented for all types which fulfill to the bounds `Debug + PartialEq +
/// 'static`. There should be no need to implement this manually.
pub trait FunctionBounds: Debug {
/// Cast self into `Any`.
fn help_cast_as_any(&self) -> &dyn Any;
/// Compare self with another function.
fn help_eq(&self, other: &dyn Function) -> bool;
}
impl<T> FunctionBounds for T where T: Debug + PartialEq + 'static {
fn help_cast_as_any(&self) -> &dyn Any {
self
}
fn help_eq(&self, other: &dyn Function) -> bool {
if let Some(other) = other.help_cast_as_any().downcast_ref::<Self>() {
self == other
} else {
false
}
}
}
/// A map from identifiers to functions.
pub struct Scope {
parsers: HashMap<String, Box<ParseFunc>>,
}
/// A function which parses a function invocation into a function type.
type ParseFunc = dyn Fn(&FuncHeader, Option<&str>, &ParseContext)
-> ParseResult<Box<dyn Function>>;
impl Scope {
/// Create a new empty scope.
pub fn new() -> Scope {
Scope { parsers: HashMap::new() }
}
/// Create a new scope with the standard functions contained:
/// - `italic`
/// - `bold`
pub fn with_std() -> Scope {
let mut std = Scope::new();
std.add::<BoldFunc>("bold");
std.add::<ItalicFunc>("italic");
std
}
/// Add a function type to the scope giving it a name.
pub fn add<F: Function + 'static>(&mut self, name: &str) {
self.parsers.insert(
name.to_owned(),
Box::new(|h, b, c| {
F::parse(h, b, c).map(|func| Box::new(func) as Box<dyn Function>)
})
);
}
/// Return the parser with the given name if there is one.
pub(crate) fn get_parser(&self, name: &str) -> Option<&ParseFunc> {
self.parsers.get(name).map(|x| &**x)
}
}
impl Debug for Scope {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "Scope ")?;
write!(f, "{:?}", self.parsers.keys())
}
}
/// Creates style functions like bold and italic.
macro_rules! style_func {
($(#[$outer:meta])* pub struct $struct:ident { $name:expr },
$new_ctx:ident => $ctx_change:block) => {
$(#[$outer])*
#[derive(Debug, PartialEq)]
pub struct $struct { body: SyntaxTree }
impl Function for $struct {
fn parse(header: &FuncHeader, body: Option<&str>, ctx: &ParseContext)
-> ParseResult<Self> where Self: Sized {
// Accept only invocations without arguments and with body.
if header.args.is_empty() && header.kwargs.is_empty() {
if let Some(body) = body {
Ok($struct { body: parse(body, ctx)? })
} else {
Err(ParseError::new(format!("expected body for function `{}`", $name)))
}
} else {
Err(ParseError::new(format!("unexpected arguments to function `{}`", $name)))
}
}
fn layout(&self, ctx: &LayoutContext) -> LayoutResult<Option<Layout>> {
// Change the context.
let mut $new_ctx = ctx.clone();
$ctx_change
// Create a box and put it into a flex layout.
let boxed = layout(&self.body, &$new_ctx)?;
let flex = FlexLayout::from_box(boxed);
Ok(Some(Layout::Flex(flex)))
}
}
};
}
style_func! {
/// Typesets text in bold.
pub struct BoldFunc { "bold" },
ctx => { ctx.style.bold = !ctx.style.bold }
}
style_func! {
/// Typesets text in italics.
pub struct ItalicFunc { "italic" },
ctx => { ctx.style.italic = !ctx.style.italic }
}
|
