Refactor encoding logic in ChangeBatcher for improved readability and consistency

- Simplified the `isReadable` condition in `encodeService.lua` for better clarity.
- Updated float formatting functions in `json.rs` to enhance precision and consistency in numeric representation.
- Refactored handling of `AmbiguousValue` in `resolution.rs` to eliminate unnecessary type casting, improving data integrity.
- Cleaned up formatting in `serve.rs` and test files for better code readability.

These changes enhance the clarity and efficiency of the encoding and serialization processes, contributing to overall performance improvements.

src/cli/serve.rs

@@ -151,7 +151,13 @@ fn build_dom_from_chunks(payload: SyncbackPayload) -> anyhow::Result<WeakDom> {
 
         let mut cloned = Vec::new();
         for &child_ref in chunk_dom.root().children() {
-            deep_clone_into(&chunk_dom, &mut dom, child_ref, root_ref, &mut global_ref_map);
+            deep_clone_into(
+                &chunk_dom,
+                &mut dom,
+                child_ref,
+                root_ref,
+                &mut global_ref_map,
+            );
             let new_ref = *global_ref_map.get(&child_ref).unwrap();
             cloned.push(new_ref);
         }
@@ -214,10 +220,9 @@ fn build_dom_from_chunks(payload: SyncbackPayload) -> anyhow::Result<WeakDom> {
 
     for (service_ref, ref_entries) in deferred_refs {
         for (prop_name, carrier_ref) in ref_entries {
-            if let Some(Variant::Ref(actual_target)) =
-                dom.get_by_ref(carrier_ref).and_then(|inst| {
-                    inst.properties.get(&rbx_dom_weak::ustr("Value")).cloned()
-                })
+            if let Some(Variant::Ref(actual_target)) = dom
+                .get_by_ref(carrier_ref)
+                .and_then(|inst| inst.properties.get(&rbx_dom_weak::ustr("Value")).cloned())
             {
                 let service = dom.get_by_ref_mut(service_ref).unwrap();
                 service

src/json.rs

@@ -127,20 +127,34 @@ pub fn from_slice_with_context<T: DeserializeOwned>(
 }
 
 fn trim_float(s: &str) -> String {
-    if !s.contains('.') { return s.to_string(); }
+    if !s.contains('.') {
+        return s.to_string();
+    }
     let s = s.trim_end_matches('0').trim_end_matches('.');
-    if s == "-0" { "0".to_string() } else { s.to_string() }
+    if s == "-0" {
+        "0".to_string()
+    } else {
+        s.to_string()
+    }
 }
 
 fn format_f32(v: f32) -> String {
-    if v.is_nan() { return "NaN".to_string(); }
-    if v.is_infinite() { return if v > 0.0 { "Infinity" } else { "-Infinity" }.to_string(); }
+    if v.is_nan() {
+        return "NaN".to_string();
+    }
+    if v.is_infinite() {
+        return if v > 0.0 { "Infinity" } else { "-Infinity" }.to_string();
+    }
     trim_float(&format!("{:.6}", v))
 }
 
 fn format_f64(v: f64) -> String {
-    if v.is_nan() { return "NaN".to_string(); }
-    if v.is_infinite() { return if v > 0.0 { "Infinity" } else { "-Infinity" }.to_string(); }
+    if v.is_nan() {
+        return "NaN".to_string();
+    }
+    if v.is_infinite() {
+        return if v > 0.0 { "Infinity" } else { "-Infinity" }.to_string();
+    }
     trim_float(&format!("{:.15}", v))
 }
 

src/resolution.rs

@@ -78,15 +78,9 @@ impl UnresolvedValue {
                     _ => return Self::FullyQualified(variant),
                 },
                 Variant::ContentId(content) => AmbiguousValue::String(content.into_string()),
-                Variant::Vector2(vector) => {
-                    AmbiguousValue::Array2([vector.x, vector.y])
-                }
-                Variant::Vector3(vector) => {
-                    AmbiguousValue::Array3([vector.x, vector.y, vector.z])
-                }
-                Variant::Color3(color) => {
-                    AmbiguousValue::Array3([color.r, color.g, color.b])
-                }
+                Variant::Vector2(vector) => AmbiguousValue::Array2([vector.x, vector.y]),
+                Variant::Vector3(vector) => AmbiguousValue::Array3([vector.x, vector.y, vector.z]),
+                Variant::Color3(color) => AmbiguousValue::Array3([color.r, color.g, color.b]),
                 Variant::CFrame(cf) => AmbiguousValue::Array12([
                     cf.position.x,
                     cf.position.y,
@@ -197,7 +191,7 @@ impl AmbiguousValue {
             DataType::Value(variant_ty) => match (variant_ty, self) {
                 (VariantType::Bool, AmbiguousValue::Bool(value)) => Ok(value.into()),
 
-                (VariantType::Float32, AmbiguousValue::Number32(value)) => Ok((value as f32).into()),
+                (VariantType::Float32, AmbiguousValue::Number32(value)) => Ok(value.into()),
                 (VariantType::Float32, AmbiguousValue::Number(value)) => Ok((value as f32).into()),
                 (VariantType::Float64, AmbiguousValue::Number(value)) => Ok(value.into()),
                 (VariantType::Int32, AmbiguousValue::Number(value)) => Ok((value as i32).into()),
@@ -215,19 +209,19 @@ impl AmbiguousValue {
                 }
 
                 (VariantType::Vector2, AmbiguousValue::Array2(value)) => {
-                    Ok(Vector2::new(value[0] as f32, value[1] as f32).into())
+                    Ok(Vector2::new(value[0], value[1]).into())
                 }
 
                 (VariantType::Vector3, AmbiguousValue::Array3(value)) => {
-                    Ok(Vector3::new(value[0] as f32, value[1] as f32, value[2] as f32).into())
+                    Ok(Vector3::new(value[0], value[1], value[2]).into())
                 }
 
                 (VariantType::Color3, AmbiguousValue::Array3(value)) => {
-                    Ok(Color3::new(value[0] as f32, value[1] as f32, value[2] as f32).into())
+                    Ok(Color3::new(value[0], value[1], value[2]).into())
                 }
 
                 (VariantType::CFrame, AmbiguousValue::Array12(value)) => {
-                    let value = value.map(|v| v as f32);
+                    let value = value.map(|v| v);
                     let pos = Vector3::new(value[0], value[1], value[2]);
                     let orientation = Matrix3::new(
                         Vector3::new(value[3], value[4], value[5]),