formatx 0.3.0

A macro for formatting non literal strings at runtime 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

//! Error types for formatx.

use crate::ast::{FormatType, Span};
use std::fmt;

/// Errors that can occur during parsing or formatting.
#[derive(Debug)]
pub enum Error {
    /// The format string could not be parsed.
    Parse {
        span: Span,
        message: String,
    },
    /// A placeholder references an argument that was not provided.
    MissingArgument {
        name: String,
        span: Span,
    },
    /// A format type (e.g. `{:x}`) requires a trait we don't support.
    UnsupportedTrait {
        format_type: FormatType,
        span: Span,
    },
    /// An underlying `std::fmt::Error` occurred during formatting.
    Format(fmt::Error),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Parse { message, span, .. } => {
                write!(f, "parse error at byte {}: {}", span.start, message)
            }
            Self::MissingArgument { name, .. } => {
                write!(f, "missing argument: `{name}`")
            }
            Self::UnsupportedTrait { format_type, .. } => {
                let trait_name = match format_type {
                    FormatType::Octal => "Octal",
                    FormatType::LowerHex => "LowerHex",
                    FormatType::UpperHex => "UpperHex",
                    FormatType::Binary => "Binary",
                    FormatType::LowerExp => "LowerExp",
                    FormatType::UpperExp => "UpperExp",
                    FormatType::Pointer => "Pointer",
                    _ => "Unknown",
                };
                write!(f, "unsupported format trait: `{trait_name}`")
            }
            Self::Format(e) => write!(f, "formatting error: {e}"),
        }
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        if let Self::Format(e) = self {
            Some(e)
        } else {
            None
        }
    }
}

impl From<fmt::Error> for Error {
    fn from(e: fmt::Error) -> Self {
        Self::Format(e)
    }
}