cinekey 0.4.0

Fast parser for movie and TV release names
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

use crate::lexer::ReleaseToken as Token;
use crate::vocabulary::{Attribute, Phrase, Word};
use crate::{AudioProfile, Edition, ReleaseFlag, StreamingService};

#[derive(Clone, Copy, Debug)]
pub(super) struct Marker {
    pub value: Attribute,
    pub end: usize,
}

fn is(tokens: &[Token<'_>], index: usize, expected: &str) -> bool {
    tokens
        .get(index)
        .is_some_and(|token| token.text.eq_ignore_ascii_case(expected))
}

fn web_context(tokens: &[Token<'_>], index: usize) -> bool {
    tokens
        .iter()
        .skip(index.saturating_sub(2))
        .take(5)
        .any(|token| {
            ["web", "webdl", "webrip"]
                .iter()
                .any(|word| token.text.eq_ignore_ascii_case(word))
        })
}

#[inline]
pub(super) fn recognize(tokens: &[Token<'_>], index: usize) -> Option<Marker> {
    use Attribute::{AudioProfile as A, Edition as E, Flag as F, Service as S};
    let token = tokens.get(index)?;
    let word = token.word?;
    let next = index + 1;
    let previous = index.checked_sub(1);
    let dts_context = || {
        previous.is_some_and(|i| {
            is(tokens, i, "dts")
                || is(tokens, i, "dtshd")
                || is(tokens, i, "hd") && i > 0 && is(tokens, i - 1, "dts")
        })
    };
    let (value, count) = match word {
        Word::Phrase(Phrase::Ma) if dts_context() => (A(AudioProfile::MasterAudio), 1),
        Word::Phrase(Phrase::Master) if dts_context() && is(tokens, next, "audio") => {
            (A(AudioProfile::MasterAudio), 2)
        }
        Word::Phrase(Phrase::HighResolution) if dts_context() => {
            (A(AudioProfile::HighResolutionAudio), 1)
        }
        Word::Phrase(Phrase::ExtendedSurround)
            if previous.is_some_and(|i| is(tokens, i, "dts")) =>
        {
            (A(AudioProfile::ExtendedSurround), 1)
        }
        Word::Phrase(Phrase::LowComplexity) if previous.is_some_and(|i| is(tokens, i, "aac")) => {
            (A(AudioProfile::LowComplexity), 1)
        }
        Word::Phrase(Phrase::HighEfficiency)
            if is(tokens, next, "aac") || previous.is_some_and(|i| is(tokens, i, "aac")) =>
        {
            (A(AudioProfile::HighEfficiency), 1)
        }
        Word::Phrase(Phrase::Ma) if web_context(tokens, index) => {
            (S(StreamingService::MoviesAnywhere), 1)
        }
        Word::Phrase(Phrase::Director) => {
            let cut = next + usize::from(is(tokens, next, "s"));
            if !is(tokens, cut, "cut") {
                return None;
            }
            (E(Edition::DirectorsCut), cut - index + 1)
        }
        Word::Phrase(Phrase::Alternative) if is(tokens, next, "cut") => {
            (E(Edition::AlternativeCut), 2)
        }
        Word::Edition(Edition::Ultimate)
            if is(tokens, next, "collector") || is(tokens, next, "collectors") =>
        {
            (E(Edition::Ultimate), 2)
        }
        Word::Phrase(Phrase::Read) if is(tokens, next, "nfo") => (F(ReleaseFlag::ReadNfo), 2),
        Word::Phrase(Phrase::Nfo) if is(tokens, next, "fix") => (F(ReleaseFlag::NfoFix), 2),
        Word::Phrase(Phrase::Proof) if is(tokens, next, "fix") => (F(ReleaseFlag::ProofFix), 2),
        _ => {
            let value = word.attribute()?;
            if matches!(value, E(Edition::Special | Edition::Anniversary))
                && !is(tokens, next, "edition")
            {
                return None;
            }
            let mut count = 1;
            if matches!(value, E(_)) {
                let qualifier = next + usize::from(is(tokens, next, "s"));
                if is(tokens, qualifier, "edition")
                    || is(tokens, qualifier, "cut")
                    || is(tokens, qualifier, "collection")
                {
                    count = qualifier - index + 1;
                }
            }
            (value, count)
        }
    };
    Some(Marker {
        value,
        end: tokens.get(index + count - 1)?.end,
    })
}

pub(super) fn phrase(tokens: &[Token<'_>], index: usize) -> bool {
    recognize(tokens, index).is_some_and(|marker| marker.end > tokens[index].end)
}

pub(super) fn service_prefix(tokens: &[Token<'_>], index: usize) -> bool {
    tokens.get(index + 1).is_some_and(|token| {
        ["web", "webdl", "webrip"]
            .iter()
            .any(|word| token.text.eq_ignore_ascii_case(word))
    }) && recognize(tokens, index)
        .is_some_and(|marker| matches!(marker.value, Attribute::Service(_)))
}

pub(super) fn edition_word(token: &Token<'_>) -> bool {
    token.word.is_some_and(crate::vocabulary::Word::is_edition)
}