hunch 2.0.2

A media filename parser for movies, TV, and anime — built in Rust, inspired by guessit
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
144
145

//! Issue #208 regression: extras/specials/bonus subdirectories should
//! block ancestor-title inheritance, not just sample/subs.
//!
//! The original `is_sample_dir` predicate only suppressed the
//! parent-title fallback for `sample/samples/subs/subtitles/featurettes`.
//! Renamed in this fix to `is_inheritance_blocking_dir` and extended to
//! cover `extras/extra/specials/bonus`.
//!
//! Without the fix, a batch tree like:
//!
//! ```text
//! tv/
//!   Movie.2024.mkv
//!   Show/Extras/Bonus.Featurette.mkv
//! ```
//!
//! would cause `Bonus.Featurette.mkv` to incorrectly inherit "Movie" via
//! the ancestor cache built up at the `tv/` level.

use assert_cmd::Command;
use std::fs;
use tempfile::TempDir;

/// Build the #208 reproducer tree. Returns the temp dir (kept alive
/// until drop).
fn build_extras_inheritance_tree() -> TempDir {
    let tmp = TempDir::new().expect("temp dir");
    let root = tmp.path();

    // Sibling movie file at the batch root \u2014 this is the title that
    // would (wrongly) leak into the Extras subtree without the fix.
    fs::write(root.join("Movie.2024.mkv"), b"").unwrap();

    // The Extras directory under a Show, holding a single bonus file.
    let extras = root.join("Show").join("Extras");
    fs::create_dir_all(&extras).unwrap();
    fs::write(extras.join("Bonus.Featurette.mkv"), b"").unwrap();

    tmp
}

/// The headline regression: `--batch -r` over the tree above must NOT
/// stamp "Movie" onto `Bonus.Featurette.mkv`.
#[test]
fn issue_208_extras_dir_blocks_ancestor_title_inheritance() {
    let tmp = build_extras_inheritance_tree();

    let output = Command::cargo_bin("hunch")
        .expect("hunch binary")
        .args(["--batch", tmp.path().to_str().unwrap(), "-r", "-j"])
        .output()
        .expect("hunch ran");

    assert!(
        output.status.success(),
        "hunch exited with: {}",
        String::from_utf8_lossy(&output.stderr),
    );

    let stdout = String::from_utf8_lossy(&output.stdout);

    // Find the Bonus.Featurette.mkv line. It must not carry "Movie" as
    // its title via the polluted ancestor cache.
    let bonus_line = stdout
        .lines()
        .find(|l| l.contains("Bonus.Featurette.mkv"))
        .unwrap_or_else(|| panic!("Bonus.Featurette.mkv missing from output:\n{stdout}"));

    assert!(
        !bonus_line.contains("\"title\":\"Movie\""),
        "Bonus.Featurette.mkv must not inherit 'Movie' title from sibling \
         batch entries. Got: {bonus_line}",
    );
}

/// Companion check: make sure all four new vocabulary words actually
/// block inheritance. We use one small tree per word to keep failures
/// pinpointable to the exact directory name that regressed.
#[test]
fn issue_208_all_extras_synonyms_block_inheritance() {
    for synonym in ["Extras", "Extra", "Specials", "Bonus"] {
        let tmp = TempDir::new().expect("temp dir");
        let root = tmp.path();

        fs::write(root.join("Movie.2024.mkv"), b"").unwrap();
        let sub = root.join("Show").join(synonym);
        fs::create_dir_all(&sub).unwrap();
        fs::write(sub.join("Aux.Clip.mkv"), b"").unwrap();

        let output = Command::cargo_bin("hunch")
            .expect("hunch binary")
            .args(["--batch", root.to_str().unwrap(), "-r", "-j"])
            .output()
            .expect("hunch ran");
        assert!(
            output.status.success(),
            "[{synonym}] hunch failed: {}",
            String::from_utf8_lossy(&output.stderr),
        );

        let stdout = String::from_utf8_lossy(&output.stdout);
        let aux_line = stdout
            .lines()
            .find(|l| l.contains("Aux.Clip.mkv"))
            .unwrap_or_else(|| panic!("[{synonym}] Aux.Clip.mkv missing from:\n{stdout}"));

        assert!(
            !aux_line.contains("\"title\":\"Movie\""),
            "[{synonym}] should block ancestor-title inheritance. Got: {aux_line}",
        );
    }
}

/// Don't regress #97: the original sample/subs vocabulary must still
/// block inheritance. Lowercase + uppercase casing both honored.
#[test]
fn issue_97_sample_synonyms_still_block_inheritance() {
    for synonym in ["Sample", "samples", "Subs", "Subtitles", "Featurettes"] {
        let tmp = TempDir::new().expect("temp dir");
        let root = tmp.path();

        fs::write(root.join("Movie.2024.mkv"), b"").unwrap();
        let sub = root.join("Show").join(synonym);
        fs::create_dir_all(&sub).unwrap();
        fs::write(sub.join("Clip.mkv"), b"").unwrap();

        let output = Command::cargo_bin("hunch")
            .expect("hunch binary")
            .args(["--batch", root.to_str().unwrap(), "-r", "-j"])
            .output()
            .expect("hunch ran");
        assert!(output.status.success());

        let stdout = String::from_utf8_lossy(&output.stdout);
        let clip_line = stdout
            .lines()
            .find(|l| l.contains("Clip.mkv"))
            .unwrap_or_else(|| panic!("[{synonym}] Clip.mkv missing"));

        assert!(
            !clip_line.contains("\"title\":\"Movie\""),
            "[{synonym}] should still block inheritance (#97). Got: {clip_line}",
        );
    }
}