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::{DecodeUntrusted, 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(
25    Serialize,
26    Deserialize,
27    Encode,
28    Decode,
29    Debug,
30    Clone,
31    PartialEq,
32    Eq,
33    PartialOrd,
34    From,
35    DecodeUntrusted,
36)]
37#[cfg_attr(feature = "value-conversion", derive(ValueConvertible))]
38#[serde(tag = "$formatVersion")]
39pub enum TokenConfigurationLocalization {
40    /// Version 0 of the token localization schema.
41    ///
42    /// Defines basic capitalization preference, singular form, and plural form
43    /// for displaying token names.
44    #[serde(rename = "0")]
45    V0(TokenConfigurationLocalizationV0),
46}
47
48impl fmt::Display for TokenConfigurationLocalization {
49    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
50        match self {
51            TokenConfigurationLocalization::V0(v0) => {
52                write!(f, "{}", v0) //just pass through
53            }
54        }
55    }
56}
57
58#[cfg(all(
59    test,
60    feature = "json-conversion",
61    feature = "value-conversion",
62    feature = "serde-conversion"
63))]
64mod json_convertible_tests {
65    use super::*;
66    use crate::data_contract::associated_token::token_configuration_localization::v0::TokenConfigurationLocalizationV0;
67
68    fn fixture() -> TokenConfigurationLocalization {
69        TokenConfigurationLocalization::V0(TokenConfigurationLocalizationV0 {
70            should_capitalize: true,
71            singular_form: "Token".to_string(),
72            plural_form: "Tokens".to_string(),
73        })
74    }
75
76    #[test]
77    fn json_round_trip_with_full_wire_shape() {
78        use crate::serialization::JsonConvertible;
79        use serde_json::json;
80        let original = fixture();
81        let json = original.to_json().expect("to_json");
82        assert_eq!(
83            json,
84            json!({
85                "$formatVersion": "0",
86                "shouldCapitalize": true,
87                "singularForm": "Token",
88                "pluralForm": "Tokens",
89            })
90        );
91        let recovered = TokenConfigurationLocalization::from_json(json).expect("from_json");
92        assert_eq!(original, recovered);
93    }
94
95    #[test]
96    fn value_round_trip_with_full_wire_shape() {
97        use crate::serialization::ValueConvertible;
98        use platform_value::platform_value;
99        let original = fixture();
100        let value = original.to_object().expect("to_object");
101        assert_eq!(
102            value,
103            platform_value!({
104                "$formatVersion": "0",
105                "shouldCapitalize": true,
106                "singularForm": "Token",
107                "pluralForm": "Tokens",
108            })
109        );
110        let recovered = TokenConfigurationLocalization::from_object(value).expect("from_object");
111        assert_eq!(original, recovered);
112    }
113}