shindan-maker 0.1.30

A Rust library for interacting with ShindanMaker, the popular personality quiz service.
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

use crate::domain::ShindanDomain;
use crate::internal;
use anyhow::{Context, Result};
use reqwest::{Client, header};
use scraper::Html;
use std::time::Duration;

#[cfg(feature = "segments")]
use crate::models::Segments;

/// A client for interacting with ShindanMaker.
#[derive(Clone, Debug)]
pub struct ShindanClient {
    client: Client,
    domain: ShindanDomain,
}

impl ShindanClient {
    /// Create a new ShindanMaker client.
    pub fn new(domain: ShindanDomain) -> Result<Self> {
        const TIMEOUT_SECS: u64 = 30;
        const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";

        Ok(Self {
            domain,
            client: Client::builder()
                .user_agent(USER_AGENT)
                .use_rustls_tls()
                .timeout(Duration::from_secs(TIMEOUT_SECS))
                .cookie_store(true)
                .build()?,
        })
    }

    /// Fetches and extracts title from a shindan page.
    pub async fn get_title(&self, id: &str) -> Result<String> {
        let document = self.fetch_document(id).await?;
        internal::extract_title(&document)
    }

    /// Fetches and extracts description from a shindan page.
    pub async fn get_description(&self, id: &str) -> Result<String> {
        let document = self.fetch_document(id).await?;
        internal::extract_description(&document)
    }

    /// Fetches and extracts both title and description from a shindan page.
    pub async fn get_title_with_description(&self, id: &str) -> Result<(String, String)> {
        let document = self.fetch_document(id).await?;
        Ok((
            internal::extract_title(&document)?,
            internal::extract_description(&document)?,
        ))
    }

    #[cfg(feature = "segments")]
    /// Get the segments of a shindan.
    pub async fn get_segments(&self, id: &str, name: &str) -> Result<Segments> {
        let (_, response_text) = self.submit_shindan(id, name, false).await?;
        internal::parse_segments(&response_text)
    }

    #[cfg(feature = "segments")]
    /// Get the segments of a shindan and the title of the shindan.
    pub async fn get_segments_with_title(
        &self,
        id: &str,
        name: &str,
    ) -> Result<(Segments, String)> {
        let (title, response_text) = self.submit_shindan(id, name, true).await?;
        let title = title.context("Title should have been extracted")?;
        let segments = internal::parse_segments(&response_text)?;

        Ok((segments, title))
    }

    #[cfg(feature = "html")]
    /// Get the HTML string of a shindan.
    pub async fn get_html_str(&self, id: &str, name: &str) -> Result<String> {
        let (_, response_text) = self.submit_shindan(id, name, false).await?;
        internal::construct_html_result(id, &response_text, &self.domain.to_string())
    }

    #[cfg(feature = "html")]
    /// Get the HTML string of a shindan and the title of the shindan.
    pub async fn get_html_str_with_title(&self, id: &str, name: &str) -> Result<(String, String)> {
        let (title, response_text) = self.submit_shindan(id, name, true).await?;
        let title = title.context("Title should have been extracted")?;
        let html = internal::construct_html_result(id, &response_text, &self.domain.to_string())?;

        Ok((html, title))
    }

    // --- Internal Helpers ---

    async fn fetch_document(&self, id: &str) -> Result<Html> {
        let url = format!("{}{}", self.domain, id);
        let text = self.client.get(&url).send().await?.text().await?;
        Ok(Html::parse_document(&text))
    }

    async fn submit_shindan(
        &self,
        id: &str,
        name: &str,
        extract_title: bool,
    ) -> Result<(Option<String>, String)> {
        let url = format!("{}{}", self.domain, id);

        // 1. Initial GET
        let initial_response = self.client.get(&url).send().await?;
        let initial_response_text = initial_response.text().await?;

        let document = Html::parse_document(&initial_response_text);

        // 2. Extract Form Data
        let form_data = internal::extract_form_data(&document, name)?;

        let title = if extract_title {
            Some(internal::extract_title(&document)?)
        } else {
            None
        };

        // 3. POST
        let mut headers = header::HeaderMap::new();
        headers.insert(
            header::CONTENT_TYPE,
            header::HeaderValue::from_static("application/x-www-form-urlencoded"),
        );

        let post_response = self
            .client
            .post(&url)
            .headers(headers)
            .form(&form_data)
            .send()
            .await?;
        let response_text = post_response.text().await?;

        Ok((title, response_text))
    }
}