diff options
Diffstat (limited to 'src/eval')
| -rw-r--r-- | src/eval/dict.rs | 417 | ||||
| -rw-r--r-- | src/eval/mod.rs | 9 | ||||
| -rw-r--r-- | src/eval/scope.rs | 35 | ||||
| -rw-r--r-- | src/eval/value.rs | 496 |
4 files changed, 957 insertions, 0 deletions
diff --git a/src/eval/dict.rs b/src/eval/dict.rs new file mode 100644 index 00000000..e6216572 --- /dev/null +++ b/src/eval/dict.rs @@ -0,0 +1,417 @@ +//! A key-value map that can also model array-like structures. + +use std::collections::BTreeMap; +use std::fmt::{self, Debug, Display, Formatter}; +use std::ops::Index; + +use crate::syntax::{Span, Spanned}; + +/// A dictionary data structure, which maps from integers (`u64`) or strings to +/// a generic value type. +/// +/// The dictionary can be used to model arrays by assigning values to successive +/// indices from `0..n`. The `push` method offers special support for this +/// pattern. +#[derive(Clone)] +pub struct Dict<V> { + nums: BTreeMap<u64, V>, + strs: BTreeMap<String, V>, + lowest_free: u64, +} + +impl<V> Dict<V> { + /// Create a new empty dictionary. + pub fn new() -> Self { + Self { + nums: BTreeMap::new(), + strs: BTreeMap::new(), + lowest_free: 0, + } + } + + /// The total number of entries in the dictionary. + pub fn len(&self) -> usize { + self.nums.len() + self.strs.len() + } + + /// Whether the dictionary contains no entries. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// The first number key-value pair (with lowest number). + pub fn first(&self) -> Option<(u64, &V)> { + self.nums.iter().next().map(|(&k, v)| (k, v)) + } + + /// The last number key-value pair (with highest number). + pub fn last(&self) -> Option<(u64, &V)> { + self.nums.iter().next_back().map(|(&k, v)| (k, v)) + } + + /// Get a reference to the value with the given key. + pub fn get<'a, K>(&self, key: K) -> Option<&V> + where + K: Into<RefKey<'a>>, + { + match key.into() { + RefKey::Num(num) => self.nums.get(&num), + RefKey::Str(string) => self.strs.get(string), + } + } + + /// Borrow the value with the given key mutably. + pub fn get_mut<'a, K>(&mut self, key: K) -> Option<&mut V> + where + K: Into<RefKey<'a>>, + { + match key.into() { + RefKey::Num(num) => self.nums.get_mut(&num), + RefKey::Str(string) => self.strs.get_mut(string), + } + } + + /// Insert a value into the dictionary. + pub fn insert<K>(&mut self, key: K, value: V) + where + K: Into<DictKey>, + { + match key.into() { + DictKey::Num(num) => { + self.nums.insert(num, value); + if self.lowest_free == num { + self.lowest_free += 1; + } + } + DictKey::Str(string) => { + self.strs.insert(string, value); + } + } + } + + /// Remove the value with the given key from the dictionary. + pub fn remove<'a, K>(&mut self, key: K) -> Option<V> + where + K: Into<RefKey<'a>>, + { + match key.into() { + RefKey::Num(num) => { + self.lowest_free = self.lowest_free.min(num); + self.nums.remove(&num) + } + RefKey::Str(string) => self.strs.remove(string), + } + } + + /// Append a value to the dictionary. + /// + /// This will associate the `value` with the lowest free number key (zero if + /// there is no number key so far). + pub fn push(&mut self, value: V) { + while self.nums.contains_key(&self.lowest_free) { + self.lowest_free += 1; + } + self.nums.insert(self.lowest_free, value); + self.lowest_free += 1; + } + + /// Iterator over all borrowed keys and values. + pub fn iter(&self) -> impl Iterator<Item = (RefKey, &V)> { + self.nums() + .map(|(&k, v)| (RefKey::Num(k), v)) + .chain(self.strs().map(|(k, v)| (RefKey::Str(k), v))) + } + + /// Iterate over all values in the dictionary. + pub fn values(&self) -> impl Iterator<Item = &V> { + self.nums().map(|(_, v)| v).chain(self.strs().map(|(_, v)| v)) + } + + /// Iterate over the number key-value pairs. + pub fn nums(&self) -> std::collections::btree_map::Iter<u64, V> { + self.nums.iter() + } + + /// Iterate over the string key-value pairs. + pub fn strs(&self) -> std::collections::btree_map::Iter<String, V> { + self.strs.iter() + } + + /// Move into an owned iterator over owned keys and values. + pub fn into_iter(self) -> impl Iterator<Item = (DictKey, V)> { + self.nums + .into_iter() + .map(|(k, v)| (DictKey::Num(k), v)) + .chain(self.strs.into_iter().map(|(k, v)| (DictKey::Str(k), v))) + } + + /// Move into an owned iterator over all values in the dictionary. + pub fn into_values(self) -> impl Iterator<Item = V> { + self.nums + .into_iter() + .map(|(_, v)| v) + .chain(self.strs.into_iter().map(|(_, v)| v)) + } + + /// Iterate over the number key-value pairs. + pub fn into_nums(self) -> std::collections::btree_map::IntoIter<u64, V> { + self.nums.into_iter() + } + + /// Iterate over the string key-value pairs. + pub fn into_strs(self) -> std::collections::btree_map::IntoIter<String, V> { + self.strs.into_iter() + } +} + +impl<'a, K, V> Index<K> for Dict<V> +where + K: Into<RefKey<'a>>, +{ + type Output = V; + + fn index(&self, index: K) -> &Self::Output { + self.get(index).expect("key not in dict") + } +} + +impl<V> Default for Dict<V> { + fn default() -> Self { + Self::new() + } +} + +impl<V: Eq> Eq for Dict<V> {} + +impl<V: PartialEq> PartialEq for Dict<V> { + fn eq(&self, other: &Self) -> bool { + self.iter().eq(other.iter()) + } +} + +impl<V: Debug> Debug for Dict<V> { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + if self.is_empty() { + return f.write_str("()"); + } + + let mut builder = f.debug_tuple(""); + + struct Entry<'a>(bool, &'a dyn Display, &'a dyn Debug); + impl<'a> Debug for Entry<'a> { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + if self.0 { + f.write_str("\"")?; + } + self.1.fmt(f)?; + if self.0 { + f.write_str("\"")?; + } + if f.alternate() { + f.write_str(" = ")?; + } else { + f.write_str("=")?; + } + self.2.fmt(f) + } + } + + for (key, value) in self.nums() { + builder.field(&Entry(false, &key, &value)); + } + + for (key, value) in self.strs() { + builder.field(&Entry(key.contains(' '), &key, &value)); + } + + builder.finish() + } +} + +/// The owned variant of a dictionary key. +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)] +pub enum DictKey { + Num(u64), + Str(String), +} + +impl From<&Self> for DictKey { + fn from(key: &Self) -> Self { + key.clone() + } +} + +impl From<RefKey<'_>> for DictKey { + fn from(key: RefKey<'_>) -> Self { + match key { + RefKey::Num(num) => Self::Num(num), + RefKey::Str(string) => Self::Str(string.to_string()), + } + } +} + +impl From<u64> for DictKey { + fn from(num: u64) -> Self { + Self::Num(num) + } +} + +impl From<String> for DictKey { + fn from(string: String) -> Self { + Self::Str(string) + } +} + +impl From<&'static str> for DictKey { + fn from(string: &'static str) -> Self { + Self::Str(string.to_string()) + } +} + +/// The borrowed variant of a dictionary key. +#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)] +pub enum RefKey<'a> { + Num(u64), + Str(&'a str), +} + +impl From<u64> for RefKey<'static> { + fn from(num: u64) -> Self { + Self::Num(num) + } +} + +impl<'a> From<&'a String> for RefKey<'a> { + fn from(string: &'a String) -> Self { + Self::Str(&string) + } +} + +impl<'a> From<&'a str> for RefKey<'a> { + fn from(string: &'a str) -> Self { + Self::Str(string) + } +} + +/// A dictionary entry which tracks key and value span. +#[derive(Clone, PartialEq)] +pub struct SpannedEntry<V> { + pub key: Span, + pub val: Spanned<V>, +} + +impl<V> SpannedEntry<V> { + /// Create a new entry. + pub fn new(key: Span, val: Spanned<V>) -> Self { + Self { key, val } + } + + /// Create an entry with the same span for key and value. + pub fn val(val: Spanned<V>) -> Self { + Self { key: val.span, val } + } + + /// Convert from `&SpannedEntry<T>` to `SpannedEntry<&T>` + pub fn as_ref(&self) -> SpannedEntry<&V> { + SpannedEntry { key: self.key, val: self.val.as_ref() } + } + + /// Map the entry to a different value type. + pub fn map<U>(self, f: impl FnOnce(V) -> U) -> SpannedEntry<U> { + SpannedEntry { key: self.key, val: self.val.map(f) } + } +} + +impl<V: Debug> Debug for SpannedEntry<V> { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + if f.alternate() { + f.write_str("key")?; + self.key.fmt(f)?; + f.write_str(" ")?; + } + self.val.fmt(f) + } +} + +#[cfg(test)] +mod tests { + use super::Dict; + + #[test] + fn test_dict_different_key_types_dont_interfere() { + let mut dict = Dict::new(); + dict.insert(10, "hello"); + dict.insert("twenty", "there"); + assert_eq!(dict.len(), 2); + assert_eq!(dict[10], "hello"); + assert_eq!(dict["twenty"], "there"); + } + + #[test] + fn test_dict_push_skips_already_inserted_keys() { + let mut dict = Dict::new(); + dict.insert(2, "2"); + dict.push("0"); + dict.insert(3, "3"); + dict.push("1"); + dict.push("4"); + assert_eq!(dict.len(), 5); + assert_eq!(dict[0], "0"); + assert_eq!(dict[1], "1"); + assert_eq!(dict[2], "2"); + assert_eq!(dict[3], "3"); + assert_eq!(dict[4], "4"); + } + + #[test] + fn test_dict_push_remove_push_reuses_index() { + let mut dict = Dict::new(); + dict.push("0"); + dict.push("1"); + dict.push("2"); + dict.remove(1); + dict.push("a"); + dict.push("3"); + assert_eq!(dict.len(), 4); + assert_eq!(dict[0], "0"); + assert_eq!(dict[1], "a"); + assert_eq!(dict[2], "2"); + assert_eq!(dict[3], "3"); + } + + #[test] + fn test_dict_first_and_last_are_correct() { + let mut dict = Dict::new(); + assert_eq!(dict.first(), None); + assert_eq!(dict.last(), None); + dict.insert(4, "hi"); + dict.insert("string", "hi"); + assert_eq!(dict.first(), Some((4, &"hi"))); + assert_eq!(dict.last(), Some((4, &"hi"))); + dict.insert(2, "bye"); + assert_eq!(dict.first(), Some((2, &"bye"))); + assert_eq!(dict.last(), Some((4, &"hi"))); + } + + #[test] + fn test_dict_format_debug() { + let mut dict = Dict::new(); + assert_eq!(format!("{:?}", dict), "()"); + assert_eq!(format!("{:#?}", dict), "()"); + + dict.insert(10, "hello"); + dict.insert("twenty", "there"); + dict.insert("sp ace", "quotes"); + assert_eq!( + format!("{:?}", dict), + r#"(10="hello", "sp ace"="quotes", twenty="there")"#, + ); + assert_eq!(format!("{:#?}", dict).lines().collect::<Vec<_>>(), [ + "(", + r#" 10 = "hello","#, + r#" "sp ace" = "quotes","#, + r#" twenty = "there","#, + ")", + ]); + } +} diff --git a/src/eval/mod.rs b/src/eval/mod.rs new file mode 100644 index 00000000..65fc71c4 --- /dev/null +++ b/src/eval/mod.rs @@ -0,0 +1,9 @@ +//! Evaluation of syntax trees. + +mod dict; +mod scope; +mod value; + +pub use dict::*; +pub use scope::*; +pub use value::*; diff --git a/src/eval/scope.rs b/src/eval/scope.rs new file mode 100644 index 00000000..8e6576d1 --- /dev/null +++ b/src/eval/scope.rs @@ -0,0 +1,35 @@ +//! Mapping from identifiers to functions. + +use std::collections::HashMap; +use std::fmt::{self, Debug, Formatter}; + +use super::value::FuncValue; + +/// A map from identifiers to functions. +pub struct Scope { + functions: HashMap<String, FuncValue>, +} + +impl Scope { + // Create a new empty scope with a fallback function that is invoked when no + // match is found. + pub fn new() -> Self { + Self { functions: HashMap::new() } + } + + /// Associate the given name with the function. + pub fn insert(&mut self, name: impl Into<String>, function: FuncValue) { + self.functions.insert(name.into(), function); + } + + /// Return the function with the given name if there is one. + pub fn func(&self, name: &str) -> Option<&FuncValue> { + self.functions.get(name) + } +} + +impl Debug for Scope { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + f.debug_set().entries(self.functions.keys()).finish() + } +} diff --git a/src/eval/value.rs b/src/eval/value.rs new file mode 100644 index 00000000..cfbc302c --- /dev/null +++ b/src/eval/value.rs @@ -0,0 +1,496 @@ +//! Computational values: Syntactical expressions can be evaluated into these. + +use std::fmt::{self, Debug, Formatter}; +use std::ops::Deref; +use std::rc::Rc; + +use fontdock::{FontStretch, FontStyle, FontWeight}; + +use super::dict::{Dict, SpannedEntry}; +use crate::color::RgbaColor; +use crate::layout::{Command, Commands, Dir, LayoutContext, SpecAlign}; +use crate::length::{Length, ScaleLength}; +use crate::paper::Paper; +use crate::syntax::{Ident, Span, SpanWith, Spanned, SynNode, SynTree}; +use crate::{DynFuture, Feedback, Pass}; + +/// A computational value. +#[derive(Clone)] +pub enum Value { + /// An identifier: `ident`. + Ident(Ident), + /// A string: `"string"`. + Str(String), + /// A boolean: `true, false`. + Bool(bool), + /// A number: `1.2, 200%`. + Number(f64), + /// A length: `2cm, 5.2in`. + Length(Length), + /// A color value with alpha channel: `#f79143ff`. + Color(RgbaColor), + /// A dictionary value: `(false, 12cm, greeting="hi")`. + Dict(DictValue), + /// A syntax tree containing typesetting content. + Tree(SynTree), + /// An executable function. + Func(FuncValue), + /// Layouting commands. + Commands(Commands), +} + +impl Value { + /// A natural-language name of the type of this expression, e.g. + /// "identifier". + pub fn name(&self) -> &'static str { + use Value::*; + match self { + Ident(_) => "identifier", + Str(_) => "string", + Bool(_) => "bool", + Number(_) => "number", + Length(_) => "length", + Color(_) => "color", + Dict(_) => "dict", + Tree(_) => "syntax tree", + Func(_) => "function", + Commands(_) => "commands", + } + } +} + +impl Spanned<Value> { + /// Transform this value into something layoutable. + /// + /// If this is already a command-value, it is simply unwrapped, otherwise + /// the value is represented as layoutable content in a reasonable way. + pub fn into_commands(self) -> Commands { + match self.v { + Value::Commands(commands) => commands, + Value::Tree(tree) => vec![Command::LayoutSyntaxTree(tree)], + + // Forward to each entry, separated with spaces. + Value::Dict(dict) => { + let mut commands = vec![]; + let mut end = None; + for entry in dict.into_values() { + if let Some(last_end) = end { + let span = Span::new(last_end, entry.key.start); + let tree = vec![SynNode::Spacing.span_with(span)]; + commands.push(Command::LayoutSyntaxTree(tree)); + } + + end = Some(entry.val.span.end); + commands.extend(entry.val.into_commands()); + } + commands + } + + // Format with debug. + val => { + let fmt = format!("{:?}", val); + let tree = vec![SynNode::Text(fmt).span_with(self.span)]; + vec![Command::LayoutSyntaxTree(tree)] + } + } + } +} + +impl Debug for Value { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + use Value::*; + match self { + Ident(i) => i.fmt(f), + Str(s) => s.fmt(f), + Bool(b) => b.fmt(f), + Number(n) => n.fmt(f), + Length(s) => s.fmt(f), + Color(c) => c.fmt(f), + Dict(t) => t.fmt(f), + Tree(t) => t.fmt(f), + Func(_) => f.pad("<function>"), + Commands(c) => c.fmt(f), + } + } +} + +impl PartialEq for Value { + fn eq(&self, other: &Self) -> bool { + use Value::*; + match (self, other) { + (Ident(a), Ident(b)) => a == b, + (Str(a), Str(b)) => a == b, + (Bool(a), Bool(b)) => a == b, + (Number(a), Number(b)) => a == b, + (Length(a), Length(b)) => a == b, + (Color(a), Color(b)) => a == b, + (Dict(a), Dict(b)) => a == b, + (Tree(a), Tree(b)) => a == b, + (Func(a), Func(b)) => Rc::ptr_eq(a, b), + (Commands(a), Commands(b)) => a == b, + _ => false, + } + } +} + +/// An executable function value. +/// +/// The first argument is a dictionary containing the arguments passed to the +/// function. The function may be asynchronous (as such it returns a dynamic +/// future) and it may emit diagnostics, which are contained in the returned +/// `Pass`. In the end, the function must evaluate to `Value`. Your typical +/// typesetting function will return a `Commands` value which will instruct the +/// layouting engine to do what the function pleases. +/// +/// The dynamic function object is wrapped in an `Rc` to keep `Value` clonable. +pub type FuncValue = + Rc<dyn Fn(Span, DictValue, LayoutContext<'_>) -> DynFuture<Pass<Value>>>; + +/// A dictionary of values. +/// +/// # Example +/// ```typst +/// (false, 12cm, greeting="hi") +/// ``` +pub type DictValue = Dict<SpannedEntry<Value>>; + +impl DictValue { + /// Retrieve and remove the matching value with the lowest number key, + /// skipping and ignoring all non-matching entries with lower keys. + pub fn take<T: TryFromValue>(&mut self) -> Option<T> { + for (&key, entry) in self.nums() { + let expr = entry.val.as_ref(); + if let Some(val) = T::try_from_value(expr, &mut Feedback::new()) { + self.remove(key); + return Some(val); + } + } + None + } + + /// Retrieve and remove the matching value with the lowest number key, + /// removing and generating errors for all non-matching entries with lower + /// keys. + /// + /// Generates an error at `err_span` when no matching value was found. + pub fn expect<T: TryFromValue>( + &mut self, + name: &str, + span: Span, + f: &mut Feedback, + ) -> Option<T> { + while let Some((num, _)) = self.first() { + let entry = self.remove(num).unwrap(); + if let Some(val) = T::try_from_value(entry.val.as_ref(), f) { + return Some(val); + } + } + error!(@f, span, "missing argument: {}", name); + None + } + + /// Retrieve and remove a matching value associated with the given key if + /// there is any. + /// + /// Generates an error if the key exists but the value does not match. + pub fn take_key<T>(&mut self, key: &str, f: &mut Feedback) -> Option<T> + where + T: TryFromValue, + { + self.remove(key).and_then(|entry| { + let expr = entry.val.as_ref(); + T::try_from_value(expr, f) + }) + } + + /// Retrieve and remove all matching pairs with number keys, skipping and + /// ignoring non-matching entries. + /// + /// The pairs are returned in order of increasing keys. + pub fn take_all_num<'a, T>(&'a mut self) -> impl Iterator<Item = (u64, T)> + 'a + where + T: TryFromValue, + { + let mut skip = 0; + std::iter::from_fn(move || { + for (&key, entry) in self.nums().skip(skip) { + let expr = entry.val.as_ref(); + if let Some(val) = T::try_from_value(expr, &mut Feedback::new()) { + self.remove(key); + return Some((key, val)); + } + skip += 1; + } + + None + }) + } + + + /// Retrieve and remove all matching values with number keys, skipping and + /// ignoring non-matching entries. + /// + /// The values are returned in order of increasing keys. + pub fn take_all_num_vals<'a, T: 'a>(&'a mut self) -> impl Iterator<Item = T> + 'a + where + T: TryFromValue, + { + self.take_all_num::<T>().map(|(_, v)| v) + } + + /// Retrieve and remove all matching pairs with string keys, skipping and + /// ignoring non-matching entries. + /// + /// The pairs are returned in order of increasing keys. + pub fn take_all_str<'a, T>(&'a mut self) -> impl Iterator<Item = (String, T)> + 'a + where + T: TryFromValue, + { + let mut skip = 0; + std::iter::from_fn(move || { + for (key, entry) in self.strs().skip(skip) { + let expr = entry.val.as_ref(); + if let Some(val) = T::try_from_value(expr, &mut Feedback::new()) { + let key = key.clone(); + self.remove(&key); + return Some((key, val)); + } + skip += 1; + } + + None + }) + } + + /// Generated `"unexpected argument"` errors for all remaining entries. + pub fn unexpected(&self, f: &mut Feedback) { + for entry in self.values() { + let span = Span::merge(entry.key, entry.val.span); + error!(@f, span, "unexpected argument"); + } + } +} + +/// A trait for converting values into more specific types. +pub trait TryFromValue: Sized { + // This trait takes references because we don't want to move the value + // out of its origin in case this returns `None`. This solution is not + // perfect because we need to do some cloning in the impls for this trait, + // but we haven't got a better solution, for now. + + /// Try to convert a value to this type. + /// + /// Returns `None` and generates an appropriate error if the value is not + /// valid for this type. + fn try_from_value(value: Spanned<&Value>, f: &mut Feedback) -> Option<Self>; +} + +macro_rules! impl_match { + ($type:ty, $name:expr, $($p:pat => $r:expr),* $(,)?) => { + impl TryFromValue for $type { + fn try_from_value(value: Spanned<&Value>, f: &mut Feedback) -> Option<Self> { + #[allow(unreachable_patterns)] + match value.v { + $($p => Some($r)),*, + other => { + error!( + @f, value.span, + "expected {}, found {}", $name, other.name() + ); + None + } + } + } + } + }; +} + +macro_rules! impl_ident { + ($type:ty, $name:expr, $parse:expr) => { + impl TryFromValue for $type { + fn try_from_value(value: Spanned<&Value>, f: &mut Feedback) -> Option<Self> { + if let Value::Ident(ident) = value.v { + let val = $parse(ident); + if val.is_none() { + error!(@f, value.span, "invalid {}", $name); + } + val + } else { + error!( + @f, value.span, + "expected {}, found {}", $name, value.v.name() + ); + None + } + } + } + }; +} + +impl<T: TryFromValue> TryFromValue for Spanned<T> { + fn try_from_value(value: Spanned<&Value>, f: &mut Feedback) -> Option<Self> { + let span = value.span; + T::try_from_value(value, f).map(|v| Spanned { v, span }) + } +} + +impl_match!(Value, "value", v => v.clone()); +impl_match!(Ident, "identifier", Value::Ident(i) => i.clone()); +impl_match!(String, "string", Value::Str(s) => s.clone()); +impl_match!(bool, "bool", &Value::Bool(b) => b); +impl_match!(f64, "number", &Value::Number(n) => n); +impl_match!(Length, "length", &Value::Length(l) => l); +impl_match!(SynTree, "tree", Value::Tree(t) => t.clone()); +impl_match!(DictValue, "dict", Value::Dict(t) => t.clone()); +impl_match!(FuncValue, "function", Value::Func(f) => f.clone()); +impl_match!(ScaleLength, "number or length", + &Value::Length(length) => ScaleLength::Absolute(length), + &Value::Number(scale) => ScaleLength::Scaled(scale), +); + +/// A value type that matches identifiers and strings and implements +/// `Into<String>`. +pub struct StringLike(pub String); + +impl From<StringLike> for String { + fn from(like: StringLike) -> String { + like.0 + } +} + +impl Deref for StringLike { + type Target = str; + + fn deref(&self) -> &str { + self.0.as_str() + } +} + +impl_match!(StringLike, "identifier or string", + Value::Ident(Ident(s)) => StringLike(s.clone()), + Value::Str(s) => StringLike(s.clone()), +); + +impl_ident!(Dir, "direction", |s| match s { + "ltr" => Some(Self::LTR), + "rtl" => Some(Self::RTL), + "ttb" => Some(Self::TTB), + "btt" => Some(Self::BTT), + _ => None, +}); + +impl_ident!(SpecAlign, "alignment", |s| match s { + "left" => Some(Self::Left), + "right" => Some(Self::Right), + "top" => Some(Self::Top), + "bottom" => Some(Self::Bottom), + "center" => Some(Self::Center), + _ => None, +}); + +impl_ident!(FontStyle, "font style", Self::from_str); +impl_ident!(FontStretch, "font stretch", Self::from_str); +impl_ident!(Paper, "paper", Self::from_name); + +impl TryFromValue for FontWeight { + fn try_from_value(value: Spanned<&Value>, f: &mut Feedback) -> Option<Self> { + match value.v { + &Value::Number(weight) => { + const MIN: u16 = 100; + const MAX: u16 = 900; + + if weight < MIN as f64 { + error!(@f, value.span, "the minimum font weight is {}", MIN); + Some(Self::THIN) + } else if weight > MAX as f64 { + error!(@f, value.span, "the maximum font weight is {}", MAX); + Some(Self::BLACK) + } else { + FontWeight::from_number(weight.round() as u16) + } + } + Value::Ident(ident) => { + let weight = Self::from_str(ident); + if weight.is_none() { + error!(@f, value.span, "invalid font weight"); + } + weight + } + other => { + error!( + @f, value.span, + "expected font weight (name or number), found {}", + other.name(), + ); + None + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn entry(value: Value) -> SpannedEntry<Value> { + SpannedEntry::val(Spanned::zero(value)) + } + + #[test] + fn test_dict_take_removes_correct_entry() { + let mut dict = Dict::new(); + dict.insert(1, entry(Value::Bool(false))); + dict.insert(2, entry(Value::Str("hi".to_string()))); + assert_eq!(dict.take::<String>(), Some("hi".to_string())); + assert_eq!(dict.len(), 1); + assert_eq!(dict.take::<bool>(), Some(false)); + assert!(dict.is_empty()); + } + + #[test] + fn test_dict_expect_errors_about_previous_entries() { + let mut f = Feedback::new(); + let mut dict = Dict::new(); + dict.insert(1, entry(Value::Bool(false))); + dict.insert(3, entry(Value::Str("hi".to_string()))); + dict.insert(5, entry(Value::Bool(true))); + assert_eq!( + dict.expect::<String>("", Span::ZERO, &mut f), + Some("hi".to_string()) + ); + assert_eq!(f.diagnostics, [error!( + Span::ZERO, + "expected string, found bool" + )]); + assert_eq!(dict.len(), 1); + } + + #[test] + fn test_dict_take_with_key_removes_the_entry() { + let mut f = Feedback::new(); + let mut dict = Dict::new(); + dict.insert(1, entry(Value::Bool(false))); + dict.insert("hi", entry(Value::Bool(true))); + assert_eq!(dict.take::<bool>(), Some(false)); + assert_eq!(dict.take_key::<f64>("hi", &mut f), None); + assert_eq!(f.diagnostics, [error!( + Span::ZERO, + "expected number, found bool" + )]); + assert!(dict.is_empty()); + } + + #[test] + fn test_dict_take_all_removes_the_correct_entries() { + let mut dict = Dict::new(); + dict.insert(1, entry(Value::Bool(false))); + dict.insert(3, entry(Value::Number(0.0))); + dict.insert(7, entry(Value::Bool(true))); + assert_eq!(dict.take_all_num::<bool>().collect::<Vec<_>>(), [ + (1, false), + (7, true) + ],); + assert_eq!(dict.len(), 1); + assert_eq!(dict[3].val.v, Value::Number(0.0)); + } +} |