snoo 0.0.4

Reddit client.
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

use crate::models::{ListingData, RedditResponse, RedditResponseGeneric};

use crate::items::{
    search::{PostSearch, SubredditSearch, UserSearch},
    submission::Submission,
    subreddit::SubredditLink,
    user::RedditUserLink,
    AbstractedApi,
};

use crate::endpoints::{self, Endpoint, EndpointBase, EndpointBuilder, SearchSort};

use crate::rate_limit::RateLimiter;
use crate::reddit_app::RedditApp;

use serde::de::DeserializeOwned;
use std::io;

/// Reddit client instance
#[derive(Clone)]
pub struct Reddit {
    pub(crate) app: RedditApp,
}

impl Reddit {
    pub fn new() -> io::Result<Reddit> {
        Ok(Reddit {
            app: RedditApp::new()?,
        })
    }

    pub fn from_app(app: RedditApp) -> io::Result<Reddit> {
        Ok(Reddit { app: app })
    }

    /// Takes a Api model and binds it to the
    /// Reddit instance so api calls can be made.
    pub fn bind<'r, T: AbstractedApi<'r>>(&'r self, api_data: T::ApiType) -> T::AbstractedType {
        T::from_parent(self, api_data)
    }

    /// Builds a new ep
    pub fn ep(&self, builder: EndpointBuilder) -> io::Result<Endpoint> {
        self.app.create_endpoint(builder)
    }

    /// Builds a new ep from a string
    pub fn ep_str(&self, str_ep: &str) -> io::Result<Endpoint> {
        self.app.create_enddpoint_str(str_ep)
    }

    pub(crate) async fn get_data<T: DeserializeOwned>(
        &self,
        ep: Endpoint,
    ) -> io::Result<RedditResponseGeneric<T>> {
        self.app
            .create_request::<RedditResponseGeneric<T>>(ep.to_url())
            .await
    }

    pub(crate) async fn get_list<T: DeserializeOwned>(&self, ep: Endpoint) -> io::Result<Vec<T>> {
        let data = self.get_data::<ListingData<T>>(ep).await?;
        let infos = data.data.inner_children();
        Ok(infos)
    }

    /// No rate limiting.
    pub fn rate_limit_off(mut self) -> Self {
        self.app.rate_limiter = RateLimiter::Off;
        self
    }

    /// Make requests as quick as possable until limit is
    /// reached, then wait for reset.
    pub fn rate_limit_bacthed(mut self) -> Self {
        self.app.rate_limiter = RateLimiter::new_batched();
        self
    }

    /// Every request will wait (requests_avalible) / (time_avalible)
    /// so the delays are evenly spaced.
    pub fn rate_limit_paced(mut self) -> Self {
        self.app.rate_limiter = RateLimiter::new_paced();
        self
    }

    // Get a user by name
    pub fn user(&self, username: &str) -> RedditUserLink {
        RedditUserLink::new(self, username)
    }

    //get a subreddit by name
    pub fn subreddit(&self, name: &str) -> SubredditLink {
        SubredditLink::new(self, name)
    }

    /// Search over all of reddit
    pub async fn search<'r, 's>(
        &'r self,
        query: &'s str,
        sort: SearchSort,
    ) -> io::Result<PostSearch<'r, 's>> {
        let search_ep = self.ep(endpoints::SEARCH)?;
        PostSearch::new_search(self, search_ep, query, sort).await
    }

    /// Search for a subreddit
    pub async fn search_subreddits<'r, 's>(
        &'r self,
        query: &'s str,
        sort: SearchSort,
    ) -> io::Result<SubredditSearch<'r, 's>> {
        let search_ep = self.ep(endpoints::SUBREDDITS_SEARCH)?;
        SubredditSearch::new_search(self, search_ep, query, sort).await
    }

    /// Search for a subreddit
    pub async fn search_users<'r, 's>(
        &'r self,
        query: &'s str,
        sort: SearchSort,
    ) -> io::Result<UserSearch<'r, 's>> {
        let search_ep = self.ep(endpoints::USERS_SEARCH)?;
        UserSearch::new_search(self, search_ep, query, sort).await
    }

    /// Get post info
    /// a "Submission" is a post + comments
    pub async fn submission_from_link(&self, url: &'_ str) -> io::Result<Submission<'_>> {
        let page_link = self.ep_str(url)?;
        let post_data = self
            .get_data::<ListingData<RedditResponse>>(page_link)
            .await?;
        Ok(Submission::from_resp(self, post_data.data))
    }
}