chap 2.5.0

Chap is an easy to learn, interpretive, scripting language 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

use std::str::FromStr;

#[cfg(not(target_family = "wasm"))]
use reqwest::{
    blocking::Client,
    header::{HeaderMap, HeaderName, HeaderValue, USER_AGENT},
};

use crate::{
    builtin_function::utils::{param_to_datatype, returns},
    common::{
        data_type::DataType,
        errors::{ChapError, Result},
        executable::ExecutableLine,
    },
    runtime::Runtime,
};

#[cfg(not(target_family = "wasm"))]
pub fn http_get(runtime: &mut Runtime, executable: &ExecutableLine) -> Result<()> {
    let p1 = param_to_datatype(runtime, executable.params.first(), executable.line_number)?;
    let p2 = if let Some(_) = executable.params.get(1) {
        Some(param_to_datatype(
            runtime,
            executable.params.get(1),
            executable.line_number,
        )?)
    } else {
        None
    };

    match p1 {
        DataType::String(url) => {
            let mut headers = HeaderMap::new();

            headers.insert(USER_AGENT, HeaderValue::from_static("Chap"));

            if let Some(p2) = p2 {
                if let DataType::Map(p2) = p2 {
                    for (key, value) in p2 {
                        let header = HeaderName::from_str(key).map_err(|_| {
                            ChapError::runtime_with_msg(
                                executable.line_number,
                                format!("invalid header name: {}", key),
                            )
                        })?;

                        let value = if let DataType::String(value) = value {
                            value
                        } else {
                            return Err(ChapError::runtime_with_msg(
                                executable.line_number,
                                format!("header value must me a string, got {}", value.type_name()),
                            ));
                        };

                        let value = HeaderValue::from_str(value).map_err(|_| {
                            ChapError::runtime_with_msg(
                                executable.line_number,
                                format!("failed to initialize TLS backend"),
                            )
                        })?;

                        headers.insert(header, value);
                    }
                } else {
                    return Err(ChapError::runtime_with_msg(
                        executable.line_number,
                        format!(
                            "second parameter for headers must be a map, got {}",
                            p2.type_name()
                        ),
                    ));
                }
            }

            let client = Client::builder()
                .default_headers(headers)
                .build()
                .map_err(|_| {
                    ChapError::runtime_with_msg(
                        executable.line_number,
                        format!("failed to initialize TLS backend"),
                    )
                })?;

            let resp = client.get(url).send().map_err(|e| {
                ChapError::runtime_with_msg(
                    executable.line_number,
                    format!("failed to send GET HTTP request: {}", e),
                )
            })?;

            let body = resp.text().map_err(|e| {
                ChapError::runtime_with_msg(
                    executable.line_number,
                    format!("failed to read response body: {}", e),
                )
            })?;

            returns(runtime, executable, DataType::String(body))
        }
        _ => {
            return Err(ChapError::runtime_with_msg(
                executable.line_number,
                format!("first parameter must be a string, got {}", p1.type_name()),
            ));
        }
    }
}

#[cfg(target_family = "wasm")]
pub fn http_get(runtime: &mut Runtime, executable: &ExecutableLine) -> Result<()> {
    Err(ChapError::runtime_with_msg(
        executable.line_number,
        "http_get not supported in wasm".to_string(),
    ))
}