rusty_dl 1.0.8

A crate for downloading youtube videos, twitter medias (videos, images, gif) from tweets and files on the web.
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

use reqwest::header::{self, HeaderMap, HeaderName, HeaderValue, IntoHeaderName};

/// Builder for constructing a `HeaderMap` instance with various headers.
#[derive(Debug, Clone)]
pub struct HeaderMapBuilder {
    map: HeaderMap,
}

impl HeaderMapBuilder {
    /// Creates a new `HeaderMapBuilder` instance.
    pub fn new() -> Self {
        Self {
            map: HeaderMap::new(),
        }
    }

    /// Builds and returns the constructed `HeaderMap`.
    pub fn build(self) -> HeaderMap {
        self.map
    }

    /// Adds a header field with the specified key and value.
    pub fn field<K: IntoHeaderName, V: Into<HeaderBuilderValue>>(mut self, key: K, val: V) -> Self {
        self.map.insert(key, val.into().into());
        self
    }

    /// Adds a 'User-Agent' header with a default value.
    pub fn with_user_agent(self) -> Self {
        self.field(
            header::USER_AGENT,
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0",
        )
    }

    /// Sets the 'User-Agent' header with the specified value.
    pub fn set_user_agent<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::USER_AGENT, user_agent_value)
    }

    /// Adds an 'Accept' header with the specified value.
    pub fn accept<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::ACCEPT, user_agent_value)
    }

    /// Adds an 'Accept-Language' header with the specified value.
    pub fn accept_language<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::ACCEPT_LANGUAGE, user_agent_value)
    }

    /// Adds a 'TE' header with the specified value.
    pub fn te<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::TE, user_agent_value)
    }

    /// Adds an 'Authorization' header with the specified value.
    pub fn authorization<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::AUTHORIZATION, user_agent_value)
    }

    /// Adds a 'Content-Type' header with the specified value.
    pub fn content_type<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::CONTENT_TYPE, user_agent_value)
    }

    /// Adds a 'Content-Length' header with the specified value.
    pub fn content_length<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::CONTENT_LENGTH, user_agent_value)
    }

    /// Adds a 'Referer' header with the specified value.
    pub fn referer<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::REFERER, user_agent_value)
    }

    /// Adds an 'Origin' header with the specified value.
    pub fn origin<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::ORIGIN, user_agent_value)
    }

    /// Adds a 'Host' header with the specified value.
    pub fn host<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::HOST, user_agent_value)
    }

    /// Adds an 'Accept-Encoding' header with the specified value.
    pub fn accept_encoding<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::ACCEPT_ENCODING, user_agent_value)
    }

    /// Adds a 'Connection' header with the specified value.
    pub fn connection<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::CONNECTION, user_agent_value)
    }

    /// Adds a 'Cache-Control' header with the specified value.
    pub fn cache_control<V: Into<HeaderBuilderValue>>(self, value: V) -> Self {
        self.field(header::CACHE_CONTROL, value)
    }

    /// Adds a 'Pragma' header with the specified value.
    pub fn pragma<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::PRAGMA, user_agent_value)
    }

    /// Adds a 'Content-Disposition' header with the specified value.
    pub fn content_disposition<V: Into<HeaderBuilderValue>>(self, user_agent_value: V) -> Self {
        self.field(header::CONTENT_DISPOSITION, user_agent_value)
    }
}

/// An enum representing various types of values that can be used in constructing HTTP headers.
#[derive(Debug, Clone)]
pub enum HeaderBuilderValue {
    /// A static string slice value.
    Static(&'static str),
    /// A value of type [`HeaderValue`].
    Value(HeaderValue),
    /// A value of type [`HeaderName`].
    Name(HeaderName),
}

impl Into<HeaderValue> for HeaderBuilderValue {
    fn into(self) -> HeaderValue {
        match self {
            HeaderBuilderValue::Static(s) => HeaderValue::from_static(s),
            HeaderBuilderValue::Value(v) => v,
            HeaderBuilderValue::Name(name) => HeaderValue::from_name(name),
        }
    }
}

impl From<&'static str> for HeaderBuilderValue {
    fn from(value: &'static str) -> Self {
        HeaderBuilderValue::Static(value)
    }
}
impl From<HeaderValue> for HeaderBuilderValue {
    fn from(value: HeaderValue) -> Self {
        HeaderBuilderValue::Value(value)
    }
}
impl From<HeaderName> for HeaderBuilderValue {
    fn from(value: HeaderName) -> Self {
        HeaderBuilderValue::Name(value)
    }
}