grim-rs 0.1.9

Rust implementation of grim screenshot utility for Wayland
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

/// Test for filename generation format
/// Verifies that default filenames follow the pattern: YYYYMMDD_HHhMMmSSs_grim.ext

#[test]
fn test_filename_format() {
    use chrono::Local;
    use regex::Regex;

    let now = Local::now();
    let timestamp = now.format("%Y%m%d_%Hh%Mm%Ss");
    let filename = format!("{}_grim.png", timestamp);

    let re = Regex::new(r"^\d{8}_\d{2}h\d{2}m\d{2}s_grim\.png$").unwrap();
    assert!(
        re.is_match(&filename),
        "Filename '{}' does not match expected format YYYYMMDD_HHhMMmSSs_grim.png",
        filename
    );

    let year: u32 = filename[0..4].parse().expect("Failed to parse year");
    assert!(
        (2020..=2100).contains(&year),
        "Year {} is out of reasonable range",
        year
    );

    let month: u32 = filename[4..6].parse().expect("Failed to parse month");
    assert!((1..=12).contains(&month), "Month {} is invalid", month);

    let day: u32 = filename[6..8].parse().expect("Failed to parse day");
    assert!((1..=31).contains(&day), "Day {} is invalid", day);

    let hour_start = 9; // After "YYYYMMDD_"
    let hour: u32 = filename[hour_start..hour_start + 2]
        .parse()
        .expect("Failed to parse hour");
    assert!(hour <= 23, "Hour {} is invalid", hour);

    let minute_start = hour_start + 3; // After "HH" and "h"
    let minute: u32 = filename[minute_start..minute_start + 2]
        .parse()
        .expect("Failed to parse minute");
    assert!(minute <= 59, "Minute {} is invalid", minute);

    let second_start = minute_start + 3; // After "MM" and "m"
    let second: u32 = filename[second_start..second_start + 2]
        .parse()
        .expect("Failed to parse second");
    assert!(second <= 59, "Second {} is invalid", second);

    println!("✓ Filename format test passed: {}", filename);
}

#[test]
fn test_filename_readability() {
    use chrono::Local;

    let now = Local::now();
    let timestamp = now.format("%Y%m%d_%Hh%Mm%Ss");
    let filename = format!("{}_grim.png", timestamp);

    assert!(
        !filename.chars().all(|c| c.is_numeric() || c == '.'),
        "Filename looks like a unix timestamp"
    );

    // Verify it contains readable separators
    assert!(
        filename.contains("h"),
        "Filename missing hour separator 'h'"
    );
    assert!(
        filename.contains("m"),
        "Filename missing minute separator 'm'"
    );
    assert!(
        filename.contains("s"),
        "Filename missing second separator 's'"
    );
    assert!(
        filename.contains("_grim"),
        "Filename missing '_grim' identifier"
    );

    println!("✓ Filename readability test passed: {}", filename);
}

#[test]
fn test_filename_with_different_extensions() {
    use chrono::Local;

    let now = Local::now();
    let timestamp = now.format("%Y%m%d_%Hh%Mm%Ss");

    let extensions = vec!["png", "jpeg"];
    for ext in extensions {
        let filename = format!("{}_grim.{}", timestamp, ext);
        assert!(
            filename.ends_with(&format!("_grim.{}", ext)),
            "Filename '{}' doesn't have correct extension",
            filename
        );
        println!("✓ Extension test passed for: {}", filename);
    }
}