Merge pull request #25 from lu-zero/dyn-compatible

Make the traits dyn-compatible

Author: utkarshgupta137

src/app_strategy.rs

@@ -4,6 +4,8 @@ use std::ffi::OsStr;
 use std::path::Path;
 use std::path::PathBuf;
 
+use crate::HomeDirError;
+
 /// The arguments to the creator method of an [`AppStrategy`](trait.AppStrategy.html).
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct AppStrategyArgs {
@@ -70,13 +72,7 @@ macro_rules! in_dir_method {
 }
 
 /// Allows applications to retrieve the paths of configuration, data, and cache directories specifically for them.
-pub trait AppStrategy: Sized {
-    /// The error type returned by `new`.
-    type CreationError: std::error::Error;
-
-    /// The constructor requires access to some basic information about your application.
-    fn new(args: AppStrategyArgs) -> Result<Self, Self::CreationError>;
-
+pub trait AppStrategy {
     /// Gets the home directory of the current user.
     fn home_dir(&self) -> &Path;
 
@@ -142,18 +138,14 @@ macro_rules! create_strategies {
         /// Returns the current OS’s native [`AppStrategy`](trait.AppStrategy.html).
         /// This uses the [`Windows`](struct.Windows.html) strategy on Windows, [`Apple`](struct.Apple.html) on macOS & iOS, and [`Xdg`](struct.Xdg.html) everywhere else.
         /// This is the convention used by most GUI applications.
-        pub fn choose_native_strategy(
-            args: AppStrategyArgs,
-        ) -> Result<$native, <$native as AppStrategy>::CreationError> {
+        pub fn choose_native_strategy(args: AppStrategyArgs) -> Result<$native, HomeDirError> {
             <$native>::new(args)
         }
 
         /// Returns the current OS’s default [`AppStrategy`](trait.AppStrategy.html).
         /// This uses the [`Windows`](struct.Windows.html) strategy on Windows, and [`Xdg`](struct.Xdg.html) everywhere else.
         /// This is the convention used by most CLI applications.
-        pub fn choose_app_strategy(
-            args: AppStrategyArgs,
-        ) -> Result<$app, <$app as AppStrategy>::CreationError> {
+        pub fn choose_app_strategy(args: AppStrategyArgs) -> Result<$app, HomeDirError> {
             <$app>::new(args)
         }
     };

src/app_strategy/apple.rs

@@ -1,5 +1,5 @@
-use crate::base_strategy;
 use crate::base_strategy::BaseStrategy;
+use crate::{base_strategy, HomeDirError};
 use std::path::{Path, PathBuf};
 
 /// This is the strategy created by Apple for use on macOS and iOS devices. It is always used by GUI apps on macOS, and is sometimes used by command-line applications there too. iOS only has GUIs, so all iOS applications follow this strategy. The specification is available [here](https://developer.apple.com/library/archive/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/FileSystemOverview/FileSystemOverview.html#//apple_ref/doc/uid/TP40010672-CH2-SW1).
@@ -49,16 +49,17 @@ pub struct Apple {
     bundle_id: String,
 }
 
-impl super::AppStrategy for Apple {
-    type CreationError = crate::HomeDirError;
-
-    fn new(args: super::AppStrategyArgs) -> Result<Self, Self::CreationError> {
+impl Apple {
+    /// Create a new Apple AppStrategy
+    pub fn new(args: super::AppStrategyArgs) -> Result<Self, HomeDirError> {
         Ok(Self {
             base_strategy: base_strategy::Apple::new()?,
             bundle_id: args.bundle_id().replace(' ', ""),
         })
     }
+}
 
+impl super::AppStrategy for Apple {
     fn home_dir(&self) -> &Path {
         self.base_strategy.home_dir()
     }

src/app_strategy/unix.rs

@@ -1,5 +1,7 @@
 use std::path::{Path, PathBuf};
 
+use crate::HomeDirError;
+
 /// This strategy has no standard or official specification. It has arisen over time through hundreds of Unixy tools. Vim and Cargo are notable examples whose configuration/data/cache directory layouts are similar to those created by this strategy.
 ///
 /// ```
@@ -48,16 +50,17 @@ pub struct Unix {
     unixy_name: String,
 }
 
-impl super::AppStrategy for Unix {
-    type CreationError = crate::HomeDirError;
-
-    fn new(args: super::AppStrategyArgs) -> Result<Self, Self::CreationError> {
+impl Unix {
+    /// Create a new Unix AppStrategy
+    pub fn new(args: super::AppStrategyArgs) -> Result<Self, HomeDirError> {
         Ok(Self {
             home_dir: crate::home_dir()?,
             unixy_name: format!(".{}", args.unixy_name()),
         })
     }
+}
 
+impl super::AppStrategy for Unix {
     fn home_dir(&self) -> &Path {
         &self.home_dir
     }

src/app_strategy/windows.rs

@@ -1,5 +1,5 @@
-use crate::base_strategy;
 use crate::base_strategy::BaseStrategy;
+use crate::{base_strategy, HomeDirError};
 use std::path::{Path, PathBuf};
 
 /// This strategy follows Windows’ conventions. It seems that all Windows GUI apps, and some command-line ones follow this pattern. The specification is available [here](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
@@ -129,16 +129,17 @@ macro_rules! dir_method {
     }};
 }
 
-impl super::AppStrategy for Windows {
-    type CreationError = crate::HomeDirError;
-
-    fn new(args: super::AppStrategyArgs) -> Result<Self, Self::CreationError> {
+impl Windows {
+    /// Create a new Windows AppStrategy
+    pub fn new(args: super::AppStrategyArgs) -> Result<Self, HomeDirError> {
         Ok(Self {
             base_strategy: base_strategy::Windows::new()?,
             author_app_name_path: PathBuf::from(args.author).join(args.app_name),
         })
     }
+}
 
+impl super::AppStrategy for Windows {
     fn home_dir(&self) -> &Path {
         self.base_strategy.home_dir()
     }

src/app_strategy/xdg.rs

@@ -1,5 +1,5 @@
-use crate::base_strategy;
 use crate::base_strategy::BaseStrategy;
+use crate::{base_strategy, HomeDirError};
 use std::path::{Path, PathBuf};
 
 /// This strategy implements the [XDG Base Directories Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html). It is the most common on Linux, but is increasingly being adopted elsewhere.
@@ -173,16 +173,17 @@ pub struct Xdg {
     unixy_name: String,
 }
 
-impl super::AppStrategy for Xdg {
-    type CreationError = crate::HomeDirError;
-
-    fn new(args: super::AppStrategyArgs) -> Result<Self, Self::CreationError> {
+impl Xdg {
+    /// Create a new Xdg AppStrategy
+    pub fn new(args: super::AppStrategyArgs) -> Result<Self, HomeDirError> {
         Ok(Self {
             base_strategy: base_strategy::Xdg::new()?,
             unixy_name: args.unixy_name(),
         })
     }
+}
 
+impl super::AppStrategy for Xdg {
     fn home_dir(&self) -> &Path {
         self.base_strategy.home_dir()
     }

src/base_strategy.rs

@@ -1,15 +1,10 @@
 //! These strategies simply provide the user’s configuration, data, and cache directories, without knowing about the application specifically.
 
+use crate::HomeDirError;
 use std::path::{Path, PathBuf};
 
 /// Provides configuration, data, and cache directories of the current user.
-pub trait BaseStrategy: Sized {
-    /// The error type returned by `new`.
-    type CreationError: std::error::Error;
-
-    /// Base strategies are constructed without knowledge of the application.
-    fn new() -> Result<Self, Self::CreationError>;
-
+pub trait BaseStrategy {
     /// Gets the home directory of the current user.
     fn home_dir(&self) -> &Path;
 
@@ -42,15 +37,14 @@ macro_rules! create_strategies {
         /// Returns the current OS’s native [`BaseStrategy`](trait.BaseStrategy.html).
         /// This uses the [`Windows`](struct.Windows.html) strategy on Windows, [`Apple`](struct.Apple.html) on macOS & iOS, and [`Xdg`](struct.Xdg.html) everywhere else.
         /// This is the convention used by most GUI applications.
-        pub fn choose_native_strategy() -> Result<$native, <$native as BaseStrategy>::CreationError>
-        {
+        pub fn choose_native_strategy() -> Result<$native, HomeDirError> {
             <$native>::new()
         }
 
         /// Returns the current OS’s default [`BaseStrategy`](trait.BaseStrategy.html).
         /// This uses the [`Windows`](struct.Windows.html) strategy on Windows, and [`Xdg`](struct.Xdg.html) everywhere else.
         /// This is the convention used by most CLI applications.
-        pub fn choose_base_strategy() -> Result<$base, <$base as BaseStrategy>::CreationError> {
+        pub fn choose_base_strategy() -> Result<$base, HomeDirError> {
             <$base>::new()
         }
     };

src/base_strategy/apple.rs

@@ -1,5 +1,7 @@
 use std::path::{Path, PathBuf};
 
+use crate::HomeDirError;
+
 /// This is the strategy created by Apple for use on macOS and iOS devices. It is always used by GUI apps on macOS, and is sometimes used by command-line applications there too. iOS only has GUIs, so all iOS applications follow this strategy. The specification is available [here](https://developer.apple.com/library/archive/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/FileSystemOverview/FileSystemOverview.html#//apple_ref/doc/uid/TP40010672-CH2-SW1).
 ///
 /// ```
@@ -40,16 +42,16 @@ use std::path::{Path, PathBuf};
 pub struct Apple {
     home_dir: PathBuf,
 }
-
-impl super::BaseStrategy for Apple {
-    type CreationError = crate::HomeDirError;
-
-    fn new() -> Result<Self, Self::CreationError> {
+impl Apple {
+    /// Create a new Apple BaseStrategy
+    pub fn new() -> Result<Self, HomeDirError> {
         Ok(Self {
             home_dir: crate::home_dir()?,
         })
     }
+}
 
+impl super::BaseStrategy for Apple {
     fn home_dir(&self) -> &Path {
         &self.home_dir
     }

src/base_strategy/windows.rs

@@ -1,5 +1,7 @@
 use std::path::{Path, PathBuf};
 
+use crate::HomeDirError;
+
 /// This strategy follows Windows’ conventions. It seems that all Windows GUI apps, and some command-line ones follow this pattern. The specification is available [here](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
 ///
 /// This initial example removes all the relevant environment variables to show the strategy’s use of the:
@@ -109,6 +111,13 @@ pub struct Windows {
 // Ref: https://github.com/rust-lang/cargo/blob/home-0.5.5/crates/home/src/windows.rs
 // We should keep this code in sync with the above.
 impl Windows {
+    /// Create a new Windows BaseStrategy
+    pub fn new() -> Result<Self, HomeDirError> {
+        Ok(Self {
+            home_dir: crate::home_dir()?,
+        })
+    }
+
     fn dir_inner(env: &'static str) -> Option<PathBuf> {
         std::env::var_os(env)
             .filter(|s| !s.is_empty())
@@ -155,14 +164,6 @@ impl Windows {
 }
 
 impl super::BaseStrategy for Windows {
-    type CreationError = crate::HomeDirError;
-
-    fn new() -> Result<Self, Self::CreationError> {
-        Ok(Self {
-            home_dir: crate::home_dir()?,
-        })
-    }
-
     fn home_dir(&self) -> &Path {
         &self.home_dir
     }

src/base_strategy/xdg.rs

@@ -1,6 +1,8 @@
 use std::path::Path;
 use std::path::PathBuf;
 
+use crate::HomeDirError;
+
 /// This strategy implements the [XDG Base Directories Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html). It is the most common on Linux, but is increasingly being adopted elsewhere.
 ///
 /// This initial example removes all the XDG environment variables to show the strategy’s use of the XDG default directories.
@@ -157,6 +159,13 @@ pub struct Xdg {
 }
 
 impl Xdg {
+    /// Create a new Xdg BaseStrategy
+    pub fn new() -> Result<Self, HomeDirError> {
+        Ok(Self {
+            home_dir: crate::home_dir()?,
+        })
+    }
+
     fn env_var_or_none(env_var: &str) -> Option<PathBuf> {
         std::env::var(env_var).ok().and_then(|path| {
             let path = PathBuf::from(path);
@@ -176,14 +185,6 @@ impl Xdg {
 }
 
 impl super::BaseStrategy for Xdg {
-    type CreationError = crate::HomeDirError;
-
-    fn new() -> Result<Self, Self::CreationError> {
-        Ok(Self {
-            home_dir: crate::home_dir()?,
-        })
-    }
-
     fn home_dir(&self) -> &Path {
         &self.home_dir
     }