serde_evaluate 0.2.2

Extract single scalar field values from Serializable structs without full deserialization.
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

use serde::ser::Error as SerdeError;
use thiserror::Error;

/// Helper to format the NestedFieldNotFound error message.
fn format_nested_field_error(path: &[String], failed_at_index: Option<usize>) -> String {
    let path_str = path.join(".");
    match failed_at_index {
        Some(idx) if idx < path.len() => {
            format!(
                "Nested field path '{}' not found (failed at segment {}: '{}')",
                path_str, idx, path[idx]
            )
        }
        _ => format!("Nested field path '{}' not found", path_str),
    }
}

/// Errors that can occur during evaluation.
#[derive(Error, Debug, PartialEq)]
pub enum EvaluateError {
    /// The target field specified for extraction was not found in the serialized data.
    #[error("Field '{field_name}' not found in the struct")]
    FieldNotFound {
        /// The name of the field that was not found.
        field_name: String,
    },

    /// The target nested field specified by the path was not found.
    #[error("{}", format_nested_field_error(path, *failed_at_index))]
    NestedFieldNotFound {
        /// The full path segments that were not found.
        path: Vec<String>,
        /// The index of the path segment where traversal failed (if known).
        failed_at_index: Option<usize>,
    },

    /// An intermediate part of the path pointed to a non-struct type.
    #[error("Cannot traverse non-struct type at path segment {index}: '{segment}'")]
    NotAStruct {
        /// The path segment that was not a struct.
        segment: String,
        /// The index in the path where this occurred.
        index: usize,
    },

    /// The value of the target field has a type that is not supported for scalar extraction.
    /// (e.g., nested structs, sequences other than `Vec<u8>`, maps).
    #[error("Unsupported type for scalar extraction: {type_name}")]
    UnsupportedType {
        /// A string representation of the unsupported type name.
        type_name: &'static str,
    },

    /// The value of the target field has a variant type that is not supported for scalar extraction.
    #[error("Unsupported variant type for scalar extraction: {variant_type}")]
    UnsupportedVariant {
        /// A string representation of the unsupported variant type.
        variant_type: &'static str,
    },

    /// The provided path string or segments were invalid (e.g., empty or contained empty segments).
    #[error("Invalid field path provided: {0}")]
    InvalidPath(String),

    /// An underlying Serde serialization error occurred.
    #[error("Serialization error: {message}")]
    SerializationError {
        /// A custom error message from serde::ser::Error::custom.
        message: String,
    },
}

impl SerdeError for EvaluateError {
    fn custom<T>(msg: T) -> Self
    where
        T: std::fmt::Display,
    {
        EvaluateError::SerializationError {
            message: msg.to_string(),
        }
    }
}