Bump version to 0.7.1

.github/workflows/ci.yml

@@ -81,7 +81,12 @@ jobs:
           profile: minimal
           toolchain: ${{ matrix.rust }}
           target: ${{ matrix.target }}
+      - run: cargo test ${{ matrix.flags }} --target ${{ matrix.target }}
+        if: matrix.target != 0 && matrix.target != 'wasm32-unknown-unknown'
+      - run: cargo build ${{ matrix.flags }} --target ${{ matrix.target }}
+        if: matrix.target != 0 && matrix.target == 'wasm32-unknown-unknown'
       - run: cargo test ${{ matrix.flags }}
+        if: matrix.target == 0
   examples:
     name: "Run examples using Rust ${{ matrix.rust }} (${{ matrix.os }})"
     runs-on: ${{ matrix.os }}

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.1] - 2024-02-15
+
+* Support `wasm` family for compilation
+
 ## [0.7.0] - 2023-11-04
 
 * Support `no_std` environments, when `default-features = false` is set for the crate

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "typed-path"
 description = "Provides typed variants of Path and PathBuf for Unix and Windows"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 authors = ["Chip Senkbeil <[email protected]>"]
 categories = ["development-tools", "filesystem", "os"]

src/common/non_utf8/path.rs

@@ -629,7 +629,7 @@ where
     /// let path = cwd.join(Path::new("a/b/../c/./d"));
     /// assert_eq!(path.absolutize().unwrap(), cwd.join(Path::new("a/c/d")));
     /// ```
-    #[cfg(feature = "std")]
+    #[cfg(all(feature = "std", not(target_family = "wasm")))]
     pub fn absolutize(&self) -> std::io::Result<PathBuf<T>> {
         if self.is_absolute() {
             Ok(self.normalize())

src/common/utf8/path.rs

@@ -581,7 +581,7 @@ where
     /// let path = cwd.join(Utf8Path::new("a/b/../c/./d"));
     /// assert_eq!(path.absolutize().unwrap(), cwd.join(Utf8Path::new("a/c/d")));
     /// ```
-    #[cfg(feature = "std")]
+    #[cfg(all(feature = "std", not(target_family = "wasm")))]
     pub fn absolutize(&self) -> std::io::Result<Utf8PathBuf<T>> {
         if self.is_absolute() {
             Ok(self.normalize())

src/lib.rs

@@ -20,10 +20,11 @@ mod no_std_compat {
 #[macro_use]
 mod common;
 mod convert;
+#[cfg(not(target_family = "wasm"))]
 mod native;
 mod typed;
 mod unix;
-#[cfg(feature = "std")]
+#[cfg(all(feature = "std", not(target_family = "wasm")))]
 pub mod utils;
 mod windows;
 
@@ -34,6 +35,7 @@ mod private {
 
 pub use common::*;
 pub use convert::*;
+#[cfg(not(target_family = "wasm"))]
 pub use native::*;
 pub use typed::*;
 pub use unix::*;

src/typed/non_utf8/path.rs

@@ -534,7 +534,7 @@ impl<'a> TypedPath<'a> {
     /// let path = cwd.join("a/b/../c/./d");
     /// assert_eq!(path.absolutize().unwrap(), cwd.join("a/c/d"));
     /// ```
-    #[cfg(feature = "std")]
+    #[cfg(all(feature = "std", not(target_family = "wasm")))]
     pub fn absolutize(&self) -> io::Result<TypedPathBuf> {
         Ok(match self {
             Self::Unix(path) => TypedPathBuf::Unix(path.absolutize()?),

src/typed/utf8/path.rs

@@ -490,7 +490,7 @@ impl<'a> Utf8TypedPath<'a> {
     /// let path = cwd.join("a/b/../c/./d");
     /// assert_eq!(path.absolutize().unwrap(), cwd.join("a/c/d"));
     /// ```
-    #[cfg(feature = "std")]
+    #[cfg(all(feature = "std", not(target_family = "wasm")))]
     pub fn absolutize(&self) -> std::io::Result<Utf8TypedPathBuf> {
         Ok(match self {
             Self::Unix(path) => Utf8TypedPathBuf::Unix(path.absolutize()?),

src/typed/utf8/pathbuf.rs

@@ -710,7 +710,7 @@ impl Utf8TypedPathBuf {
     /// let path = cwd.join("a/b/../c/./d");
     /// assert_eq!(path.absolutize().unwrap(), cwd.join("a/c/d"));
     /// ```
-    #[cfg(feature = "std")]
+    #[cfg(all(feature = "std", not(target_family = "wasm")))]
     pub fn absolutize(&self) -> std::io::Result<Utf8TypedPathBuf> {
         self.to_path().absolutize()
     }