shapdf 0.2.1

Create Shapes into PDF
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

use clap::Parser;
use shapdf::{execute_instructions, parse_script, Generator};
use std::{
    error::Error,
    fs,
    io::{self, Read},
    path::PathBuf,
};

#[derive(Parser, Debug)]
#[command(
    about = "Generate vector shapes into PDF via declarative scripts",
    author,
    version
)]
struct Cli {
    /// Input script file. Use '-' to read from standard input.
    #[arg(value_name = "INPUT")]
    input: Option<String>,

    /// Output PDF file path.
    #[arg(short, long, value_name = "OUTPUT")]
    output: Option<PathBuf>,
}

fn main() -> Result<(), Box<dyn Error>> {
    let cli = Cli::parse();
    let (script, inferred_output) = read_script(cli.input.as_deref())?;

    let output_path = cli
        .output
        .or(inferred_output)
        .unwrap_or_else(|| PathBuf::from("output/shapes.pdf"));

    let instructions = parse_script(&script)?;
    let mut generator = Generator::new(output_path.clone());
    execute_instructions(&mut generator, &instructions)?;
    generator.write_pdf()?;
    Ok(())
}

fn read_script(input: Option<&str>) -> Result<(String, Option<PathBuf>), Box<dyn Error>> {
    match input {
        Some("-") => Ok((read_from_stdin()?, None)),
        Some(path) => {
            let path = PathBuf::from(path);
            let script = fs::read_to_string(&path)?;
            let output = path.with_extension("pdf");
            Ok((script, Some(output)))
        }
        None => Ok((read_from_stdin()?, None)),
    }
}

fn read_from_stdin() -> Result<String, io::Error> {
    let mut buffer = String::new();
    io::stdin().read_to_string(&mut buffer)?;
    Ok(buffer)
}