Update debug implementation to no longer require encoding to implement debug

Author: chipsenkbeil

CHANGELOG.md

@@ -7,9 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.2.2] - 2023-02-14
+## [0.3.0] - 2023-02-14
 
 * Add `Clone` implementation for `Box<Path<T>>` and `Box<Utf8Path<T>>`
+* Fix `Clone` implementation for `PathBuf<T>` and `Utf8PathBuf<T>` requiring a
+  clone implementation for the encoding, which is not necessary
+  ([#5](https://github.com/chipsenkbeil/typed-path/issues/5))
+* Update `Debug` implementation for `Path<T>`, `Utf8Path<T>`, `PathBuf<T>`, and
+  `Utf8PathBuf<T>` to no longer require debug implementation for encoding,
+  which is not necessary
+* Add `label` method to encoding implementations, used for debugging purposes
 
 ## [0.2.1] - 2022-12-12
 
@@ -28,7 +35,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Initial release of the library!
 
-[Unreleased]: https://github.com/chipsenkbeil/typed-path/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/chipsenkbeil/typed-path/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/chipsenkbeil/typed-path/compare/v0.2.1...v0.3.0
 [0.2.1]: https://github.com/chipsenkbeil/typed-path/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/chipsenkbeil/typed-path/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/chipsenkbeil/typed-path/releases/tag/v0.1.0

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "typed-path"
 description = "Provides typed variants of Path and PathBuf for Unix and Windows"
-version = "0.2.2"
+version = "0.3.0"
 edition = "2021"
 authors = ["Chip Senkbeil <chip@senkbeil.org>"]
 categories = ["development-tools", "filesystem", "os"]

README.md

@@ -20,7 +20,7 @@ and Windows.
 
 ```toml
 [dependencies]
-typed-path = "0.2"
+typed-path = "0.3"
 ```
 
 ## Why?

src/common/non_utf8.rs

@@ -20,6 +20,9 @@ pub trait Encoding<'a>: private::Sealed {
     /// Represents the type of component that will be derived by this encoding
     type Components: Components<'a>;
 
+    /// Static label representing encoding type
+    fn label() -> &'static str;
+
     /// Produces an iterator of [`Component`]s over the given the byte slice (`path`)
     fn components(path: &'a [u8]) -> Self::Components;
 

src/common/non_utf8/path.rs

@@ -796,8 +796,11 @@ impl<T> fmt::Debug for Path<T>
 where
     T: for<'enc> Encoding<'enc>,
 {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.inner, formatter)
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Path")
+            .field("_encoding", &T::label())
+            .field("inner", &&self.inner)
+            .finish()
     }
 }
 

src/common/non_utf8/pathbuf.rs

@@ -3,6 +3,7 @@ use std::{
     borrow::{Borrow, Cow},
     cmp,
     collections::TryReserveError,
+    fmt,
     hash::{Hash, Hasher},
     iter::{Extend, FromIterator},
     marker::PhantomData,
@@ -57,7 +58,6 @@ use std::{
 /// ```
 ///
 /// Which method works best depends on what kind of situation you're in.
-#[derive(Clone, Debug)]
 pub struct PathBuf<T>
 where
     T: for<'enc> Encoding<'enc>,
@@ -388,6 +388,31 @@ where
     }
 }
 
+impl<T> Clone for PathBuf<T>
+where
+    T: for<'enc> Encoding<'enc>,
+{
+    #[inline]
+    fn clone(&self) -> Self {
+        Self {
+            _encoding: self._encoding,
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T> fmt::Debug for PathBuf<T>
+where
+    T: for<'enc> Encoding<'enc>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PathBuf")
+            .field("_encoding", &T::label())
+            .field("inner", &self.inner)
+            .finish()
+    }
+}
+
 impl<T> AsRef<[u8]> for PathBuf<T>
 where
     T: for<'enc> Encoding<'enc>,

src/common/utf8.rs

@@ -16,6 +16,9 @@ pub trait Utf8Encoding<'a>: private::Sealed {
     /// Represents the type of component that will be derived by this encoding
     type Components: Utf8Components<'a>;
 
+    /// Static label representing encoding type
+    fn label() -> &'static str;
+
     /// Produces an iterator of [`Utf8Component`]s over the given the byte slice (`path`)
     fn components(path: &'a str) -> Self::Components;
 

src/common/utf8/path.rs

@@ -786,8 +786,11 @@ impl<T> fmt::Debug for Utf8Path<T>
 where
     T: for<'enc> Utf8Encoding<'enc>,
 {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.inner, formatter)
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Utf8Path")
+            .field("_encoding", &T::label())
+            .field("inner", &&self.inner)
+            .finish()
     }
 }
 

src/common/utf8/pathbuf.rs

@@ -63,7 +63,6 @@ use std::{
 /// ```
 ///
 /// Which method works best depends on what kind of situation you're in.
-#[derive(Clone, Debug)]
 pub struct Utf8PathBuf<T>
 where
     T: for<'enc> Utf8Encoding<'enc>,
@@ -475,6 +474,31 @@ where
     }
 }
 
+impl<T> Clone for Utf8PathBuf<T>
+where
+    T: for<'enc> Utf8Encoding<'enc>,
+{
+    #[inline]
+    fn clone(&self) -> Self {
+        Self {
+            _encoding: self._encoding,
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T> fmt::Debug for Utf8PathBuf<T>
+where
+    T: for<'enc> Utf8Encoding<'enc>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Utf8PathBuf")
+            .field("_encoding", &T::label())
+            .field("inner", &self.inner)
+            .finish()
+    }
+}
+
 impl<T> AsRef<[u8]> for Utf8PathBuf<T>
 where
     T: for<'enc> Utf8Encoding<'enc>,

src/native.rs

@@ -25,6 +25,17 @@ mod non_utf8 {
     /// [`Component`](crate::Component) that is native to the platform during compilation
     #[cfg(windows)]
     pub type NativeComponent<'a> = crate::windows::WindowsComponent<'a>;
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        #[test]
+        fn native_path_buf_should_be_cloneable() {
+            let path = NativePathBuf::from("hello.txt");
+            assert_eq!(path, path.clone());
+        }
+    }
 }
 
 mod utf8 {
@@ -51,4 +62,15 @@ mod utf8 {
     /// [`Utf8Component`](crate::Utf8Component) that is native to the platform during compilation
     #[cfg(windows)]
     pub type Utf8NativeComponent<'a> = crate::windows::Utf8WindowsComponent<'a>;
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        #[test]
+        fn utf8_native_path_buf_should_be_cloneable() {
+            let path = Utf8NativePathBuf::from("hello.txt");
+            assert_eq!(path, path.clone());
+        }
+    }
 }