tv-renamer 0.3.3

TV renaming application with TVDB titles and templating support
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

#[derive(Clone, Debug, PartialEq)]
pub enum TemplateToken {
    Character(char),
    Series,
    Season,
    Episode,
    TvdbTitle,
    TvdbFirstAired,

}

// The default template signature is `${SERIES} ${SEASON}x${EPISODE} ${TITLE}`
pub fn default_template() -> Vec<TemplateToken> {
    vec![TemplateToken::Series,
         TemplateToken::Character(' '),
         TemplateToken::Character('-'),
         TemplateToken::Character(' '),
         TemplateToken::Season,
         TemplateToken::Character('x'),
         TemplateToken::Episode,
         TemplateToken::Character(' '),
         TemplateToken::Character('-'),
         TemplateToken::Character(' '),
         TemplateToken::TvdbTitle]
}

/// This tokenizer will take the template string as input and convert it into an ordered vector of tokens.
pub fn tokenize_template(template: &str) -> Vec<TemplateToken> {
    let mut tokens = Vec::new();
    let mut pattern = String::new();
    let mut matching = false;
    for character in template.chars() {
        match (character, matching) {
            ('$', true) => {
                matching = false;
                for character in pattern.chars() {
                    tokens.push(TemplateToken::Character(character));
                }
                tokens.push(TemplateToken::Character('$'));
                pattern.clear();
            }
            ('$', false) => {
                matching = true;
                pattern.push('$');
            }
            ('{', true) => {
                if pattern.len() == 1 {
                    pattern.push('{');
                } else {
                    matching = false;
                    for character in pattern.chars() {
                        tokens.push(TemplateToken::Character(character));
                    }
                    tokens.push(TemplateToken::Character('$'));
                    pattern.clear();
                }
            }
            ('{', false) => tokens.push(TemplateToken::Character('{')),
            ('}', true) => {
                pattern.push('}');
                match match_token(&pattern) {
                    Some(value) => tokens.push(value),
                    None => {
                        for character in pattern.chars() {
                            tokens.push(TemplateToken::Character(character));
                        }
                        tokens.push(TemplateToken::Character('$'));
                    }
                }
                matching = false;
                pattern.clear();
            }
            (_, true) => pattern.push(character),
            (_, false) => tokens.push(TemplateToken::Character(character)),
        }
    }
    tokens
}

/// Given a pattern, this function will attempt to match the pattern to a predefined token.
fn match_token(pattern: &str) -> Option<TemplateToken> {
    match pattern {
        "${Series}"           => Some(TemplateToken::Series),
        "${Season}"           => Some(TemplateToken::Season),
        "${Episode}"          => Some(TemplateToken::Episode),
        "${TVDB_Title}"       => Some(TemplateToken::TvdbTitle),
        "${TVDB_First_Aired}" => Some(TemplateToken::TvdbFirstAired),
        _                     => None
    }
}

#[test]
fn test_tokenize() {
    assert_eq!(default_template(), tokenize_template("${Series} - ${Season}x${Episode} - ${TVDB_Title}"));
}

#[test]
fn test_match_token() {
    assert_eq!(Some(TemplateToken::Series), match_token("${Series}"));
    assert_eq!(Some(TemplateToken::Season), match_token("${Season}"));
    assert_eq!(Some(TemplateToken::Episode), match_token("${Episode}"));
    assert_eq!(Some(TemplateToken::TvdbTitle), match_token("${TVDB_Title}"));
    assert_eq!(Some(TemplateToken::TvdbFirstAired), match_token("${TVDB_First_Aired}"));
    assert_eq!(None, match_token("${invalid}"));
}