mirror of
https://github.com/typst/typst
synced 2025-05-14 17:15:28 +08:00
643 lines
18 KiB
Rust
643 lines
18 KiB
Rust
#![allow(non_snake_case)]
|
||
|
||
use std::fmt::Debug;
|
||
|
||
use super::parse;
|
||
use crate::color::RgbaColor;
|
||
use crate::diag::{Diag, Level, Pass};
|
||
use crate::geom::Unit;
|
||
use crate::syntax::*;
|
||
|
||
use BinOp::*;
|
||
use Node::{Emph, Linebreak, Parbreak, Space, Strong};
|
||
use UnOp::*;
|
||
|
||
macro_rules! t {
|
||
($src:literal
|
||
nodes: [$($node:expr),* $(,)?]
|
||
$(, errors: [$($err:expr),* $(,)?])?
|
||
$(, warnings: [$($warn:expr),* $(,)?])?
|
||
$(, spans: $spans:expr)?
|
||
$(,)?
|
||
) => {{
|
||
#[allow(unused)]
|
||
let mut spans = false;
|
||
$(spans = $spans;)?
|
||
|
||
let Pass { output, feedback } = parse($src);
|
||
check($src, Content![@$($node),*], output, spans);
|
||
check(
|
||
$src,
|
||
vec![
|
||
$($(into!($err).map(|s: &str| Diag::new(Level::Error, s)),)*)?
|
||
$($(into!($warn).map(|s: &str| Diag::new(Level::Warning, s)),)*)?
|
||
],
|
||
feedback.diags,
|
||
true,
|
||
);
|
||
}};
|
||
|
||
($src:literal $($node:expr),* $(,)?) => {
|
||
t!($src nodes: [$($node),*]);
|
||
};
|
||
}
|
||
|
||
/// Assert that expected and found are equal, printing both and the source of
|
||
/// the test case if they aren't.
|
||
///
|
||
/// When `cmp_spans` is false, spans are ignored.
|
||
#[track_caller]
|
||
pub fn check<T>(src: &str, exp: T, found: T, cmp_spans: bool)
|
||
where
|
||
T: Debug + PartialEq,
|
||
{
|
||
Span::set_cmp(cmp_spans);
|
||
|
||
if exp != found {
|
||
println!("source: {:?}", src);
|
||
println!("expected: {:#?}", exp);
|
||
println!("found: {:#?}", found);
|
||
panic!("test failed");
|
||
}
|
||
|
||
Span::set_cmp(true);
|
||
}
|
||
|
||
/// Shorthand for `Spanned::new`.
|
||
fn S<T>(span: impl Into<Span>, v: T) -> Spanned<T> {
|
||
Spanned::new(v, span)
|
||
}
|
||
|
||
// Enables tests to optionally specify spans.
|
||
impl<T> From<T> for Spanned<T> {
|
||
fn from(t: T) -> Self {
|
||
Spanned::zero(t)
|
||
}
|
||
}
|
||
|
||
/// Shorthand for `Into::<Spanned<_>>::into`.
|
||
macro_rules! into {
|
||
($val:expr) => {
|
||
Into::<Spanned<_>>::into($val)
|
||
};
|
||
}
|
||
|
||
fn Text(text: &str) -> Node {
|
||
Node::Text(text.into())
|
||
}
|
||
|
||
fn Heading(level: impl Into<Spanned<u8>>, contents: Tree) -> Node {
|
||
Node::Heading(NodeHeading { level: level.into(), contents })
|
||
}
|
||
|
||
fn Raw(lang: Option<&str>, lines: &[&str], inline: bool) -> Node {
|
||
Node::Raw(NodeRaw {
|
||
lang: lang.map(|id| Ident(id.into())),
|
||
lines: lines.iter().map(ToString::to_string).collect(),
|
||
inline,
|
||
})
|
||
}
|
||
|
||
fn Id(ident: &str) -> Expr {
|
||
Expr::Lit(Lit::Ident(Ident(ident.to_string())))
|
||
}
|
||
|
||
fn Bool(b: bool) -> Expr {
|
||
Expr::Lit(Lit::Bool(b))
|
||
}
|
||
|
||
fn Int(int: i64) -> Expr {
|
||
Expr::Lit(Lit::Int(int))
|
||
}
|
||
|
||
fn Float(float: f64) -> Expr {
|
||
Expr::Lit(Lit::Float(float))
|
||
}
|
||
|
||
fn Percent(percent: f64) -> Expr {
|
||
Expr::Lit(Lit::Percent(percent))
|
||
}
|
||
|
||
fn Length(val: f64, unit: Unit) -> Expr {
|
||
Expr::Lit(Lit::Length(val, unit))
|
||
}
|
||
|
||
fn Color(color: RgbaColor) -> Expr {
|
||
Expr::Lit(Lit::Color(color))
|
||
}
|
||
|
||
fn Str(string: &str) -> Expr {
|
||
Expr::Lit(Lit::Str(string.to_string()))
|
||
}
|
||
|
||
fn Block(expr: Expr) -> Node {
|
||
Node::Expr(expr)
|
||
}
|
||
|
||
fn Binary(
|
||
lhs: impl Into<Spanned<Expr>>,
|
||
op: impl Into<Spanned<BinOp>>,
|
||
rhs: impl Into<Spanned<Expr>>,
|
||
) -> Expr {
|
||
Expr::Binary(ExprBinary {
|
||
lhs: Box::new(lhs.into()),
|
||
op: op.into(),
|
||
rhs: Box::new(rhs.into()),
|
||
})
|
||
}
|
||
|
||
fn Unary(op: impl Into<Spanned<UnOp>>, expr: impl Into<Spanned<Expr>>) -> Expr {
|
||
Expr::Unary(ExprUnary {
|
||
op: op.into(),
|
||
expr: Box::new(expr.into()),
|
||
})
|
||
}
|
||
|
||
macro_rules! Array {
|
||
(@$($expr:expr),* $(,)?) => {
|
||
vec![$(into!($expr)),*]
|
||
};
|
||
($($tts:tt)*) => (Expr::Array(Array![@$($tts)*]));
|
||
}
|
||
|
||
macro_rules! Dict {
|
||
(@$($name:expr => $expr:expr),* $(,)?) => {
|
||
vec![$(Named {
|
||
name: into!($name).map(|s: &str| Ident(s.into())),
|
||
expr: into!($expr)
|
||
}),*]
|
||
};
|
||
($($tts:tt)*) => (Expr::Dict(Dict![@$($tts)*]));
|
||
}
|
||
|
||
macro_rules! Args {
|
||
(@$a:expr) => {
|
||
Argument::Pos(into!($a))
|
||
};
|
||
(@$a:expr => $b:expr) => {
|
||
Argument::Named(Named {
|
||
name: into!($a).map(|s: &str| Ident(s.into())),
|
||
expr: into!($b)
|
||
})
|
||
};
|
||
($($a:expr $(=> $b:expr)?),* $(,)?) => {
|
||
vec![$(Args!(@$a $(=> $b)?)),*]
|
||
};
|
||
}
|
||
|
||
macro_rules! Content {
|
||
(@$($node:expr),* $(,)?) => (vec![$(into!($node)),*]);
|
||
($($tts:tt)*) => (Expr::Content(Content![@$($tts)*]));
|
||
}
|
||
|
||
macro_rules! Call {
|
||
(@@$name:expr) => {
|
||
Call!(@@$name, Args![])
|
||
};
|
||
(@@$name:expr, $args:expr) => {
|
||
ExprCall {
|
||
name: into!($name).map(|s: &str| Ident(s.into())),
|
||
args: into!($args),
|
||
}
|
||
};
|
||
(@$($tts:tt)*) => (Expr::Call(Call!(@@$($tts)*)));
|
||
($($tts:tt)*) => (Node::Expr(Call!(@$($tts)*)));
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_comments() {
|
||
// In body.
|
||
t!("a// you\nb" Text("a"), Space, Text("b"));
|
||
t!("* // \n /*\n\n*/*" Strong, Space, Space, Strong);
|
||
|
||
// In header.
|
||
t!("[v /*12pt*/]" Call!("v"));
|
||
t!("[v //\n]" Call!("v"));
|
||
t!("[v 12, /*\n*/ size: 14]" Call!("v", Args![Int(12), "size" => Int(14)]));
|
||
|
||
// Error.
|
||
t!("a*/b"
|
||
nodes: [Text("a"), Text("b")],
|
||
errors: [S(1..3, "unexpected end of block comment")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_simple_nodes() {
|
||
// Basics.
|
||
t!("");
|
||
t!(" " Space);
|
||
t!("hi" Text("hi"));
|
||
t!("🧽" Text("🧽"));
|
||
t!("_" Emph);
|
||
t!("*" Strong);
|
||
t!("~" Text("\u{00A0}"));
|
||
t!(r"\" Linebreak);
|
||
t!("\n\n" Parbreak);
|
||
|
||
// Multiple nodes.
|
||
t!("ab c" Text("ab"), Space, Text("c"));
|
||
t!("a`hi`\r\n\r*" Text("a"), Raw(None, &["hi"], true), Parbreak, Strong);
|
||
|
||
// Spans.
|
||
t!("*🌍*"
|
||
nodes: [S(0..1, Strong), S(1..5, Text("🌍")), S(5..6, Strong)],
|
||
spans: true);
|
||
|
||
// Errors.
|
||
t!("]}"
|
||
nodes: [],
|
||
errors: [S(0..1, "unexpected closing bracket"),
|
||
S(1..2, "unexpected closing brace")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_headings() {
|
||
// Basics with spans.
|
||
t!("#a"
|
||
nodes: [S(0..2, Heading(S(0..1, 0), Content![@S(1..2, Text("a"))]))],
|
||
spans: true);
|
||
|
||
// Multiple hashtags.
|
||
t!("###three" Heading(2, Content![@Text("three")]));
|
||
t!("###### six" Heading(5, Content![@Space, Text("six")]));
|
||
|
||
// Start of heading.
|
||
t!("/**/#" Heading(0, Content![@]));
|
||
t!("[f][#ok]" Call!("f", Args![Content![Heading(0, Content![@Text("ok")])]]));
|
||
|
||
// End of heading.
|
||
t!("#a\nb" Heading(0, Content![@Text("a")]), Space, Text("b"));
|
||
|
||
// Continued heading.
|
||
t!("#a{\n1\n}b" Heading(0, Content![@Text("a"), Block(Int(1)), Text("b")]));
|
||
t!("#a[f][\n\n]d" Heading(0, Content![@
|
||
Text("a"), Call!("f", Args![Content![Parbreak]]), Text("d"),
|
||
]));
|
||
|
||
// No heading.
|
||
t!(r"\#" Text("#"));
|
||
t!("Nr. #1" Text("Nr."), Space, Text("#"), Text("1"));
|
||
t!("[v]#" Call!("v"), Text("#"));
|
||
|
||
// Too many hashtags.
|
||
t!("####### seven"
|
||
nodes: [Heading(5, Content![@Space, Text("seven")])],
|
||
warnings: [S(0..7, "section depth should not exceed 6")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_raw() {
|
||
// Basic, mostly tested in tokenizer and resolver.
|
||
t!("`py`" nodes: [S(0..4, Raw(None, &["py"], true))], spans: true);
|
||
t!("`endless"
|
||
nodes: [Raw(None, &["endless"], true)],
|
||
errors: [S(8..8, "expected backtick(s)")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_escape_sequences() {
|
||
// Basic, mostly tested in tokenizer.
|
||
t!(r"\[" Text("["));
|
||
t!(r"\u{1F3D5}" nodes: [S(0..9, Text("🏕"))], spans: true);
|
||
|
||
// Bad value.
|
||
t!(r"\u{FFFFFF}"
|
||
nodes: [Text(r"\u{FFFFFF}")],
|
||
errors: [S(0..10, "invalid unicode escape sequence")]);
|
||
|
||
// No closing brace.
|
||
t!(r"\u{41*"
|
||
nodes: [Text("A"), Strong],
|
||
errors: [S(5..5, "expected closing brace")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_groups() {
|
||
// Test paren group.
|
||
t!("{([v 1) + 3}"
|
||
nodes: [Block(Binary(
|
||
Content![Call!("v", Args![Int(1)])],
|
||
Add,
|
||
Int(3),
|
||
))],
|
||
errors: [S(6..6, "expected closing bracket")]);
|
||
|
||
// Test bracket group.
|
||
t!("[)"
|
||
nodes: [Call!("")],
|
||
errors: [S(1..2, "expected function name, found closing paren"),
|
||
S(2..2, "expected closing bracket")]);
|
||
|
||
t!("[v {*]_"
|
||
nodes: [Call!("v", Args![Content![Strong]]), Emph],
|
||
errors: [S(5..5, "expected closing brace")]);
|
||
|
||
// Test brace group.
|
||
t!("{1 + [}"
|
||
nodes: [Block(Binary(Int(1), Add, Content![Call!("")]))],
|
||
errors: [S(6..6, "expected function name"),
|
||
S(6..6, "expected closing bracket")]);
|
||
|
||
// Test subheader group.
|
||
t!("[v (|u )]"
|
||
nodes: [Call!("v", Args![Array![], Content![Call!("u")]])],
|
||
errors: [S(4..4, "expected closing paren"),
|
||
S(7..8, "expected expression, found closing paren")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_blocks() {
|
||
// Basic with spans.
|
||
t!("{1}" nodes: [S(0..3, Block(Int(1)))], spans: true);
|
||
|
||
// Function calls.
|
||
t!("{f()}" Call!("f"));
|
||
t!("{[f]}" Block(Content![Call!("f")]));
|
||
|
||
// Missing or bad value.
|
||
t!("{}{1u}"
|
||
nodes: [],
|
||
errors: [S(1..1, "expected expression"),
|
||
S(3..5, "expected expression, found invalid token")]);
|
||
|
||
// Too much stuff.
|
||
t!("{1 #{} end"
|
||
nodes: [Block(Int(1)), Space, Text("end")],
|
||
errors: [S(3..4, "unexpected hex value"),
|
||
S(4..5, "unexpected opening brace")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_bracket_funcs() {
|
||
// Basic.
|
||
t!("[function]" Call!("function"));
|
||
t!("[ v ]" Call!("v"));
|
||
|
||
// Body and no body.
|
||
t!("[v][[f]]" Call!("v", Args![Content![Call!("f")]]));
|
||
t!("[v][v][v]" Call!("v", Args![Content![Text("v")]]), Call!("v"));
|
||
t!("[v] [f]" Call!("v"), Space, Call!("f"));
|
||
|
||
// Spans.
|
||
t!("[v 1][📐]"
|
||
nodes: [S(0..11, Call!(S(1..2, "v"), S(3..4, Args![
|
||
S(3..4, Int(1)),
|
||
S(5..11, Content![S(6..10, Text("📐"))]),
|
||
])))],
|
||
spans: true);
|
||
|
||
// No name and no closing bracket.
|
||
t!("["
|
||
nodes: [Call!("")],
|
||
errors: [S(1..1, "expected function name"),
|
||
S(1..1, "expected closing bracket")]);
|
||
|
||
// No name.
|
||
t!("[]"
|
||
nodes: [Call!("")],
|
||
errors: [S(1..1, "expected function name")]);
|
||
|
||
// Bad name.
|
||
t!("[# 1]"
|
||
nodes: [Call!("", Args![Int(1)])],
|
||
errors: [S(1..2, "expected function name, found hex value")]);
|
||
|
||
// String in header eats closing bracket.
|
||
t!(r#"[v "]"#
|
||
nodes: [Call!("v", Args![Str("]")])],
|
||
errors: [S(5..5, "expected quote"),
|
||
S(5..5, "expected closing bracket")]);
|
||
|
||
// Raw in body eats closing bracket.
|
||
t!("[v][`a]`"
|
||
nodes: [Call!("v", Args![Content![Raw(None, &["a]"], true)]])],
|
||
errors: [S(8..8, "expected closing bracket")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_chaining() {
|
||
// Basic.
|
||
t!("[a | b]" Call!("a", Args![Content![Call!("b")]]));
|
||
t!("[a|b|c]" Call!("a", Args![Content![
|
||
Call!("b", Args![Content![Call!("c")]])
|
||
]]));
|
||
|
||
// With body and spans.
|
||
t!("[a|b][💕]"
|
||
nodes: [S(0..11, Call!(S(1..2, "a"), S(2..2, Args![
|
||
S(3..11, Content![S(3..11, Call!(S(3..4, "b"), S(4..4, Args![
|
||
S(5..11, Content![S(6..10, Text("💕"))])
|
||
])))])
|
||
])))],
|
||
spans: true);
|
||
|
||
// No name in second subheader.
|
||
t!("[a 1|]"
|
||
nodes: [Call!("a", Args![Int(1), Content![Call!("")]])],
|
||
errors: [S(5..5, "expected function name")]);
|
||
|
||
// No name in first subheader.
|
||
t!("[|a true]"
|
||
nodes: [Call!("", Args![Content![Call!("a", Args![Bool(true)])]])],
|
||
errors: [S(1..1, "expected function name")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_arguments() {
|
||
// Bracket functions.
|
||
t!("[v a]" Call!("v", Args![Id("a")]));
|
||
t!("[v 1,]" Call!("v", Args![Int(1)]));
|
||
t!("[v a:2]" Call!("v", Args!["a" => Int(2)]));
|
||
|
||
// Parenthesized function with nested array literal.
|
||
t!(r#"{f(1, a: (2, 3), #004, b: "five")}"# Block(Call!(@"f", Args![
|
||
Int(1),
|
||
"a" => Array![Int(2), Int(3)],
|
||
Color(RgbaColor::new(0, 0, 0x44, 0xff)),
|
||
"b" => Str("five"),
|
||
])));
|
||
|
||
// Bad expression.
|
||
t!("[v */]"
|
||
nodes: [Call!("v", Args![])],
|
||
errors: [S(3..5, "expected expression, found end of block comment")]);
|
||
|
||
// Bad expression.
|
||
t!("[v a:1:]"
|
||
nodes: [Call!("v", Args!["a" => Int(1)])],
|
||
errors: [S(6..7, "expected expression, found colon")]);
|
||
|
||
// Missing comma between arguments.
|
||
t!("[v 1 2]"
|
||
nodes: [Call!("v", Args![Int(1), Int(2)])],
|
||
errors: [S(4..4, "expected comma")]);
|
||
|
||
// Name has to be identifier.
|
||
t!("[v 1:]"
|
||
nodes: [Call!("v", Args![])],
|
||
errors: [S(3..4, "name must be identifier"),
|
||
S(5..5, "expected expression")]);
|
||
|
||
// Name has to be identifier.
|
||
t!("[v 1:2]"
|
||
nodes: [Call!("v", Args![])],
|
||
errors: [S(3..4, "name must be identifier")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_arrays() {
|
||
// Empty array.
|
||
t!("{()}" Block(Array![]));
|
||
|
||
// Array with one item and trailing comma + spans.
|
||
t!("{-(1,)}"
|
||
nodes: [S(0..7, Block(Unary(
|
||
S(1..2, Neg),
|
||
S(2..6, Array![S(3..4, Int(1))])
|
||
)))],
|
||
spans: true);
|
||
|
||
// Array with three items and trailing comma.
|
||
t!(r#"{("one", 2, #003,)}"# Block(Array![
|
||
Str("one"),
|
||
Int(2),
|
||
Color(RgbaColor::new(0, 0, 0x33, 0xff))
|
||
]));
|
||
|
||
// Unclosed.
|
||
t!("{(}"
|
||
nodes: [Block(Array![])],
|
||
errors: [S(2..2, "expected closing paren")]);
|
||
|
||
// Missing comma + invalid token.
|
||
t!("{(1*/2)}"
|
||
nodes: [Block(Array![Int(1), Int(2)])],
|
||
errors: [S(3..5, "expected expression, found end of block comment"),
|
||
S(3..3, "expected comma")]);
|
||
|
||
// Invalid token.
|
||
t!("{(1, 1u 2)}"
|
||
nodes: [Block(Array![Int(1), Int(2)])],
|
||
errors: [S(5..7, "expected expression, found invalid token")]);
|
||
|
||
// Coerced to expression with leading comma.
|
||
t!("{(,1)}"
|
||
nodes: [Block(Int(1))],
|
||
errors: [S(2..3, "expected expression, found comma")]);
|
||
|
||
// Missing expression after name makes this an array.
|
||
t!("{(a:)}"
|
||
nodes: [Block(Array![])],
|
||
errors: [S(4..4, "expected expression")]);
|
||
|
||
// Expected expression, found named pair.
|
||
t!("{(1, b: 2)}"
|
||
nodes: [Block(Array![Int(1)])],
|
||
errors: [S(5..9, "expected expression, found named pair")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_dictionaries() {
|
||
// Empty dictionary.
|
||
t!("{(:)}" Block(Dict![]));
|
||
|
||
// Dictionary with two pairs + spans.
|
||
t!("{(one: 1, two: 2)}"
|
||
nodes: [S(0..18, Block(Dict![
|
||
S(2..5, "one") => S(7..8, Int(1)),
|
||
S(10..13, "two") => S(15..16, Int(2)),
|
||
]))],
|
||
spans: true);
|
||
|
||
// Expected named pair, found expression.
|
||
t!("{(a: 1, b)}"
|
||
nodes: [Block(Dict!["a" => Int(1)])],
|
||
errors: [S(8..9, "expected named pair, found expression")]);
|
||
|
||
// Dictionary marker followed by more stuff.
|
||
t!("{(:1 b:2, true::)}"
|
||
nodes: [Block(Dict!["b" => Int(2)])],
|
||
errors: [S(3..4, "expected named pair, found expression"),
|
||
S(4..4, "expected comma"),
|
||
S(10..14, "name must be identifier"),
|
||
S(15..16, "expected expression, found colon")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_expressions() {
|
||
// Parentheses.
|
||
t!("{(x)}{(1)}" Block(Id("x")), Block(Int(1)));
|
||
|
||
// Unary operations.
|
||
t!("{-1}" Block(Unary(Neg, Int(1))));
|
||
t!("{--1}" Block(Unary(Neg, Unary(Neg, Int(1)))));
|
||
|
||
// Binary operations.
|
||
t!(r#"{"x"+"y"}"# Block(Binary(Str("x"), Add, Str("y"))));
|
||
t!("{1-2}" Block(Binary(Int(1), Sub, Int(2))));
|
||
t!("{a * b}" Block(Binary(Id("a"), Mul, Id("b"))));
|
||
t!("{12pt/.4}" Block(Binary(Length(12.0, Unit::Pt), Div, Float(0.4))));
|
||
|
||
// Associativity.
|
||
t!("{1+2+3}" Block(Binary(Binary(Int(1), Add, Int(2)), Add, Int(3))));
|
||
t!("{1/2*3}" Block(Binary(Binary(Int(1), Div, Int(2)), Mul, Int(3))));
|
||
|
||
// Precedence.
|
||
t!("{1+2*-3}" Block(Binary(
|
||
Int(1), Add, Binary(Int(2), Mul, Unary(Neg, Int(3))),
|
||
)));
|
||
|
||
// Confusion with floating-point literal.
|
||
t!("{1e-3-4e+4}" Block(Binary(Float(1e-3), Sub, Float(4e+4))));
|
||
|
||
// Spans + parentheses winning over precedence.
|
||
t!("{(1+2)*3}"
|
||
nodes: [S(0..9, Block(Binary(
|
||
S(1..6, Binary(S(2..3, Int(1)), S(3..4, Add), S(4..5, Int(2)))),
|
||
S(6..7, Mul),
|
||
S(7..8, Int(3)),
|
||
)))],
|
||
spans: true);
|
||
|
||
// Errors.
|
||
t!("{-}{1+}{2*}"
|
||
nodes: [Block(Int(1)), Block(Int(2))],
|
||
errors: [S(2..2, "expected expression"),
|
||
S(6..6, "expected expression"),
|
||
S(10..10, "expected expression")]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_values() {
|
||
// Basics.
|
||
t!("{_}" Block(Id("_")));
|
||
t!("{name}" Block(Id("name")));
|
||
t!("{ke-bab}" Block(Id("ke-bab")));
|
||
t!("{α}" Block(Id("α")));
|
||
t!("{true}" Block(Bool(true)));
|
||
t!("{false}" Block(Bool(false)));
|
||
t!("{1.0e-4}" Block(Float(1e-4)));
|
||
t!("{3.15}" Block(Float(3.15)));
|
||
t!("{50%}" Block(Percent(50.0)));
|
||
t!("{4.5cm}" Block(Length(4.5, Unit::Cm)));
|
||
t!("{12e1pt}" Block(Length(12e1, Unit::Pt)));
|
||
|
||
// Strings.
|
||
t!(r#"{"hi"}"# Block(Str("hi")));
|
||
t!(r#"{"a\n[]\"\u{1F680}string"}"# Block(Str("a\n[]\"🚀string")));
|
||
|
||
// Colors.
|
||
t!("{#f7a20500}" Block(Color(RgbaColor::new(0xf7, 0xa2, 0x05, 0))));
|
||
t!("{#a5}"
|
||
nodes: [Block(Color(RgbaColor::new(0, 0, 0, 0xff)))],
|
||
errors: [S(1..4, "invalid color")]);
|
||
|
||
// Content.
|
||
t!("{{*Hi*}}" Block(Content![Strong, Text("Hi"), Strong]));
|
||
|
||
// Invalid tokens.
|
||
t!("{1u}"
|
||
nodes: [],
|
||
errors: [S(1..3, "expected expression, found invalid token")]);
|
||
}
|