texforge 0.8.0

Self-contained LaTeX to PDF compiler CLI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! `texforge stats` command implementation.

use anyhow::Result;
use clap::ValueEnum;

use crate::domain::project::Project;
use crate::texparse;
use crate::wordcount::{self, DocumentStats};

/// Breakdown mode for `texforge stats`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub enum ByMode {
    /// Report per section.
    Section,
    /// Report per `.tex` file.
    File,
}

/// Count words and report document statistics.
pub fn execute(json: bool, by: ByMode) -> Result<()> {
    let project = Project::load()?;

    let entry = project.root.join(&project.config.build.entry);
    if !entry.exists() {
        anyhow::bail!("Entry point file does not exist: {}", entry.display());
    }

    let files = texparse::tokenize_document(&project.root, &project.config.build.entry);
    let stats = match by {
        ByMode::Section => wordcount::count_document(&project.config.document.title, &files),
        ByMode::File => wordcount::count_by_file(&project.config.document.title, &files),
    };

    if json {
        println!("{}", serde_json::to_string_pretty(&stats)?);
    } else {
        print_human(&stats, by);
    }

    Ok(())
}

/// Human-readable breakdown with dotted leaders and a total.
fn print_human(stats: &DocumentStats, by: ByMode) {
    println!("{}", stats.document);

    if stats.preamble_words > 0 {
        println!(
            "  {}",
            dotted_line("preamble", &stats.preamble_words.to_string())
        );
    }
    for section in &stats.sections {
        let left = match by {
            ByMode::Section => format!(
                "{} {}",
                section.path,
                section.title.as_deref().unwrap_or("")
            ),
            ByMode::File => section.path.clone(),
        };
        println!("  {}", dotted_line(&left, &section.words.to_string()));
    }
    if stats.preamble_words > 0 || !stats.sections.is_empty() {
        println!("  {}", dotted_line("Total", &stats.total_words.to_string()));
    }
}

/// Join `left` and `right` with a run of dots, padded to `WIDTH`.
fn dotted_line(left: &str, right: &str) -> String {
    const WIDTH: usize = 60;
    let dots = WIDTH.saturating_sub(left.chars().count() + right.chars().count());
    format!("{left}{dots}{right}", dots = ".".repeat(dots))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn dotted_line_pads_with_dots() {
        let line = dotted_line("Total", "12");
        assert!(line.starts_with("Total"));
        assert!(line.ends_with("12"));
        assert_eq!(line.chars().count(), 60);
        assert!(line.contains("...."));
    }

    #[test]
    fn dotted_line_tolerates_overlong_left() {
        let line = dotted_line(&"x".repeat(70), "1");
        assert!(line.ends_with("1"));
    }

    #[test]
    fn execute_json_on_small_project() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::write(
            tmp.path().join("project.toml"),
            "[document]\ntitle = \"T\"\nauthor = \"A\"\ntemplate = \"general\"\n\n[build]\nentry = \"main.tex\"\n",
        )
        .unwrap();
        std::fs::write(
            tmp.path().join("main.tex"),
            "\\begin{document}\nhello world\n\\section{S}\ntext\n\\end{document}",
        )
        .unwrap();
        let orig = std::env::current_dir().unwrap();
        std::env::set_current_dir(tmp.path()).unwrap();
        let result = execute(true, ByMode::Section);
        std::env::set_current_dir(&orig).unwrap();
        result.unwrap();
    }

    #[test]
    fn execute_missing_entry_errors() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::write(
            tmp.path().join("project.toml"),
            "[document]\ntitle = \"T\"\nauthor = \"A\"\ntemplate = \"general\"\n\n[build]\nentry = \"main.tex\"\n",
        )
        .unwrap();
        let orig = std::env::current_dir().unwrap();
        std::env::set_current_dir(tmp.path()).unwrap();
        let result = execute(false, ByMode::Section);
        std::env::set_current_dir(&orig).unwrap();
        assert!(result.is_err());
    }
}