badpod 0.9.1

A Rust crate for working with imperfect feeds of podcasts.
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

use crate::utils;
use crate::Other;
use strum::EnumIter;

/// Podcast platforms.
///
/// Taken from
/// <https://raw.githubusercontent.com/Podcastindex-org/podcast-namespace/main/serviceslugs.txt>.
#[derive(Debug, PartialEq, Eq, EnumIter)]
pub enum Service {
    Acast,
    Amazon,
    Anchor,
    Apple,
    Audible,
    Audioboom,
    Backtracks,
    Bitcoin,
    Blubrry,
    Buzzsprout,
    Captivate,
    Castos,
    Castopod,
    Facebook,
    Fireside,
    Fyyd,
    Google,
    GPodder,
    HyperCatcher,
    Kasts,
    Libsyn,
    Mastodon,
    Megafono,
    Megaphone,
    OmnyStudio,
    Overcast,
    PayPal,
    Pinecast,
    Podbean,
    PodcastAddict,
    PodcastGuru,
    PodcastIndex,
    Podcasts,
    Podchaser,
    PodCloud,
    Podfriend,
    Podiant,
    Podigee,
    Podnews,
    Podomatic,
    PodServe,
    Podverse,
    RedCircle,
    Relay,
    ResonateRecordings,
    Rss,
    ShoutEngine,
    Simplecast,
    Slack,
    SoundCloud,
    Spotify,
    Spreaker,
    TikTok,
    Transistor,
    Twitter,
    Whooshkaa,
    YouTube,
    ZenCast,

    Other(Other),
}

impl std::str::FromStr for Service {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match utils::from_str_exact(s) {
            Some(variant) => Ok(variant),
            None => Ok(Self::Other((s.to_string(), "should be a service slug from <https://raw.githubusercontent.com/Podcastindex-org/podcast-namespace/main/serviceslugs.txt>".to_string()))),
        }
    }
}

impl std::fmt::Display for Service {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Other((s, _)) => write!(f, "{s}"),
            _ => {
                let s = format!("{self:?}");
                write!(f, "{}", s.to_lowercase())
            }
        }
    }
}

impl Service {
    pub fn parse(s: &str) -> Self {
        match s.parse() {
            Ok(service) => service,
            Err(e) => Self::Other((s.to_string(), e)),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_fmt() {
        pretty_assertions::assert_eq!(format!("{}", Service::YouTube), "youtube");
        pretty_assertions::assert_eq!(format!("{}", Service::Amazon), "amazon");
        pretty_assertions::assert_eq!(format!("{}", Service::TikTok), "tiktok");
        pretty_assertions::assert_eq!(
            format!("{}", Service::Other(("other-service".to_string(), "should be a service slug from <https://raw.githubusercontent.com/Podcastindex-org/podcast-namespace/main/serviceslugs.txt>".to_string()))),
            "other-service"
        );
    }
}