pisnge 0.1.5

A Rust-based diagram rendering library inspired by Mermaid.js, focused on generating SVG pie charts
Documentation 
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

use clap::Parser;
use pisnge::parser::parse_pie_chart;
use pisnge::png::svg_to_png;
use pisnge::renderer::render_pie_chart_svg;
use std::fs;
use std::path::Path;

#[derive(Parser)]
#[command(name = "pisnge")]
#[command(about = "A Rust-based diagram rendering library inspired by Mermaid.js")]
struct Cli {
    #[arg(short, long)]
    input: String,

    #[arg(short, long)]
    output: String,

    #[arg(short, long, value_parser = ["png", "svg"])]
    format: Option<String>,

    #[arg(short, long)]
    verbose: bool,

    #[arg(short, long, default_value = "800")]
    width: u32,

    #[arg(short = 'H', long, default_value = "600")]
    height: u32,

    #[arg(long, default_value = "Liberation Sans")]
    font: String,
}

fn detect_format_from_extension(output_path: &str) -> Option<String> {
    Path::new(output_path)
        .extension()
        .and_then(|ext| ext.to_str())
        .map(|ext| ext.to_lowercase())
        .and_then(|ext| match ext.as_str() {
            "png" => Some("png".to_string()),
            "svg" => Some("svg".to_string()),
            _ => None,
        })
}

fn main() {
    let cli = Cli::parse();

    println!("Pisnge - Diagram Renderer");

    // Determine output format: use -f flag if provided, otherwise detect from file extension
    let output_format = match cli.format {
        Some(format) => format,
        None => match detect_format_from_extension(&cli.output) {
            Some(format) => format,
            None => {
                eprintln!("Error: Could not detect output format from file extension '{}'. Please specify format using -f flag.", 
                    Path::new(&cli.output).extension().and_then(|ext| ext.to_str()).unwrap_or("(none)"));
                eprintln!("Supported formats: png, svg");
                std::process::exit(1);
            }
        },
    };

    if cli.verbose {
        println!("Input file: {}", cli.input);
        println!("Output file: {}", cli.output);
        println!("Output format: {}", output_format);
    }

    match fs::read_to_string(&cli.input) {
        Ok(content) => {
            // Ensure content ends with newline for easier parsing
            let normalized_content = if content.ends_with('\n') {
                content
            } else {
                format!("{}\n", content)
            };

            match parse_pie_chart(&normalized_content) {
                Ok((_, pie_chart)) => {
                    if cli.verbose {
                        println!("\nParsed pie chart:");
                        println!("  Show data: {}", pie_chart.show_data);
                        if let Some(title) = &pie_chart.title {
                            println!("  Title: {}", title);
                        }
                        println!("  Data entries: {}", pie_chart.data.len());
                        for entry in &pie_chart.data {
                            println!("    \"{}\": {}", entry.label, entry.value);
                        }
                    }

                    match output_format.as_str() {
                        "svg" => {
                            let (svg_document, _) =
                                render_pie_chart_svg(&pie_chart, cli.width, cli.height, &cli.font);
                            match fs::write(&cli.output, svg_document.to_string()) {
                                Ok(_) => println!("SVG saved to: {}", cli.output),
                                Err(e) => {
                                    eprintln!("Failed to write SVG file: {}", e);
                                    std::process::exit(1);
                                }
                            }
                        }
                        "png" => {
                            let (svg_document, actual_height) =
                                render_pie_chart_svg(&pie_chart, cli.width, cli.height, &cli.font);
                            match svg_to_png(&svg_document.to_string(), cli.width, actual_height) {
                                Ok(png_data) => match fs::write(&cli.output, png_data) {
                                    Ok(_) => println!("PNG saved to: {}", cli.output),
                                    Err(e) => {
                                        eprintln!("Failed to write PNG file: {}", e);
                                        std::process::exit(1);
                                    }
                                },
                                Err(e) => {
                                    eprintln!("Failed to convert SVG to PNG: {}", e);
                                    std::process::exit(1);
                                }
                            }
                        }
                        _ => {
                            eprintln!(
                                "Unsupported format: {}. Supported formats: png, svg",
                                output_format
                            );
                            std::process::exit(1);
                        }
                    }
                }
                Err(e) => {
                    eprintln!("Failed to parse pie chart: {:?}", e);
                    std::process::exit(1);
                }
            }
        }
        Err(e) => {
            eprintln!("Failed to read input file: {}", e);
            std::process::exit(1);
        }
    }
}