rustboxd 0.2.0

A Letterboxd web scraper and API client library written in Rust
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

use crate::core::constants::DOMAIN;

/// Convert regular URL to AJAX URL for pagination
pub fn get_ajax_url(url: &str) -> String {
    if url.contains("/films/") {
        url.replace("/films/", "/ajax/films/")
    } else if url.contains("/film/") {
        url.replace("/film/", "/ajax/film/")
    } else if url.contains("/lists/") {
        url.replace("/lists/", "/ajax/lists/")
    } else if url.contains("/reviews/") {
        url.replace("/reviews/", "/ajax/reviews/")
    } else {
        format!("{}/ajax", url.trim_end_matches('/'))
    }
}

/// Build Letterboxd URL from components
pub fn build_letterboxd_url(path: &str) -> String {
    let path = path.trim_start_matches('/');
    format!("{}/{}", DOMAIN, path)
}

/// Build user profile URL
pub fn build_user_url(username: &str) -> String {
    format!("{}/{}/", DOMAIN, username)
}

/// Build film URL from slug
pub fn build_film_url(slug: &str) -> String {
    format!("{}/film/{}/", DOMAIN, slug)
}

/// Build list URL from author and slug
pub fn build_list_url(author: &str, slug: &str) -> String {
    format!("{}/{}/list/{}/", DOMAIN, author, slug)
}

/// Build search URL
pub fn build_search_url(query: &str, filter: Option<&str>) -> String {
    let encoded_query = urlencoding::encode(query);
    
    if let Some(filter) = filter {
        format!("{}/s/search/{}/{}/", DOMAIN, filter, encoded_query)
    } else {
        format!("{}/s/search/{}/", DOMAIN, encoded_query)
    }
}

/// Build diary URL with optional date components
pub fn build_diary_url(username: &str, year: Option<i32>, month: Option<u32>, day: Option<u32>) -> String {
    let mut url = format!("{}/{}/films/diary/", DOMAIN, username);
    
    if let Some(year) = year {
        url.push_str(&format!("for/{}/", year));
        
        if let Some(month) = month {
            url.push_str(&format!("{:02}/", month));
            
            if let Some(day) = day {
                url.push_str(&format!("{:02}/", day));
            }
        }
    }
    
    url
}

/// Build films URL with optional filters
pub fn build_films_url(username: &str, filter: Option<&str>) -> String {
    let mut url = format!("{}/{}/films/", DOMAIN, username);
    
    if let Some(filter) = filter {
        url.push_str(&format!("{}/", filter));
    }
    
    url
}

/// Add page parameter to URL
pub fn add_page_to_url(base_url: &str, page: u32) -> String {
    let base = base_url.trim_end_matches('/');
    format!("{}/page/{}/", base, page)
}

/// Normalize Letterboxd URL (ensure it has proper format)
pub fn normalize_letterboxd_url(url: &str) -> String {
    let url = url.trim();
    
    if url.starts_with("http://") || url.starts_with("https://") {
        return url.to_string();
    }
    
    if url.starts_with("/") {
        return format!("{}{}", DOMAIN, url);
    }
    
    format!("{}/{}", DOMAIN, url)
}

/// Extract pagination info from URL
pub fn extract_page_from_url(url: &str) -> Option<u32> {
    if url.contains("/page/") {
        let parts: Vec<&str> = url.split("/page/").collect();
        if parts.len() > 1 {
            let page_part = parts[1].split('/').next().unwrap_or("");
            return page_part.parse().ok();
        }
    }
    None
}

/// Remove page info from URL
pub fn remove_page_from_url(url: &str) -> String {
    if url.contains("/page/") {
        let parts: Vec<&str> = url.split("/page/").collect();
        if !parts.is_empty() {
            return parts[0].to_string();
        }
    }
    url.to_string()
}

/// Build URL for specific film sections
pub fn build_film_section_url(slug: &str, section: &str) -> String {
    format!("{}/film/{}/{}/", DOMAIN, slug, section)
}

/// Build URL for user sections
pub fn build_user_section_url(username: &str, section: &str) -> String {
    format!("{}/{}/{}/", DOMAIN, username, section)
}