feat(indexer): tvsearch with season and episode tags (#78)

crates/arr-parse/src/episodes.rs

@@ -0,0 +1,158 @@
+//! Season and episode tags in release names.
+//!
+//! A pack and a single episode carry the same series title and differ only
+//! here, so the distinction is a parse result rather than a downstream guess.
+
+use crate::EpisodeClaim;
+
+/// Longest episode range expanded from a tag like `S01E01-E12`. Anything
+/// wider is a malformed tag rather than a real multi-episode file.
+const MAX_RANGE: u32 = 100;
+
+/// The first season, episode or air-date tag in a tokenised release name.
+pub(crate) fn claim(tokens: &[&str]) -> Option<EpisodeClaim> {
+    for (index, token) in tokens.iter().enumerate() {
+        if let Some(claim) = tag_of(token) {
+            return Some(claim);
+        }
+        if matches!(*token, "season" | "seasons") {
+            if let Some(claim) = tokens.get(index + 1).and_then(|next| season_words(next)) {
+                return Some(claim);
+            }
+        }
+        if let (Some(month), Some(day)) = (tokens.get(index + 1), tokens.get(index + 2)) {
+            if let Some(claim) = date(token, month, day) {
+                return Some(claim);
+            }
+        }
+    }
+    None
+}
+
+/// A season, episode or air-date claim held in a single token.
+pub(crate) fn tag_of(token: &str) -> Option<EpisodeClaim> {
+    season_tag(token)
+        .or_else(|| cross_tag(token))
+        .or_else(|| date_tag(token))
+}
+
+/// `S01`, `S01-S03`, `S01E02`, `S01E02E03`, `S01E02-E04`.
+fn season_tag(token: &str) -> Option<EpisodeClaim> {
+    let rest = token.strip_prefix('s')?;
+    let (season, mut rest) = digits(rest);
+    if !(1..=2).contains(&season.len()) {
+        return None;
+    }
+    let season: u32 = season.parse().ok()?;
+
+    if rest.is_empty() {
+        return Some(EpisodeClaim::Season { season });
+    }
+
+    if let Some(range) = rest.strip_prefix("-s") {
+        let (last, tail) = digits(range);
+        if !tail.is_empty() || !(1..=2).contains(&last.len()) {
+            return None;
+        }
+        let last: u32 = last.parse().ok()?;
+        return (last > season).then_some(EpisodeClaim::Seasons {
+            first: season,
+            last,
+        });
+    }
+
+    let mut episodes: Vec<u32> = Vec::new();
+    while !rest.is_empty() {
+        let (ranged, body) = if let Some(body) = rest.strip_prefix('e') {
+            (false, body)
+        } else {
+            (
+                true,
+                rest.strip_prefix("-e").or_else(|| rest.strip_prefix('-'))?,
+            )
+        };
+        let (number, tail) = digits(body);
+        if !(1..=3).contains(&number.len()) {
+            return None;
+        }
+        let number: u32 = number.parse().ok()?;
+        match episodes.last().copied() {
+            Some(previous) if ranged => {
+                if number <= previous || number - previous > MAX_RANGE {
+                    return None;
+                }
+                episodes.extend(previous.saturating_add(1)..=number);
+            }
+            _ => {
+                if !episodes.contains(&number) {
+                    episodes.push(number);
+                }
+            }
+        }
+        rest = tail;
+    }
+
+    (!episodes.is_empty()).then_some(EpisodeClaim::Episodes { season, episodes })
+}
+
+/// `1x02`, the alternative single-episode form.
+fn cross_tag(token: &str) -> Option<EpisodeClaim> {
+    let (season, rest) = digits(token);
+    if !(1..=2).contains(&season.len()) {
+        return None;
+    }
+    let (episode, tail) = digits(rest.strip_prefix('x')?);
+    if !tail.is_empty() || !(2..=3).contains(&episode.len()) {
+        return None;
+    }
+    Some(EpisodeClaim::Episodes {
+        season: season.parse().ok()?,
+        episodes: vec![episode.parse().ok()?],
+    })
+}
+
+/// A hyphenated air date, `2024-05-13`.
+fn date_tag(token: &str) -> Option<EpisodeClaim> {
+    let mut parts = token.split('-');
+    let (year, month, day) = (parts.next()?, parts.next()?, parts.next()?);
+    if parts.next().is_some() {
+        return None;
+    }
+    date(year, month, day)
+}
+
+/// An air date split across three tokens, `2024.05.13`.
+fn date(year: &str, month: &str, day: &str) -> Option<EpisodeClaim> {
+    if year.len() != 4 || month.len() != 2 || day.len() != 2 {
+        return None;
+    }
+    let year: u16 = year.parse().ok()?;
+    let month: u8 = month.parse().ok()?;
+    let day: u8 = day.parse().ok()?;
+    ((1900..=2999).contains(&year) && (1..=12).contains(&month) && (1..=31).contains(&day))
+        .then_some(EpisodeClaim::Daily { year, month, day })
+}
+
+/// The number after a spelled-out `Season`: `Season 1`, `Seasons 1-3`.
+fn season_words(token: &str) -> Option<EpisodeClaim> {
+    let (first, rest) = digits(token);
+    if !(1..=2).contains(&first.len()) {
+        return None;
+    }
+    let first: u32 = first.parse().ok()?;
+    if rest.is_empty() {
+        return Some(EpisodeClaim::Season { season: first });
+    }
+    let (last, tail) = digits(rest.strip_prefix('-')?);
+    if !tail.is_empty() || !(1..=2).contains(&last.len()) {
+        return None;
+    }
+    let last: u32 = last.parse().ok()?;
+    (last > first).then_some(EpisodeClaim::Seasons { first, last })
+}
+
+/// Splits a leading run of ASCII digits off a token.
+fn digits(token: &str) -> (&str, &str) {
+    let count = token.bytes().take_while(u8::is_ascii_digit).count();
+    token.split_at(count)
+}

crates/arr-parse/src/lib.rs

@@ -8,6 +8,7 @@
 //! Parsing never fails: a malformed name yields a partial [`NameClaims`],
 //! worst case an empty one.
 
+mod episodes;
 mod markers;
 
 use serde::{Deserialize, Serialize};
@@ -144,6 +145,82 @@ pub enum Edition {
     Limited,
 }
 
+/// What a release name claims about which episodes it holds. A season pack
+/// and one episode of that season carry the same series title and differ
+/// only here.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum EpisodeClaim {
+    /// One or more episodes of a single season: `S01E02`, `S01E02E03`,
+    /// `S01E02-E04`, `1x02`.
+    Episodes {
+        season: u32,
+        /// Claimed episode numbers, in order of appearance. Ranges are
+        /// expanded.
+        episodes: Vec<u32>,
+    },
+    /// A whole season, no episode number: `S01`, `Season 1`.
+    Season { season: u32 },
+    /// Several whole seasons: `S01-S03`, `Seasons 1-3`.
+    Seasons { first: u32, last: u32 },
+    /// A daily show identified by its air date: `2024.05.13`.
+    Daily { year: u16, month: u8, day: u8 },
+}
+
+impl EpisodeClaim {
+    /// Whether the release claims a whole season or more, rather than
+    /// named episodes.
+    #[must_use]
+    pub fn is_season_pack(&self) -> bool {
+        matches!(self, Self::Season { .. } | Self::Seasons { .. })
+    }
+
+    /// Whether the release claims several episodes in one file.
+    #[must_use]
+    pub fn is_multi_episode(&self) -> bool {
+        matches!(self, Self::Episodes { episodes, .. } if episodes.len() > 1)
+    }
+
+    /// Whether the claim covers one numbered episode.
+    #[must_use]
+    pub fn covers(&self, season: u32, episode: u32) -> bool {
+        match self {
+            Self::Episodes {
+                season: claimed,
+                episodes,
+            } => *claimed == season && episodes.contains(&episode),
+            Self::Season { .. } | Self::Seasons { .. } => self.covers_season(season),
+            Self::Daily { .. } => false,
+        }
+    }
+
+    /// Whether the claim covers any part of one season.
+    #[must_use]
+    pub fn covers_season(&self, season: u32) -> bool {
+        match self {
+            Self::Episodes {
+                season: claimed, ..
+            }
+            | Self::Season { season: claimed } => *claimed == season,
+            Self::Seasons { first, last } => (*first..=*last).contains(&season),
+            Self::Daily { .. } => false,
+        }
+    }
+
+    /// Whether the claim is exactly this air date.
+    #[must_use]
+    pub fn covers_date(&self, year: u16, month: u8, day: u8) -> bool {
+        matches!(
+            self,
+            Self::Daily {
+                year: claimed_year,
+                month: claimed_month,
+                day: claimed_day,
+            } if *claimed_year == year && *claimed_month == month && *claimed_day == day
+        )
+    }
+}
+
 /// What a release name claims about itself. Every field is unverified
 /// (`DESIGN.md` §5.6); absence of a marker means nothing.
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -167,6 +244,9 @@ pub struct NameClaims {
     pub editions: Vec<Edition>,
     /// Claimed release group.
     pub group: Option<String>,
+    /// Claimed season, episodes or air date. `None` for anything that does
+    /// not carry a TV tag.
+    pub episode: Option<EpisodeClaim>,
 }
 
 #[derive(Debug, Clone)]
@@ -205,11 +285,13 @@ pub fn parse(name: &str) -> NameClaims {
         .copied();
     let boundary = year_idx.map_or(limit, |y| y.min(limit));
 
+    let lows: Vec<&str> = toks.iter().map(|t| t.low.as_str()).collect();
     let mut claims = NameClaims {
         year: year_idx
             .and_then(|i| toks.get(i))
             .and_then(|t| markers::year_of(&t.low)),
         group: dash_group.or(bracket_group),
+        episode: episodes::claim(&lows),
         ..NameClaims::default()
     };
 

crates/arr-parse/src/markers.rs

@@ -159,37 +159,10 @@ fn is_audio_family(t: &str) -> bool {
     })
 }
 
-/// `S01`, `S01E02`, `S01E01E02`, `S01-E02`, `1x02`.
+/// `S01`, `S01E02`, `S01E01E02`, `S01-E02`, `1x02`, `S01-S03`, an air
+/// date. Anything that ends the title region on a TV tag.
 pub(crate) fn is_season_episode(t: &str) -> bool {
-    fn digits(s: &str) -> (usize, &str) {
-        let n = s.bytes().take_while(u8::is_ascii_digit).count();
-        (n, &s[n..])
-    }
-    if let Some(rest) = t.strip_prefix('s') {
-        let (n, mut rest) = digits(rest);
-        if !(1..=2).contains(&n) {
-            return false;
-        }
-        while !rest.is_empty() {
-            let Some(r) = rest.strip_prefix('e').or_else(|| rest.strip_prefix("-e")) else {
-                return false;
-            };
-            let (m, r2) = digits(r);
-            if !(1..=3).contains(&m) {
-                return false;
-            }
-            rest = r2;
-        }
-        return true;
-    }
-    let (n, rest) = digits(t);
-    if (1..=2).contains(&n) {
-        if let Some(r) = rest.strip_prefix('x') {
-            let (m, r2) = digits(r);
-            return (2..=3).contains(&m) && r2.is_empty();
-        }
-    }
-    false
+    crate::episodes::tag_of(t).is_some()
 }
 
 /// A plausible release year: four digits, 1900–2099.

crates/arr-parse/tests/corpus.rs

@@ -8,7 +8,9 @@
 //! pt-BR/pt-PT markers from §5.2, and real-world malformed names that
 //! must parse partially rather than fail.
 
-use arr_parse::{parse, Codec, Edition, HdrMarker, LanguageMarker, NameClaims, Resolution, Source};
+use arr_parse::{
+    parse, Codec, Edition, EpisodeClaim, HdrMarker, LanguageMarker, NameClaims, Resolution, Source,
+};
 use serde as _;
 
 struct Case {
@@ -21,6 +23,14 @@ fn s(v: &str) -> Option<String> {
     Some(v.to_string())
 }
 
+#[allow(clippy::unnecessary_wraps)]
+fn episodes(season: u32, episodes: &[u32]) -> Option<EpisodeClaim> {
+    Some(EpisodeClaim::Episodes {
+        season,
+        episodes: episodes.to_vec(),
+    })
+}
+
 /// Every resolution and every source tier appears at least once here,
 /// pulled from a broad search rather than picked to fit.
 #[allow(clippy::too_many_lines)]
@@ -56,6 +66,7 @@ fn matrix_cases() -> Vec<Case> {
                 source: Some(Source::WebDl),
                 codec: Some(Codec::X264),
                 group: s("RAWR"),
+                episode: episodes(2, &[1]),
                 ..NameClaims::default()
             },
         },
@@ -67,6 +78,7 @@ fn matrix_cases() -> Vec<Case> {
                 source: Some(Source::Hdtv),
                 codec: Some(Codec::X264),
                 group: s("SYNCOPY"),
+                episode: episodes(8, &[14]),
                 ..NameClaims::default()
             },
         },
@@ -78,6 +90,7 @@ fn matrix_cases() -> Vec<Case> {
                 source: Some(Source::BluRay),
                 codec: Some(Codec::X264),
                 group: s("CtrlHD"),
+                episode: episodes(3, &[22]),
                 ..NameClaims::default()
             },
         },
@@ -229,6 +242,7 @@ fn matrix_cases() -> Vec<Case> {
                 source: Some(Source::WebDl),
                 codec: Some(Codec::X265),
                 group: s("NTb"),
+                episode: Some(EpisodeClaim::Season { season: 1 }),
                 ..NameClaims::default()
             },
         },
@@ -268,6 +282,7 @@ fn matrix_cases() -> Vec<Case> {
                 source: Some(Source::Hdtv),
                 codec: Some(Codec::X264),
                 group: s("TJET"),
+                episode: Some(EpisodeClaim::Daily { year: 2026, month: 8, day: 21 }),
                 ..NameClaims::default()
             },
         },
@@ -279,6 +294,7 @@ fn matrix_cases() -> Vec<Case> {
                 resolution: Some(Resolution::P480),
                 codec: Some(Codec::X264),
                 group: s("mSD"),
+                episode: episodes(8, &[37]),
                 ..NameClaims::default()
             },
         },
@@ -291,6 +307,7 @@ fn matrix_cases() -> Vec<Case> {
                 resolution: Some(Resolution::P2160),
                 codec: Some(Codec::X265),
                 group: s("FaiLED"),
+                episode: episodes(1, &[1]),
                 ..NameClaims::default()
             },
         },
@@ -399,6 +416,7 @@ fn pt_br_cases() -> Vec<Case> {
                 resolution: Some(Resolution::P1080),
                 source: Some(Source::Hdtv),
                 languages: vec![LanguageMarker::Portuguese, LanguageMarker::PtPt],
+                episode: Some(EpisodeClaim::Season { season: 1 }),
                 ..NameClaims::default()
             },
         },
@@ -409,6 +427,7 @@ fn pt_br_cases() -> Vec<Case> {
                 resolution: Some(Resolution::P576),
                 source: Some(Source::WebDl),
                 languages: vec![LanguageMarker::Portuguese, LanguageMarker::PtPt],
+                episode: Some(EpisodeClaim::Season { season: 1 }),
                 ..NameClaims::default()
             },
         },
@@ -471,6 +490,7 @@ fn multi_audio_cases() -> Vec<Case> {
                 codec: Some(Codec::X264),
                 languages: vec![LanguageMarker::Multi],
                 group: s("mSD"),
+                episode: episodes(4, &[18]),
                 ..NameClaims::default()
             },
         },
@@ -484,6 +504,7 @@ fn multi_audio_cases() -> Vec<Case> {
                 codec: Some(Codec::X264),
                 languages: vec![LanguageMarker::Multi],
                 group: s("HiggsBoson"),
+                episode: episodes(1, &[1]),
                 ..NameClaims::default()
             },
         },
@@ -523,6 +544,7 @@ fn multi_audio_cases() -> Vec<Case> {
                 hdr: vec![HdrMarker::DolbyVision, HdrMarker::Hdr10Plus],
                 languages: vec![LanguageMarker::Dual],
                 group: s("Kitsune"),
+                episode: Some(EpisodeClaim::Season { season: 2 }),
                 ..NameClaims::default()
             },
         },
@@ -723,6 +745,146 @@ fn malformed_cases() -> Vec<Case> {
                 year: Some(2003),
                 resolution: Some(Resolution::P480),
                 source: Some(Source::Remux),
+                episode: Some(EpisodeClaim::Season { season: 1 }),
+                ..NameClaims::default()
+            },
+        },
+    ]
+}
+
+/// Season and episode tags, the distinction grab selection turns on
+/// (issue #37): single episodes, season packs, multi-episode files and
+/// daily-dated shows.
+#[allow(clippy::too_many_lines)]
+fn tv_cases() -> Vec<Case> {
+    vec![
+        Case {
+            name: "The Rookie S08E14 720p HDTV x264-SYNCOPY".into(),
+            want: NameClaims {
+                title: s("The Rookie"),
+                resolution: Some(Resolution::P720),
+                source: Some(Source::Hdtv),
+                codec: Some(Codec::X264),
+                group: s("SYNCOPY"),
+                episode: episodes(8, &[14]),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "Slow.Horses.1x02.1080p.WEB-DL.DDP5.1.H.264-NTb".into(),
+            want: NameClaims {
+                title: s("Slow Horses"),
+                resolution: Some(Resolution::P1080),
+                source: Some(Source::WebDl),
+                codec: Some(Codec::X264),
+                group: s("NTb"),
+                episode: episodes(1, &[2]),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "Severance.S02.2160p.ATVP.WEB-DL.DDP5.1.Atmos.DV.HDR.H.265-FLUX".into(),
+            want: NameClaims {
+                title: s("Severance"),
+                resolution: Some(Resolution::P2160),
+                source: Some(Source::WebDl),
+                codec: Some(Codec::X265),
+                hdr: vec![HdrMarker::DolbyVision, HdrMarker::Hdr],
+                group: s("FLUX"),
+                episode: Some(EpisodeClaim::Season { season: 2 }),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "The Bear Season 3 1080p WEB-DL x265-GROUP".into(),
+            want: NameClaims {
+                title: s("The Bear"),
+                resolution: Some(Resolution::P1080),
+                source: Some(Source::WebDl),
+                codec: Some(Codec::X265),
+                group: s("GROUP"),
+                episode: Some(EpisodeClaim::Season { season: 3 }),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "Peep.Show.S01-S09.COMPLETE.1080p.BluRay.x264-SHORTBREHD".into(),
+            want: NameClaims {
+                title: s("Peep Show"),
+                resolution: Some(Resolution::P1080),
+                source: Some(Source::BluRay),
+                codec: Some(Codec::X264),
+                group: s("SHORTBREHD"),
+                episode: Some(EpisodeClaim::Seasons { first: 1, last: 9 }),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "Adventure.Time.S05E01E02.1080p.WEB-DL.AAC2.0.H.264-iT00NZ".into(),
+            want: NameClaims {
+                title: s("Adventure Time"),
+                resolution: Some(Resolution::P1080),
+                source: Some(Source::WebDl),
+                codec: Some(Codec::X264),
+                group: s("iT00NZ"),
+                episode: episodes(5, &[1, 2]),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "Bluey.S03E01-E04.1080p.WEB-DL.DD+5.1.H.264-playWEB".into(),
+            want: NameClaims {
+                title: s("Bluey"),
+                resolution: Some(Resolution::P1080),
+                source: Some(Source::WebDl),
+                codec: Some(Codec::X264),
+                group: s("playWEB"),
+                episode: episodes(3, &[1, 2, 3, 4]),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "The.Daily.Show.2024.05.13.Jon.Stewart.1080p.WEB.h264-EDITH".into(),
+            want: NameClaims {
+                title: s("The Daily Show"),
+                year: Some(2024),
+                resolution: Some(Resolution::P1080),
+                source: Some(Source::WebDl),
+                codec: Some(Codec::X264),
+                group: s("EDITH"),
+                episode: Some(EpisodeClaim::Daily {
+                    year: 2024,
+                    month: 5,
+                    day: 13,
+                }),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "Last.Week.Tonight.With.John.Oliver.2024-09-15.720p.HDTV.x264-aAF".into(),
+            want: NameClaims {
+                title: s("Last Week Tonight With John Oliver"),
+                resolution: Some(Resolution::P720),
+                source: Some(Source::Hdtv),
+                codec: Some(Codec::X264),
+                group: s("aAF"),
+                episode: Some(EpisodeClaim::Daily {
+                    year: 2024,
+                    month: 9,
+                    day: 15,
+                }),
+                ..NameClaims::default()
+            },
+        },
+        Case {
+            name: "Dune.Part.Two.2024.2160p.WEB-DL.DDP5.1.Atmos.H.265-FLUX".into(),
+            want: NameClaims {
+                title: s("Dune Part Two"),
+                year: Some(2024),
+                resolution: Some(Resolution::P2160),
+                source: Some(Source::WebDl),
+                codec: Some(Codec::X265),
+                group: s("FLUX"),
                 ..NameClaims::default()
             },
         },
@@ -735,6 +897,7 @@ fn all_cases() -> Vec<Case> {
     cases.extend(multi_audio_cases());
     cases.extend(dv_hdr_cases());
     cases.extend(malformed_cases());
+    cases.extend(tv_cases());
     cases
 }
 

crates/arr-parse/tests/parse.rs

@@ -2,7 +2,9 @@
 //! corpus pulled from real indexers is issue #9; these rows pin the parser's
 //! behaviour per shape of name.
 
-use arr_parse::{parse, Codec, Edition, HdrMarker, LanguageMarker, NameClaims, Resolution, Source};
+use arr_parse::{
+    parse, Codec, Edition, EpisodeClaim, HdrMarker, LanguageMarker, NameClaims, Resolution, Source,
+};
 use serde as _;
 
 struct Case {
@@ -116,6 +118,10 @@ fn cases() -> Vec<Case> {
                 source: Some(Source::Hdtv),
                 codec: Some(Codec::X264),
                 group: s("LOL"),
+                episode: Some(EpisodeClaim::Episodes {
+                    season: 1,
+                    episodes: vec![2],
+                }),
                 ..NameClaims::default()
             },
         },
@@ -297,6 +303,7 @@ fn cases() -> Vec<Case> {
                 codec: Some(Codec::X265),
                 hdr: vec![HdrMarker::DolbyVision, HdrMarker::Hdr10],
                 group: s("NTb"),
+                episode: Some(EpisodeClaim::Season { season: 2 }),
                 ..NameClaims::default()
             },
         },
@@ -353,3 +360,66 @@ fn garbage_never_panics() {
         let _ = parse(input);
     }
 }
+
+#[test]
+fn episode_tags_separate_packs_from_single_episodes() {
+    let single = parse("Show.S01E02.1080p.WEB-DL.x264-GRP")
+        .episode
+        .expect("S01E02 is an episode tag");
+    assert_eq!(
+        single,
+        EpisodeClaim::Episodes {
+            season: 1,
+            episodes: vec![2]
+        }
+    );
+    assert!(!single.is_season_pack());
+    assert!(!single.is_multi_episode());
+    assert!(single.covers(1, 2));
+    assert!(!single.covers(1, 3));
+    assert!(single.covers_season(1));
+
+    let multi = parse("Show.S01E02-E04.1080p.WEB-DL.x264-GRP")
+        .episode
+        .expect("S01E02-E04 is an episode tag");
+    assert!(multi.is_multi_episode());
+    assert!(!multi.is_season_pack());
+    assert!(multi.covers(1, 3));
+    assert!(!multi.covers(1, 5));
+
+    let pack = parse("Show.S01.1080p.WEB-DL.x264-GRP")
+        .episode
+        .expect("S01 is a season tag");
+    assert!(pack.is_season_pack());
+    assert!(
+        pack.covers(1, 7),
+        "a season pack covers every episode in it"
+    );
+    assert!(!pack.covers(2, 7));
+
+    let seasons = parse("Show.S01-S03.1080p.WEB-DL.x264-GRP")
+        .episode
+        .expect("S01-S03 is a season range");
+    assert!(seasons.is_season_pack());
+    assert!(seasons.covers_season(2));
+    assert!(!seasons.covers_season(4));
+
+    let daily = parse("Show.2024.05.13.1080p.WEB.h264-GRP")
+        .episode
+        .expect("a dotted air date is a daily tag");
+    assert!(daily.covers_date(2024, 5, 13));
+    assert!(!daily.covers_date(2024, 5, 14));
+    assert!(!daily.covers(1, 1), "a daily episode has no season number");
+}
+
+#[test]
+fn non_tv_names_claim_no_episode() {
+    for name in [
+        "Dune.Part.Two.2024.2160p.WEB-DL.H.265-FLUX",
+        "Movie.1999.1080p.BluRay.x264-GRP",
+        "Show.2024.13.45.1080p.WEB-DL.x264-GRP",
+        "Blade.Runner.2049.2017.2160p.UHD.BluRay.x265-TERMiNAL",
+    ] {
+        assert_eq!(parse(name).episode, None, "{name}");
+    }
+}