summaryrefslogtreecommitdiff
path: root/morphology-img/src/render.rs
blob: 842f796c9b05adc2910c7fc516ced1012edd2ed9 (plain)
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
// LilyPond CLI invocation for SVG generation

use std::process::Command;
use std::path::{Path, PathBuf};
use std::fs;
use crate::error::RenderError;

/// Checks if LilyPond is available on the system.
///
/// This function attempts to run `lilypond --version` to detect if LilyPond
/// is installed and accessible in the system PATH.
///
/// # Returns
/// - `Ok(version_string)` if LilyPond is found and responds successfully
/// - `Err(RenderError::LilyPondNotFound)` if LilyPond is not found or fails to execute
///
/// # Examples
/// ```no_run
/// use morphology_img::render::check_lilypond_available;
///
/// match check_lilypond_available() {
///     Ok(version) => println!("LilyPond is available: {}", version),
///     Err(e) => eprintln!("LilyPond not found: {}", e),
/// }
/// ```
///
/// # Installation Instructions
/// If LilyPond is not found, install it from:
/// - **macOS**: `brew install lilypond`
/// - **Ubuntu/Debian**: `sudo apt-get install lilypond`
/// - **Windows**: Download from <https://lilypond.org/download.html>
pub fn check_lilypond_available() -> Result<String, RenderError> {
    let output = Command::new("lilypond")
        .arg("--version")
        .output();

    match output {
        Ok(output) => {
            if output.status.success() {
                let version = String::from_utf8_lossy(&output.stdout);
                Ok(version.lines().next().unwrap_or("Unknown version").to_string())
            } else {
                Err(RenderError::LilyPondNotFound(
                    "LilyPond command failed".to_string()
                ))
            }
        }
        Err(e) => {
            Err(RenderError::LilyPondNotFound(
                format!("LilyPond not found in PATH: {}. Please install LilyPond from https://lilypond.org", e)
            ))
        }
    }
}

/// Renders multiple .ly files to SVGs by calling LilyPond once with all files.
///
/// This function invokes LilyPond with all .ly files as arguments in a single command,
/// which is significantly more efficient than calling LilyPond separately for each file.
/// It eliminates process startup overhead and allows the OS to handle scheduling optimally.
///
/// # Arguments
/// - `ly_files`: Paths to the .ly files to render
/// - `output_dir`: Directory where SVGs should be created
/// - `lilypond_binary`: Path to the LilyPond binary (typically "lilypond")
///
/// # Returns
/// Vector of paths to generated SVG files, in the same order as input
///
/// # Errors
/// - `RenderError::FileIO` if the output directory cannot be created
/// - `RenderError::LilyPondExecution` if LilyPond fails to execute or produce output
/// - `RenderError::Template` if any .ly filename is invalid
///
/// # Examples
/// ```no_run
/// use morphology_img::render::render_all_ly_files_batch;
/// use std::path::{Path, PathBuf};
///
/// let ly_files = vec![
///     PathBuf::from("/tmp/sequence-0.ly"),
///     PathBuf::from("/tmp/sequence-1.ly"),
/// ];
/// let output_dir = Path::new("output");
/// let lilypond = Path::new("lilypond");
///
/// let svg_paths = render_all_ly_files_batch(&ly_files, output_dir, lilypond).unwrap();
/// println!("Generated {} SVG files", svg_paths.len());
/// ```
///
/// # Performance Notes
/// - All files are processed in a single LilyPond invocation
/// - Much faster than sequential individual file processing
/// - Optimal for batches of any size
pub fn render_all_ly_files_batch(
    ly_files: &[PathBuf],
    output_dir: &Path,
    lilypond_binary: &Path,
) -> Result<Vec<PathBuf>, RenderError> {
    // Handle empty input
    if ly_files.is_empty() {
        return Ok(Vec::new());
    }

    // Ensure output directory exists
    fs::create_dir_all(output_dir)?;

    // Get the directory containing the .ly files (should all be in same temp dir)
    let ly_dir = ly_files[0]
        .parent()
        .ok_or_else(|| RenderError::Template("Invalid .ly file path".to_string()))?;

    // Build command: lilypond --svg file1.ly file2.ly file3.ly ...
    // WITHOUT -o flag, so SVGs are created next to .ly files with correct names
    let output = Command::new(lilypond_binary)
        .arg("--svg")
        .args(ly_files)
        .current_dir(ly_dir)  // Run in the temp directory
        .output()?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(RenderError::LilyPondExecution(stderr.to_string()));
    }

    // Copy SVG files from temp directory to output directory
    let mut svg_paths = Vec::with_capacity(ly_files.len());

    for ly_file in ly_files.iter() {
        let svg_filename = ly_file
            .file_stem()
            .ok_or_else(|| RenderError::Template("Invalid .ly filename".to_string()))?
            .to_string_lossy()
            .to_string() + ".svg";

        // SVG was created next to the .ly file in temp directory
        let temp_svg_path = ly_dir.join(&svg_filename);

        // Verify the SVG was created
        if !temp_svg_path.exists() {
            return Err(RenderError::LilyPondExecution(
                format!("Expected SVG not created: {}", temp_svg_path.display())
            ));
        }

        // Copy to output directory (can't use rename - may be different filesystem)
        let final_svg_path = output_dir.join(&svg_filename);
        fs::copy(&temp_svg_path, &final_svg_path)?;

        svg_paths.push(final_svg_path);
    }

    Ok(svg_paths)
}