String formatting: support padding, alignment and precision

Allows to use `format!("{s:>6}")` and similar expressions, yielding expected results.
Tries to not allocate extra strings if no custom formatting options are needed.

Author: Bromeon

godot-core/src/builtin/string/gstring.rs

@@ -13,7 +13,7 @@ use godot_ffi as sys;
 use sys::types::OpaqueString;
 use sys::{ffi_methods, interface_fn, GodotFfi};
 
-use crate::builtin::string::Encoding;
+use crate::builtin::string::{pad_if_needed, Encoding};
 use crate::builtin::{inner, NodePath, StringName, Variant};
 use crate::meta::error::StringError;
 use crate::meta::AsArg;
@@ -298,11 +298,13 @@ impl_shared_string_api! {
 
 impl fmt::Display for GString {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for ch in self.chars() {
-            f.write_char(*ch)?;
-        }
+        pad_if_needed(f, |f| {
+            for ch in self.chars() {
+                f.write_char(*ch)?;
+            }
 
-        Ok(())
+            Ok(())
+        })
     }
 }
 

godot-core/src/builtin/string/mod.rs

@@ -155,3 +155,48 @@ fn found_to_option(index: i64) -> Option<usize> {
         Some(index_usize)
     }
 }
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Padding, alignment and precision support
+
+// Used by sub-modules of this module.
+use standard_fmt::pad_if_needed;
+
+mod standard_fmt {
+    use std::fmt;
+    use std::fmt::Write;
+
+    pub fn pad_if_needed<F>(f: &mut fmt::Formatter<'_>, display_impl: F) -> fmt::Result
+    where
+        F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
+    {
+        let needs_format = f.width().is_some() || f.precision().is_some() || f.align().is_some();
+
+        // Early exit if no custom formatting is needed.
+        if !needs_format {
+            return display_impl(f);
+        }
+
+        let ic = FmtInterceptor { display_impl };
+
+        let mut local_str = String::new();
+        write!(&mut local_str, "{ic}")?;
+        f.pad(&local_str)
+    }
+
+    struct FmtInterceptor<F>
+    where
+        F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
+    {
+        display_impl: F,
+    }
+
+    impl<'a, F> fmt::Display for FmtInterceptor<F>
+    where
+        F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
+    {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            (self.display_impl)(f)
+        }
+    }
+}

itest/rust/src/builtin_tests/string/gstring_test.rs

@@ -279,6 +279,14 @@ crate::generate_string_bytes_and_cstr_tests!(
     ]
 );
 
+crate::generate_string_standard_fmt_tests!(
+    builtin: GString,
+    tests: [
+        gstring_display,
+        gstring_standard_pad,
+    ]
+);
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Helpers
 

itest/rust/src/builtin_tests/string/node_path_test.rs

@@ -31,6 +31,7 @@ fn node_path_conversion() {
 
     assert_eq!(string, back);
 }
+
 #[itest]
 fn node_path_equality() {
     let string = NodePath::from("some string");
@@ -126,3 +127,11 @@ fn node_path_get_subname() {
         assert_eq!(path.get_subname(2), "".into());
     })
 }
+
+crate::generate_string_standard_fmt_tests!(
+    builtin: NodePath,
+    tests: [
+        node_path_display,
+        node_path_standard_pad,
+    ]
+);

itest/rust/src/builtin_tests/string/string_name_test.rs

@@ -175,3 +175,11 @@ crate::generate_string_bytes_and_cstr_tests!(
         string_name_from_cstr_utf8,
     ]
 );
+
+crate::generate_string_standard_fmt_tests!(
+    builtin: StringName,
+    tests: [
+        node_path_display,
+        string_name_standard_pad,
+    ]
+);

itest/rust/src/builtin_tests/string/string_test_macros.rs

@@ -162,3 +162,35 @@ macro_rules! generate_string_bytes_and_cstr_tests {
         }
     };
 }
+
+// Tests padding with the standard formatter.
+#[macro_export]
+macro_rules! generate_string_standard_fmt_tests {
+    (
+        builtin: $T:ty,
+        tests: [
+            $display:ident,
+            $standard_pad:ident,
+        ]
+    ) => {
+        #[itest(focus)]
+        fn $display() {
+            let s = <$T>::from("abcd");
+
+            assert_eq!(format!("{s}"), "abcd");
+        }
+
+        #[itest(focus)]
+        fn $standard_pad() {
+            let s = <$T>::from("abcd");
+
+            // Padding with spaces + alignment.
+            assert_eq!(format!("{s:<6}"), "abcd  ");
+            assert_eq!(format!("{s:>6}"), "  abcd");
+
+            // Precision.
+            assert_eq!(format!("{s:.2}"), "ab");
+            assert_eq!(format!("{s:.3}"), "abc");
+        }
+    };
+}