hypershell-reqwest-components 0.1.0-alpha

Modular DSL for shellscripting 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

use core::marker::PhantomData;

use cgp::prelude::*;
use hypershell_components::components::CanExtractStringArg;
use hypershell_components::dsl::{Header, WithHeaders};
use reqwest::RequestBuilder;
use reqwest::header::{HeaderName, HeaderValue, InvalidHeaderName, InvalidHeaderValue};

use crate::components::{
    CanUpdateRequestBuilder, RequestBuilderUpdater, RequestBuilderUpdaterComponent,
};

#[cgp_new_provider]
impl<Context, Key, Value> RequestBuilderUpdater<Context, Header<Key, Value>> for UpdateRequestHeader
where
    Context: CanExtractStringArg<Key>
        + CanExtractStringArg<Value>
        + CanRaiseError<InvalidHeaderName>
        + CanRaiseError<InvalidHeaderValue>,
{
    fn update_request_builder(
        context: &Context,
        _phantom: PhantomData<Header<Key, Value>>,
        builder: RequestBuilder,
    ) -> Result<RequestBuilder, Context::Error> {
        let key_str = context.extract_string_arg(PhantomData::<Key>);
        let value_str = context.extract_string_arg(PhantomData::<Value>);

        let key = HeaderName::from_bytes(key_str.as_bytes()).map_err(Context::raise_error)?;

        let value = HeaderValue::from_bytes(value_str.as_bytes()).map_err(Context::raise_error)?;

        Ok(builder.header(key, value))
    }
}

pub struct UpdateRequestHeaders;

#[cgp_provider]
impl<Context, Arg, Args> RequestBuilderUpdater<Context, WithHeaders<Cons<Arg, Args>>>
    for UpdateRequestHeaders
where
    Context: CanUpdateRequestBuilder<Arg>,
    Self: RequestBuilderUpdater<Context, WithHeaders<Args>>,
{
    fn update_request_builder(
        context: &Context,
        _phantom: PhantomData<WithHeaders<Cons<Arg, Args>>>,
        builder: RequestBuilder,
    ) -> Result<RequestBuilder, Context::Error> {
        let builder = context.update_request_builder(PhantomData, builder)?;
        let builder =
            Self::update_request_builder(context, PhantomData::<WithHeaders<Args>>, builder)?;

        Ok(builder)
    }
}

#[cgp_provider]
impl<Context> RequestBuilderUpdater<Context, WithHeaders<Nil>> for UpdateRequestHeaders
where
    Context: HasErrorType,
{
    fn update_request_builder(
        _context: &Context,
        _phantom: PhantomData<WithHeaders<Nil>>,
        builder: RequestBuilder,
    ) -> Result<RequestBuilder, Context::Error> {
        Ok(builder)
    }
}