ortho_config_macros 0.9.0

Procedural macros for ortho_config.
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

//! Validation helpers for field documentation metadata.

use std::collections::HashMap;

use syn::Ident;

/// Validates that an environment variable name is well-formed.
pub(super) fn validate_env_name(field: &Ident, env_name: &str) -> syn::Result<()> {
    if env_name.is_empty() {
        return Err(syn::Error::new_spanned(
            field,
            "environment variable names must be non-empty",
        ));
    }
    if env_name
        .chars()
        .all(|ch| ch.is_ascii_alphanumeric() || ch == '_')
    {
        return Ok(());
    }
    Err(syn::Error::new_spanned(
        field,
        format!(
            "environment variable '{env_name}' must contain only ASCII alphanumeric characters or '_'",
        ),
    ))
}

/// Validates that a file key path is well-formed.
pub(super) fn validate_file_key(field: &Ident, key_path: &str) -> syn::Result<()> {
    if key_path.is_empty() {
        return Err(syn::Error::new_spanned(
            field,
            "file key paths must be non-empty",
        ));
    }
    for segment in key_path.split('.') {
        if segment.is_empty() {
            return Err(syn::Error::new_spanned(
                field,
                format!("file key path '{key_path}' must not contain empty segments"),
            ));
        }
        let valid = segment
            .chars()
            .all(|ch| ch.is_ascii_alphanumeric() || ch == '_' || ch == '-');
        if !valid {
            return Err(syn::Error::new_spanned(
                field,
                format!(
                    "file key path '{key_path}' must contain only ASCII alphanumeric characters, '_' or '-'",
                ),
            ));
        }
    }
    Ok(())
}

/// Ensures a key is unique, tracking seen keys and their spans.
pub(super) fn ensure_unique(
    kind: &str,
    field: &Ident,
    key: &str,
    seen: &mut HashMap<String, proc_macro2::Span>,
) -> syn::Result<()> {
    if let Some(existing) = seen.get(key) {
        let mut err =
            syn::Error::new_spanned(field, format!("duplicate {kind} identifier '{key}'"));
        err.combine(syn::Error::new(*existing, "first defined here"));
        return Err(err);
    }
    seen.insert(key.to_owned(), field.span());
    Ok(())
}