diff options
Diffstat (limited to 'src/model')
| -rw-r--r-- | src/model/content.rs | 614 | ||||
| -rw-r--r-- | src/model/element.rs | 134 | ||||
| -rw-r--r-- | src/model/introspect.rs | 352 | ||||
| -rw-r--r-- | src/model/label.rs | 16 | ||||
| -rw-r--r-- | src/model/mod.rs | 148 | ||||
| -rw-r--r-- | src/model/realize.rs | 228 | ||||
| -rw-r--r-- | src/model/selector.rs | 296 | ||||
| -rw-r--r-- | src/model/styles.rs | 750 |
8 files changed, 0 insertions, 2538 deletions
diff --git a/src/model/content.rs b/src/model/content.rs deleted file mode 100644 index 015f8b76..00000000 --- a/src/model/content.rs +++ /dev/null @@ -1,614 +0,0 @@ -use std::any::TypeId; -use std::fmt::{self, Debug, Formatter, Write}; -use std::iter::Sum; -use std::ops::{Add, AddAssign}; - -use comemo::Prehashed; -use ecow::{eco_format, EcoString, EcoVec}; - -use super::{ - element, Behave, Behaviour, ElemFunc, Element, Fold, Guard, Label, Locatable, - Location, Recipe, Selector, Style, Styles, Synthesize, -}; -use crate::diag::{SourceResult, StrResult}; -use crate::doc::Meta; -use crate::eval::{Dict, FromValue, IntoValue, Str, Value, Vm}; -use crate::syntax::Span; -use crate::util::pretty_array_like; - -/// Composable representation of styled content. -#[derive(Clone, Hash)] -#[allow(clippy::derived_hash_with_manual_eq)] -pub struct Content { - func: ElemFunc, - attrs: EcoVec<Attr>, -} - -/// Attributes that can be attached to content. -#[derive(Debug, Clone, PartialEq, Hash)] -enum Attr { - Span(Span), - Field(EcoString), - Value(Prehashed<Value>), - Child(Prehashed<Content>), - Styles(Styles), - Prepared, - Guard(Guard), - Location(Location), -} - -impl Content { - /// Create an empty element. - pub fn new(func: ElemFunc) -> Self { - Self { func, attrs: EcoVec::new() } - } - - /// Create empty content. - pub fn empty() -> Self { - Self::new(SequenceElem::func()) - } - - /// Create a new sequence element from multiples elements. - pub fn sequence(iter: impl IntoIterator<Item = Self>) -> Self { - let mut iter = iter.into_iter(); - let Some(first) = iter.next() else { return Self::empty() }; - let Some(second) = iter.next() else { return first }; - let mut content = Content::empty(); - content.attrs.push(Attr::Child(Prehashed::new(first))); - content.attrs.push(Attr::Child(Prehashed::new(second))); - content - .attrs - .extend(iter.map(|child| Attr::Child(Prehashed::new(child)))); - content - } - - /// The element function of the contained content. - pub fn func(&self) -> ElemFunc { - self.func - } - - /// Whether the content is an empty sequence. - pub fn is_empty(&self) -> bool { - self.is::<SequenceElem>() && self.attrs.is_empty() - } - - /// Whether the contained element is of type `T`. - pub fn is<T: Element>(&self) -> bool { - self.func == T::func() - } - - /// Cast to `T` if the contained element is of type `T`. - pub fn to<T: Element>(&self) -> Option<&T> { - T::unpack(self) - } - - /// Access the children if this is a sequence. - pub fn to_sequence(&self) -> Option<impl Iterator<Item = &Self>> { - if !self.is::<SequenceElem>() { - return None; - } - Some(self.attrs.iter().filter_map(Attr::child)) - } - - /// Access the child and styles. - pub fn to_styled(&self) -> Option<(&Content, &Styles)> { - if !self.is::<StyledElem>() { - return None; - } - let child = self.attrs.iter().find_map(Attr::child)?; - let styles = self.attrs.iter().find_map(Attr::styles)?; - Some((child, styles)) - } - - /// Whether the contained element has the given capability. - pub fn can<C>(&self) -> bool - where - C: ?Sized + 'static, - { - (self.func.0.vtable)(TypeId::of::<C>()).is_some() - } - - /// Whether the contained element has the given capability. - /// Where the capability is given by a `TypeId`. - pub fn can_type_id(&self, type_id: TypeId) -> bool { - (self.func.0.vtable)(type_id).is_some() - } - - /// Cast to a trait object if the contained element has the given - /// capability. - pub fn with<C>(&self) -> Option<&C> - where - C: ?Sized + 'static, - { - let vtable = (self.func.0.vtable)(TypeId::of::<C>())?; - let data = self as *const Self as *const (); - Some(unsafe { &*crate::util::fat::from_raw_parts(data, vtable) }) - } - - /// Cast to a mutable trait object if the contained element has the given - /// capability. - pub fn with_mut<C>(&mut self) -> Option<&mut C> - where - C: ?Sized + 'static, - { - let vtable = (self.func.0.vtable)(TypeId::of::<C>())?; - let data = self as *mut Self as *mut (); - Some(unsafe { &mut *crate::util::fat::from_raw_parts_mut(data, vtable) }) - } - - /// The content's span. - pub fn span(&self) -> Span { - self.attrs.iter().find_map(Attr::span).unwrap_or(Span::detached()) - } - - /// Attach a span to the content if it doesn't already have one. - pub fn spanned(mut self, span: Span) -> Self { - if self.span().is_detached() { - self.attrs.push(Attr::Span(span)); - } - self - } - - /// Attach a field to the content. - pub fn with_field( - mut self, - name: impl Into<EcoString>, - value: impl IntoValue, - ) -> Self { - self.push_field(name, value); - self - } - - /// Attach a field to the content. - pub fn push_field(&mut self, name: impl Into<EcoString>, value: impl IntoValue) { - let name = name.into(); - if let Some(i) = self.attrs.iter().position(|attr| match attr { - Attr::Field(field) => *field == name, - _ => false, - }) { - self.attrs.make_mut()[i + 1] = - Attr::Value(Prehashed::new(value.into_value())); - } else { - self.attrs.push(Attr::Field(name)); - self.attrs.push(Attr::Value(Prehashed::new(value.into_value()))); - } - } - - /// Access a field on the content. - pub fn field(&self, name: &str) -> Option<Value> { - if let (Some(iter), "children") = (self.to_sequence(), name) { - Some(Value::Array(iter.cloned().map(Value::Content).collect())) - } else if let (Some((child, _)), "child") = (self.to_styled(), name) { - Some(Value::Content(child.clone())) - } else { - self.field_ref(name).cloned() - } - } - - /// Access a field on the content by reference. - /// - /// Does not include synthesized fields for sequence and styled elements. - pub fn field_ref(&self, name: &str) -> Option<&Value> { - self.fields_ref() - .find(|&(field, _)| field == name) - .map(|(_, value)| value) - } - - /// Iter over all fields on the content. - /// - /// Does not include synthesized fields for sequence and styled elements. - pub fn fields(&self) -> impl Iterator<Item = (&EcoString, Value)> { - static CHILD: EcoString = EcoString::inline("child"); - static CHILDREN: EcoString = EcoString::inline("children"); - - let option = if let Some(iter) = self.to_sequence() { - Some((&CHILDREN, Value::Array(iter.cloned().map(Value::Content).collect()))) - } else if let Some((child, _)) = self.to_styled() { - Some((&CHILD, Value::Content(child.clone()))) - } else { - None - }; - - self.fields_ref() - .map(|(name, value)| (name, value.clone())) - .chain(option) - } - - /// Iter over all fields on the content. - /// - /// Does not include synthesized fields for sequence and styled elements. - pub fn fields_ref(&self) -> impl Iterator<Item = (&EcoString, &Value)> { - let mut iter = self.attrs.iter(); - std::iter::from_fn(move || { - let field = iter.find_map(Attr::field)?; - let value = iter.next()?.value()?; - Some((field, value)) - }) - } - - /// Try to access a field on the content as a specified type. - pub fn cast_field<T: FromValue>(&self, name: &str) -> Option<T> { - match self.field(name) { - Some(value) => value.cast().ok(), - None => None, - } - } - - /// Expect a field on the content to exist as a specified type. - #[track_caller] - pub fn expect_field<T: FromValue>(&self, name: &str) -> T { - self.field(name).unwrap().cast().unwrap() - } - - /// Whether the content has the specified field. - pub fn has(&self, field: &str) -> bool { - self.field(field).is_some() - } - - /// Borrow the value of the given field. - pub fn at(&self, field: &str, default: Option<Value>) -> StrResult<Value> { - self.field(field) - .or(default) - .ok_or_else(|| missing_field_no_default(field)) - } - - /// Return the fields of the content as a dict. - pub fn dict(&self) -> Dict { - self.fields() - .map(|(key, value)| (key.to_owned().into(), value)) - .collect() - } - - /// The content's label. - pub fn label(&self) -> Option<&Label> { - match self.field_ref("label")? { - Value::Label(label) => Some(label), - _ => None, - } - } - - /// Attach a label to the content. - pub fn labelled(self, label: Label) -> Self { - self.with_field("label", label) - } - - /// Style this content with a style entry. - pub fn styled(mut self, style: impl Into<Style>) -> Self { - if self.is::<StyledElem>() { - let prev = - self.attrs.make_mut().iter_mut().find_map(Attr::styles_mut).unwrap(); - prev.apply_one(style.into()); - self - } else { - self.styled_with_map(style.into().into()) - } - } - - /// Style this content with a full style map. - pub fn styled_with_map(mut self, styles: Styles) -> Self { - if styles.is_empty() { - return self; - } - - if self.is::<StyledElem>() { - let prev = - self.attrs.make_mut().iter_mut().find_map(Attr::styles_mut).unwrap(); - prev.apply(styles); - self - } else { - let mut content = Content::new(StyledElem::func()); - content.attrs.push(Attr::Child(Prehashed::new(self))); - content.attrs.push(Attr::Styles(styles)); - content - } - } - - /// Style this content with a recipe, eagerly applying it if possible. - pub fn styled_with_recipe(self, vm: &mut Vm, recipe: Recipe) -> SourceResult<Self> { - if recipe.selector.is_none() { - recipe.apply_vm(vm, self) - } else { - Ok(self.styled(recipe)) - } - } - - /// Repeat this content `count` times. - pub fn repeat(&self, count: usize) -> Self { - Self::sequence(vec![self.clone(); count]) - } - - /// Disable a show rule recipe. - pub fn guarded(mut self, guard: Guard) -> Self { - self.attrs.push(Attr::Guard(guard)); - self - } - - /// Check whether a show rule recipe is disabled. - pub fn is_guarded(&self, guard: Guard) -> bool { - self.attrs.contains(&Attr::Guard(guard)) - } - - /// Whether no show rule was executed for this content so far. - pub fn is_pristine(&self) -> bool { - !self.attrs.iter().any(|modifier| matches!(modifier, Attr::Guard(_))) - } - - /// Whether this content has already been prepared. - pub fn is_prepared(&self) -> bool { - self.attrs.contains(&Attr::Prepared) - } - - /// Mark this content as prepared. - pub fn mark_prepared(&mut self) { - self.attrs.push(Attr::Prepared); - } - - /// Whether the content needs to be realized specially. - pub fn needs_preparation(&self) -> bool { - (self.can::<dyn Locatable>() - || self.can::<dyn Synthesize>() - || self.label().is_some()) - && !self.is_prepared() - } - - /// This content's location in the document flow. - pub fn location(&self) -> Option<Location> { - self.attrs.iter().find_map(|modifier| match modifier { - Attr::Location(location) => Some(*location), - _ => None, - }) - } - - /// Attach a location to this content. - pub fn set_location(&mut self, location: Location) { - self.attrs.push(Attr::Location(location)); - } - - /// Queries the content tree for all elements that match the given selector. - /// - /// Elements produced in `show` rules will not be included in the results. - #[tracing::instrument(skip_all)] - pub fn query(&self, selector: Selector) -> Vec<&Content> { - let mut results = Vec::new(); - self.traverse(&mut |element| { - if selector.matches(element) { - results.push(element); - } - }); - results - } - - /// Queries the content tree for the first element that match the given - /// selector. - /// - /// Elements produced in `show` rules will not be included in the results. - #[tracing::instrument(skip_all)] - pub fn query_first(&self, selector: Selector) -> Option<&Content> { - let mut result = None; - self.traverse(&mut |element| { - if result.is_none() && selector.matches(element) { - result = Some(element); - } - }); - result - } - - /// Extracts the plain text of this content. - pub fn plain_text(&self) -> EcoString { - let mut text = EcoString::new(); - self.traverse(&mut |element| { - if let Some(textable) = element.with::<dyn PlainText>() { - textable.plain_text(&mut text); - } - }); - text - } - - /// Traverse this content. - fn traverse<'a, F>(&'a self, f: &mut F) - where - F: FnMut(&'a Content), - { - f(self); - - for attr in &self.attrs { - match attr { - Attr::Child(child) => child.traverse(f), - Attr::Value(value) => walk_value(value, f), - _ => {} - } - } - - /// Walks a given value to find any content that matches the selector. - fn walk_value<'a, F>(value: &'a Value, f: &mut F) - where - F: FnMut(&'a Content), - { - match value { - Value::Content(content) => content.traverse(f), - Value::Array(array) => { - for value in array { - walk_value(value, f); - } - } - _ => {} - } - } - } -} - -impl Debug for Content { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - let name = self.func.name(); - if let Some(text) = item!(text_str)(self) { - f.write_char('[')?; - f.write_str(&text)?; - f.write_char(']')?; - return Ok(()); - } else if name == "space" { - return f.write_str("[ ]"); - } - - let mut pieces: Vec<_> = self - .fields() - .map(|(name, value)| eco_format!("{name}: {value:?}")) - .collect(); - - if self.is::<StyledElem>() { - pieces.push(EcoString::from("..")); - } - - f.write_str(name)?; - f.write_str(&pretty_array_like(&pieces, false)) - } -} - -impl Default for Content { - fn default() -> Self { - Self::empty() - } -} - -impl PartialEq for Content { - fn eq(&self, other: &Self) -> bool { - if let (Some(left), Some(right)) = (self.to_sequence(), other.to_sequence()) { - left.eq(right) - } else if let (Some(left), Some(right)) = (self.to_styled(), other.to_styled()) { - left == right - } else { - self.func == other.func && self.fields_ref().eq(other.fields_ref()) - } - } -} - -impl Add for Content { - type Output = Self; - - fn add(self, mut rhs: Self) -> Self::Output { - let mut lhs = self; - match (lhs.is::<SequenceElem>(), rhs.is::<SequenceElem>()) { - (true, true) => { - lhs.attrs.extend(rhs.attrs); - lhs - } - (true, false) => { - lhs.attrs.push(Attr::Child(Prehashed::new(rhs))); - lhs - } - (false, true) => { - rhs.attrs.insert(0, Attr::Child(Prehashed::new(lhs))); - rhs - } - (false, false) => Self::sequence([lhs, rhs]), - } - } -} - -impl AddAssign for Content { - fn add_assign(&mut self, rhs: Self) { - *self = std::mem::take(self) + rhs; - } -} - -impl Sum for Content { - fn sum<I: Iterator<Item = Self>>(iter: I) -> Self { - Self::sequence(iter) - } -} - -impl Attr { - fn child(&self) -> Option<&Content> { - match self { - Self::Child(child) => Some(child), - _ => None, - } - } - - fn styles(&self) -> Option<&Styles> { - match self { - Self::Styles(styles) => Some(styles), - _ => None, - } - } - - fn styles_mut(&mut self) -> Option<&mut Styles> { - match self { - Self::Styles(styles) => Some(styles), - _ => None, - } - } - - fn field(&self) -> Option<&EcoString> { - match self { - Self::Field(field) => Some(field), - _ => None, - } - } - - fn value(&self) -> Option<&Value> { - match self { - Self::Value(value) => Some(value), - _ => None, - } - } - - fn span(&self) -> Option<Span> { - match self { - Self::Span(span) => Some(*span), - _ => None, - } - } -} - -/// Display: Sequence -/// Category: special -#[element] -struct SequenceElem {} - -/// Display: Sequence -/// Category: special -#[element] -struct StyledElem {} - -/// Hosts metadata and ensures metadata is produced even for empty elements. -/// -/// Display: Meta -/// Category: special -#[element(Behave)] -pub struct MetaElem { - /// Metadata that should be attached to all elements affected by this style - /// property. - #[fold] - pub data: Vec<Meta>, -} - -impl Behave for MetaElem { - fn behaviour(&self) -> Behaviour { - Behaviour::Ignorant - } -} - -impl Fold for Vec<Meta> { - type Output = Self; - - fn fold(mut self, outer: Self::Output) -> Self::Output { - self.extend(outer); - self - } -} - -/// Tries to extract the plain-text representation of the element. -pub trait PlainText { - /// Write this element's plain text into the given buffer. - fn plain_text(&self, text: &mut EcoString); -} - -/// The missing key access error message when no default value was given. -#[cold] -fn missing_field_no_default(key: &str) -> EcoString { - eco_format!( - "content does not contain field {:?} and \ - no default value was specified", - Str::from(key) - ) -} diff --git a/src/model/element.rs b/src/model/element.rs deleted file mode 100644 index c673ee41..00000000 --- a/src/model/element.rs +++ /dev/null @@ -1,134 +0,0 @@ -use std::any::TypeId; -use std::fmt::{self, Debug, Formatter}; -use std::hash::{Hash, Hasher}; - -use once_cell::sync::Lazy; - -use super::{Content, Selector, Styles}; -use crate::diag::SourceResult; -use crate::eval::{cast, Args, Dict, Func, FuncInfo, Value, Vm}; - -/// A document element. -pub trait Element: Construct + Set + Sized + 'static { - /// Pack the element into type-erased content. - fn pack(self) -> Content; - - /// Extract this element from type-erased content. - fn unpack(content: &Content) -> Option<&Self>; - - /// The element's function. - fn func() -> ElemFunc; -} - -/// An element's constructor function. -pub trait Construct { - /// Construct an element from the arguments. - /// - /// This is passed only the arguments that remain after execution of the - /// element's set rule. - fn construct(vm: &mut Vm, args: &mut Args) -> SourceResult<Content>; -} - -/// An element's set rule. -pub trait Set { - /// Parse relevant arguments into style properties for this element. - fn set(args: &mut Args) -> SourceResult<Styles>; -} - -/// An element's function. -#[derive(Copy, Clone)] -pub struct ElemFunc(pub(super) &'static NativeElemFunc); - -impl ElemFunc { - /// The function's name. - pub fn name(self) -> &'static str { - self.0.name - } - - /// Apply the given arguments to the function. - pub fn with(self, args: Args) -> Func { - Func::from(self).with(args) - } - - /// Extract details about the function. - pub fn info(&self) -> &'static FuncInfo { - &self.0.info - } - - /// Construct an element. - pub fn construct(self, vm: &mut Vm, args: &mut Args) -> SourceResult<Content> { - (self.0.construct)(vm, args) - } - - /// Whether the contained element has the given capability. - pub fn can<C>(&self) -> bool - where - C: ?Sized + 'static, - { - (self.0.vtable)(TypeId::of::<C>()).is_some() - } - - /// Create a selector for elements of this function. - pub fn select(self) -> Selector { - Selector::Elem(self, None) - } - - /// Create a selector for elements of this function, filtering for those - /// whose [fields](super::Content::field) match the given arguments. - pub fn where_(self, fields: Dict) -> Selector { - Selector::Elem(self, Some(fields)) - } - - /// Execute the set rule for the element and return the resulting style map. - pub fn set(self, mut args: Args) -> SourceResult<Styles> { - let styles = (self.0.set)(&mut args)?; - args.finish()?; - Ok(styles) - } -} - -impl Debug for ElemFunc { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - f.pad(self.name()) - } -} - -impl Eq for ElemFunc {} - -impl PartialEq for ElemFunc { - fn eq(&self, other: &Self) -> bool { - std::ptr::eq(self.0, other.0) - } -} - -impl Hash for ElemFunc { - fn hash<H: Hasher>(&self, state: &mut H) { - state.write_usize(self.0 as *const _ as usize); - } -} - -cast! { - ElemFunc, - self => Value::Func(self.into()), - v: Func => v.element().ok_or("expected element function")?, -} - -impl From<&'static NativeElemFunc> for ElemFunc { - fn from(native: &'static NativeElemFunc) -> Self { - Self(native) - } -} - -/// An element function backed by a Rust type. -pub struct NativeElemFunc { - /// The element's name. - pub name: &'static str, - /// The element's vtable for capability dispatch. - pub vtable: fn(of: TypeId) -> Option<*const ()>, - /// The element's constructor. - pub construct: fn(&mut Vm, &mut Args) -> SourceResult<Content>, - /// The element's set rule. - pub set: fn(&mut Args) -> SourceResult<Styles>, - /// Details about the function. - pub info: Lazy<FuncInfo>, -} diff --git a/src/model/introspect.rs b/src/model/introspect.rs deleted file mode 100644 index 42c1a9e1..00000000 --- a/src/model/introspect.rs +++ /dev/null @@ -1,352 +0,0 @@ -use std::cell::RefCell; -use std::collections::HashMap; -use std::fmt::{self, Debug, Formatter}; -use std::hash::Hash; -use std::num::NonZeroUsize; - -use comemo::{Prehashed, Track, Tracked, Validate}; -use ecow::EcoVec; -use indexmap::IndexMap; - -use super::{Content, Selector}; -use crate::diag::{bail, StrResult}; -use crate::doc::{Frame, FrameItem, Meta, Position}; -use crate::eval::{cast, Value}; -use crate::geom::{Point, Transform}; -use crate::model::Label; -use crate::util::NonZeroExt; - -/// Identifies the location of an element in the document. -/// -/// This struct is created by [`Locator::locate`]. -#[derive(Copy, Clone, Eq, PartialEq, Hash)] -pub struct Location { - /// The hash of the element. - hash: u128, - /// An unique number among elements with the same hash. This is the reason - /// we need a `Locator` everywhere. - disambiguator: usize, - /// A synthetic location created from another one. This is used for example - /// in bibliography management to create individual linkable locations for - /// reference entries from the bibliography's location. - variant: usize, -} - -impl Location { - /// Produce a variant of this location. - pub fn variant(mut self, n: usize) -> Self { - self.variant = n; - self - } -} - -impl Debug for Location { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - f.pad("..") - } -} - -cast! { - type Location: "location", -} - -/// Provides locations for elements in the document. -/// -/// A [`Location`] consists of an element's hash plus a disambiguator. Just the -/// hash is not enough because we can have multiple equal elements with the same -/// hash (not a hash collision, just equal elements!). Between these, we -/// disambiguate with an increasing number. In principle, the disambiguator -/// could just be counted up. However, counting is an impure operation and as -/// such we can't count across a memoization boundary. [^1] -/// -/// Instead, we only mutate within a single "layout run" and combine the results -/// with disambiguators from an outer tracked locator. Thus, the locators form a -/// "tracked chain". When a layout run ends, its mutations are discarded and, on -/// the other side of the memoization boundary, we -/// [reconstruct](Self::visit_frame) them from the resulting [frames](Frame). -/// -/// [^1]: Well, we could with [`TrackedMut`](comemo::TrackedMut), but the -/// overhead is quite high, especially since we need to save & undo the counting -/// when only measuring. -#[derive(Default)] -pub struct Locator<'a> { - /// Maps from a hash to the maximum number we've seen for this hash. This - /// number becomes the `disambiguator`. - hashes: RefCell<HashMap<u128, usize>>, - /// An outer `Locator`, from which we can get disambiguator for hashes - /// outside of the current "layout run". - /// - /// We need to override the constraint's lifetime here so that `Tracked` is - /// covariant over the constraint. If it becomes invariant, we're in for a - /// world of lifetime pain. - outer: Option<Tracked<'a, Self, <Locator<'static> as Validate>::Constraint>>, -} - -impl<'a> Locator<'a> { - /// Create a new locator. - pub fn new() -> Self { - Self::default() - } - - /// Create a new chained locator. - pub fn chained(outer: Tracked<'a, Self>) -> Self { - Self { outer: Some(outer), ..Default::default() } - } - - /// Start tracking this locator. - /// - /// In comparison to [`Track::track`], this method skips this chain link - /// if it does not contribute anything. - pub fn track(&self) -> Tracked<'_, Self> { - match self.outer { - Some(outer) if self.hashes.borrow().is_empty() => outer, - _ => Track::track(self), - } - } - - /// Produce a stable identifier for this call site. - pub fn locate(&mut self, hash: u128) -> Location { - // Get the current disambiguator for this hash. - let disambiguator = self.disambiguator_impl(hash); - - // Bump the next disambiguator up by one. - self.hashes.borrow_mut().insert(hash, disambiguator + 1); - - // Create the location in its default variant. - Location { hash, disambiguator, variant: 0 } - } - - /// Advance past a frame. - pub fn visit_frame(&mut self, frame: &Frame) { - for (_, item) in frame.items() { - match item { - FrameItem::Group(group) => self.visit_frame(&group.frame), - FrameItem::Meta(Meta::Elem(elem), _) => { - let mut hashes = self.hashes.borrow_mut(); - let loc = elem.location().unwrap(); - let entry = hashes.entry(loc.hash).or_default(); - - // Next disambiguator needs to be at least one larger than - // the maximum we've seen so far. - *entry = (*entry).max(loc.disambiguator + 1); - } - _ => {} - } - } - } - - /// Advance past a number of frames. - pub fn visit_frames<'b>(&mut self, frames: impl IntoIterator<Item = &'b Frame>) { - for frame in frames { - self.visit_frame(frame); - } - } - - /// The current disambiguator for the given hash. - fn disambiguator_impl(&self, hash: u128) -> usize { - *self - .hashes - .borrow_mut() - .entry(hash) - .or_insert_with(|| self.outer.map_or(0, |outer| outer.disambiguator(hash))) - } -} - -#[comemo::track] -impl<'a> Locator<'a> { - /// The current disambiguator for the hash. - fn disambiguator(&self, hash: u128) -> usize { - self.disambiguator_impl(hash) - } -} - -/// Can be queried for elements and their positions. -pub struct Introspector { - /// The number of pages in the document. - pages: usize, - /// All introspectable elements. - elems: IndexMap<Location, (Prehashed<Content>, Position)>, - /// The page numberings, indexed by page number minus 1. - page_numberings: Vec<Value>, - /// Caches queries done on the introspector. This is important because - /// even if all top-level queries are distinct, they often have shared - /// subqueries. Example: Individual counter queries with `before` that - /// all depend on a global counter query. - queries: RefCell<HashMap<u128, EcoVec<Prehashed<Content>>>>, -} - -impl Introspector { - /// Create a new introspector. - #[tracing::instrument(skip(frames))] - pub fn new(frames: &[Frame]) -> Self { - let mut introspector = Self { - pages: frames.len(), - elems: IndexMap::new(), - page_numberings: vec![], - queries: RefCell::default(), - }; - for (i, frame) in frames.iter().enumerate() { - let page = NonZeroUsize::new(1 + i).unwrap(); - introspector.extract(frame, page, Transform::identity()); - } - introspector - } - - /// Extract metadata from a frame. - #[tracing::instrument(skip_all)] - fn extract(&mut self, frame: &Frame, page: NonZeroUsize, ts: Transform) { - for (pos, item) in frame.items() { - match item { - FrameItem::Group(group) => { - let ts = ts - .pre_concat(Transform::translate(pos.x, pos.y)) - .pre_concat(group.transform); - self.extract(&group.frame, page, ts); - } - FrameItem::Meta(Meta::Elem(content), _) - if !self.elems.contains_key(&content.location().unwrap()) => - { - let pos = pos.transform(ts); - let ret = self.elems.insert( - content.location().unwrap(), - (Prehashed::new(content.clone()), Position { page, point: pos }), - ); - assert!(ret.is_none(), "duplicate locations"); - } - FrameItem::Meta(Meta::PageNumbering(numbering), _) => { - self.page_numberings.push(numbering.clone()); - } - _ => {} - } - } - } - - /// Iterate over all locatable elements. - pub fn all(&self) -> impl Iterator<Item = &Prehashed<Content>> + '_ { - self.elems.values().map(|(c, _)| c) - } - - /// Get an element by its location. - fn get(&self, location: &Location) -> Option<&Prehashed<Content>> { - self.elems.get(location).map(|(elem, _)| elem) - } - - /// Get the index of this element among all. - fn index(&self, elem: &Content) -> usize { - self.elems - .get_index_of(&elem.location().unwrap()) - .unwrap_or(usize::MAX) - } -} - -#[comemo::track] -impl Introspector { - /// Query for all matching elements. - pub fn query(&self, selector: &Selector) -> EcoVec<Prehashed<Content>> { - let hash = crate::util::hash128(selector); - if let Some(output) = self.queries.borrow().get(&hash) { - return output.clone(); - } - - let output = match selector { - Selector::Elem(..) - | Selector::Label(_) - | Selector::Regex(_) - | Selector::Can(_) - | Selector::Or(_) - | Selector::And(_) => { - self.all().filter(|elem| selector.matches(elem)).cloned().collect() - } - - Selector::Location(location) => { - self.get(location).cloned().into_iter().collect() - } - Selector::Before { selector, end, inclusive } => { - let mut list = self.query(selector); - if let Some(end) = self.query_first(end) { - // Determine which elements are before `end`. - let split = match list - .binary_search_by_key(&self.index(&end), |elem| self.index(elem)) - { - // Element itself is contained. - Ok(i) => i + *inclusive as usize, - // Element itself is not contained. - Err(i) => i, - }; - list = list[..split].into(); - } - list - } - Selector::After { selector, start, inclusive } => { - let mut list = self.query(selector); - if let Some(start) = self.query_first(start) { - // Determine which elements are after `start`. - let split = match list - .binary_search_by_key(&self.index(&start), |elem| { - self.index(elem) - }) { - // Element itself is contained. - Ok(i) => i + !*inclusive as usize, - // Element itself is not contained. - Err(i) => i, - }; - list = list[split..].into(); - } - list - } - }; - - self.queries.borrow_mut().insert(hash, output.clone()); - output - } - - /// Query for the first element that matches the selector. - pub fn query_first(&self, selector: &Selector) -> Option<Prehashed<Content>> { - match selector { - Selector::Location(location) => self.get(location).cloned(), - _ => self.query(selector).first().cloned(), - } - } - - /// Query for a unique element with the label. - pub fn query_label(&self, label: &Label) -> StrResult<Prehashed<Content>> { - let mut found = None; - for elem in self.all().filter(|elem| elem.label() == Some(label)) { - if found.is_some() { - bail!("label occurs multiple times in the document"); - } - found = Some(elem.clone()); - } - found.ok_or_else(|| "label does not exist in the document".into()) - } - - /// The total number pages. - pub fn pages(&self) -> NonZeroUsize { - NonZeroUsize::new(self.pages).unwrap_or(NonZeroUsize::ONE) - } - - /// Gets the page numbering for the given location, if any. - pub fn page_numbering(&self, location: Location) -> Value { - let page = self.page(location); - self.page_numberings.get(page.get() - 1).cloned().unwrap_or_default() - } - - /// Find the page number for the given location. - pub fn page(&self, location: Location) -> NonZeroUsize { - self.position(location).page - } - - /// Find the position for the given location. - pub fn position(&self, location: Location) -> Position { - self.elems - .get(&location) - .map(|(_, loc)| *loc) - .unwrap_or(Position { page: NonZeroUsize::ONE, point: Point::zero() }) - } -} - -impl Default for Introspector { - fn default() -> Self { - Self::new(&[]) - } -} diff --git a/src/model/label.rs b/src/model/label.rs deleted file mode 100644 index ef8f3edd..00000000 --- a/src/model/label.rs +++ /dev/null @@ -1,16 +0,0 @@ -use std::fmt::{self, Debug, Formatter}; - -use ecow::EcoString; - -/// A label for an element. -#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)] -pub struct Label(pub EcoString); - -impl Debug for Label { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "<{}>", self.0) - } -} - -/// Indicates that an element cannot be labelled. -pub trait Unlabellable {} diff --git a/src/model/mod.rs b/src/model/mod.rs deleted file mode 100644 index ee940236..00000000 --- a/src/model/mod.rs +++ /dev/null @@ -1,148 +0,0 @@ -//! The document model. - -mod content; -mod element; -mod introspect; -mod label; -mod realize; -mod selector; -mod styles; - -#[doc(inline)] -pub use typst_macros::element; - -pub use self::content::{Content, MetaElem, PlainText}; -pub use self::element::{Construct, ElemFunc, Element, NativeElemFunc, Set}; -pub use self::introspect::{Introspector, Location, Locator}; -pub use self::label::{Label, Unlabellable}; -pub use self::realize::{ - applicable, realize, Behave, Behaviour, Finalize, Guard, Locatable, Show, Synthesize, -}; -pub use self::selector::{LocatableSelector, Selector, ShowableSelector}; -pub use self::styles::{ - Fold, Property, Recipe, Resolve, Style, StyleChain, StyleVec, StyleVecBuilder, - Styles, Transform, -}; - -use std::mem::ManuallyDrop; - -use comemo::{Track, Tracked, TrackedMut, Validate}; - -use crate::diag::{SourceError, SourceResult}; -use crate::doc::Document; -use crate::eval::Tracer; -use crate::World; - -/// Typeset content into a fully layouted document. -#[comemo::memoize] -#[tracing::instrument(skip(world, tracer, content))] -pub fn typeset( - world: Tracked<dyn World + '_>, - mut tracer: TrackedMut<Tracer>, - content: &Content, -) -> SourceResult<Document> { - tracing::info!("Starting typesetting"); - - let library = world.library(); - let styles = StyleChain::new(&library.styles); - - let mut iter = 0; - let mut document; - let mut delayed; - - // We need `ManuallyDrop` until this lands in stable: - // https://github.com/rust-lang/rust/issues/70919 - let mut introspector = ManuallyDrop::new(Introspector::new(&[])); - - // Relayout until all introspections stabilize. - // If that doesn't happen within five attempts, we give up. - loop { - tracing::info!("Layout iteration {iter}"); - - delayed = DelayedErrors::default(); - - let constraint = <Introspector as Validate>::Constraint::new(); - let mut locator = Locator::new(); - let mut vt = Vt { - world, - tracer: TrackedMut::reborrow_mut(&mut tracer), - locator: &mut locator, - introspector: introspector.track_with(&constraint), - delayed: delayed.track_mut(), - }; - - // Layout! - let result = (library.items.layout)(&mut vt, content, styles)?; - - // Drop the old introspector. - ManuallyDrop::into_inner(introspector); - - // Only now assign the document and construct the new introspector. - document = result; - introspector = ManuallyDrop::new(Introspector::new(&document.pages)); - iter += 1; - - if iter >= 5 || introspector.validate(&constraint) { - break; - } - } - - // Drop the introspector. - ManuallyDrop::into_inner(introspector); - - // Promote delayed errors. - if !delayed.0.is_empty() { - return Err(Box::new(delayed.0)); - } - - Ok(document) -} - -/// A virtual typesetter. -/// -/// Holds the state needed to [typeset] content. -pub struct Vt<'a> { - /// The compilation environment. - pub world: Tracked<'a, dyn World + 'a>, - /// Provides access to information about the document. - pub introspector: Tracked<'a, Introspector>, - /// Provides stable identities to elements. - pub locator: &'a mut Locator<'a>, - /// Delayed errors that do not immediately terminate execution. - pub delayed: TrackedMut<'a, DelayedErrors>, - /// The tracer for inspection of the values an expression produces. - pub tracer: TrackedMut<'a, Tracer>, -} - -impl Vt<'_> { - /// Perform a fallible operation that does not immediately terminate further - /// execution. Instead it produces a delayed error that is only promoted to - /// a fatal one if it remains at the end of the introspection loop. - pub fn delayed<F, T>(&mut self, f: F) -> T - where - F: FnOnce(&mut Self) -> SourceResult<T>, - T: Default, - { - match f(self) { - Ok(value) => value, - Err(errors) => { - for error in *errors { - self.delayed.push(error); - } - T::default() - } - } - } -} - -/// Holds delayed errors. -#[derive(Default, Clone)] -pub struct DelayedErrors(Vec<SourceError>); - -#[comemo::track] -impl DelayedErrors { - /// Push a delayed error. - fn push(&mut self, error: SourceError) { - self.0.push(error); - } -} diff --git a/src/model/realize.rs b/src/model/realize.rs deleted file mode 100644 index 01c46b81..00000000 --- a/src/model/realize.rs +++ /dev/null @@ -1,228 +0,0 @@ -use super::{Content, ElemFunc, Element, MetaElem, Recipe, Selector, StyleChain, Vt}; -use crate::diag::SourceResult; -use crate::doc::Meta; -use crate::util::hash128; - -/// Whether the target is affected by show rules in the given style chain. -pub fn applicable(target: &Content, styles: StyleChain) -> bool { - if target.needs_preparation() { - return true; - } - - if target.can::<dyn Show>() && target.is_pristine() { - return true; - } - - // Find out how many recipes there are. - let mut n = styles.recipes().count(); - - // Find out whether any recipe matches and is unguarded. - for recipe in styles.recipes() { - if recipe.applicable(target) && !target.is_guarded(Guard::Nth(n)) { - return true; - } - n -= 1; - } - - false -} - -/// Apply the show rules in the given style chain to a target. -pub fn realize( - vt: &mut Vt, - target: &Content, - styles: StyleChain, -) -> SourceResult<Option<Content>> { - // Pre-process. - if target.needs_preparation() { - let mut elem = target.clone(); - if target.can::<dyn Locatable>() || target.label().is_some() { - let location = vt.locator.locate(hash128(target)); - elem.set_location(location); - } - - if let Some(elem) = elem.with_mut::<dyn Synthesize>() { - elem.synthesize(vt, styles)?; - } - - elem.mark_prepared(); - - if elem.location().is_some() { - let span = elem.span(); - let meta = Meta::Elem(elem.clone()); - return Ok(Some( - (elem + MetaElem::new().pack().spanned(span)) - .styled(MetaElem::set_data(vec![meta])), - )); - } - - return Ok(Some(elem)); - } - - // Find out how many recipes there are. - let mut n = styles.recipes().count(); - - // Find an applicable recipe. - let mut realized = None; - for recipe in styles.recipes() { - let guard = Guard::Nth(n); - if recipe.applicable(target) && !target.is_guarded(guard) { - if let Some(content) = try_apply(vt, target, recipe, guard)? { - realized = Some(content); - break; - } - } - n -= 1; - } - - // Realize if there was no matching recipe. - if let Some(showable) = target.with::<dyn Show>() { - let guard = Guard::Base(target.func()); - if realized.is_none() && !target.is_guarded(guard) { - realized = Some(showable.show(vt, styles)?); - } - } - - // Finalize only if this is the first application for this element. - if let Some(elem) = target.with::<dyn Finalize>() { - if target.is_pristine() { - if let Some(already) = realized { - realized = Some(elem.finalize(already, styles)); - } - } - } - - Ok(realized) -} - -/// Try to apply a recipe to the target. -fn try_apply( - vt: &mut Vt, - target: &Content, - recipe: &Recipe, - guard: Guard, -) -> SourceResult<Option<Content>> { - match &recipe.selector { - Some(Selector::Elem(element, _)) => { - if target.func() != *element { - return Ok(None); - } - - recipe.apply_vt(vt, target.clone().guarded(guard)).map(Some) - } - - Some(Selector::Label(label)) => { - if target.label() != Some(label) { - return Ok(None); - } - - recipe.apply_vt(vt, target.clone().guarded(guard)).map(Some) - } - - Some(Selector::Regex(regex)) => { - let Some(text) = item!(text_str)(target) else { - return Ok(None); - }; - - let make = |s: &str| target.clone().with_field("text", s); - let mut result = vec![]; - let mut cursor = 0; - - for m in regex.find_iter(&text) { - let start = m.start(); - if cursor < start { - result.push(make(&text[cursor..start])); - } - - let piece = make(m.as_str()).guarded(guard); - let transformed = recipe.apply_vt(vt, piece)?; - result.push(transformed); - cursor = m.end(); - } - - if result.is_empty() { - return Ok(None); - } - - if cursor < text.len() { - result.push(make(&text[cursor..])); - } - - Ok(Some(Content::sequence(result))) - } - - // Not supported here. - Some( - Selector::Or(_) - | Selector::And(_) - | Selector::Location(_) - | Selector::Can(_) - | Selector::Before { .. } - | Selector::After { .. }, - ) => Ok(None), - - None => Ok(None), - } -} - -/// Makes this element locatable through `vt.locate`. -pub trait Locatable {} - -/// Synthesize fields on an element. This happens before execution of any show -/// rule. -pub trait Synthesize { - /// Prepare the element for show rule application. - fn synthesize(&mut self, vt: &mut Vt, styles: StyleChain) -> SourceResult<()>; -} - -/// The base recipe for an element. -pub trait Show { - /// Execute the base recipe for this element. - fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content>; -} - -/// Post-process an element after it was realized. -pub trait Finalize { - /// Finalize the fully realized form of the element. Use this for effects - /// that should work even in the face of a user-defined show rule. - fn finalize(&self, realized: Content, styles: StyleChain) -> Content; -} - -/// How the element interacts with other elements. -pub trait Behave { - /// The element's interaction behaviour. - fn behaviour(&self) -> Behaviour; - - /// Whether this weak element is larger than a previous one and thus picked - /// as the maximum when the levels are the same. - #[allow(unused_variables)] - fn larger(&self, prev: &Content) -> bool { - false - } -} - -/// How an element interacts with other elements in a stream. -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub enum Behaviour { - /// A weak element which only survives when a supportive element is before - /// and after it. Furthermore, per consecutive run of weak elements, only - /// one survives: The one with the lowest weakness level (or the larger one - /// if there is a tie). - Weak(usize), - /// An element that enables adjacent weak elements to exist. The default. - Supportive, - /// An element that destroys adjacent weak elements. - Destructive, - /// An element that does not interact at all with other elements, having the - /// same effect as if it didn't exist. - Ignorant, -} - -/// Guards content against being affected by the same show rule multiple times. -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub enum Guard { - /// The nth recipe from the top of the chain. - Nth(usize), - /// The [base recipe](Show) for a kind of element. - Base(ElemFunc), -} diff --git a/src/model/selector.rs b/src/model/selector.rs deleted file mode 100644 index 9723ee4f..00000000 --- a/src/model/selector.rs +++ /dev/null @@ -1,296 +0,0 @@ -use std::any::{Any, TypeId}; -use std::fmt::{self, Debug, Formatter, Write}; -use std::sync::Arc; - -use ecow::{eco_format, EcoString, EcoVec}; - -use super::{Content, ElemFunc, Label, Location}; -use crate::diag::{bail, StrResult}; -use crate::eval::{ - cast, CastInfo, Dict, FromValue, Func, IntoValue, Reflect, Regex, Value, -}; -use crate::model::Locatable; -use crate::util::pretty_array_like; - -/// A selector in a show rule. -#[derive(Clone, PartialEq, Hash)] -pub enum Selector { - /// Matches a specific type of element. - /// - /// If there is a dictionary, only elements with the fields from the - /// dictionary match. - Elem(ElemFunc, Option<Dict>), - /// Matches the element at the specified location. - Location(Location), - /// Matches elements with a specific label. - Label(Label), - /// Matches text elements through a regular expression. - Regex(Regex), - /// Matches elements with a specific capability. - Can(TypeId), - /// Matches if any of the subselectors match. - Or(EcoVec<Self>), - /// Matches if all of the subselectors match. - And(EcoVec<Self>), - /// Matches all matches of `selector` before `end`. - Before { selector: Arc<Self>, end: Arc<Self>, inclusive: bool }, - /// Matches all matches of `selector` after `start`. - After { selector: Arc<Self>, start: Arc<Self>, inclusive: bool }, -} - -impl Selector { - /// Define a simple text selector. - pub fn text(text: &str) -> Self { - Self::Regex(Regex::new(®ex::escape(text)).unwrap()) - } - - /// Define a simple [`Selector::Can`] selector. - pub fn can<T: ?Sized + Any>() -> Self { - Self::Can(TypeId::of::<T>()) - } - - /// Transforms this selector and an iterator of other selectors into a - /// [`Selector::Or`] selector. - pub fn and(self, others: impl IntoIterator<Item = Self>) -> Self { - Self::And(others.into_iter().chain(Some(self)).collect()) - } - - /// Transforms this selector and an iterator of other selectors into a - /// [`Selector::And`] selector. - pub fn or(self, others: impl IntoIterator<Item = Self>) -> Self { - Self::Or(others.into_iter().chain(Some(self)).collect()) - } - - /// Transforms this selector into a [`Selector::Before`] selector. - pub fn before(self, location: impl Into<Self>, inclusive: bool) -> Self { - Self::Before { - selector: Arc::new(self), - end: Arc::new(location.into()), - inclusive, - } - } - - /// Transforms this selector into a [`Selector::After`] selector. - pub fn after(self, location: impl Into<Self>, inclusive: bool) -> Self { - Self::After { - selector: Arc::new(self), - start: Arc::new(location.into()), - inclusive, - } - } - - /// Whether the selector matches for the target. - pub fn matches(&self, target: &Content) -> bool { - match self { - Self::Elem(element, dict) => { - target.func() == *element - && dict - .iter() - .flat_map(|dict| dict.iter()) - .all(|(name, value)| target.field_ref(name) == Some(value)) - } - Self::Label(label) => target.label() == Some(label), - Self::Regex(regex) => { - target.func() == item!(text_func) - && item!(text_str)(target).map_or(false, |text| regex.is_match(&text)) - } - Self::Can(cap) => target.can_type_id(*cap), - Self::Or(selectors) => selectors.iter().any(move |sel| sel.matches(target)), - Self::And(selectors) => selectors.iter().all(move |sel| sel.matches(target)), - Self::Location(location) => target.location() == Some(*location), - // Not supported here. - Self::Before { .. } | Self::After { .. } => false, - } - } -} - -impl From<Location> for Selector { - fn from(value: Location) -> Self { - Self::Location(value) - } -} - -impl Debug for Selector { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - match self { - Self::Elem(elem, dict) => { - f.write_str(elem.name())?; - if let Some(dict) = dict { - f.write_str(".where")?; - dict.fmt(f)?; - } - Ok(()) - } - Self::Label(label) => label.fmt(f), - Self::Regex(regex) => regex.fmt(f), - Self::Can(cap) => cap.fmt(f), - Self::Or(selectors) | Self::And(selectors) => { - f.write_str(if matches!(self, Self::Or(_)) { "or" } else { "and" })?; - let pieces: Vec<_> = - selectors.iter().map(|sel| eco_format!("{sel:?}")).collect(); - f.write_str(&pretty_array_like(&pieces, false)) - } - Self::Location(loc) => loc.fmt(f), - Self::Before { selector, end: split, inclusive } - | Self::After { selector, start: split, inclusive } => { - selector.fmt(f)?; - - if matches!(self, Self::Before { .. }) { - f.write_str(".before(")?; - } else { - f.write_str(".after(")?; - } - - split.fmt(f)?; - if !*inclusive { - f.write_str(", inclusive: false")?; - } - f.write_char(')') - } - } - } -} - -cast! { - type Selector: "selector", - func: Func => func - .element() - .ok_or("only element functions can be used as selectors")? - .select(), - label: Label => Self::Label(label), - text: EcoString => Self::text(&text), - regex: Regex => Self::Regex(regex), - location: Location => Self::Location(location), -} - -/// A selector that can be used with `query`. -/// -/// Hopefully, this is made obsolete by a more powerful query mechanism in the -/// future. -#[derive(Clone, PartialEq, Hash)] -pub struct LocatableSelector(pub Selector); - -impl Reflect for LocatableSelector { - fn describe() -> CastInfo { - CastInfo::Union(vec![ - CastInfo::Type("function"), - CastInfo::Type("label"), - CastInfo::Type("selector"), - ]) - } - - fn castable(value: &Value) -> bool { - matches!(value.type_name(), "function" | "label" | "selector") - } -} - -impl IntoValue for LocatableSelector { - fn into_value(self) -> Value { - self.0.into_value() - } -} - -impl FromValue for LocatableSelector { - fn from_value(value: Value) -> StrResult<Self> { - fn validate(selector: &Selector) -> StrResult<()> { - match selector { - Selector::Elem(elem, _) => { - if !elem.can::<dyn Locatable>() { - Err(eco_format!("{} is not locatable", elem.name()))? - } - } - Selector::Location(_) => {} - Selector::Label(_) => {} - Selector::Regex(_) => bail!("text is not locatable"), - Selector::Can(_) => bail!("capability is not locatable"), - Selector::Or(list) | Selector::And(list) => { - for selector in list { - validate(selector)?; - } - } - Selector::Before { selector, end: split, .. } - | Selector::After { selector, start: split, .. } => { - for selector in [selector, split] { - validate(selector)?; - } - } - } - Ok(()) - } - - if !Self::castable(&value) { - return Err(Self::error(&value)); - } - - let selector = Selector::from_value(value)?; - validate(&selector)?; - Ok(Self(selector)) - } -} - -/// A selector that can be used with show rules. -/// -/// Hopefully, this is made obsolete by a more powerful showing mechanism in the -/// future. -#[derive(Clone, PartialEq, Hash)] -pub struct ShowableSelector(pub Selector); - -impl Reflect for ShowableSelector { - fn describe() -> CastInfo { - CastInfo::Union(vec![ - CastInfo::Type("function"), - CastInfo::Type("label"), - CastInfo::Type("string"), - CastInfo::Type("regular expression"), - CastInfo::Type("symbol"), - CastInfo::Type("selector"), - ]) - } - - fn castable(value: &Value) -> bool { - matches!( - value.type_name(), - "symbol" - | "string" - | "label" - | "function" - | "regular expression" - | "selector" - ) - } -} - -impl IntoValue for ShowableSelector { - fn into_value(self) -> Value { - self.0.into_value() - } -} - -impl FromValue for ShowableSelector { - fn from_value(value: Value) -> StrResult<Self> { - fn validate(selector: &Selector) -> StrResult<()> { - match selector { - Selector::Elem(_, _) => {} - Selector::Label(_) => {} - Selector::Regex(_) => {} - Selector::Or(_) - | Selector::And(_) - | Selector::Location(_) - | Selector::Can(_) - | Selector::Before { .. } - | Selector::After { .. } => { - bail!("this selector cannot be used with show") - } - } - Ok(()) - } - - if !Self::castable(&value) { - return Err(Self::error(&value)); - } - - let selector = Selector::from_value(value)?; - validate(&selector)?; - Ok(Self(selector)) - } -} diff --git a/src/model/styles.rs b/src/model/styles.rs deleted file mode 100644 index 23748a3f..00000000 --- a/src/model/styles.rs +++ /dev/null @@ -1,750 +0,0 @@ -use std::fmt::{self, Debug, Formatter, Write}; -use std::iter; -use std::mem; -use std::ptr; - -use comemo::Prehashed; -use ecow::{eco_vec, EcoString, EcoVec}; - -use super::{Content, ElemFunc, Element, Selector, Vt}; -use crate::diag::{SourceResult, Trace, Tracepoint}; -use crate::eval::{cast, Args, FromValue, Func, IntoValue, Value, Vm}; -use crate::syntax::Span; - -/// A list of style properties. -#[derive(Default, PartialEq, Clone, Hash)] -pub struct Styles(EcoVec<Prehashed<Style>>); - -impl Styles { - /// Create a new, empty style list. - pub fn new() -> Self { - Self::default() - } - - /// Whether this contains no styles. - pub fn is_empty(&self) -> bool { - self.0.is_empty() - } - - /// Set an inner value for a style property. - /// - /// If the property needs folding and the value is already contained in the - /// style map, `self` contributes the outer values and `value` is the inner - /// one. - pub fn set(&mut self, style: impl Into<Style>) { - self.0.push(Prehashed::new(style.into())); - } - - /// Remove the style that was last set. - pub fn unset(&mut self) { - self.0.pop(); - } - - /// Apply outer styles. Like [`chain`](StyleChain::chain), but in-place. - pub fn apply(&mut self, mut outer: Self) { - outer.0.extend(mem::take(self).0.into_iter()); - *self = outer; - } - - /// Apply one outer styles. - pub fn apply_one(&mut self, outer: Style) { - self.0.insert(0, Prehashed::new(outer)); - } - - /// Apply a slice of outer styles. - pub fn apply_slice(&mut self, outer: &[Prehashed<Style>]) { - self.0 = outer.iter().cloned().chain(mem::take(self).0.into_iter()).collect(); - } - - /// Add an origin span to all contained properties. - pub fn spanned(mut self, span: Span) -> Self { - for entry in self.0.make_mut() { - entry.update(|entry| { - if let Style::Property(property) = entry { - property.span = Some(span); - } - }); - } - self - } - - /// Returns `Some(_)` with an optional span if this list contains - /// styles for the given element. - pub fn interruption<T: Element>(&self) -> Option<Option<Span>> { - let func = T::func(); - self.0.iter().find_map(|entry| match &**entry { - Style::Property(property) => property.is_of(func).then_some(property.span), - Style::Recipe(recipe) => recipe.is_of(func).then_some(Some(recipe.span)), - }) - } -} - -impl From<Style> for Styles { - fn from(entry: Style) -> Self { - Self(eco_vec![Prehashed::new(entry)]) - } -} - -impl Debug for Styles { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - f.pad("..") - } -} - -/// A single style property or recipe. -#[derive(Clone, PartialEq, Hash)] -pub enum Style { - /// A style property originating from a set rule or constructor. - Property(Property), - /// A show rule recipe. - Recipe(Recipe), -} - -impl Style { - /// If this is a property, return it. - pub fn property(&self) -> Option<&Property> { - match self { - Self::Property(property) => Some(property), - _ => None, - } - } - - /// If this is a recipe, return it. - pub fn recipe(&self) -> Option<&Recipe> { - match self { - Self::Recipe(recipe) => Some(recipe), - _ => None, - } - } -} - -impl Debug for Style { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - match self { - Self::Property(property) => property.fmt(f), - Self::Recipe(recipe) => recipe.fmt(f), - } - } -} - -impl From<Property> for Style { - fn from(property: Property) -> Self { - Self::Property(property) - } -} - -impl From<Recipe> for Style { - fn from(recipe: Recipe) -> Self { - Self::Recipe(recipe) - } -} - -/// A style property originating from a set rule or constructor. -#[derive(Clone, PartialEq, Hash)] -pub struct Property { - /// The element the property belongs to. - element: ElemFunc, - /// The property's name. - name: EcoString, - /// The property's value. - value: Value, - /// The span of the set rule the property stems from. - span: Option<Span>, -} - -impl Property { - /// Create a new property from a key-value pair. - pub fn new( - element: ElemFunc, - name: impl Into<EcoString>, - value: impl IntoValue, - ) -> Self { - Self { - element, - name: name.into(), - value: value.into_value(), - span: None, - } - } - - /// Whether this property is the given one. - pub fn is(&self, element: ElemFunc, name: &str) -> bool { - self.element == element && self.name == name - } - - /// Whether this property belongs to the given element. - pub fn is_of(&self, element: ElemFunc) -> bool { - self.element == element - } -} - -impl Debug for Property { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "set {}({}: {:?})", self.element.name(), self.name, self.value)?; - Ok(()) - } -} - -/// A show rule recipe. -#[derive(Clone, PartialEq, Hash)] -pub struct Recipe { - /// The span errors are reported with. - pub span: Span, - /// Determines whether the recipe applies to an element. - pub selector: Option<Selector>, - /// The transformation to perform on the match. - pub transform: Transform, -} - -impl Recipe { - /// Whether this recipe is for the given type of element. - pub fn is_of(&self, element: ElemFunc) -> bool { - match self.selector { - Some(Selector::Elem(own, _)) => own == element, - _ => false, - } - } - - /// Whether the recipe is applicable to the target. - pub fn applicable(&self, target: &Content) -> bool { - self.selector - .as_ref() - .map_or(false, |selector| selector.matches(target)) - } - - /// Apply the recipe to the given content. - pub fn apply_vm(&self, vm: &mut Vm, content: Content) -> SourceResult<Content> { - match &self.transform { - Transform::Content(content) => Ok(content.clone()), - Transform::Func(func) => { - let args = Args::new(self.span, [Value::Content(content.clone())]); - let mut result = func.call_vm(vm, args); - // For selector-less show rules, a tracepoint makes no sense. - if self.selector.is_some() { - let point = || Tracepoint::Show(content.func().name().into()); - result = result.trace(vm.world(), point, content.span()); - } - Ok(result?.display()) - } - Transform::Style(styles) => Ok(content.styled_with_map(styles.clone())), - } - } - - /// Apply the recipe to the given content. - pub fn apply_vt(&self, vt: &mut Vt, content: Content) -> SourceResult<Content> { - match &self.transform { - Transform::Content(content) => Ok(content.clone()), - Transform::Func(func) => { - let mut result = func.call_vt(vt, [Value::Content(content.clone())]); - if self.selector.is_some() { - let point = || Tracepoint::Show(content.func().name().into()); - result = result.trace(vt.world, point, content.span()); - } - Ok(result?.display()) - } - Transform::Style(styles) => Ok(content.styled_with_map(styles.clone())), - } - } -} - -impl Debug for Recipe { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - f.write_str("show")?; - if let Some(selector) = &self.selector { - f.write_char(' ')?; - selector.fmt(f)?; - } - f.write_str(": ")?; - self.transform.fmt(f) - } -} - -/// A show rule transformation that can be applied to a match. -#[derive(Clone, PartialEq, Hash)] -pub enum Transform { - /// Replacement content. - Content(Content), - /// A function to apply to the match. - Func(Func), - /// Apply styles to the content. - Style(Styles), -} - -impl Debug for Transform { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - match self { - Self::Content(content) => content.fmt(f), - Self::Func(func) => func.fmt(f), - Self::Style(styles) => styles.fmt(f), - } - } -} - -cast! { - Transform, - content: Content => Self::Content(content), - func: Func => Self::Func(func), -} - -/// A chain of styles, similar to a linked list. -/// -/// A style chain allows to combine properties from multiple style lists in a -/// element hierarchy in a non-allocating way. Rather than eagerly merging the -/// lists, each access walks the hierarchy from the innermost to the outermost -/// map, trying to find a match and then folding it with matches further up the -/// chain. -#[derive(Default, Clone, Copy, Hash)] -pub struct StyleChain<'a> { - /// The first link of this chain. - head: &'a [Prehashed<Style>], - /// The remaining links in the chain. - tail: Option<&'a Self>, -} - -impl<'a> StyleChain<'a> { - /// Start a new style chain with root styles. - pub fn new(root: &'a Styles) -> Self { - Self { head: &root.0, tail: None } - } - - /// Make the given style list the first link of this chain. - /// - /// The resulting style chain contains styles from `local` as well as - /// `self`. The ones from `local` take precedence over the ones from - /// `self`. For folded properties `local` contributes the inner value. - pub fn chain<'b>(&'b self, local: &'b Styles) -> StyleChain<'b> { - if local.is_empty() { - *self - } else { - StyleChain { head: &local.0, tail: Some(self) } - } - } - - /// Cast the first value for the given property in the chain. - pub fn get<T: FromValue>( - self, - func: ElemFunc, - name: &'a str, - inherent: Option<Value>, - default: impl Fn() -> T, - ) -> T { - self.properties::<T>(func, name, inherent) - .next() - .unwrap_or_else(default) - } - - /// Cast the first value for the given property in the chain. - pub fn get_resolve<T: FromValue + Resolve>( - self, - func: ElemFunc, - name: &'a str, - inherent: Option<Value>, - default: impl Fn() -> T, - ) -> T::Output { - self.get(func, name, inherent, default).resolve(self) - } - - /// Cast the first value for the given property in the chain. - pub fn get_fold<T: FromValue + Fold>( - self, - func: ElemFunc, - name: &'a str, - inherent: Option<Value>, - default: impl Fn() -> T::Output, - ) -> T::Output { - fn next<T: Fold>( - mut values: impl Iterator<Item = T>, - _styles: StyleChain, - default: &impl Fn() -> T::Output, - ) -> T::Output { - values - .next() - .map(|value| value.fold(next(values, _styles, default))) - .unwrap_or_else(default) - } - next(self.properties::<T>(func, name, inherent), self, &default) - } - - /// Cast the first value for the given property in the chain. - pub fn get_resolve_fold<T>( - self, - func: ElemFunc, - name: &'a str, - inherent: Option<Value>, - default: impl Fn() -> <T::Output as Fold>::Output, - ) -> <T::Output as Fold>::Output - where - T: FromValue + Resolve, - T::Output: Fold, - { - fn next<T>( - mut values: impl Iterator<Item = T>, - styles: StyleChain, - default: &impl Fn() -> <T::Output as Fold>::Output, - ) -> <T::Output as Fold>::Output - where - T: Resolve, - T::Output: Fold, - { - values - .next() - .map(|value| value.resolve(styles).fold(next(values, styles, default))) - .unwrap_or_else(default) - } - next(self.properties::<T>(func, name, inherent), self, &default) - } - - /// Iterate over all style recipes in the chain. - pub fn recipes(self) -> impl Iterator<Item = &'a Recipe> { - self.entries().filter_map(Style::recipe) - } - - /// Iterate over all values for the given property in the chain. - pub fn properties<T: FromValue + 'a>( - self, - func: ElemFunc, - name: &'a str, - inherent: Option<Value>, - ) -> impl Iterator<Item = T> + '_ { - inherent - .into_iter() - .chain( - self.entries() - .filter_map(Style::property) - .filter(move |property| property.is(func, name)) - .map(|property| property.value.clone()), - ) - .map(move |value| { - value.cast().unwrap_or_else(|err| { - panic!("{} (for {}.{})", err, func.name(), name) - }) - }) - } - - /// Convert to a style map. - pub fn to_map(self) -> Styles { - let mut suffix = Styles::new(); - for link in self.links() { - suffix.apply_slice(link); - } - suffix - } - - /// Iterate over the entries of the chain. - fn entries(self) -> Entries<'a> { - Entries { inner: [].as_slice().iter(), links: self.links() } - } - - /// Iterate over the links of the chain. - fn links(self) -> Links<'a> { - Links(Some(self)) - } - - /// Build owned styles from the suffix (all links beyond the `len`) of the - /// chain. - fn suffix(self, len: usize) -> Styles { - let mut suffix = Styles::new(); - let take = self.links().count().saturating_sub(len); - for link in self.links().take(take) { - suffix.apply_slice(link); - } - suffix - } - - /// Remove the last link from the chain. - fn pop(&mut self) { - *self = self.tail.copied().unwrap_or_default(); - } -} - -impl Debug for StyleChain<'_> { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - for entry in self.entries().collect::<Vec<_>>().into_iter().rev() { - writeln!(f, "{:?}", entry)?; - } - Ok(()) - } -} - -impl PartialEq for StyleChain<'_> { - fn eq(&self, other: &Self) -> bool { - ptr::eq(self.head, other.head) - && match (self.tail, other.tail) { - (Some(a), Some(b)) => ptr::eq(a, b), - (None, None) => true, - _ => false, - } - } -} - -/// An iterator over the entries in a style chain. -struct Entries<'a> { - inner: std::slice::Iter<'a, Prehashed<Style>>, - links: Links<'a>, -} - -impl<'a> Iterator for Entries<'a> { - type Item = &'a Style; - - fn next(&mut self) -> Option<Self::Item> { - loop { - if let Some(entry) = self.inner.next_back() { - return Some(entry); - } - - match self.links.next() { - Some(next) => self.inner = next.iter(), - None => return None, - } - } - } -} - -/// An iterator over the links of a style chain. -struct Links<'a>(Option<StyleChain<'a>>); - -impl<'a> Iterator for Links<'a> { - type Item = &'a [Prehashed<Style>]; - - fn next(&mut self) -> Option<Self::Item> { - let StyleChain { head, tail } = self.0?; - self.0 = tail.copied(); - Some(head) - } -} - -/// A sequence of items with associated styles. -#[derive(Clone, Hash)] -pub struct StyleVec<T> { - items: Vec<T>, - styles: Vec<(Styles, usize)>, -} - -impl<T> StyleVec<T> { - /// Whether there are any items in the sequence. - pub fn is_empty(&self) -> bool { - self.items.is_empty() - } - - /// Number of items in the sequence. - pub fn len(&self) -> usize { - self.items.len() - } - - /// Insert an item in the front. The item will share the style of the - /// current first item. - /// - /// This method has no effect if the vector is empty. - pub fn push_front(&mut self, item: T) { - if !self.styles.is_empty() { - self.items.insert(0, item); - self.styles[0].1 += 1; - } - } - - /// Map the contained items. - pub fn map<F, U>(&self, f: F) -> StyleVec<U> - where - F: FnMut(&T) -> U, - { - StyleVec { - items: self.items.iter().map(f).collect(), - styles: self.styles.clone(), - } - } - - /// Iterate over references to the contained items and associated styles. - pub fn iter(&self) -> impl Iterator<Item = (&T, &Styles)> + '_ { - self.items().zip( - self.styles - .iter() - .flat_map(|(map, count)| iter::repeat(map).take(*count)), - ) - } - - /// Iterate over the contained items. - pub fn items(&self) -> std::slice::Iter<'_, T> { - self.items.iter() - } - - /// Iterate over the contained style lists. Note that zipping this with - /// `items()` does not yield the same result as calling `iter()` because - /// this method only returns lists once that are shared by consecutive - /// items. This method is designed for use cases where you want to check, - /// for example, whether any of the lists fulfills a specific property. - pub fn styles(&self) -> impl Iterator<Item = &Styles> { - self.styles.iter().map(|(map, _)| map) - } -} - -impl StyleVec<Content> { - pub fn to_vec(self) -> Vec<Content> { - self.items - .into_iter() - .zip( - self.styles - .iter() - .flat_map(|(map, count)| iter::repeat(map).take(*count)), - ) - .map(|(content, styles)| content.styled_with_map(styles.clone())) - .collect() - } -} - -impl<T> Default for StyleVec<T> { - fn default() -> Self { - Self { items: vec![], styles: vec![] } - } -} - -impl<T> FromIterator<T> for StyleVec<T> { - fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self { - let items: Vec<_> = iter.into_iter().collect(); - let styles = vec![(Styles::new(), items.len())]; - Self { items, styles } - } -} - -impl<T: Debug> Debug for StyleVec<T> { - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - f.debug_list() - .entries(self.iter().map(|(item, styles)| { - crate::util::debug(|f| { - styles.fmt(f)?; - item.fmt(f) - }) - })) - .finish() - } -} - -/// Assists in the construction of a [`StyleVec`]. -#[derive(Debug)] -pub struct StyleVecBuilder<'a, T> { - items: Vec<T>, - chains: Vec<(StyleChain<'a>, usize)>, -} - -impl<'a, T> StyleVecBuilder<'a, T> { - /// Create a new style-vec builder. - pub fn new() -> Self { - Self { items: vec![], chains: vec![] } - } - - /// Whether the builder is empty. - pub fn is_empty(&self) -> bool { - self.items.is_empty() - } - - /// Push a new item into the style vector. - pub fn push(&mut self, item: T, styles: StyleChain<'a>) { - self.items.push(item); - - if let Some((prev, count)) = self.chains.last_mut() { - if *prev == styles { - *count += 1; - return; - } - } - - self.chains.push((styles, 1)); - } - - /// Iterate over the contained items. - pub fn elems(&self) -> std::slice::Iter<'_, T> { - self.items.iter() - } - - /// Finish building, returning a pair of two things: - /// - a style vector of items with the non-shared styles - /// - a shared prefix chain of styles that apply to all items - pub fn finish(self) -> (StyleVec<T>, StyleChain<'a>) { - let mut iter = self.chains.iter(); - let mut trunk = match iter.next() { - Some(&(chain, _)) => chain, - None => return Default::default(), - }; - - let mut shared = trunk.links().count(); - for &(mut chain, _) in iter { - let len = chain.links().count(); - if len < shared { - for _ in 0..shared - len { - trunk.pop(); - } - shared = len; - } else if len > shared { - for _ in 0..len - shared { - chain.pop(); - } - } - - while shared > 0 && chain != trunk { - trunk.pop(); - chain.pop(); - shared -= 1; - } - } - - let styles = self - .chains - .into_iter() - .map(|(chain, count)| (chain.suffix(shared), count)) - .collect(); - - (StyleVec { items: self.items, styles }, trunk) - } -} - -impl<'a, T> Default for StyleVecBuilder<'a, T> { - fn default() -> Self { - Self::new() - } -} - -/// A property that is resolved with other properties from the style chain. -pub trait Resolve { - /// The type of the resolved output. - type Output; - - /// Resolve the value using the style chain. - fn resolve(self, styles: StyleChain) -> Self::Output; -} - -impl<T: Resolve> Resolve for Option<T> { - type Output = Option<T::Output>; - - fn resolve(self, styles: StyleChain) -> Self::Output { - self.map(|v| v.resolve(styles)) - } -} - -/// A property that is folded to determine its final value. -/// -/// In the example below, the chain of stroke values is folded into a single -/// value: `4pt + red`. -/// -/// ```example -/// #set rect(stroke: red) -/// #set rect(stroke: 4pt) -/// #rect() -/// ``` -pub trait Fold { - /// The type of the folded output. - type Output; - - /// Fold this inner value with an outer folded value. - fn fold(self, outer: Self::Output) -> Self::Output; -} - -impl<T> Fold for Option<T> -where - T: Fold, - T::Output: Default, -{ - type Output = Option<T::Output>; - - fn fold(self, outer: Self::Output) -> Self::Output { - self.map(|inner| inner.fold(outer.unwrap_or_default())) - } -} |