From ebfdb1dafa430786db10dad2ef7d5467c1bdbed1 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Sun, 2 Jul 2023 19:59:52 +0200
Subject: Move everything into `crates/` directory

---
 src/model/content.rs | 614 ---------------------------------------------------
 1 file changed, 614 deletions(-)
 delete mode 100644 src/model/content.rs

(limited to 'src/model/content.rs')

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)
-    )
-}
-- 
cgit v1.2.3