lib.rs

//! hongo - LaTeX の文書を PDF に組み上げるライブラリ
//!
//! 読み取り（token, parse）と、番号付け（number）と、組み上げ（layout, line, page）と、
//! 書き出し（pdf, stream, embed）を分けている。数式は suki、化学式は lina に渡す。
//!
//! 外の crate には依存しない。フォントの読み取りも PDF の書き出しも自前で行う。
//!
//! ```no_run
//! use std::path::Path;
//!
//! let library = hongo::font::open(
//!     Path::new("font/latinmodern-math.otf"),
//!     None, None, None, None, None,
//!     Some(Path::new("font/ipaexm.ttf")),
//! ).unwrap();
//! let style = hongo::style::Style::default();
//! let source = std::fs::read_to_string("doc.tex").unwrap();
//! let made = hongo::render(&source, &library, &style, Path::new(".")).unwrap();
//! std::fs::write("doc.pdf", made.data).unwrap();
//! ```
//!
//! 組むのに 2 回通す。1 回目でどの見出しがどのページに来るかが決まり、
//! 2 回目でその番号を目次と `\pageref` に入れる。

pub mod chem;
pub mod draw;
pub mod embed;
pub mod error;
pub mod font;
pub mod image;
pub mod layout;
pub mod line;
pub mod math;
pub mod node;
pub mod number;
pub mod page;
pub mod parse;
pub mod pdf;
pub mod stream;
pub mod style;
pub mod text;
pub mod token;

pub use error::Error;
pub use font::Library;
pub use style::Style;
use std::collections::BTreeSet;
use std::path::Path;


/// `\input` をたどる深さの上限
const INCLUDE_LIMIT: usize = 16;


/// 組み上がったもの
#[derive(Debug, Clone, PartialEq)]
pub struct Made {
    /// PDF そのもの
    pub data: Vec<u8>,
    pub page: usize,
    /// どの書体にもなかった字
    pub missing: BTreeSet<char>,
}


/// LaTeX の文書を PDF にする
pub fn render(source: &str, library: &Library, style: &Style, base: &Path) -> Result<Made, Error> {
    let joined = include(source, base, 0)?;
    let characters: Vec<char> = joined.chars().collect();
    let mut document = parse::parse(&characters)
        .map_err(|reason| Error::new(error::describe(&characters, &reason), reason.position))?;
    let mut shaped = style.clone();
    style::apply(&mut shaped, &document.option);

    let mut numbering = number::assign(&mut document);
    let (block, _, _) = layout::build(&document, library, &shaped, &numbering, base)?;
    page::paginate(&block, library, &shaped, &mut numbering);

    let (block, picture, missing) = layout::build(&document, library, &shaped, &numbering, base)?;
    let (page, destination) = page::paginate(&block, library, &shaped, &mut numbering);
    let title = node::plain(&document.title);
    let data = pdf::write(&page, library, &picture, title.trim(), &destination);

    Ok(Made {data, page: page.len(), missing})
}


/// `\input{…}` と `\include{…}` を、そのファイルの中身に置き換える
fn include(source: &str, base: &Path, depth: usize) -> Result<String, Error> {
    if depth >= INCLUDE_LIMIT {
        return Err(Error::new("\\input が深すぎます", 0));
    }

    if !source.contains("\\input") && !source.contains("\\include{") {
        return Ok(source.to_string());
    }

    let raw: Vec<char> = source.chars().collect();
    let skip = verbatim_ranges(&raw);
    let mut out = String::with_capacity(source.len());
    let mut at = 0;

    while at < raw.len() {
        if skip.iter().any(|(start, end)| at >= *start && at < *end) {
            out.push(raw[at]);
            at += 1;

            continue;
        }

        let found = ["\\input", "\\include"]
            .iter()
            .find(|name| starts_with(&raw, at, name));

        match found {
            Some(name) => {
                let (path, next) = match brace_after(&raw, at + name.chars().count()) {
                    Some(pair) => pair,
                    None => {
                        out.push(raw[at]);
                        at += 1;

                        continue;
                    }
                };
                let full = with_suffix(base, &path);
                let body = std::fs::read_to_string(&full).map_err(|reason| {
                    Error::new(format!("読めません: {}: {reason}", full.display()), at)
                })?;
                out.push_str(&include(&body, base, depth + 1)?);
                at = next;
            }
            None => {
                out.push(raw[at]);
                at += 1;
            }
        }
    }

    Ok(out)
}


/// `.tex` を足したファイル名
fn with_suffix(base: &Path, path: &str) -> std::path::PathBuf {
    let direct = base.join(path);

    if direct.is_file() {
        return direct;
    }

    base.join(format!("{path}.tex"))
}


/// その位置から並びが始まっているか
fn starts_with(source: &[char], at: usize, needle: &str) -> bool {
    let want: Vec<char> = needle.chars().collect();

    if at + want.len() > source.len() || source[at..at + want.len()] != want[..] {
        return false;
    }

    // \input と \inputmore を取り違えない
    !source
        .get(at + want.len())
        .is_some_and(|character| character.is_alphabetic())
}


/// 空白を飛ばした先の `{…}` の中身と、その次の位置
fn brace_after(source: &[char], at: usize) -> Option<(String, usize)> {
    let mut start = at;

    while start < source.len() && source[start].is_whitespace() {
        start += 1;
    }

    if source.get(start) != Some(&'{') {
        return None;
    }

    let mut end = start + 1;

    while end < source.len() && source[end] != '}' {
        end += 1;
    }

    if end >= source.len() {
        return None;
    }

    Some((source[start + 1..end].iter().collect(), end + 1))
}


/// そのまま出す部分の範囲。ここでは `\input` を開かない
fn verbatim_ranges(source: &[char]) -> Vec<(usize, usize)> {
    let open: Vec<char> = "\\begin{verbatim}".chars().collect();
    let close: Vec<char> = "\\end{verbatim}".chars().collect();
    let mut found = Vec::new();
    let mut at = 0;

    while at < source.len() {
        if source[at..].len() >= open.len() && source[at..at + open.len()] == open[..] {
            let mut end = at + open.len();

            while end + close.len() <= source.len() {
                if source[end..end + close.len()] == close[..] {
                    break;
                }

                end += 1;
            }

            found.push((at, (end + close.len()).min(source.len())));
            at = end + close.len();

            continue;
        }

        at += 1;
    }

    found
}


#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;
    use std::sync::OnceLock;

    /// 試験に使う書体。読み込みは 1 度だけ
    fn library() -> &'static Library {
        static ONCE: OnceLock<Library> = OnceLock::new();

        ONCE.get_or_init(|| {
            font::open(
                Path::new("font/latinmodern-math.otf"),
                None,
                None,
                None,
                None,
                None,
                japanese().as_deref(),
            )
            .expect("試験用の書体")
        })
    }

    /// この機械にある和文の書体。なければ和文の試験は飛ばす
    fn japanese() -> Option<PathBuf> {
        let path = PathBuf::from("/Library/Fonts/Arial Unicode.ttf");

        if path.is_file() {Some(path)} else {None}
    }

    fn make(body: &str) -> Made {
        let source =
            format!("\\documentclass{{article}}\n\\begin{{document}}\n{body}\n\\end{{document}}");

        render(&source, library(), &Style::default(), Path::new("test")).expect(body)
    }

    fn text_of(made: &Made) -> String {
        String::from_utf8_lossy(&made.data).to_string()
    }

    #[test]
    fn a_document_becomes_a_pdf() {
        let made = make("こんにちは。 Hello.");
        assert!(made.data.starts_with(b"%PDF-1.7"));
        assert!(made.data.ends_with(b"%%EOF\n"));
        assert_eq!(made.page, 1);

        let body = text_of(&made);
        assert!(body.contains("/Type /Catalog"));
        assert!(body.contains("/Type /Pages"));
        assert!(body.contains("/Subtype /Type0"));
        assert!(body.contains("/Encoding /Identity-H"));
        assert!(body.contains("startxref"));
    }

    #[test]
    fn a_long_document_runs_over_more_than_one_page() {
        let one = "This is a paragraph that fills a good deal of a line, and there are many. ";
        let made = make(&one.repeat(200));
        assert!(made.page > 1, "{}", made.page);
    }

    #[test]
    fn math_and_chemistry_come_out() {
        let made = make(
            "文中に $e^{i\\pi}+1=0$ があります。\n\n\
\\[ x = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a} \\]\n\n\
\\chemfig{H_3C-CH_2-OH}",
        );
        assert_eq!(made.page, 1);
        assert!(made.data.len() > 10_000);
    }

    #[test]
    fn headings_reach_the_outline() {
        let made = make("\\section{はじめに}\\subsection{その中}本文。");
        let body = text_of(&made);
        assert!(body.contains("/Type /Outlines"));
        assert!(body.contains("/PageMode /UseOutlines"));
    }

    #[test]
    fn a_picture_is_carried_over_as_it_is() {
        let made = make("\\includegraphics[width=3cm]{color.png}");
        let body = text_of(&made);
        assert!(body.contains("/Subtype /Image"));
        assert!(body.contains("/Filter /FlateDecode"));
        assert!(body.contains("/Predictor 15"));
    }

    #[test]
    fn an_unknown_command_says_where_it_is() {
        let source = "\\documentclass{article}\\begin{document}\\nosuchthing\\end{document}";
        let found = render(source, library(), &Style::default(), Path::new("test")).unwrap_err();
        assert!(found.message.contains("知らない命令"), "{}", found.message);
        assert!(found.message.contains("行"), "{}", found.message);
    }

    #[test]
    fn a_missing_picture_says_so() {
        let source =
            "\\documentclass{article}\\begin{document}\\includegraphics{nope}\\end{document}";
        let found = render(source, library(), &Style::default(), Path::new("test")).unwrap_err();
        assert!(found.message.contains("画像が見つかりません"), "{}", found.message);
    }

    #[test]
    fn japanese_needs_no_missing_letters() {
        if japanese().is_none() {
            return;
        }

        let made = make("日本語の文章を組みます。ひらがな、カタカナ、漢字。");
        assert!(made.missing.is_empty(), "{:?}", made.missing);
    }

    #[test]
    fn ruby_does_not_change_the_line_spacing() {
        if japanese().is_none() {
            return;
        }

        let plain = make("漢字の上に何も載せない行です。\n\n同じ行を続けます。");
        let ruby = make("\\ruby{漢字}{かんじ}の上に何も載せない行です。\n\n同じ行を続けます。");
        assert_eq!(plain.page, ruby.page);
        assert!(ruby.missing.is_empty(), "{:?}", ruby.missing);
    }

    #[test]
    fn a_table_and_a_list_come_out() {
        let made = make(
            "\\begin{itemize}\\item 1 つ目\\item 2 つ目\\end{itemize}\n\n\
\\begin{tabular}{|l|r|}\\hline a & 1 \\\\ b & 22 \\\\ \\hline\\end{tabular}",
        );
        assert_eq!(made.page, 1);
        assert!(text_of(&made).contains(" re f"));
    }

    #[test]
    fn a_defined_command_is_opened_up() {
        let made = make("\\newcommand{\\hi}[1]{こんにちは、#1さん}\\hi{本郷}");
        assert_eq!(made.page, 1);
        assert!(made.missing.is_empty() || japanese().is_none());
    }

    #[test]
    fn a_page_reference_finds_the_page_it_points_at() {
        let source = format!(
            "\\documentclass{{article}}\\begin{{document}}\\tableofcontents\n\n\
\\section{{A}}\\label{{a}}\n\n{}\n\n\\newpage\\section{{B}}\\label{{b}}\n\n\
\\ref{{b}} は \\pageref{{b}} ページ。\\end{{document}}",
            "text ".repeat(400)
        );
        let characters: Vec<char> = source.chars().collect();
        let mut document = parse::parse(&characters).unwrap();
        let mut numbering = number::assign(&mut document);
        let style = Style::default();
        let base = Path::new("test");
        let (block, _, _) =
            layout::build(&document, library(), &style, &numbering, base).unwrap();
        let (leaf, destination) = page::paginate(&block, library(), &style, &mut numbering);
        assert_eq!(leaf.len(), 2);
        assert_eq!(numbering.page.get("a"), Some(&1));
        assert_eq!(numbering.page.get("b"), Some(&2));
        assert_eq!(numbering.page.get("contents:1"), Some(&2));
        // 目次そのものも飛び先になる
        assert_eq!(destination.len(), 3);
        assert_eq!(destination[0].title, "目次");
        assert_eq!(destination[2].title, "2 B");
    }
}