read-url 0.0.10

Read from a wide variety of URL types
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

use super::{
    super::{context::*, url::*, util::*},
    http_url::*,
};

use relative_path::*;

impl URL for HttpUrl {
    fn context(&self) -> &UrlContext {
        &*self.context
    }

    fn query(&self) -> Option<UrlQuery> {
        url_query(&self.url)
    }

    fn fragment(&self) -> Option<String> {
        url_fragment(&self.url)
    }

    fn format(&self) -> Option<String> {
        // TODO: from MIME type?
        get_format_from_path(self.url.path())
    }

    fn base(&self) -> Option<UrlRef> {
        get_relative_path_parent(self.url.path()).map(|path| self.new_with(path.as_str()).into())
    }

    fn relative(&self, path: &str) -> UrlRef {
        self.new_with(RelativePath::new(self.url.path()).join(path).as_str()).into()
    }

    #[cfg(feature = "blocking")]
    fn conform(&mut self) -> Result<(), super::super::UrlError> {
        use super::super::errors::*;

        let tokio = runtime()?;
        // TODO: can we get the MIME type here for format?
        let response = tokio.block_on(self.context.http_client.head(self.url.clone()).send())?;
        if response.status().is_success() { Ok(()) } else { Err(UrlError::new_io_not_found(self)) }
    }

    #[cfg(feature = "async")]
    fn conform_async(&self) -> Result<ConformFuture, super::super::UrlError> {
        use super::super::errors::*;

        async fn conform_async(url: HttpUrl) -> Result<UrlRef, UrlError> {
            let response = url.context.http_client.head(url.url.clone()).send().await?;
            if response.status().is_success() {
                Ok(url.into())
            } else {
                Err(UrlError::new_io_not_found(url.url.as_str()))
            }
        }

        Ok(Box::pin(conform_async(self.clone())))
    }

    #[cfg(feature = "blocking")]
    fn open(&self) -> Result<ReadRef, super::super::UrlError> {
        use kutil::io::stream::{bytes::*, *};

        let runtime = runtime()?;
        let response = runtime.block_on(self.context.http_client.get(self.url.clone()).send())?;
        let stream = response.bytes_stream();
        let reader = BlockingBytesStreamReader::new(BlockingStream::new(stream, runtime));
        Ok(Box::new(reader))
    }

    #[cfg(feature = "async")]
    fn open_async(&self) -> Result<OpenFuture, super::super::UrlError> {
        use {super::super::errors::*, kutil::io::stream::bytes::*};

        async fn open_async(url: HttpUrl) -> Result<AsyncReadRef, UrlError> {
            let response = url.context.http_client.get(url.url.clone()).send().await?;
            let stream = response.bytes_stream();
            let reader = AsyncBytesStreamReader::new(stream);
            Ok(Box::pin(reader))
        }

        Ok(Box::pin(open_async(self.clone())))
    }
}

#[cfg(feature = "blocking")]
fn runtime() -> Result<tokio::runtime::Runtime, super::super::UrlError> {
    Ok(tokio::runtime::Builder::new_current_thread().enable_all().build()?)
}