Mohamad KhaniandClaude Fable 5
46c7879954
Rebuilt from the exact zed-industries/zed @ 8c74db00c4053d6c0a9037863d7bd048658da4ca tree (previous orphan was based on a stale/wrong fetch). Same 3-file patch: - serial.rs: add SerialKind::KeyboardEnter - client.rs: store wl_keyboard.enter serial; add latest_serial_of() - window.rs: activate() uses keyboard-enter serial (Mutter focus gate) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
136 lines
4.0 KiB
Rust
136 lines
4.0 KiB
Rust
use serde::Serializer;
|
|
|
|
/// Serializes an f32 value with 2 decimal places of precision.
|
|
///
|
|
/// This function rounds the value to 2 decimal places and formats it as a string,
|
|
/// then parses it back to f64 before serialization. This ensures clean JSON output
|
|
/// without IEEE 754 floating-point artifacts.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `value` - The f32 value to serialize
|
|
/// * `serializer` - The serde serializer to use
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// Result of the serialization operation
|
|
///
|
|
/// # Usage
|
|
///
|
|
/// This function can be used with Serde's `serialize_with` attribute:
|
|
/// ```
|
|
/// use serde::Serialize;
|
|
/// use settings_content::serialize_f32_with_two_decimal_places;
|
|
///
|
|
/// #[derive(Serialize)]
|
|
/// struct ExampleStruct(#[serde(serialize_with = "serialize_f32_with_two_decimal_places")] f32);
|
|
/// ```
|
|
pub fn serialize_f32_with_two_decimal_places<S>(
|
|
value: &f32,
|
|
serializer: S,
|
|
) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let rounded = (value * 100.0).round() / 100.0;
|
|
let formatted = format!("{:.2}", rounded);
|
|
let clean_value: f64 = formatted.parse().unwrap_or(rounded as f64);
|
|
serializer.serialize_f64(clean_value)
|
|
}
|
|
|
|
/// Serializes an optional f32 value with 2 decimal places of precision.
|
|
///
|
|
/// This function handles `Option<f32>` types, serializing `Some` values with 2 decimal
|
|
/// places of precision and `None` values as null. For `Some` values, it rounds to 2 decimal
|
|
/// places and formats as a string, then parses back to f64 before serialization. This ensures
|
|
/// clean JSON output without IEEE 754 floating-point artifacts.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `value` - The optional f32 value to serialize
|
|
/// * `serializer` - The serde serializer to use
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// Result of the serialization operation
|
|
///
|
|
/// # Behavior
|
|
///
|
|
/// * `Some(v)` - Serializes the value rounded to 2 decimal places
|
|
/// * `None` - Serializes as JSON null
|
|
///
|
|
/// # Usage
|
|
///
|
|
/// This function can be used with Serde's `serialize_with` attribute:
|
|
/// ```
|
|
/// use serde::Serialize;
|
|
/// use settings_content::serialize_optional_f32_with_two_decimal_places;
|
|
///
|
|
/// #[derive(Serialize)]
|
|
/// struct ExampleStruct {
|
|
/// #[serde(serialize_with = "serialize_optional_f32_with_two_decimal_places")]
|
|
/// optional_value: Option<f32>,
|
|
/// }
|
|
/// ```
|
|
pub fn serialize_optional_f32_with_two_decimal_places<S>(
|
|
value: &Option<f32>,
|
|
serializer: S,
|
|
) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
match value {
|
|
Some(v) => {
|
|
let rounded = (v * 100.0).round() / 100.0;
|
|
let formatted = format!("{:.2}", rounded);
|
|
let clean_value: f64 = formatted.parse().unwrap_or(rounded as f64);
|
|
serializer.serialize_some(&clean_value)
|
|
}
|
|
None => serializer.serialize_none(),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
struct TestOptional {
|
|
#[serde(serialize_with = "serialize_optional_f32_with_two_decimal_places")]
|
|
value: Option<f32>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
struct TestNonOptional {
|
|
#[serde(serialize_with = "serialize_f32_with_two_decimal_places")]
|
|
value: f32,
|
|
}
|
|
|
|
#[test]
|
|
fn test_serialize_optional_f32_with_two_decimal_places() {
|
|
let cases = [
|
|
(Some(123.456789), r#"{"value":123.46}"#),
|
|
(Some(1.2), r#"{"value":1.2}"#),
|
|
(Some(300.00000), r#"{"value":300.0}"#),
|
|
];
|
|
for (value, expected) in cases {
|
|
let value = TestOptional { value };
|
|
assert_eq!(serde_json::to_string(&value).unwrap(), expected);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_serialize_f32_with_two_decimal_places() {
|
|
let cases = [
|
|
(123.456789, r#"{"value":123.46}"#),
|
|
(1.200, r#"{"value":1.2}"#),
|
|
(300.00000, r#"{"value":300.0}"#),
|
|
];
|
|
for (value, expected) in cases {
|
|
let value = TestNonOptional { value };
|
|
assert_eq!(serde_json::to_string(&value).unwrap(), expected);
|
|
}
|
|
}
|
|
}
|