fml 0.2.0

Friendly Markup Language
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

use super::*;
use crate::ast::{
	FunctionToken, Token,
	token::{self, TokenVec},
};
use chumsky::Parser;

impl TryFrom<Token> for FmlValue {
	type Error = ();

	fn try_from(value: Token) -> Result<Self, Self::Error> {
		Ok(match value {
			Token::Linebreak => FmlValue::Linebreak,
			Token::CodeBlock { lang, body } => FmlValue::CodeBlock { lang, body },
			Token::CodeInline(s) => FmlValue::CodeInline(s),
			Token::Heading1(tokens) => FmlValue::Heading1(TokenVec(tokens).try_into()?),
			Token::Heading2(tokens) => FmlValue::Heading2(TokenVec(tokens).try_into()?),
			Token::Heading3(tokens) => FmlValue::Heading3(TokenVec(tokens).try_into()?),
			Token::SupLine(tokens) => FmlValue::Superline(TokenVec(tokens).try_into()?),
			Token::SubLine(tokens) => FmlValue::Subline(TokenVec(tokens).try_into()?),
			Token::ListItem(tokens) => FmlValue::ListItem(TokenVec(tokens).try_into()?),
			Token::Quote(s) => {
				let p = crate::parser::functions::fml_values();
				let tokens = p.parse(&s).into_result().map_err(|_| ())?;
				let values = TokenVec(tokens).try_into()?;
				Quote(values)
			}
			Token::CwSpoiler(tokens) => FmlValue::ContentWarning {
				reason: "Spoilers".into(),
				body: TokenVec(tokens).try_into()?,
			},
			Token::Hyperlink { fml, uri } => FmlValue::Hyperlink {
				fml: TokenVec(fml).try_into()?,
				uri,
			},
			Token::Bold(tokens) => FmlValue::Bold(TokenVec(tokens).try_into()?),
			Token::Italic(tokens) => FmlValue::Italic(TokenVec(tokens).try_into()?),
			Token::Strikethrough(tokens) => FmlValue::Strikethrough(TokenVec(tokens).try_into()?),
			Token::Underline(tokens) => FmlValue::Underline(TokenVec(tokens).try_into()?),
			Token::Superscript(tokens) => FmlValue::Superscript(TokenVec(tokens).try_into()?),
			Token::Subscript(tokens) => FmlValue::Subscript(TokenVec(tokens).try_into()?),
			Token::Function(FunctionToken { name, params, body }) => FmlFunction {
				name,
				params,
				body: TokenVec(body).try_into()?,
			}
			.interpret(),
			Token::Typst(s) => FmlValue::Typst(s),
			Token::Text(s) => FmlValue::Text(s),
		})
	}
}

impl TryFrom<TokenVec> for Vec<FmlValue> {
	type Error = ();

	fn try_from(tokens: TokenVec) -> Result<Self, Self::Error> {
		let mut vec = vec![];
		for t in tokens.0 {
			vec.push(t.try_into()?);
		}
		Ok(vec)
	}
}