tikra-cli 1.0.0

Command line for tikra: TikZ to SVG and PNG.
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

use std::process::ExitCode;
use std::{env, fs, io};

const HELP: &str = "\
tikra — TikZ figures to SVG and PNG, no TeX install

USAGE
  tikra <file.tex> [-o out.svg|out.png] [options]
  cat figure.tex | tikra -o figure.png

OPTIONS
  -o, --output <file>     .svg or .png (by its name); without -o, prints the SVG
      --dpi <n>           PNG resolution (default 300)
      --transparent       PNG without the white background
      --warnings          lists what was ignored or approximated
  -V, --version
  -h, --help
";

fn main() -> ExitCode {
    let mut input: Option<String> = None;
    let mut output: Option<String> = None;
    let mut dpi = 300.0f32;
    let mut background = true;
    let mut show_warnings = false;
    let mut it = env::args().skip(1);
    while let Some(a) = it.next() {
        match a.as_str() {
            "-h" | "--help" => {
                print!("{HELP}");
                return ExitCode::SUCCESS;
            }
            "-V" | "--version" => {
                println!("tikra {}", tikra::VERSION);
                return ExitCode::SUCCESS;
            }
            "-o" | "--output" => output = it.next(),
            "--dpi" => dpi = it.next().and_then(|v| v.parse().ok()).unwrap_or(300.0),
            "--transparent" => background = false,
            "--warnings" => show_warnings = true,
            _ => input = Some(a),
        }
    }
    let code = match &input {
        Some(c) => match fs::read_to_string(c) {
            Ok(t) => t,
            Err(e) => {
                eprintln!("tikra: could not read {c}: {e}");
                return ExitCode::from(1);
            }
        },
        None => match io::read_to_string(io::stdin()) {
            Ok(t) => t,
            Err(e) => {
                eprintln!("tikra: could not read standard input: {e}");
                return ExitCode::from(1);
            }
        },
    };
    let r = match tikra::convert(&code) {
        Ok(r) => r,
        Err(e) => {
            eprintln!("tikra: {e}");
            return ExitCode::from(1);
        }
    };
    for w in &r.warnings {
        if show_warnings {
            println!("warning: {w}");
        } else {
            eprintln!("tikra: warning: {w}");
        }
    }
    match output {
        Some(s) if s.ends_with(".png") => match tikra::png(&r.svg, dpi, background) {
            Ok(b) => {
                if let Err(e) = fs::write(&s, b) {
                    eprintln!("tikra: could not write {s}: {e}");
                    return ExitCode::from(1);
                }
            }
            Err(e) => {
                eprintln!("tikra: {e}");
                return ExitCode::from(1);
            }
        },
        Some(s) => {
            if let Err(e) = fs::write(&s, &r.svg) {
                eprintln!("tikra: could not write {s}: {e}");
                return ExitCode::from(1);
            }
        }
        None if !show_warnings => println!("{}", r.svg),
        None => {}
    }
    ExitCode::SUCCESS
}