path-slash

Releases

1. ▸▾0.2.16 Aug 20222 sources agree

   Added CowExt::to_slash and CowExt::to_slash_lossy . PathExt is no longer necessary to convert Cow<'a, Path> paths into slash paths.

   • Added CowExt::to_slash and CowExt::to_slash_lossy. PathExt is no longer necessary to convert Cow<'a, Path> paths into slash paths.
   • Clarified minimum supported Rust version. Rust 1.38 or later is supported. rust-version field in Cargo.toml was added so that cargo can check the MSRV is met.
   • Improved documents of trait methods. The documents were moved from implementations of the trait methods to definitions of them so that users can find out the documents more easily. Documents for implementations are folded by default, but definitions aren't.

   Open source →
2. ▸▾0.2.05 Jul 2022

   BREAKING: to_slash and to_slash_lossy return Cow<'_, str> instead of String . Now heap allocation hapnens only when path separator is replaced. On Uni

   • BREAKING: to_slash and to_slash_lossy return Cow<'_, str> instead of String. Now heap allocation hapnens only when path separator is replaced. On Unix-like OS, almost all heap allocations can be removed by this change. Migrating from 0.1 to 0.2 is quite easy by adding Cow::into_owned call. If &str is sufficient for your use case, Cow::as_ref is better to avoid heap allocation. (#9)

     use path_slash::PathExt as _;
     
     // 0.1
     let s: Option<String> = Path::new("/a/b").to_slash();
     let s: String = Path::new("/a/b").to_slash_lossy();
     // 0.2
     let s: Option<String> = Path::new("/a/b").to_slash().map(Cow::into_owned);
     let s: String = Path::new("/a/b").to_slash_lossy().into_owned();

     API changes are as follows:
     • 0.1.5
       • Path::to_slash(&self) -> Option<String>
       • Path::to_slash_lossy(&self) -> String
     • 0.2.0
       • Path::to_slash(&self) -> Option<Cow<'_, Path>>
       • Path::to_slash_lossy(&self) -> Cow<'_, Path>
   • BREAKING: Fix inconsistency on Windows and on Unix-like OS in terms of trailing slash in path. Now a trailing slash in path is always preserved. (#10)

     // 0.1
     #[cfg(target_os = "windows")]
     assert_eq!(Path::new(r"\a\b\").to_slash_lossy(), "/a/b"); // Trailing slash is removed
     #[cfg(not(target_os = "windows"))]
     assert_eq!(Path::new("/a/b/").to_slash_lossy(), "/a/b/"); // Trailing slash is preserved
     
     // 0.2
     #[cfg(target_os = "windows")]
     assert_eq!(Path::new(r"\a\b\").to_slash_lossy(), "/a/b/"); // Trailing slash is preserved
     #[cfg(not(target_os = "windows"))]
     assert_eq!(Path::new("/a/b/").to_slash_lossy(), "/a/b/"); // Trailing slash is preserved

   • New API path_slash::CowExt is added to extend Cow<'_, Path>. Its methods convert slash paths into Cow<'_, Path>. It is useful to avoid heap allocations as much as possible compared with PathBufExt. See the API document for more details. (#9)

     use path_slash::CowExt as _;
     let p = Cow::from_slash("foo/bar/piyo.txt"); // Heap allocation only happens on Windows
     
     #[cfg(target_os = "windows")]
     assert_eq!(p, Cow::Owned(PathBuf::from(r"foo\bar\piyo.txt")));
     #[cfg(not(target_os = "windows"))]
     assert_eq!(p, Cow::Borrowed(Path::new("foo/bar/piyo.txt")));

     All methods added by importing CowExt are as follows:
     • Cow::<Path>::from_slash(s: &str) -> Self
     • Cow::<Path>::from_slash_lossy(s: &OsStr) -> Self
     • Cow::<Path>::from_backslash(s: &str) -> Self
     • Cow::<Path>::from_backslash_lossy(s: &OsStr) -> Self
   • More tests are added. Now the line coverage is 100%.
     • UTF-16 test cases for native encoding on Windows
     • All error cases including broken UTF-8 and UTF-16 sequences