k2f_math 0.3.2

K2F native math layout
Documentation
use super::{EnvKind, MathNode, Parser};
use crate::error::MathError;
use crate::token::Token;

impl Parser<'_> {
    pub(super) fn parse_begin(&mut self) -> Result<MathNode, MathError> {
        let name = self.parse_env_name()?;
        let kind = env_kind(&name)?;
        let rows = self.parse_env_body(&name)?;
        Ok(MathNode::Env { kind, rows })
    }

    fn parse_env_name(&mut self) -> Result<String, MathError> {
        match self.bump() {
            Some(Token::GroupOpen) => {}
            _ => return Err(MathError::Parse("\\begin/\\end requires '{name}'".into())),
        }
        let mut name = String::new();
        loop {
            match self.bump().cloned() {
                Some(Token::GroupClose) => break,
                Some(Token::Char(c)) if c.is_ascii_alphabetic() => name.push(c),
                Some(_) => {
                    return Err(MathError::Parse("invalid environment name".into()));
                }
                None => return Err(MathError::Parse("unmatched '{' in environment name".into())),
            }
        }
        if name.is_empty() {
            return Err(MathError::Parse("empty environment name".into()));
        }
        Ok(name)
    }

    fn parse_env_body(&mut self, expected: &str) -> Result<Vec<Vec<MathNode>>, MathError> {
        let mut rows: Vec<Vec<MathNode>> = Vec::new();
        let mut row: Vec<MathNode> = Vec::new();
        loop {
            let cell = self.parse_list(is_cell_stop)?;
            row.push(cell);
            match self.peek() {
                Some(Token::AlignTab) => {
                    self.i += 1;
                }
                Some(Token::LineBreak) => {
                    self.i += 1;
                    rows.push(std::mem::take(&mut row));
                }
                Some(Token::Command(s)) if s == "end" => {
                    rows.push(std::mem::take(&mut row));
                    self.parse_end(expected)?;
                    break;
                }
                None => return Err(MathError::Parse(format!("missing \\end{{{expected}}}"))),
                Some(Token::GroupClose) => {
                    return Err(MathError::Parse("unexpected '}' in environment".into()))
                }
                _ => {
                    return Err(MathError::Parse(format!(
                        "unexpected token in \\begin{{{expected}}}"
                    )))
                }
            }
        }
        if rows
            .last()
            .is_some_and(|r| r.len() == 1 && is_empty_cell(&r[0]))
        {
            rows.pop();
        }
        if rows.is_empty() {
            rows.push(vec![MathNode::Row(vec![])]);
        }
        Ok(rows)
    }

    fn parse_end(&mut self, expected: &str) -> Result<(), MathError> {
        match self.bump() {
            Some(Token::Command(s)) if s == "end" => {}
            _ => return Err(MathError::Parse("missing \\end".into())),
        }
        let name = self.parse_env_name()?;
        if name != expected {
            return Err(MathError::Parse(format!(
                "\\begin{{{expected}}} closed by \\end{{{name}}}"
            )));
        }
        Ok(())
    }
}

fn is_cell_stop(t: &Token) -> bool {
    matches!(t, Token::AlignTab | Token::LineBreak | Token::GroupClose)
        || matches!(t, Token::Command(s) if s == "end")
}

fn is_empty_cell(n: &MathNode) -> bool {
    matches!(n, MathNode::Row(v) if v.is_empty())
}

fn env_kind(name: &str) -> Result<EnvKind, MathError> {
    match name {
        "matrix" => Ok(EnvKind::Matrix),
        "pmatrix" => Ok(EnvKind::PMatrix),
        "bmatrix" => Ok(EnvKind::BMatrix),
        "align" => Ok(EnvKind::Align),
        "cases" => Ok(EnvKind::Cases),
        other => Err(MathError::Unsupported(format!(
            "unknown environment '{other}'"
        ))),
    }
}