serde_attributes/rename_all/
syn.rs

1use serde_rename_rule::{ParseError as RenameRuleParseError, RenameRule};
2use syn::{Lit, Meta, MetaNameValue, NestedMeta};
3
4use crate::rename::{Rename, RenameIndependent, syn::FromMetaError as RenameFromMetaError};
5
6use super::{RenameAll, RenameAllIndependent};
7
8/// [Ref](https://github.com/serde-rs/serde/blob/v1.0.127/serde_derive/src/internals/symbol.rs#L24)
9pub const RENAME_ALL: &str = "rename_all";
10
11/// [Ref](https://github.com/serde-rs/serde/blob/v1.0.127/serde_derive/src/internals/attr.rs#L335-L364)
12impl<'a> core::convert::TryFrom<&'a Meta> for RenameAll {
13    type Error = FromMetaError<'a>;
14
15    fn try_from(meta: &'a Meta) -> Result<Self, Self::Error> {
16        match Rename::try_from_meta(meta, RENAME_ALL) {
17            Ok(rename) => match rename {
18                Rename::Normal(name) => RenameRule::from_rename_all_str(name.as_str())
19                    .map(Self::Normal)
20                    .map_err(FromMetaError::RenameRuleParseError),
21                Rename::Independent(RenameIndependent::Serialize(ser_name)) => {
22                    RenameRule::from_rename_all_str(ser_name.as_str())
23                        .map(|x| Self::Independent(RenameAllIndependent::Serialize(x)))
24                        .map_err(FromMetaError::RenameRuleParseError)
25                }
26                Rename::Independent(RenameIndependent::Deserialize(de_name)) => {
27                    RenameRule::from_rename_all_str(de_name.as_str())
28                        .map(|x| Self::Independent(RenameAllIndependent::Deserialize(x)))
29                        .map_err(FromMetaError::RenameRuleParseError)
30                }
31                Rename::Independent(RenameIndependent::Both {
32                    serialize: ser_name,
33                    deserialize: de_name,
34                }) => Ok(Self::Independent(RenameAllIndependent::Both {
35                    serialize: RenameRule::from_rename_all_str(ser_name.as_str())
36                        .map_err(FromMetaError::RenameRuleParseError)?,
37                    deserialize: RenameRule::from_rename_all_str(de_name.as_str())
38                        .map_err(FromMetaError::RenameRuleParseError)?,
39                })),
40            },
41            Err(err) => match err {
42                RenameFromMetaError::MetaTypeOrPathMismatch(meta) => {
43                    Err(FromMetaError::MetaTypeOrPathMismatch(meta))
44                }
45                RenameFromMetaError::LitTypeMismatch(lit) => {
46                    Err(FromMetaError::LitTypeMismatch(lit))
47                }
48                RenameFromMetaError::NestedMetaTypeMismatch(nested_meta) => {
49                    Err(FromMetaError::NestedMetaTypeMismatch(nested_meta))
50                }
51                RenameFromMetaError::NestedMetaPathMismatch(nested_meta, meta_name_value) => Err(
52                    FromMetaError::NestedMetaPathMismatch(nested_meta, meta_name_value),
53                ),
54                RenameFromMetaError::AtLeastOneOfSerAndDe => {
55                    Err(FromMetaError::AtLeastOneOfSerAndDe)
56                }
57            },
58        }
59    }
60}
61
62pub enum FromMetaError<'a> {
63    MetaTypeOrPathMismatch(&'a Meta),
64    LitTypeMismatch(&'a Lit),
65    NestedMetaTypeMismatch(&'a NestedMeta),
66    NestedMetaPathMismatch(&'a NestedMeta, &'a MetaNameValue),
67    AtLeastOneOfSerAndDe,
68    RenameRuleParseError(RenameRuleParseError),
69}
70impl<'a> core::fmt::Debug for FromMetaError<'a> {
71    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
72        match self {
73            Self::MetaTypeOrPathMismatch(_) => write!(f, "MetaTypeOrPathMismatch"),
74            Self::LitTypeMismatch(_) => write!(f, "LitTypeMismatch"),
75            Self::NestedMetaTypeMismatch(_) => write!(f, "NestedMetaTypeMismatch"),
76            Self::NestedMetaPathMismatch(_, _) => write!(f, "NestedMetaPathMismatch"),
77            Self::AtLeastOneOfSerAndDe => write!(f, "AtLeastOneOfSerAndDe"),
78            Self::RenameRuleParseError(_) => write!(f, "RenameRuleParseError"),
79        }
80    }
81}
82impl<'a> core::fmt::Display for FromMetaError<'a> {
83    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
84        write!(f, "{self:?}")
85    }
86}
87#[cfg(feature = "std")]
88impl<'a> std::error::Error for FromMetaError<'a> {}
serde_attributes/rename_all/syn.rs

serde_attributes/rename_all/
syn.rs
