Skip to main content

dpp/data_contract/associated_token/token_configuration_localization/
mod.rs

1use crate::data_contract::associated_token::token_configuration_localization::v0::TokenConfigurationLocalizationV0;
2#[cfg(feature = "json-conversion")]
3use crate::serialization::JsonConvertible;
4#[cfg(feature = "value-conversion")]
5use crate::serialization::ValueConvertible;
6use bincode::Encode;
7use derive_more::From;
8use platform_serialization::de::Decode;
9use serde::{Deserialize, Serialize};
10use std::fmt;
11
12pub mod accessors;
13pub mod v0;
14
15/// Versioned wrapper for token name localization data.
16///
17/// `TokenConfigurationLocalization` allows extensibility for future schema upgrades
18/// while preserving backward compatibility. Each variant represents a specific format
19/// version for localization information.
20///
21/// This structure is used to map language codes to localized token names in a flexible,
22/// forward-compatible manner.
23#[cfg_attr(feature = "json-conversion", derive(JsonConvertible))]
24#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, PartialOrd, From)]
25#[cfg_attr(feature = "value-conversion", derive(ValueConvertible))]
26#[serde(tag = "$formatVersion")]
27pub enum TokenConfigurationLocalization {
28    /// Version 0 of the token localization schema.
29    ///
30    /// Defines basic capitalization preference, singular form, and plural form
31    /// for displaying token names.
32    #[serde(rename = "0")]
33    V0(TokenConfigurationLocalizationV0),
34}
35
36impl fmt::Display for TokenConfigurationLocalization {
37    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
38        match self {
39            TokenConfigurationLocalization::V0(v0) => {
40                write!(f, "{}", v0) //just pass through
41            }
42        }
43    }
44}
45
46#[cfg(all(
47    test,
48    feature = "json-conversion",
49    feature = "value-conversion",
50    feature = "serde-conversion"
51))]
52mod json_convertible_tests {
53    use super::*;
54    use crate::data_contract::associated_token::token_configuration_localization::v0::TokenConfigurationLocalizationV0;
55
56    fn fixture() -> TokenConfigurationLocalization {
57        TokenConfigurationLocalization::V0(TokenConfigurationLocalizationV0 {
58            should_capitalize: true,
59            singular_form: "Token".to_string(),
60            plural_form: "Tokens".to_string(),
61        })
62    }
63
64    #[test]
65    fn json_round_trip_with_full_wire_shape() {
66        use crate::serialization::JsonConvertible;
67        use serde_json::json;
68        let original = fixture();
69        let json = original.to_json().expect("to_json");
70        assert_eq!(
71            json,
72            json!({
73                "$formatVersion": "0",
74                "shouldCapitalize": true,
75                "singularForm": "Token",
76                "pluralForm": "Tokens",
77            })
78        );
79        let recovered = TokenConfigurationLocalization::from_json(json).expect("from_json");
80        assert_eq!(original, recovered);
81    }
82
83    #[test]
84    fn value_round_trip_with_full_wire_shape() {
85        use crate::serialization::ValueConvertible;
86        use platform_value::platform_value;
87        let original = fixture();
88        let value = original.to_object().expect("to_object");
89        assert_eq!(
90            value,
91            platform_value!({
92                "$formatVersion": "0",
93                "shouldCapitalize": true,
94                "singularForm": "Token",
95                "pluralForm": "Tokens",
96            })
97        );
98        let recovered = TokenConfigurationLocalization::from_object(value).expect("from_object");
99        assert_eq!(original, recovered);
100    }
101}