Dont canonicalize per default

Author: OpenByteDev

src/shortcut.rs

@@ -1,5 +1,6 @@
 use std::{
     borrow::Cow,
+    io,
     path::{Path, PathBuf},
     ptr,
 };
@@ -52,32 +53,6 @@ pub struct Shortcut {
     pub run_as_admin: bool,
 }
 
-/// Options for loading a [`Shortcut`], can be specified when using [`load_with_options`](Shortcut::load_with_options).
-#[derive(Debug, Clone, Copy)]
-pub struct LoadOptions {
-    /// If true, canonicalizes paths.
-    pub canonicalize: bool,
-}
-
-impl Default for LoadOptions {
-    fn default() -> Self {
-        Self { canonicalize: true } // keep current behavior as default
-    }
-}
-
-/// Options for saving a [`Shortcut`], can be specified when using [`save_with_options`](Shortcut::save_with_options).
-#[derive(Debug, Clone, Copy)]
-pub struct SaveOptions {
-    /// If true, canonicalizes paths.
-    pub canonicalize: bool,
-}
-
-impl Default for SaveOptions {
-    fn default() -> Self {
-        Self { canonicalize: true }
-    }
-}
-
 impl Shortcut {
     /// Create a new empty [`ShortcutBuilder`].
     #[must_use]
@@ -100,11 +75,6 @@ impl Shortcut {
         }
     }
 
-    /// Loads a `.lnk` file from disk and parses it into a [`Shortcut`].
-    pub fn load(path: impl AsRef<Path>) -> Result<Self> {
-        Self::load_with_options(path, LoadOptions::default())
-    }
-
     /// Canonicalizes all filesystem paths contained in this shortcut in-place.
     ///
     /// The following fields are affected:
@@ -116,27 +86,25 @@ impl Shortcut {
     /// If a path is **relative** and `base` is [`Some`], it is first resolved
     /// relative to `base` (typically the directory containing the `.lnk` file)
     /// and then canonicalized.
-    /// 
-    /// # Errors
-    /// Errors during canonicalization are ignored.
-    pub fn canonicalize(&mut self, base: Option<&Path>) {
-        try_canonicalize_with_base_inplace_opt(self.target_path.as_mut(), base);
-        try_canonicalize_with_base_inplace_opt(self.working_dir.as_mut(), base);
-        try_canonicalize_with_base_inplace_opt(self.icon.as_mut().map(|i| &mut i.path), base);
+    pub fn canonicalize(&mut self, base: Option<&Path>) -> io::Result<()> {
+        canonicalize_with_base_inplace_opt(self.target_path.as_mut(), base)?;
+        canonicalize_with_base_inplace_opt(self.working_dir.as_mut(), base)?;
+        canonicalize_with_base_inplace_opt(self.icon.as_mut().map(|i| &mut i.path), base)?;
+        Ok(())
     }
 
     /// Returns a canonicalized clone of this shortcut.
     ///
     /// This is a non-mutating variant of [`canonicalize`](Self::canonicalize).
     /// The original [`Shortcut`] is left unchanged.
-    pub fn canonicalized(&self, base: Option<&Path>) -> Self {
+    pub fn canonicalized(&self, base: Option<&Path>) -> io::Result<Self> {
         let mut clone = self.clone();
-        clone.canonicalize(base);
-        clone
+        clone.canonicalize(base)?;
+        Ok(clone)
     }
 
-    /// Loads a `.lnk` file from disk and parses it into a [`Shortcut`], considering the given [`LoadOptions`].
-    pub fn load_with_options(path: impl AsRef<Path>, options: LoadOptions) -> Result<Self> {
+    /// Loads a `.lnk` file from disk and parses it into a [`Shortcut`].
+    pub fn load(path: impl AsRef<Path>) -> Result<Self> {
         let path = path.as_ref();
         com::ensure_initialized()?;
 
@@ -181,7 +149,7 @@ impl Shortcut {
         #[cfg(feature = "runas")]
         let run_as_admin = runas::read_runas_bit(&path)?;
 
-        let mut shortcut = Shortcut {
+        let shortcut = Shortcut {
             target_path,
             arguments,
             working_dir,
@@ -193,31 +161,19 @@ impl Shortcut {
             run_as_admin,
         };
 
-        if options.canonicalize {
-            shortcut.canonicalize(path.parent());
-        }
-
         Ok(shortcut)
     }
 
     /// Saves the shortcut to disk as a `.lnk` file.
     pub fn save(&self, path: impl AsRef<Path>) -> Result<()> {
-        self.save_with_options(path, SaveOptions::default())
-    }
-
-    /// Saves the shortcut to disk as a `.lnk` file, considering the given [`SaveOptions`].
-    pub fn save_with_options(&self, path: impl AsRef<Path>, options: SaveOptions) -> Result<()> {
         com::ensure_initialized()?;
 
-        let path = maybe_try_canonicalize(path.as_ref(), options.canonicalize);
-        let base = path.parent();
+        let path = try_canonicalize(path.as_ref());
 
         let link: IShellLinkW = unsafe { CoCreateInstance(&ShellLink, None, CLSCTX_INPROC_SERVER) }
             .context(None, "CoCreateInstance")?;
 
         if let Some(target_path) = &self.target_path {
-            let target_path =
-                maybe_try_canonicalize_with_base(target_path, base, options.canonicalize);
             let w = U16CString::from_os_str(target_path.as_os_str())?;
             unsafe { link.SetPath(PCWSTR(w.as_ptr())) }.context(Some("IShellLinkW"), "SetPath")?;
         }
@@ -229,8 +185,6 @@ impl Shortcut {
         }
 
         if let Some(working_dir) = &self.working_dir {
-            let working_dir =
-                maybe_try_canonicalize_with_base(working_dir, base, options.canonicalize);
             let w = U16CString::from_os_str(working_dir.as_os_str())?;
             unsafe { link.SetWorkingDirectory(PCWSTR(w.as_ptr())) }
                 .context(Some("IShellLinkW"), "SetWorkingDirectory")?;
@@ -243,9 +197,7 @@ impl Shortcut {
         }
 
         if let Some(icon) = &self.icon {
-            let icon_path =
-                maybe_try_canonicalize_with_base(&icon.path, base, options.canonicalize);
-            let w = U16CString::from_os_str(icon_path.as_os_str())?;
+            let w = U16CString::from_os_str(icon.path.as_os_str())?;
             unsafe { link.SetIconLocation(PCWSTR(w.as_ptr()), icon.index) }
                 .context(Some("IShellLinkW"), "SetIconLocation")?;
         }
@@ -400,76 +352,32 @@ impl ShortcutBuilder {
     }
 }
 
-fn try_canonicalize_inplace(path: &mut PathBuf) -> bool {
-    if let Ok(canon) = dunce::canonicalize(&path) {
-        *path = canon;
-        true
-    } else {
-        false
-    }
-}
-/* 
-fn try_canonicalize_inplace_opt(opt: Option<&mut PathBuf>) -> bool {
-    if let Some(path) = opt {
-        try_canonicalize_inplace(path)
-    } else {
-        false
-    }
+fn canonicalize_inplace(path: &mut PathBuf) -> io::Result<()> {
+    *path = dunce::canonicalize(&path)?;
+    Ok(())
 }
-*/
 #[allow(clippy::unnecessary_unwrap)]
-fn try_canonicalize_with_base_inplace(path: &mut PathBuf, base: Option<&Path>) -> bool {
+fn canonicalize_with_base_inplace(path: &mut PathBuf, base: Option<&Path>) -> io::Result<()> {
     if path.is_absolute() || base.is_none() {
-        try_canonicalize_inplace(path)
+        canonicalize_inplace(path)
     } else {
         let mut absolute = base.unwrap().join(&path);
-        let success = try_canonicalize_inplace(&mut absolute);
-        if success {
-            *path = absolute;
-        }
-        success
+        canonicalize_inplace(&mut absolute)?;
+        *path = absolute;
+        Ok(())
     }
 }
-fn try_canonicalize_with_base_inplace_opt(opt: Option<&mut PathBuf>, base: Option<&Path>) -> bool {
+fn canonicalize_with_base_inplace_opt(
+    opt: Option<&mut PathBuf>,
+    base: Option<&Path>,
+) -> io::Result<()> {
     if let Some(path) = opt {
-        try_canonicalize_with_base_inplace(path, base)
+        canonicalize_with_base_inplace(path, base)
     } else {
-        false
+        Ok(())
     }
 }
 
 fn try_canonicalize(path: &'_ Path) -> Cow<'_, Path> {
     dunce::canonicalize(path).map_or_else(|_| Cow::Borrowed(path), Cow::Owned)
 }
-fn maybe_try_canonicalize(path: &'_ Path, enabled: bool) -> Cow<'_, Path> {
-    if enabled {
-        try_canonicalize(path)
-    } else {
-        Cow::Borrowed(path)
-    }
-}
-
-#[allow(clippy::unnecessary_unwrap)]
-fn try_canonicalize_with_base<'a>(path: &'a Path, base: Option<&'_ Path>) -> Cow<'a, Path> {
-    if path.is_absolute() || base.is_none() {
-        try_canonicalize(path)
-    } else {
-        let mut absolute = base.unwrap().join(path);
-        if try_canonicalize_inplace(&mut absolute) {
-            Cow::Owned(absolute)
-        } else {
-            Cow::Borrowed(path)
-        }
-    }
-}
-fn maybe_try_canonicalize_with_base<'a>(
-    path: &'a Path,
-    base: Option<&'_ Path>,
-    enabled: bool,
-) -> Cow<'a, Path> {
-    if enabled {
-        try_canonicalize_with_base(path, base)
-    } else {
-        Cow::Borrowed(path)
-    }
-}