pkce-std 0.2.1

Handling Proof Key for Code Exchange.
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

//! Checking PKCE code verifier strings.

use const_macros::{const_map_err, const_try};

#[cfg(feature = "diagnostics")]
use miette::Diagnostic;

use thiserror::Error;

use crate::check::{ascii, bytes};

/// Represents sources of errors that can occur when checking strings.
#[derive(Debug, Error)]
#[error("invalid string encountered")]
#[cfg_attr(feature = "diagnostics", derive(Diagnostic))]
pub enum Error {
    /// Non-ASCII string encountered.
    #[cfg_attr(
        feature = "diagnostics",
        diagnostic(
            code(pkce_std::check::string::ascii),
            help("ensure the string is ASCII")
        )
    )]
    Ascii(#[from] ascii::Error),
    /// Invalid byte encountered.
    #[cfg_attr(
        feature = "diagnostics",
        diagnostic(code(pkce_std::check::string::byte), help("ensure the byte is valid"))
    )]
    Bytes(#[from] bytes::Error),
}

/// Recursively checks that the given string contains valid characters only.
///
/// One may need to increase the recursion limit manually to use this `const` function.
///
/// This is done via applying the `recursion_limit` attribute to the crate:
///
/// ```
/// #![recursion_limit = "256"]
/// ```
///
/// # Errors
///
/// Returns [`enum@Error`] on non-ASCII or otherwise invalid strings.
pub const fn const_check_str(string: &str) -> Result<(), Error> {
    pub const fn check_bytes(bytes: &[u8]) -> Result<(), bytes::Error> {
        match *bytes {
            [] => Ok(()),
            [byte, ref rest @ ..] => {
                const_try!(bytes::check(byte));

                check_bytes(rest)
            }
        }
    }

    const_try!(const_map_err!(ascii::check_str(string) => Error::Ascii));

    const_map_err!(check_bytes(string.as_bytes()) => Error::Bytes)
}

/// Iterarively checks that the given string contains valid characters only.
///
/// # Errors
///
/// Returns [`enum@Error`] on non-ASCII or otherwise invalid codes.
pub fn check_str(string: &str) -> Result<(), Error> {
    fn check_bytes(bytes: &[u8]) -> Result<(), bytes::Error> {
        bytes.iter().copied().try_for_each(bytes::check)
    }

    ascii::check(string)?;

    check_bytes(string.as_bytes())?;

    Ok(())
}

/// Similar to [`check_str`], except it is generic over [`AsRef<str>`].
///
/// # Errors
///
/// Any [`enum@Error`] in [`check_str`] is propagated.
pub fn check<S: AsRef<str>>(string: S) -> Result<(), Error> {
    check_str(string.as_ref())
}