rsconstruct 0.9.78

Rust based fast build system
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

use anyhow::{Context, Result};
use std::fs;
use std::process::Command;

use serde::{Deserialize, Serialize};

use crate::config::StandardConfig;
use crate::file_index::FileIndex;
use crate::graph::{BuildGraph, Product};
use crate::processors::{Processor, run_command, check_command_output};

use super::DiscoverParams;

const fn default_pdflatex_runs() -> usize {
    2
}

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct PdflatexConfig {
    #[serde(default = "default_pdflatex_runs")]
    pub runs: usize,
    #[serde(default = "crate::config::default_true")]
    pub qpdf: bool,
    /// Pass -shell-escape to pdflatex. Historically always on; note it lets
    /// any .tex input execute arbitrary shell commands during the build.
    #[serde(default = "crate::config::default_true")]
    pub shell_escape: bool,
    #[serde(flatten)]
    pub standard: StandardConfig,
}

impl Default for PdflatexConfig {
    fn default() -> Self {
        Self {
            runs: 2,
            qpdf: true,
            shell_escape: true,
            standard: StandardConfig::default(),
        }
    }
}

/// Temp file extensions produced by pdflatex that should be cleaned between runs.
pub struct PdflatexProcessor {
    config: PdflatexConfig,
}

impl PdflatexProcessor {
    pub const fn new(config: PdflatexConfig) -> Self {
        Self {
            config,
        }
    }
}

impl Processor for PdflatexProcessor {
    fn scan_config(&self) -> &crate::config::StandardConfig {
        &self.config.standard
    }

    // Serialize the FULL config (the trait default covers StandardConfig
    // only), so the extra fields reach config-change detection.
    fn config_json(&self) -> Option<String> {
        crate::processors::ProcessorBase::config_json(&self.config)
    }

    fn clean(&self, product: &crate::graph::Product, verbose: bool) -> anyhow::Result<usize> {
        crate::processors::ProcessorBase::clean(product, &product.processor, verbose)
    }

    fn required_tools(&self) -> Vec<String> {
        let mut tools = vec![self.config.standard.command.clone()];
        if self.config.qpdf {
            tools.push("qpdf".to_string());
        }
        tools
    }

    fn discover(&self, graph: &mut BuildGraph, file_index: &FileIndex, instance_name: &str) -> Result<()> {
        let params = DiscoverParams {
            scan: &self.config.standard,
            dep_inputs: &self.config.standard.dep_inputs,
            config: &self.config,
            output_dir: &self.config.standard.output_dir,
            processor_name: instance_name,
            checksum_fields: crate::config::checksum_fields_of(instance_name),
        };
        super::discover_single_format(graph, file_index, &params, "pdf")
    }

    fn execute(&self, ctx: &crate::build_context::BuildContext, product: &Product) -> Result<()> {
        let input = product.primary_input();
        let final_output = product.primary_output();

        // pdflatex writes output next to the input or in -output-directory
        // We use a temp directory for the build, then move the PDF to the final output location.
        let input_stem = input.file_stem()
            .context("pdflatex input has no file stem")?
            .to_string_lossy();

        // Ensure output directory exists
        crate::processors::ensure_output_dir(final_output)?;

        let build_dir = crate::processors::parent_dir(final_output);

        // Per-product scratch directory. pdflatex's aux/toc/log files are
        // keyed by stem only, so two same-stem sources sharing an output
        // parent would corrupt each other's temp files under -j (silently
        // producing PDFs with broken cross-references) — the same hazard
        // marp solved with a per-invocation namespace. The scratch dir also
        // makes cleanup a single remove_dir_all instead of a by-extension
        // guess list.
        let scratch = build_dir.join(format!(".pdflatex-{}",
            &crate::checksum::bytes_checksum(input.display().to_string().as_bytes())[..12]));
        fs::create_dir_all(&scratch)
            .with_context(|| format!("Failed to create pdflatex scratch dir: {}", scratch.display()))?;

        // Run pdflatex N times into the scratch dir. Nothing is cleaned
        // between runs: the .aux/.toc written by run N is exactly what run
        // N+1 consumes to resolve \ref and the table of contents — an
        // earlier version deleted them between runs, which made multi-pass
        // (the default, runs = 2) behave like a single cold run. Floor at 1:
        // runs = 0 would skip pdflatex entirely and record a "successful"
        // product with no output.
        for run in 0..self.config.runs.max(1) {
            let mut cmd = Command::new(&self.config.standard.command);
            if self.config.shell_escape {
                cmd.arg("-shell-escape");
            }
            cmd.arg("-interaction=nonstopmode");
            cmd.arg("-halt-on-error");
            cmd.arg(format!("-output-directory={}", scratch.display()));
            for arg in &self.config.standard.args {
                cmd.arg(arg);
            }
            cmd.arg(input);

            let out = run_command(ctx, &cmd)?;
            check_command_output(&out, format_args!("pdflatex run {} of {}", run + 1, input.display()))?;
        }

        let pdf_in_scratch = scratch.join(format!("{input_stem}.pdf"));

        // Optional qpdf post-processing
        if self.config.qpdf {
            let qpdf_tmp = scratch.join(format!("{input_stem}.qpdf.pdf"));

            let mut cmd = Command::new("qpdf");
            cmd.arg("--deterministic-id");
            cmd.arg("--linearize");
            cmd.arg(&pdf_in_scratch);
            cmd.arg(&qpdf_tmp);

            let out = run_command(ctx, &cmd)?;
            check_command_output(&out, format_args!("qpdf {}", pdf_in_scratch.display()))?;

            // Replace original with linearized version
            fs::rename(&qpdf_tmp, &pdf_in_scratch)
                .with_context(|| format!("Failed to rename qpdf output: {}", qpdf_tmp.display()))?;
        }

        // Move the finished PDF into place (same filesystem: scratch lives
        // under the output parent), then drop the scratch dir wholesale.
        fs::rename(&pdf_in_scratch, final_output)
            .with_context(|| format!("Failed to move pdflatex output into place: {}", final_output.display()))?;
        fs::remove_dir_all(&scratch)
            .with_context(|| format!("Failed to remove pdflatex scratch dir: {}", scratch.display()))?;

        Ok(())
    }

}

fn plugin_create(toml: &toml::Value) -> anyhow::Result<Box<dyn crate::processors::Processor>> {
    crate::registries::deserialize_and_create(toml, |cfg| Box::new(PdflatexProcessor::new(cfg)))
}
inventory::submit! {
    crate::registries::ProcessorPlugin {
        version: 1,
        name: "pdflatex",
        processor_type: crate::processors::ProcessorType::Generator,
        create: plugin_create,
        fields: &[
            crate::config::FieldSpec { name: "runs", ty: crate::config::FieldType::Integer,
                affects_output: true, required: false,
                doc: "Number of pdflatex compilation passes" },
            crate::config::FieldSpec { name: "qpdf", ty: crate::config::FieldType::Bool,
                affects_output: true, required: false,
                doc: "Run qpdf to optimize the output PDF" },
            crate::config::FieldSpec { name: "shell_escape", ty: crate::config::FieldType::Bool,
                affects_output: true, required: false,
                doc: "Pass -shell-escape to pdflatex (lets .tex files run shell commands)" },
        ],
        omit_standard_fields: &["formats"],
        scan_defaults: Some(crate::config::ScanDefaultsData { src_dirs: &[], src_extensions: &[".tex"], src_exclude_dirs: &[] }),
        defaults: Some(crate::config::ProcessorDefaults { command: "pdflatex", output_dir: "out/pdflatex", ..crate::config::ProcessorDefaults::EMPTY }),
        defconfig_json: crate::registries::default_config_json::<PdflatexConfig>,
        keywords: &["latex", "tex", "pdf", "generator", "typesetting"],
        description: "Compile LaTeX documents using pdflatex",
        is_native: false,
        can_fix: false,
        supports_batch: false,
        max_jobs_cap: None,
    }
}