cargo-slide 0.1.3

Code-driven presentation engine combining Typst typesetting with a native Rust viewer, developed as part of the Apich workspace backend.
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

use std::process::Command;
use tempfile::tempdir;

#[test]
fn test_cli_version_and_help() {
    let bin = env!("CARGO_BIN_EXE_cargo-slide");

    let output = Command::new(bin)
        .arg("--version")
        .output()
        .expect("Failed to execute cargo-slide --version");
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("cargo-slide"));

    let help_output = Command::new(bin)
        .arg("--help")
        .output()
        .expect("Failed to execute cargo-slide --help");
    assert!(help_output.status.success());
    let help_stdout = String::from_utf8_lossy(&help_output.stdout);
    assert!(help_stdout.contains("Modern code-driven presentation system"));
    assert!(help_stdout.contains("init"));
    assert!(help_stdout.contains("build"));
    assert!(help_stdout.contains("export"));
}

#[test]
fn test_cli_init_and_new() {
    let bin = env!("CARGO_BIN_EXE_cargo-slide");
    let dir = tempdir().expect("tempdir");

    // Test new
    let new_res = Command::new(bin)
        .arg("new")
        .arg("my_presentation")
        .current_dir(dir.path())
        .output()
        .expect("Execute cargo-slide new");
    assert!(new_res.status.success());

    let proj_dir = dir.path().join("my_presentation");
    assert!(proj_dir.join("slides.typ").exists());
    assert!(proj_dir.join("theme.typ").exists());
    assert!(proj_dir.join("slide.typ").exists());
    assert!(proj_dir.join("assets/data.csv").exists());
    assert!(proj_dir.join(".gitignore").exists());

    // Test init in existing dir
    let init_dir = dir.path().join("init_project");
    std::fs::create_dir_all(&init_dir).unwrap();
    let init_res = Command::new(bin)
        .arg("init")
        .current_dir(&init_dir)
        .output()
        .expect("Execute cargo-slide init");
    assert!(init_res.status.success());
    assert!(init_dir.join("slides.typ").exists());
}

#[test]
fn test_cli_export_pdf_and_svg() {
    let bin = env!("CARGO_BIN_EXE_cargo-slide");
    let dir = tempdir().expect("tempdir");

    // Create presentation
    let init_res = Command::new(bin)
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("Execute cargo-slide init");
    assert!(init_res.status.success());

    // Export PDF
    let out_pdf = dir.path().join("output.pdf");
    let pdf_res = Command::new(bin)
        .arg("export")
        .arg("slides.typ")
        .arg("--format")
        .arg("pdf")
        .arg("-o")
        .arg(&out_pdf)
        .current_dir(dir.path())
        .output()
        .expect("Execute cargo-slide export pdf");
    assert!(pdf_res.status.success(), "PDF export failed: {:?}", pdf_res);
    assert!(out_pdf.exists());
    assert!(out_pdf.metadata().unwrap().len() > 0);

    // Export SVG
    let out_svgs = dir.path().join("output_svgs");
    let svg_res = Command::new(bin)
        .arg("export")
        .arg("slides.typ")
        .arg("--format")
        .arg("svg")
        .arg("-o")
        .arg(&out_svgs)
        .current_dir(dir.path())
        .output()
        .expect("Execute cargo-slide export svg");
    assert!(svg_res.status.success(), "SVG export failed: {:?}", svg_res);
    assert!(out_svgs.exists());
    assert!(out_svgs.join("page-1.svg").exists());
}

#[test]
fn test_cli_build_standalone_binary() {
    let bin = env!("CARGO_BIN_EXE_cargo-slide");
    let dir = tempdir().expect("tempdir");

    // Initialize presentation
    let init_res = Command::new(bin)
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("Execute cargo-slide init");
    assert!(init_res.status.success());

    let out_bin = dir.path().join("standalone_app");
    let build_res = Command::new(bin)
        .arg("build")
        .arg("slides.typ")
        .arg("-o")
        .arg(&out_bin)
        .current_dir(dir.path())
        .output()
        .expect("Execute cargo-slide build");

    let stdout = String::from_utf8_lossy(&build_res.stdout);
    let stderr = String::from_utf8_lossy(&build_res.stderr);
    assert!(
        build_res.status.success(),
        "Standalone build failed! stdout:\n{}\nstderr:\n{}",
        stdout,
        stderr
    );
    assert!(
        out_bin.exists(),
        "Output binary must exist at {:?}",
        out_bin
    );
    assert!(out_bin.metadata().unwrap().len() > 1_000_000);
}