Implement proper Debug for all foundation types

Author: madsmtm

objc2-foundation/CHANGELOG.md

@@ -9,6 +9,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Added
 * Implement `UnwindSafe` and `RefUnwindSafe` for all objects.
 
+### Fixed
+* Made `Debug` impls for all objects print something useful.
+
 ### Removed
 * `NSObject::hash_code`, `NSObject::is_equal` and `NSObject::description` in
   favour of just having the trait implementations `Hash`, `PartiqalEq` and

objc2-foundation/src/array.rs

@@ -1,4 +1,5 @@
 use alloc::vec::Vec;
+use core::fmt;
 use core::marker::PhantomData;
 use core::ops::{Index, Range};
 use core::panic::{RefUnwindSafe, UnwindSafe};
@@ -26,7 +27,7 @@ __inner_extern_class! {
     /// What about `Id<NSArray<T, Shared>, Owned>`?
     // `T: PartialEq` bound correct because `NSArray` does deep (instead of
     // shallow) equality comparisons.
-    #[derive(Debug, PartialEq, Eq, Hash)]
+    #[derive(PartialEq, Eq, Hash)]
     unsafe pub struct NSArray<T, O: Ownership>: NSObject {
         item: PhantomData<Id<T, O>>,
         notunwindsafe: PhantomData<&'static mut ()>,
@@ -215,6 +216,13 @@ impl<T: Message> DefaultId for NSArray<T, Shared> {
     }
 }
 
+impl<T: fmt::Debug + Message, O: Ownership> fmt::Debug for NSArray<T, O> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.iter_fast()).finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloc::format;
@@ -276,15 +284,11 @@ mod tests {
     }
 
     #[test]
-    #[ignore = "Output is different depending on OS version and runtime"]
     fn test_debug() {
+        let obj = sample_number_array(0);
+        assert_eq!(format!("{:?}", obj), "[]");
         let obj = sample_number_array(3);
-        let expected = r#"(
-    "<00>",
-    "<01>",
-    "<02>"
-)"#;
-        assert_eq!(format!("{:?}", obj), format!("{:?}", expected));
+        assert_eq!(format!("{:?}", obj), "[0, 1, 2]");
     }
 
     #[test]

objc2-foundation/src/attributed_string.rs

@@ -1,3 +1,4 @@
+use core::fmt;
 use core::panic::{RefUnwindSafe, UnwindSafe};
 
 use objc2::rc::{DefaultId, Id, Shared};
@@ -22,7 +23,7 @@ extern_class! {
     /// framework contains most of the extension methods.
     ///
     /// See [Apple's documentation](https://developer.apple.com/documentation/foundation/nsattributedstring?language=objc).
-    #[derive(Debug, PartialEq, Eq, Hash)]
+    #[derive(PartialEq, Eq, Hash)]
     unsafe pub struct NSAttributedString: NSObject;
 }
 
@@ -132,10 +133,19 @@ impl alloc::borrow::ToOwned for NSAttributedString {
     }
 }
 
+impl fmt::Debug for NSAttributedString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Use -[NSAttributedString description] since it is pretty good
+        let obj: &NSObject = self;
+        fmt::Debug::fmt(obj, f)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloc::string::ToString;
-    use objc2::rc::autoreleasepool;
+    use alloc::{format, vec};
+    use objc2::rc::{autoreleasepool, Owned};
 
     use super::*;
 
@@ -174,4 +184,28 @@ mod tests {
         assert_ne!(Id::as_ptr(&s1), Id::as_ptr(&s3).cast());
         assert!(s3.is_kind_of(NSMutableAttributedString::class()));
     }
+
+    #[test]
+    fn test_debug() {
+        let s = NSAttributedString::from_nsstring(&NSString::from_str("abc"));
+        let expected = if cfg!(feature = "gnustep-1-7") {
+            "abc{}"
+        } else {
+            "abc{\n}"
+        };
+        assert_eq!(format!("{:?}", s), expected);
+
+        let obj: Id<Object, Owned> = unsafe { Id::cast(NSObject::new()) };
+        let ptr: *const Object = &*obj;
+        let s = NSAttributedString::new_with_attributes(
+            &NSString::from_str("abc"),
+            &NSDictionary::from_keys_and_objects(&[&*NSString::from_str("test")], vec![obj]),
+        );
+        let expected = if cfg!(feature = "gnustep-1-7") {
+            format!("abc{{test = \"<NSObject: {:?}>\"; }}", ptr)
+        } else {
+            format!("abc{{\n    test = \"<NSObject: {:?}>\";\n}}", ptr)
+        };
+        assert_eq!(format!("{:?}", s), expected);
+    }
 }

objc2-foundation/src/data.rs

@@ -1,6 +1,7 @@
 #[cfg(feature = "block")]
 use alloc::vec::Vec;
 use core::ffi::c_void;
+use core::fmt;
 use core::ops::Index;
 use core::panic::{RefUnwindSafe, UnwindSafe};
 use core::slice::{self, SliceIndex};
@@ -17,7 +18,7 @@ extern_class! {
     /// This is similar to a [`slice`][`prim@slice`] of [`u8`].
     ///
     /// See [Apple's documentation](https://developer.apple.com/documentation/foundation/nsdata?language=objc).
-    #[derive(Debug, PartialEq, Eq, Hash)]
+    #[derive(PartialEq, Eq, Hash)]
     unsafe pub struct NSData: NSObject;
 }
 
@@ -120,6 +121,14 @@ impl DefaultId for NSData {
     }
 }
 
+impl fmt::Debug for NSData {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // -[NSData description] is quite unreadable
+        fmt::Debug::fmt(self.bytes(), f)
+    }
+}
+
 pub(crate) unsafe fn data_with_bytes(cls: &Class, bytes: &[u8]) -> *mut Object {
     let bytes_ptr: *const c_void = bytes.as_ptr().cast();
     unsafe {
@@ -164,6 +173,7 @@ pub(crate) unsafe fn data_from_vec(cls: &Class, bytes: Vec<u8>) -> *mut Object {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::format;
     #[cfg(feature = "block")]
     use alloc::vec;
 
@@ -190,4 +200,11 @@ mod tests {
         let data = NSData::from_vec(bytes);
         assert_eq!(data.bytes().as_ptr(), bytes_ptr);
     }
+
+    #[test]
+    fn test_debug() {
+        let bytes = [3, 7, 16, 52, 112, 19];
+        let data = NSData::with_bytes(&bytes);
+        assert_eq!(format!("{:?}", data), "[3, 7, 16, 52, 112, 19]");
+    }
 }

objc2-foundation/src/dictionary.rs

@@ -1,5 +1,6 @@
 use alloc::vec::Vec;
 use core::cmp::min;
+use core::fmt;
 use core::marker::PhantomData;
 use core::ops::Index;
 use core::panic::{RefUnwindSafe, UnwindSafe};
@@ -11,7 +12,7 @@ use objc2::{msg_send, msg_send_id, Message};
 use super::{NSArray, NSCopying, NSEnumerator, NSFastEnumeration, NSObject, __inner_extern_class};
 
 __inner_extern_class! {
-    #[derive(Debug, PartialEq, Eq, Hash)]
+    #[derive(PartialEq, Eq, Hash)]
     unsafe pub struct NSDictionary<K, V>: NSObject {
         key: PhantomData<Id<K, Shared>>,
         obj: PhantomData<Id<V, Owned>>,
@@ -159,8 +160,17 @@ impl<'a, K: Message, V: Message> Index<&'a K> for NSDictionary<K, V> {
     }
 }
 
+impl<K: fmt::Debug + Message, V: fmt::Debug + Message> fmt::Debug for NSDictionary<K, V> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter_keys().zip(self.iter_values());
+        f.debug_map().entries(iter).finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use alloc::format;
     use alloc::vec;
     use objc2::rc::{autoreleasepool, Id, Shared};
 
@@ -250,4 +260,13 @@ mod tests {
         // let objs = NSDictionary::into_values_array(dict);
         // assert_eq!(objs.len(), 1);
     }
+
+    #[test]
+    fn test_debug() {
+        let key = NSString::from_str("a");
+        // TODO: Fix this
+        let val = unsafe { Id::from_shared(NSString::from_str("b")) };
+        let dict = NSDictionary::from_keys_and_objects(&[&*key], vec![val]);
+        assert_eq!(format!("{:?}", dict), r#"{"a": "b"}"#);
+    }
 }

objc2-foundation/src/exception.rs

@@ -158,9 +158,9 @@ mod tests {
         assert_eq!(format!("{:?}", exc), debug);
 
         let description = if cfg!(feature = "gnustep-1-7") {
-            format!("\"<NSException: {:p}> NAME:abc REASON:def\"", exc)
+            format!("<NSException: {:p}> NAME:abc REASON:def", exc)
         } else {
-            "\"def\"".into()
+            "def".into()
         };
 
         let exc: &NSObject = &exc;

objc2-foundation/src/mutable_array.rs

@@ -1,6 +1,7 @@
 use alloc::vec::Vec;
 use core::cmp::Ordering;
 use core::ffi::c_void;
+use core::fmt;
 use core::marker::PhantomData;
 use core::ops::{Index, IndexMut};
 
@@ -17,7 +18,7 @@ use crate::{
 __inner_extern_class! {
     // TODO: Ensure that this deref to NSArray is safe!
     // This "inherits" NSArray, and has the same `Send`/`Sync` impls as that.
-    #[derive(Debug, PartialEq, Eq, Hash)]
+    #[derive(PartialEq, Eq, Hash)]
     unsafe pub struct NSMutableArray<T, O: Ownership>: NSArray<T, O>, NSObject {
         p: PhantomData<*mut ()>,
     }
@@ -197,6 +198,13 @@ impl<T: Message, O: Ownership> DefaultId for NSMutableArray<T, O> {
     }
 }
 
+impl<T: fmt::Debug + Message, O: Ownership> fmt::Debug for NSMutableArray<T, O> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloc::vec;

objc2-foundation/src/mutable_attributed_string.rs

@@ -1,3 +1,5 @@
+use core::fmt;
+
 use objc2::rc::{DefaultId, Id, Owned, Shared};
 use objc2::{msg_send, msg_send_id};
 
@@ -7,7 +9,7 @@ extern_class! {
     /// A mutable string that has associated attributes.
     ///
     /// See [Apple's documentation](https://developer.apple.com/documentation/foundation/nsmutableattributedstring?language=objc).
-    #[derive(Debug, PartialEq, Eq, Hash)]
+    #[derive(PartialEq, Eq, Hash)]
     unsafe pub struct NSMutableAttributedString: NSAttributedString, NSObject;
 }
 
@@ -76,6 +78,12 @@ impl alloc::borrow::ToOwned for NSMutableAttributedString {
     }
 }
 
+impl fmt::Debug for NSMutableAttributedString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloc::string::ToString;

objc2-foundation/src/mutable_data.rs

@@ -1,6 +1,7 @@
 #[cfg(feature = "block")]
 use alloc::vec::Vec;
 use core::ffi::c_void;
+use core::fmt;
 use core::ops::{Index, IndexMut, Range};
 use core::slice::{self, SliceIndex};
 use std::io;
@@ -19,7 +20,7 @@ extern_class! {
     /// See [Apple's documentation](https://developer.apple.com/documentation/foundation/nsmutabledata?language=objc).
     ///
     /// [`Vec`]: std::vec::Vec
-    #[derive(Debug, PartialEq, Eq, Hash)]
+    #[derive(PartialEq, Eq, Hash)]
     unsafe pub struct NSMutableData: NSData, NSObject;
 }
 
@@ -208,6 +209,13 @@ impl DefaultId for NSMutableData {
     }
 }
 
+impl fmt::Debug for NSMutableData {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use objc2::runtime::Object;

objc2-foundation/src/mutable_string.rs

@@ -164,17 +164,26 @@ impl fmt::Display for NSMutableString {
 }
 
 impl fmt::Debug for NSMutableString {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&**self, f)
+        fmt::Debug::fmt(&**self, f)
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use alloc::format;
     use alloc::string::ToString;
 
     use super::*;
 
+    #[test]
+    fn display_debug() {
+        let s = NSMutableString::from_str("test\"123");
+        assert_eq!(format!("{}", s), "test\"123");
+        assert_eq!(format!("{:?}", s), r#""test\"123""#);
+    }
+
     #[test]
     fn test_from_nsstring() {
         let s = NSString::from_str("abc");