dynasty 1.4.1

Dynasty Reader's CLI downloader
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
146
147
148

use std::{fmt::Display, str::FromStr};

use anyhow::Result;
use dynasty_api::directory::DirectoryKind;
use lazy_regex::regex;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ParsedArgumentValue {
    Chapter(String),
    #[cfg(feature = "search")]
    Search(SearchValue),
    Tag(TagValue),
}

#[cfg(feature = "search")]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SearchValue {
    pub query: String,
    pub sort: Option<dynasty_api::search::SearchSort>,
    pub categories: Vec<dynasty_api::search::SearchCategory>,
}

#[cfg(feature = "search")]
impl TryFrom<crate::search::SearchCommand> for SearchValue {
    type Error = anyhow::Error;

    fn try_from(value: crate::search::SearchCommand) -> Result<Self, Self::Error> {
        let query = if let Some(query) = value.query {
            query
        } else {
            dialoguer::Input::with_theme(&dialoguer::theme::ColorfulTheme::default())
                .with_prompt("query")
                .report(false)
                .interact_text()?
        };
        let sort = value.sort.map(|i| i.0);
        let categories = value.categories.iter().map(|i| i.0).collect();

        Ok(SearchValue {
            query,
            sort,
            categories,
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TagValue {
    pub kind: DirectoryKind,
    pub permalink: String,
}

impl Display for TagValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}/{}", self.kind, self.permalink)
    }
}

impl Display for ParsedArgumentValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self {
            ParsedArgumentValue::Chapter(value) => value.fmt(f),
            ParsedArgumentValue::Tag(value) => value.fmt(f),
            #[cfg(feature = "search")]
            ParsedArgumentValue::Search(value) => value.query.fmt(f),
        }
    }
}

impl FromStr for ParsedArgumentValue {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let re = regex!(
            r"(?x)
        ^
        (?:https?://dynasty-scans.com)
        /?
        (?P<directory>\w+)
        /?
        (?P<permalink>\w+)?
        /?
        $"
        );

        if let Some(captures) = re.captures(s) {
            let directory = captures.name("directory").unwrap().as_str();

            if let Some(permalink_match) = captures.name("permalink") {
                if directory == "chapters" {
                    return Ok(ParsedArgumentValue::Chapter(
                        permalink_match.as_str().to_string(),
                    ));
                } else if let Ok(kind) = directory.parse::<DirectoryKind>() {
                    return Ok(ParsedArgumentValue::Tag(TagValue {
                        kind,
                        permalink: permalink_match.as_str().to_string(),
                    }));
                }
            }
        }

        Err(anyhow::anyhow!("not a valid Dynasty Reader URL"))
    }
}

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

    #[test]
    fn should_parse_dynasty_api_argument() -> Result<()> {
        let predicates = [
            (
                "https://dynasty-scans.com/series/liar_satsuki_can_see_death",
                ParsedArgumentValue::Tag(TagValue {
                    kind: DirectoryKind::Series,
                    permalink: "liar_satsuki_can_see_death".to_string(),
                }),
            ),
            (
                "https://dynasty-scans.com/chapters/kiss_distance",
                ParsedArgumentValue::Chapter("kiss_distance".to_string()),
            ),
        ];

        for (left, right) in predicates {
            assert_eq!(left.parse::<ParsedArgumentValue>()?, right);
        }

        Ok(())
    }

    #[test]
    fn should_fail_parse_dynasty_api_argument() -> Result<()> {
        let predicates = [
            "https://google.com/a/b",         // wrong website host
            "anytextorwhateverthisisn",       // <-
            "https://dynasty-scans.com/tags", // incomplete path
        ];

        for predicate in predicates {
            assert!(predicate.parse::<ParsedArgumentValue>().is_err())
        }

        Ok(())
    }
}