Impl builder

.gitignore

@@ -1,2 +1,5 @@
 /target
 /Cargo.lock
+
+*.html
+*.js

Cargo.toml

@@ -9,4 +9,7 @@ license = "Apache-2.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lints.clippy]
+nursery = "warn"
+
 [dependencies]

src/attributes.rs

@@ -0,0 +1,75 @@
+/// Direction for [`Attribute::Dir`].
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Dir {
+    RightToLeft,
+    LeftToRight,
+}
+
+/// ScriptLevel for [`Attribute::ScriptLevel`].
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ScriptLevel {
+    Add(usize),
+    Sub(usize),
+    Num(usize),
+}
+
+/// Attribute of a MathML element.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Attribute {
+    /// Class of the element, same as in HTML.
+    Class(String),
+
+    /// Data attribute with custom name and value (e.g. `data-name="value"`).
+    Data {
+        /// Name of the data attribute, the part after `data-` prefix. e.g. `data-abc="2"` has the
+        /// name "abc".
+        name: String,
+
+        /// The value of the data attribute. e.g. `data-name="test"` has value "test".
+        value: String,
+    },
+
+    /// Direction of the math element. Must be either `rtl` (`RightToLeft`) or `ltr`
+    /// (`LeftToRight`).
+    Dir(Dir),
+
+    /// Display style of the element, `true` maps to `normal` and `false` to `compact`.
+    DisplayStyle(bool),
+
+    /// Id of the element, same as in HTML.
+    Id(String),
+
+    /// Presentational hint for the background color of the element. Must be a value that is
+    /// [color](https://www.w3.org/TR/css-color-4/#propdef-color)
+    MathBackground(String),
+
+    /// Presentational hint for the color of the element. Must be a value that is
+    /// [color](https://www.w3.org/TR/css-color-4/#propdef-color).
+    MathColor(String),
+
+    /// Presentational hint for the font size of the element. Must be a value that is
+    /// [length-percentage](https://www.w3.org/TR/css-values-4/#typedef-length-percentage).
+    MathSize(String),
+
+    /// The `nonce` attribute, same as in HTML.
+    Nonce(String),
+
+    /// Presentational hint for setting the element's math-depth property to the corresponding
+    /// value. Can be `+<U>` ([`ScriptLevel::Add`]), `-<U>` ([`ScriptLevel::Sub`]) or `<U>`
+    /// ([`ScriptLevel::Num`]) where `<U>` is a [`usize`].
+    ScriptLevel(ScriptLevel),
+
+    /// The `style` attribute of the element, same as in HTML.
+    Style(String),
+
+    /// The `tabindex` attribute, same as in HTML.
+    TabIndex(i16),
+
+    OnHandler {
+        /// Name of the event.
+        name: String,
+
+        /// Handler function for the event.
+        handler: String,
+    },
+}

src/elements.rs

@@ -0,0 +1,57 @@
+//! Elements found in the MathML Core Specification. These elements are called MathML Core
+//! elements.
+
+mod maction;
+mod math;
+mod merror;
+mod mmultiscripts;
+mod mphantom;
+mod mrow;
+mod mstyle;
+
+pub mod grouping {
+    pub use super::maction::*;
+    pub use super::math::*;
+    pub use super::merror::*;
+    pub use super::mmultiscripts::Prescripts;
+    pub use super::mphantom::*;
+    pub use super::mrow::*;
+    pub use super::mstyle::*;
+}
+
+mod mroot;
+
+pub mod radicals {
+    pub use super::mroot::*;
+}
+
+mod msubsup;
+mod munderover;
+
+pub mod scripted {
+    pub use super::mmultiscripts::Multiscripts;
+    pub use super::msubsup::*;
+    pub use super::munderover::*;
+}
+
+mod annotation;
+mod mfrac;
+mod mi;
+mod mn;
+mod mo;
+mod mpadded;
+mod ms;
+mod mspace;
+mod mtable;
+mod mtext;
+
+pub use annotation::*;
+pub use mfrac::*;
+pub use mi::*;
+pub use mn::*;
+pub use mo::*;
+pub use mpadded::*;
+pub use ms::*;
+pub use mspace::*;
+pub use mtable::*;
+pub use mtext::*;

src/elements/annotation.rs

@@ -0,0 +1,168 @@
+use std::marker::PhantomData;
+
+use crate::{
+    attributes::Attribute,
+    markers::{Init, Uninit},
+    MathMl,
+};
+
+/// The content of `annotation` element, either text or MathML.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AnnotationContent {
+    Text(String),
+    MathMl(MathMl),
+}
+
+impl From<String> for AnnotationContent {
+    fn from(value: String) -> Self {
+        Self::Text(value)
+    }
+}
+
+impl<T> From<T> for AnnotationContent
+where
+    T: Into<MathMl>,
+{
+    fn from(value: T) -> Self {
+        Self::MathMl(value.into())
+    }
+}
+
+/// An attribute of `annotation` element. Either one of the global [`Attribute`]s, or `encode`
+/// attribute.
+///
+/// [`Attribute`]: crate::attributes::Attribute
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AnnotationAttr {
+    Global(Attribute),
+    Encoding(String),
+}
+
+impl From<Attribute> for AnnotationAttr {
+    fn from(value: Attribute) -> Self {
+        Self::Global(value)
+    }
+}
+
+/// The `annotation` (and `annotation-xml`) element.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Annotation {
+    content: AnnotationContent,
+    attributes: Vec<AnnotationAttr>,
+}
+
+impl Annotation {
+    pub fn builder() -> AnnotationBuilder<Uninit> {
+        AnnotationBuilder::default()
+    }
+}
+
+impl<T> From<T> for Annotation
+where
+    T: Into<AnnotationContent>,
+{
+    fn from(value: T) -> Self {
+        Self {
+            content: value.into(),
+            attributes: Default::default(),
+        }
+    }
+}
+
+crate::tag_from_type!(Annotation => Annotation);
+
+#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct AnnotationBuilder<T> {
+    content: Option<AnnotationContent>,
+    attr: Vec<AnnotationAttr>,
+
+    _marker: PhantomData<(T,)>,
+}
+
+impl<T> AnnotationBuilder<T> {
+    pub fn content(self, content: impl Into<AnnotationContent>) -> AnnotationBuilder<Init> {
+        AnnotationBuilder {
+            content: Some(content.into()),
+            attr: self.attr,
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn attr<I, A>(mut self, attr: I) -> Self
+    where
+        I: IntoIterator<Item = A>,
+        A: Into<AnnotationAttr>,
+    {
+        self.attr.extend(attr.into_iter().map(Into::into));
+        self
+    }
+}
+
+impl AnnotationBuilder<Init> {
+    pub fn build(self) -> Annotation {
+        Annotation {
+            content: self
+                .content
+                .expect("Content is guaranteed to be initialized at compile time."),
+            attributes: self.attr,
+        }
+    }
+}
+
+/// The `semantics` element is the container element that associates annotations with a MathML
+/// expression. Typically, the `semantics` element has as its first child element a MathML
+/// expression to be annotated while subsequent child elements represent text annotations within an
+/// `annotation` element, or more complex markup annotations within an `annotation-xml` element.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Semantics {
+    /// Children of the `semantics` element. Rendering is same as `mrow`.
+    children: MathMl,
+
+    /// The `semantics` element accepts the global [`Attribute`]s.
+    attr: Vec<Attribute>,
+}
+
+impl Semantics {
+    pub fn builder() -> SemanticsBuilder<Uninit> {
+        SemanticsBuilder::default()
+    }
+}
+
+crate::tag_from_type!(Semantics => Semantics);
+
+#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct SemanticsBuilder<T> {
+    content: Option<MathMl>,
+    attr: Vec<Attribute>,
+
+    _marker: PhantomData<(T,)>,
+}
+
+impl<T> SemanticsBuilder<T> {
+    pub fn content(self, content: impl Into<MathMl>) -> SemanticsBuilder<Init> {
+        SemanticsBuilder {
+            content: Some(content.into()),
+            attr: self.attr,
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn attr<A>(mut self, attr: A) -> Self
+    where
+        A: IntoIterator<Item = Attribute>,
+    {
+        self.attr.extend(attr);
+        self
+    }
+}
+
+impl SemanticsBuilder<Init> {
+    pub fn build(self) -> Semantics {
+        Semantics {
+            children: self
+                .content
+                .expect("Content is guaranteed to be initialized at compile time."),
+            attr: self.attr,
+        }
+    }
+}