Make debug formatting useful on credentials.

As reported in hwchen#201, the existing debug print of credentials gives no information about the underlying platform credential. This fixes that.

Author: brotskydotcom

src/credential.rs

@@ -27,9 +27,10 @@ if  matches!(persistence, credential::CredentialPersistence::UntilDelete) {
 }
 ```
  */
-use super::Result;
 use std::any::Any;
 
+use super::Result;
+
 /// The API that [credentials](Credential) implement.
 pub trait CredentialApi {
     /// Set the credential's password (a string).
@@ -66,17 +67,30 @@ pub trait CredentialApi {
     /// can do platform-specific things with it (e.g.,
     /// query its attributes in the underlying store).
     fn as_any(&self) -> &dyn Any;
-}
 
-impl std::fmt::Debug for Credential {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.as_any().fmt(f)
+    /// The Debug trait call for the object.
+    ///
+    /// This is used to implement the Debug trait on this type; it
+    /// allows generic code to provide debug printing as provided by
+    /// the underlying concrete object.
+    ///
+    /// We provide a (useless) default implementation for backward
+    /// compatibility with existing implementors who may have not
+    /// implemented the Debug trait for their credential objects
+    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self.as_any(), f)
     }
 }
 
 /// A thread-safe implementation of the [Credential API](CredentialApi).
 pub type Credential = dyn CredentialApi + Send + Sync;
 
+impl std::fmt::Debug for Credential {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.debug_fmt(f)
+    }
+}
+
 /// A descriptor for the lifetime of stored credentials, returned from
 /// a credential store's [persistence](CredentialBuilderApi::persistence) call.
 #[non_exhaustive]

src/ios.rs

@@ -16,10 +16,12 @@ wildcards when looking up credentials by attribute value.)
 On iOS, the target parameter is ignored, because there is only one keychain
 that can be targeted to store a generic credential.
  */
+
 use security_framework::base::Error;
 use security_framework::passwords::{
     delete_generic_password, get_generic_password, set_generic_password,
 };
+use std::fmt::Debug;
 
 use super::credential::{Credential, CredentialApi, CredentialBuilder, CredentialBuilderApi};
 use super::error::{decode_password, Error as ErrorCode, Result};
@@ -87,6 +89,11 @@ impl CredentialApi for IosCredential {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
+
+    /// Expose the concrete debug formatter for use via the [Credential] trait
+    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self, f)
+    }
 }
 
 impl IosCredential {

src/keyutils.rs

@@ -97,11 +97,13 @@ Alternatively, you can drop the secret-service credential store altogether
 with `--no-default-features` and `--features linux-no-secret-service`.
 
  */
+
 use super::credential::{
     Credential, CredentialApi, CredentialBuilder, CredentialBuilderApi, CredentialPersistence,
 };
 use super::error::{decode_password, Error as ErrorCode, Result};
 use linux_keyutils::{KeyError, KeyRing, KeyRingIdentifier};
+use std::fmt::Debug;
 
 /// Representation of a keyutils credential.
 ///
@@ -223,6 +225,11 @@ impl CredentialApi for KeyutilsCredential {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
+
+    /// Expose the concrete debug formatter for use via the [Credential] trait
+    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self, f)
+    }
 }
 
 impl KeyutilsCredential {

src/macos.rs

@@ -27,6 +27,7 @@ name as the target parameter to `Entry::new_with_target`.
 Any name other than one of the OS-supplied keychains (User, Common, System, and Dynamic)
 will be mapped to `User`.
  */
+
 use security_framework::base::Error;
 use security_framework::os::macos::keychain::{SecKeychain, SecPreferencesDomain};
 use security_framework::os::macos::passwords::find_generic_password;
@@ -110,6 +111,11 @@ impl CredentialApi for MacCredential {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
+
+    /// Expose the concrete debug formatter for use via the [Credential] trait
+    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self, f)
+    }
 }
 
 impl MacCredential {

src/mock.rs

@@ -34,6 +34,7 @@ entry.set_password("test").expect("error has been cleared");
 ```
  */
 use std::cell::RefCell;
+use std::fmt::Debug;
 use std::sync::Mutex;
 
 use super::credential::{
@@ -174,6 +175,11 @@ impl CredentialApi for MockCredential {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
+
+    /// Expose the concrete debug formatter for use via the [Credential] trait
+    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self, f)
+    }
 }
 
 impl MockCredential {

src/secret_service.rs

@@ -76,15 +76,15 @@ there is no "default" collection defined under WSL.  So
 this keystore doesn't work "out of the box" on WSL.  See the
 issue for more details and possible workarounds.
  */
-use std::collections::HashMap;
-
 #[cfg(not(feature = "async-secret-service"))]
 use dbus_secret_service::{Collection, EncryptionType, Error, Item, SecretService};
 #[cfg(feature = "async-secret-service")]
 use secret_service::{
     blocking::{Collection, Item, SecretService},
     EncryptionType, Error,
 };
+use std::collections::HashMap;
+use std::fmt::Debug;
 
 use super::credential::{Credential, CredentialApi, CredentialBuilder, CredentialBuilderApi};
 use super::error::{decode_password, Error as ErrorCode, Result};
@@ -361,6 +361,11 @@ impl CredentialBuilderApi for SsCredentialBuilder {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
+
+    /// Expose the concrete debug formatter for use via the [Credential] trait
+    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self, f)
+    }
 }
 
 //

src/windows.rs

@@ -29,7 +29,9 @@ the order in which they were made.  Careful testing has
 shown that modifying the same entry in the same (almost simultaneous) order from
 different threads produces different results on different runs.
 */
+
 use byteorder::{ByteOrder, LittleEndian};
+use std::fmt::Debug;
 use std::iter::once;
 use std::mem::MaybeUninit;
 use std::str;
@@ -166,6 +168,11 @@ impl CredentialApi for WinCredential {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
+
+    /// Expose the concrete debug formatter for use via the [Credential] trait
+    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self, f)
+    }
 }
 
 impl WinCredential {