credence-lib 0.0.6

An unfussy web server designed for straightforward authoring and scalable performance
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

use {
    compris::resolve::*,
    kutil::std::{error::*, immutable::*},
    std::{fmt, fs::*, io, path::*},
};

//
// LoadableBytes
//

/// A [Bytes] that be specified either explicitly or as a path from which to read it.
///
/// Resolves from:
///
/// * A single-key map where the key is either "content" or "path".
/// * Directly from a [Bytes].
#[derive(Clone, Debug, Resolve)]
pub enum LoadableBytes {
    /// Content.
    #[resolve(single, key = "content")]
    Content(Bytes),

    /// Path.
    #[resolve(key = "path")]
    Path(PathBuf),
}

impl LoadableBytes {
    /// If it's [Content](LoadableBytes::Content), returns it.
    ///
    /// If it's [Path](LoadableBytes::Path), will attempt to read from it.
    pub fn to_bytes(&self) -> io::Result<Bytes> {
        match self {
            Self::Content(bytes) => Ok(bytes.clone()),
            Self::Path(path) => read(path).map(|bytes| bytes.into()).with_path(path),
        }
    }

    /// If it's already [Content](LoadableBytes::Content), returns self.
    ///
    /// If it's [Path](LoadableBytes::Path), will attempt to read from the path and return a new
    /// [LoadableBytes] with [Content](LoadableBytes::Content).
    pub fn into_content(self) -> io::Result<Self> {
        match &self {
            Self::Content(_) => Ok(self),
            Self::Path(_) => Ok(Self::Content(self.to_bytes()?)),
        }
    }
}

impl Default for LoadableBytes {
    fn default() -> Self {
        Self::Content(Default::default())
    }
}

impl From<Bytes> for LoadableBytes {
    fn from(blob: Bytes) -> Self {
        Self::Content(blob)
    }
}

impl From<ByteString> for LoadableBytes {
    fn from(string: ByteString) -> Self {
        Self::Content(string.into_bytes())
    }
}

impl From<&str> for LoadableBytes {
    fn from(string: &str) -> Self {
        Self::Content(Bytes::copy_from_slice(string.as_bytes()))
    }
}

impl TryInto<Bytes> for LoadableBytes {
    type Error = io::Error;

    fn try_into(self) -> Result<Bytes, Self::Error> {
        match self {
            Self::Content(bytes) => Ok(bytes),
            Self::Path(_) => self.to_bytes(),
        }
    }
}

impl fmt::Display for LoadableBytes {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Content(bytes) => write!(formatter, "content: {} bytes", bytes.len()),
            Self::Path(path) => write!(formatter, "path: {}", path.display()),
        }
    }
}