glowpub 0.5.0

A glowfic to epub converter.
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] // Not serialized
pub struct Continuity {
    pub board: Board,
    pub threads: Vec<Thread>,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Board {
    pub id: u64,
    pub name: String,
    pub board_sections: Vec<Section>,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Section {
    pub id: u64,
    pub name: String,
    pub order: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] // Not serialized
pub struct Thread {
    pub post: Post,
    pub replies: Vec<Reply>,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Post {
    pub id: u64,
    pub authors: Vec<User>,
    pub board: BoardInPost,
    pub character: Option<Character>,
    pub content: String,
    #[serde(with = "crate::rfc3339")]
    pub created_at: DateTime<Utc>,
    pub description: Option<String>,
    pub icon: Option<Icon>,
    pub num_replies: u64,
    pub section: Option<Section>,
    pub section_order: u64,
    pub status: String,
    pub subject: String,
    #[serde(with = "crate::rfc3339")]
    pub tagged_at: DateTime<Utc>,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct User {
    pub id: u64,
    pub username: String,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Token {
    pub token: String,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BoardInPost {
    pub id: u64,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Character {
    pub id: u64,
    pub name: String,
    pub screenname: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Icon {
    pub id: u64,
    pub keyword: Option<String>,
    pub url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Reply {
    pub id: u64,
    pub character: Option<Character>,
    /// The name being used for this character in this reply.
    /// This will be an alias if one was used, or else the same as `self.character.name`.
    pub character_name: Option<String>,
    pub content: String,
    #[serde(with = "crate::rfc3339")]
    pub created_at: DateTime<Utc>,
    pub icon: Option<Icon>,
    #[serde(with = "crate::rfc3339")]
    pub updated_at: DateTime<Utc>,
    pub user: User,
}

mod helpers {
    use std::{
        collections::{BTreeSet, HashSet},
        iter,
    };

    use crate::generate::transform;

    use super::*;

    // TODO: can we rely on there always being at least one thread?
    impl Continuity {
        pub fn created_at(&self) -> Option<DateTime<Utc>> {
            self.threads.iter().map(|t| t.post.created_at).min()
        }
        pub fn tagged_at(&self) -> Option<DateTime<Utc>> {
            self.threads.iter().map(|t| t.post.tagged_at).max()
        }
        pub fn authors(&self) -> Vec<User> {
            self.threads
                .iter()
                .flat_map(|t| t.post.authors.clone())
                .collect::<BTreeSet<_>>()
                .into_iter()
                .collect()
        }
        pub fn sections(&self) -> (Vec<(Section, Vec<&Thread>)>, Vec<&Thread>) {
            let mut sections = self.board.board_sections.clone();
            sections.sort_by_key(|s| s.order);

            let sections: Vec<(Section, Vec<&Thread>)> = sections
                .into_iter()
                .map(|s| {
                    let mut threads: Vec<&Thread> = self
                        .threads
                        .iter()
                        .filter(|t| t.post.section.as_ref().map(|s| s.id) == Some(s.id))
                        .collect();
                    threads.sort_by_key(|t| t.post.section_order);
                    (s, threads)
                })
                .collect();

            let mut sectionless_threads: Vec<&Thread> = self
                .threads
                .iter()
                .filter(|t| t.post.section.is_none())
                .collect();
            sectionless_threads.sort_by_key(|t| t.post.section_order);

            (sections, sectionless_threads)
        }
    }
    impl Thread {
        pub fn image_urls(&self) -> HashSet<String> {
            let contents = iter::once(&self.post.content)
                .chain(&self.post.description)
                .chain(self.replies.iter().map(|r| &r.content));

            let mut urls = HashSet::new();
            for c in contents {
                transform::edit_image_urls(c, |url| {
                    urls.insert(url.clone());
                    url
                });
            }

            urls
        }
    }
}