tera-rand 0.2.2

A suite of random data generation functions for the Tera template engine
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

use anyhow::anyhow;
use tera::Error;
use thiserror::Error;

#[derive(Debug, Error)]
pub(crate) enum TeraRandError {
    #[error("Unable to parse argument for `{0}` due to error")]
    UnableToParseArgument(&'static str, #[source] anyhow::Error),

    #[error("Unsupported argument `{argument}` for `{parameter}`")]
    UnsupportedArgument {
        parameter: &'static str,
        argument: String,
    },

    #[error("Required argument missing for parameter `{0}`")]
    RequiredArgumentMissing(&'static str),

    #[error("Unable to read file at path: `{0}`")]
    UnableToReadFile(String, #[source] anyhow::Error),

    #[error("Unable to sample from an empty file: `{0}`")]
    EmptyFile(String),

    #[error(
        "Provided cidr length {provided_bound}, which is out of bounds. \
         Cidr length should be between {valid_bound_start} and {valid_bound_end}"
    )]
    CidrPrefixLengthOutOfBounds {
        provided_bound: u32,
        valid_bound_start: u32,
        valid_bound_end: u32,
    },

    #[error("Internal error: {0}")]
    Internal(String),
}

// Tera functions must return a `Result` using `tera::Error`, so
// we need to convert our internal errors
impl Into<tera::Error> for TeraRandError {
    fn into(self) -> Error {
        match &self {
            _ => Error::msg(self),
        }
    }
}

// convenience

pub(crate) fn arg_parse_error(
    parameter: &'static str,
    source: impl Into<anyhow::Error>,
) -> tera::Error {
    let tera_rand_error: TeraRandError =
        TeraRandError::UnableToParseArgument(parameter, anyhow!(source));
    Into::<tera::Error>::into(tera_rand_error)
}

pub(crate) fn unsupported_arg(parameter: &'static str, argument: String) -> tera::Error {
    let tera_rand_error: TeraRandError = TeraRandError::UnsupportedArgument {
        parameter,
        argument,
    };
    Into::<tera::Error>::into(tera_rand_error)
}

pub(crate) fn missing_arg(parameter: &'static str) -> tera::Error {
    let tera_rand_error: TeraRandError = TeraRandError::RequiredArgumentMissing(parameter);
    Into::<tera::Error>::into(tera_rand_error)
}

pub(crate) fn read_file_error(path: String, source: impl Into<anyhow::Error>) -> tera::Error {
    let tera_rand_error: TeraRandError = TeraRandError::UnableToReadFile(path, anyhow!(source));
    Into::<tera::Error>::into(tera_rand_error)
}

pub(crate) fn empty_file(path: String) -> tera::Error {
    let tera_rand_error: TeraRandError = TeraRandError::EmptyFile(path);
    Into::<tera::Error>::into(tera_rand_error)
}

pub(crate) fn cidr_prefix_length_out_of_bounds(
    provided_bound: u32,
    valid_bound_start: u32,
    valid_bound_end: u32,
) -> tera::Error {
    let tera_rand_error: TeraRandError = TeraRandError::CidrPrefixLengthOutOfBounds {
        provided_bound,
        valid_bound_start,
        valid_bound_end,
    };
    Into::<tera::Error>::into(tera_rand_error)
}

pub(crate) fn internal_error(msg: String) -> tera::Error {
    let tera_rand_error: TeraRandError = TeraRandError::Internal(msg);
    Into::<tera::Error>::into(tera_rand_error)
}