Cargo.toml

@@ -15,7 +15,6 @@ once_cell = "1.4"
 slog = { version = "2", features = ["max_level_trace", "release_max_level_trace"] }
 slog-term = "2.5"
 slog-async = "2.7"
-nonzero_ext = "0.3.0"
 
 [dev-dependencies]
 tempfile = "3"

src/artifacts/mod.rs

@@ -1,24 +1,13 @@
-use std::path::{self, PathBuf};
+use std::path::{Path as ActualPath, PathBuf};
-use std::rc::Rc;
 
 #[derive(Clone, Debug)]
-pub struct Path(Rc<path::Path>);
+pub struct Path(PathBuf);
 
-impl Path {
+// FIXME: This is a specialization since with Path: Into<PathBuf>
-  pub(crate) fn clone_rc(&self) -> Rc<path::Path> {
-    Rc::clone(&self.0)
-  }
-
-  pub fn join(&self, path: impl AsRef<path::Path>) -> Self {
-    Self::from(self.0.join(path))
-  }
-}
-
-// FIXME: This is a specialization since with Path: AsRef<path::Path>
 // it would overwrite impl<T> From <T> for T
-//impl<T: AsRef<path::Path>> From<T> for Path {
+//impl<T: Into<PathBuf>> From<T> for Path {
 //  fn from(v: T) -> Self {
-//    Self(v.as_ref().into())
+//    Path(v.into())
 //  }
 //}
 
@@ -26,8 +15,7 @@ macro_rules! path_from {
   ( $t:ty ) => {
     impl From<$t> for Path {
       fn from(v: $t) -> Self {
-        let path: &path::Path = v.as_ref();
+        Self(v.into())
-        Self(path.into())
       }
     }
   };
@@ -37,35 +25,23 @@ path_from!(String);
 path_from!(&str);
 path_from!(PathBuf);
 
-impl From<Rc<path::Path>> for Path {
+impl From<Path> for PathBuf {
-  fn from(v: Rc<path::Path>) -> Self {
-    Self(v)
-  }
-}
-
-impl AsRef<path::Path> for Path {
-  fn as_ref(&self) -> &path::Path {
-    &self.0
-  }
-}
-
-impl From<Path> for Rc<path::Path> {
   fn from(v: Path) -> Self {
     v.0
   }
 }
 
-impl From<&Path> for Rc<path::Path> {
+impl AsRef<ActualPath> for Path {
-  fn from(v: &Path) -> Self {
+  fn as_ref(&self) -> &ActualPath {
-    v.0.clone()
+    &self.0
   }
 }
 
 #[derive(Clone, Debug)]
-pub struct UserName(pub Rc<str>);
+pub struct UserName(pub String);
 
 #[derive(Clone, Debug)]
-pub struct ServiceName(pub Rc<str>);
+pub struct ServiceName(pub String);
 
 #[derive(Clone, Debug)]
-pub struct DatabaseName(pub Rc<str>);
+pub struct DatabaseName(pub String);

src/bin.rs

@@ -2,7 +2,7 @@ use std::env;
 use std::process::exit;
 
 pub fn schematics_main(run: &dyn Fn(bool) -> Result<(), ()>) {
-  let args: Box<[String]> = env::args().collect();
+  let args: Vec<String> = env::args().collect();
   let dry_run = match args.len() {
     1 => false,
     2 => {

src/build.rs

@@ -15,8 +15,7 @@ pub fn create_static_output(
     .to_str()
     .ok_or("Filename is not valid unicode")?
     .to_uppercase();
-  let file = read_file(source_path)?;
+  let content = String::from_utf8(read_file(source_path)?)?;
-  let content = std::str::from_utf8(&file)?;
   let fence = content.chars().filter(|&c| c == '#').collect::<String>() + "#";
 
   writeln!(

src/builder.rs

@@ -41,8 +41,7 @@ use crate::templates::systemd::{
 };
 use crate::to_artifact::ToArtifact;
 use std::fmt::Display;
-use std::path::Path;
+use std::path::{Path, PathBuf};
-use std::rc::Rc;
 
 pub trait ImplementationBuilder<R> {
   type Prerequisites: ToArtifact;
@@ -65,13 +64,13 @@ impl<D> ImplementationBuilder<Key<D>> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_resource: &Key<D>) -> Self::Prerequisites {}
 
-  type Implementation = KeySymbol<StdCommandRunner, Rc<Path>>;
+  type Implementation = KeySymbol<StdCommandRunner, PathBuf>;
   fn create(
     _resource: &Key<D>,
     target: &<Key<D> as Resource>::Artifact,
     (): <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
-    KeySymbol::new(StdCommandRunner, target.clone_rc())
+    KeySymbol::new(StdCommandRunner, target.clone().into())
   }
 }
 
@@ -81,7 +80,7 @@ impl<D: Clone> ImplementationBuilder<Csr<D>> for DefaultBuilder {
     Key(resource.0.clone())
   }
 
-  type Implementation = CsrSymbol<StdCommandRunner, D, Rc<Path>, Rc<Path>>;
+  type Implementation = CsrSymbol<StdCommandRunner, D, PathBuf, PathBuf>;
   fn create(
     resource: &Csr<D>,
     target: &<Csr<D> as Resource>::Artifact,
@@ -90,8 +89,8 @@ impl<D: Clone> ImplementationBuilder<Csr<D>> for DefaultBuilder {
     CsrSymbol::new(
       StdCommandRunner,
       resource.0.clone(),
-      key.clone_rc(),
+      key.into(),
-      target.clone_rc(),
+      target.clone().into(),
     )
   }
 }
@@ -117,7 +116,7 @@ impl<D: Clone> ImplementationBuilder<Cert<D>> for DefaultBuilder {
   }
 
   type Implementation =
-    CertSymbol<SetuidCommandRunner<Rc<str>>, SetuidCommandRunner<Rc<str>>, D, Rc<Path>>;
+    CertSymbol<SetuidCommandRunner<String>, SetuidCommandRunner<String>, D, PathBuf>;
   fn create(
     resource: &Cert<D>,
     target: &<Cert<D> as Resource>::Artifact,
@@ -126,11 +125,11 @@ impl<D: Clone> ImplementationBuilder<Cert<D>> for DefaultBuilder {
     CertSymbol::new(
       resource.0.clone(),
       SetuidCommandRunner::new(user_name.0),
-      root_cert.clone_rc(),
+      root_cert.into(),
-      account_key.clone_rc(),
+      account_key.into(),
-      challenges_dir.clone_rc(),
+      challenges_dir.into(),
-      csr.clone_rc(),
+      csr.into(),
-      target.clone_rc(),
+      target.clone().into(),
     )
   }
 }
@@ -141,13 +140,13 @@ impl<D: Clone> ImplementationBuilder<CertChain<D>> for DefaultBuilder {
     (Cert(resource.0.clone()), AcmeRootCert)
   }
 
-  type Implementation = ConcatSymbol<[Rc<Path>; 2], Rc<Path>, Rc<Path>>;
+  type Implementation = ConcatSymbol<[PathBuf; 2], PathBuf, PathBuf>;
   fn create(
     _resource: &CertChain<D>,
     target: &<CertChain<D> as Resource>::Artifact,
     (cert, root_cert): <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
-    ConcatSymbol::new([cert.clone_rc(), root_cert.clone_rc()], target.clone_rc())
+    ConcatSymbol::new([cert.into(), root_cert.into()], target.clone().into())
   }
 }
 
@@ -157,13 +156,13 @@ impl<D: Clone> ImplementationBuilder<KeyAndCertBundle<D>> for DefaultBuilder {
     (CertChain(resource.0.clone()), Key(resource.0.clone()))
   }
 
-  type Implementation = ConcatSymbol<[Rc<Path>; 2], Rc<Path>, Rc<Path>>;
+  type Implementation = ConcatSymbol<[PathBuf; 2], PathBuf, PathBuf>;
   fn create(
     _resource: &KeyAndCertBundle<D>,
     target: &<KeyAndCertBundle<D> as Resource>::Artifact,
     (cert_chain, key): <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
-    ConcatSymbol::new([key.clone_rc(), cert_chain.clone_rc()], target.clone_rc())
+    ConcatSymbol::new([key.into(), cert_chain.into()], target.clone().into())
   }
 }
 
@@ -171,7 +170,7 @@ impl<P: AsRef<Path> + Clone> ImplementationBuilder<File<P>> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_resource: &File<P>) -> Self::Prerequisites {}
 
-  type Implementation = FileSymbol<P, Rc<str>>;
+  type Implementation = FileSymbol<P, String>;
   fn create(
     resource: &File<P>,
     _target: &<File<P> as Resource>::Artifact,
@@ -202,7 +201,7 @@ impl ImplementationBuilder<DefaultServer> for DefaultBuilder {
   }
 
   type Implementation = (
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
     ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
   );
   fn create(
@@ -212,8 +211,8 @@ impl ImplementationBuilder<DefaultServer> for DefaultBuilder {
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        target.clone_rc(),
+        target.clone().into(),
-        nginx::default_server(challenges_snippet_path).into(),
+        nginx::default_server(challenges_snippet_path),
       ),
       ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
     )
@@ -231,7 +230,7 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeCustom<D>> for
   }
 
   type Implementation = (
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
     ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
   );
   fn create(
@@ -241,8 +240,8 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeCustom<D>> for
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        target.clone_rc(),
+        target.clone().into(),
-        nginx::server_config(&resource.0, cert, key, &resource.1, challenges_snippet_path).into(),
+        nginx::server_config(&resource.0, cert, key, &resource.1, challenges_snippet_path),
       ),
       ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
     )
@@ -268,7 +267,7 @@ impl<D: Clone + Display, P: AsRef<Path>, C: Clone + Into<PhpFpmPoolConfig>>
   }
 
   type Implementation = (
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
     ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
   );
   fn create(
@@ -278,15 +277,14 @@ impl<D: Clone + Display, P: AsRef<Path>, C: Clone + Into<PhpFpmPoolConfig>>
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        target.clone_rc(),
+        target.clone().into(),
         nginx::server_config(
           &resource.0,
           cert,
           key,
           nginx::php_snippet(resource.2, pool.0, &resource.1) + &resource.3,
           challenges_snippet_path,
-        )
+        ),
-        .into(),
       ),
       ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
     )
@@ -318,7 +316,7 @@ impl<D: Clone + Display, P: Clone + AsRef<Path>> ImplementationBuilder<ServeServ
   }
 
   type Implementation = (
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
     ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
   );
   fn create(
@@ -328,15 +326,14 @@ impl<D: Clone + Display, P: Clone + AsRef<Path>> ImplementationBuilder<ServeServ
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        target.clone_rc(),
+        target.clone().into(),
         nginx::server_config(
           &resource.0,
           cert,
           key,
           nginx::proxy_snippet(&socket.0, &resource.3),
           challenges_snippet_path,
-        )
+        ),
-        .into(),
       ),
       ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
     )
@@ -354,7 +351,7 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeRedir<D>> for D
   }
 
   type Implementation = (
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
     ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
   );
   fn create(
@@ -364,15 +361,14 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeRedir<D>> for D
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        target.clone_rc(),
+        target.clone().into(),
         nginx::server_config(
           &resource.0,
           cert,
           key,
           nginx::redir_snippet(resource.1.as_ref()),
           challenges_snippet_path,
-        )
+        ),
-        .into(),
       ),
       ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
     )
@@ -392,7 +388,7 @@ impl<D: AsRef<str> + Clone + Display, P: AsRef<Path>> ImplementationBuilder<Serv
   }
 
   type Implementation = (
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
     ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
   );
   fn create(
@@ -402,15 +398,14 @@ impl<D: AsRef<str> + Clone + Display, P: AsRef<Path>> ImplementationBuilder<Serv
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        target.clone_rc(),
+        target.clone().into(),
         nginx::server_config(
           &resource.0,
           cert,
           key,
           nginx::static_snippet(resource.1.as_ref()),
           challenges_snippet_path,
-        )
+        ),
-        .into(),
       ),
       ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
     )
@@ -422,8 +417,8 @@ impl<D: Clone> ImplementationBuilder<PhpFpmPool<D>> for DefaultBuilder {
   fn prerequisites(_resource: &PhpFpmPool<D>) -> Self::Prerequisites {}
 
   type Implementation = (
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
-    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, Rc<str>>,
+    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, String>,
   );
   fn create(
     resource: &PhpFpmPool<D>,
@@ -432,8 +427,8 @@ impl<D: Clone> ImplementationBuilder<PhpFpmPool<D>> for DefaultBuilder {
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        conf_path.clone_rc(),
+        conf_path.clone().into(),
-        php_fpm_pool_config(&user_name.0, socket_path, &resource.1).into(),
+        php_fpm_pool_config(&user_name.0, socket_path, &resource.1),
       ),
       ReloadServiceSymbol::new(StdCommandRunner, service_name.0.clone()),
     )
@@ -446,10 +441,10 @@ impl<D, P: AsRef<Path>> ImplementationBuilder<SystemdSocketService<D, P>> for De
 
   type Implementation = (
     // First three could be parallel
-    FileSymbol<Rc<Path>, Box<str>>,
+    FileSymbol<PathBuf, String>,
-    SystemdUserSessionSymbol<'static, Rc<str>, StdCommandRunner>,
+    SystemdUserSessionSymbol<'static, String, StdCommandRunner>,
-    OwnerSymbol<StdCommandRunner, StdCommandRunner, Box<Path>, Rc<str>>,
+    OwnerSymbol<StdCommandRunner, StdCommandRunner, PathBuf, String>,
-    UserServiceSymbol<'static, Rc<Path>, Rc<str>>,
+    UserServiceSymbol<'static, PathBuf, String>,
   );
   fn create(
     resource: &SystemdSocketService<D, P>,
@@ -458,7 +453,7 @@ impl<D, P: AsRef<Path>> ImplementationBuilder<SystemdSocketService<D, P>> for De
   ) -> Self::Implementation {
     (
       FileSymbol::new(
-        conf_path.clone_rc(),
+        conf_path.clone().into(),
         if resource.4 {
           systemd_nodejs_service(&resource.2, socket_path, &resource.3)
         } else {
@@ -468,16 +463,15 @@ impl<D, P: AsRef<Path>> ImplementationBuilder<SystemdSocketService<D, P>> for De
             &resource.3,
             "",
           )
-        }
+        },
-        .into(),
       ),
       SystemdUserSessionSymbol::new(user_name.0.clone(), &StdCommandRunner),
       OwnerSymbol::new(
-        conf_path.as_ref().parent().unwrap().into(),
+        conf_path.as_ref().parent().unwrap().to_path_buf(),
         user_name.0.clone(),
         StdCommandRunner,
       ),
-      UserServiceSymbol::new(socket_path.clone_rc(), user_name.0.clone(), resource.1),
+      UserServiceSymbol::new(socket_path.clone().into(), user_name.0.clone(), resource.1),
     )
   }
 }
@@ -522,7 +516,7 @@ impl<P: Clone + AsRef<Path>> ImplementationBuilder<StoredDirectory<P>> for Defau
   ) -> Self::Implementation {
     SavedDirectorySymbol::new(
       resource.1.clone(),
-      SimpleStorage::new(target.clone_rc()),
+      SimpleStorage::new(target.clone().into()),
       StorageDirection::Store,
       StdCommandRunner,
     )
@@ -541,7 +535,7 @@ impl<P: Clone + AsRef<Path>> ImplementationBuilder<LoadedDirectory<P>> for Defau
   ) -> Self::Implementation {
     SavedDirectorySymbol::new(
       resource.1.clone(),
-      SimpleStorage::new(target.clone_rc()),
+      SimpleStorage::new(target.clone().into()),
       StorageDirection::Load,
       StdCommandRunner,
     )
@@ -552,7 +546,7 @@ impl<D: Clone> ImplementationBuilder<UserForDomain<D>> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_resource: &UserForDomain<D>) -> Self::Prerequisites {}
 
-  type Implementation = UserSymbol<Rc<str>, StdCommandRunner>;
+  type Implementation = UserSymbol<String, StdCommandRunner>;
   fn create(
     _resource: &UserForDomain<D>,
     (user_name, _home_path): &<UserForDomain<D> as Resource>::Artifact,
@@ -566,7 +560,7 @@ impl ImplementationBuilder<User> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_resource: &User) -> Self::Prerequisites {}
 
-  type Implementation = UserSymbol<Rc<str>, StdCommandRunner>;
+  type Implementation = UserSymbol<String, StdCommandRunner>;
   fn create(
     resource: &User,
     (): &<User as Resource>::Artifact,
@@ -580,7 +574,7 @@ impl<P: AsRef<Path> + Clone> ImplementationBuilder<Owner<P>> for DefaultBuilder
   type Prerequisites = ();
   fn prerequisites(_resource: &Owner<P>) -> Self::Prerequisites {}
 
-  type Implementation = OwnerSymbol<StdCommandRunner, StdCommandRunner, P, Rc<str>>;
+  type Implementation = OwnerSymbol<StdCommandRunner, StdCommandRunner, P, String>;
   fn create(
     resource: &Owner<P>,
     (): &<Owner<P> as Resource>::Artifact,
@@ -594,7 +588,7 @@ impl ImplementationBuilder<AcmeUser> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_resource: &AcmeUser) -> Self::Prerequisites {}
 
-  type Implementation = UserSymbol<Rc<str>, StdCommandRunner>;
+  type Implementation = UserSymbol<String, StdCommandRunner>;
   fn create(
     _resource: &AcmeUser,
     user_name: &<AcmeUser as Resource>::Artifact,
@@ -611,8 +605,8 @@ impl ImplementationBuilder<AcmeChallengesDir> for DefaultBuilder {
   }
 
   type Implementation = (
-    DirSymbol<Rc<Path>>,
+    DirSymbol<PathBuf>,
-    OwnerSymbol<StdCommandRunner, StdCommandRunner, Rc<Path>, Rc<str>>,
+    OwnerSymbol<StdCommandRunner, StdCommandRunner, PathBuf, String>,
   );
   fn create(
     _resource: &AcmeChallengesDir,
@@ -620,8 +614,8 @@ impl ImplementationBuilder<AcmeChallengesDir> for DefaultBuilder {
     user_name: <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
     (
-      DirSymbol::new(target.clone_rc()),
+      DirSymbol::new(target.clone().into()),
-      OwnerSymbol::new(target.clone_rc(), user_name.0, StdCommandRunner),
+      OwnerSymbol::new(target.clone().into(), user_name.0, StdCommandRunner),
     )
   }
 }
@@ -632,15 +626,15 @@ impl ImplementationBuilder<AcmeChallengesNginxSnippet> for DefaultBuilder {
     AcmeChallengesDir
   }
 
-  type Implementation = FileSymbol<Rc<Path>, Box<str>>;
+  type Implementation = FileSymbol<PathBuf, String>;
   fn create(
     _resource: &AcmeChallengesNginxSnippet,
     target: &<AcmeChallengesNginxSnippet as Resource>::Artifact,
     challenges_dir: <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
     FileSymbol::new(
-      target.clone_rc(),
+      target.clone().into(),
-      nginx::acme_challenges_snippet(challenges_dir).into(),
+      nginx::acme_challenges_snippet(challenges_dir),
     )
   }
 }
@@ -652,8 +646,8 @@ impl ImplementationBuilder<AcmeAccountKey> for DefaultBuilder {
   }
 
   type Implementation = (
-    KeySymbol<StdCommandRunner, Rc<Path>>,
+    KeySymbol<StdCommandRunner, PathBuf>,
-    OwnerSymbol<StdCommandRunner, StdCommandRunner, Rc<Path>, Rc<str>>,
+    OwnerSymbol<StdCommandRunner, StdCommandRunner, PathBuf, String>,
   );
   fn create(
     _resource: &AcmeAccountKey,
@@ -661,8 +655,8 @@ impl ImplementationBuilder<AcmeAccountKey> for DefaultBuilder {
     user_name: <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
     (
-      KeySymbol::new(StdCommandRunner, target.clone_rc()),
+      KeySymbol::new(StdCommandRunner, target.clone().into()),
-      OwnerSymbol::new(target.clone_rc(), user_name.0, StdCommandRunner),
+      OwnerSymbol::new(target.clone().into(), user_name.0, StdCommandRunner),
     )
   }
 }
@@ -671,13 +665,13 @@ impl ImplementationBuilder<AcmeRootCert> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_resource: &AcmeRootCert) -> Self::Prerequisites {}
 
-  type Implementation = FileSymbol<Rc<Path>, &'static str>;
+  type Implementation = FileSymbol<PathBuf, &'static str>;
   fn create(
     _resource: &AcmeRootCert,
     target: &<AcmeRootCert as Resource>::Artifact,
     (): <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
-    FileSymbol::new(target.clone_rc(), LETS_ENCRYPT_R3)
+    FileSymbol::new(target.clone().into(), LETS_ENCRYPT_R3)
   }
 }
 
@@ -685,7 +679,7 @@ impl<D> ImplementationBuilder<MariaDbUser<D>> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_resource: &MariaDbUser<D>) -> Self::Prerequisites {}
 
-  type Implementation = MariaDbUserSymbol<'static, Rc<str>, StdCommandRunner>;
+  type Implementation = MariaDbUserSymbol<'static, String, StdCommandRunner>;
   fn create(
     _resource: &MariaDbUser<D>,
     user_name: &<MariaDbUser<D> as Resource>::Artifact,
@@ -702,15 +696,15 @@ impl<D: Clone> ImplementationBuilder<MariaDbDatabase<D>> for DefaultBuilder {
   }
 
   type Implementation = (
-    MariaDbDatabaseSymbol<'static, Rc<str>, SimpleStorage, StdCommandRunner>,
+    MariaDbDatabaseSymbol<'static, String, SimpleStorage, StdCommandRunner>,
-    MariaDbDumpSymbol<'static, Rc<str>, StdCommandRunner, SimpleStorage>,
+    MariaDbDumpSymbol<'static, String, StdCommandRunner, SimpleStorage>,
   );
   fn create(
     _resource: &MariaDbDatabase<D>,
     (db_name, _, data_path): &<MariaDbDatabase<D> as Resource>::Artifact,
     _: <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
-    let db_dump = SimpleStorage::new(data_path.clone_rc());
+    let db_dump = SimpleStorage::new(data_path.clone().into());
     (
       MariaDbDatabaseSymbol::new(db_name.0.clone(), db_dump.clone(), &StdCommandRunner),
       MariaDbDumpSymbol::new(db_name.0.clone(), db_dump, &StdCommandRunner),
@@ -722,13 +716,13 @@ impl<D: Clone> ImplementationBuilder<PostgresqlDatabase<D>> for DefaultBuilder {
   type Prerequisites = ();
   fn prerequisites(_: &PostgresqlDatabase<D>) -> Self::Prerequisites {}
 
-  type Implementation = (PostgreSQLDatabaseSymbol<'static, Rc<str>, Rc<str>, StdCommandRunner>,);
+  type Implementation = (PostgreSQLDatabaseSymbol<'static, String, String, StdCommandRunner>,);
   fn create(
     _resource: &PostgresqlDatabase<D>,
     (db_name, data_path): &<PostgresqlDatabase<D> as Resource>::Artifact,
     _: <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
-    let db_dump = SimpleStorage::new(data_path.clone_rc());
+    let db_dump = SimpleStorage::new(data_path.clone().into());
     (PostgreSQLDatabaseSymbol::new(
       db_name.0.clone(),
       db_dump.read_filename().unwrap().to_str().unwrap().into(),
@@ -738,9 +732,9 @@ impl<D: Clone> ImplementationBuilder<PostgresqlDatabase<D>> for DefaultBuilder {
 }
 
 impl<P: Clone + AsRef<Path>> ImplementationBuilder<WordpressPlugin<P>> for DefaultBuilder {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn prerequisites(resource: &WordpressPlugin<P>) -> Self::Prerequisites {
-    Dir::new(resource.0.as_ref().join("wp-content/plugins"))
+    Dir(resource.0.as_ref().join("wp-content/plugins"))
   }
 
   type Implementation = WordpressPluginSymbol<'static, P, &'static str, StdCommandRunner>;
@@ -753,21 +747,21 @@ impl<P: Clone + AsRef<Path>> ImplementationBuilder<WordpressPlugin<P>> for Defau
   }
 }
 
-impl<P: AsRef<Path>> ImplementationBuilder<WordpressTranslation<P>> for DefaultBuilder {
+impl<P: Clone + AsRef<Path>> ImplementationBuilder<WordpressTranslation<P>> for DefaultBuilder {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn prerequisites(resource: &WordpressTranslation<P>) -> Self::Prerequisites {
-    Dir::new(resource.0.as_ref().join("wp-content/languages"))
+    Dir(resource.0.as_ref().join("wp-content/languages"))
   }
 
   type Implementation =
-    WordpressTranslationSymbol<'static, &'static str, Box<Path>, StdCommandRunner>;
+    WordpressTranslationSymbol<'static, &'static str, PathBuf, StdCommandRunner>;
   fn create(
     resource: &WordpressTranslation<P>,
     (): &<WordpressTranslation<P> as Resource>::Artifact,
     _: <Self::Prerequisites as ToArtifact>::Artifact,
   ) -> Self::Implementation {
     WordpressTranslationSymbol::new(
-      (*resource.0.as_ref().join("wp-content/languages")).into(),
+      resource.0.as_ref().join("wp-content/languages"),
       resource.1,
       resource.2,
       &StdCommandRunner,
@@ -781,7 +775,7 @@ impl<D: Clone> ImplementationBuilder<Cron<D>> for DefaultBuilder {
     UserForDomain(resource.0.clone())
   }
 
-  type Implementation = CronSymbol<'static, Box<str>, Rc<str>, StdCommandRunner>;
+  type Implementation = CronSymbol<'static, String, String, StdCommandRunner>;
   fn create(
     resource: &Cron<D>,
     (): &<Cron<D> as Resource>::Artifact,

src/command_runner.rs

@@ -19,7 +19,7 @@ fn check_success(output: Output) -> Result<Output, Box<dyn Error>> {
   if output.status.success() {
     Ok(output)
   } else {
-    Err(std::str::from_utf8(&output.stderr)?.into())
+    Err(String::from_utf8(output.stderr)?.into())
   }
 }
 
@@ -93,7 +93,7 @@ struct TempSetEnv<'a> {
 }
 
 impl<'a> TempSetEnv<'a> {
-  fn new(name: &'a str, new_value: impl AsRef<OsStr>) -> TempSetEnv<'a> {
+  fn new(name: &'a str, new_value: String) -> TempSetEnv<'a> {
     let old_value = env::var(name);
     env::set_var(name, new_value);
     TempSetEnv {

src/locator.rs

@@ -12,8 +12,7 @@ use crate::resources::{
 use crate::to_artifact::ToArtifact;
 use std::fmt::Display;
 use std::marker::PhantomData;
-use std::path::Path;
+use std::path::{Path, PathBuf};
-use std::rc::Rc;
 
 pub trait Policy {
   #[must_use]
@@ -22,13 +21,13 @@ pub trait Policy {
   }
 
   #[must_use]
-  fn user_home(user_name: &str) -> Rc<Path> {
+  fn user_home(user_name: &str) -> PathBuf {
-    Path::new("/home").join(user_name).into()
+    Path::new("/home").join(user_name)
   }
 
   #[must_use]
-  fn user_name_for_domain(domain_name: &'_ str) -> Rc<str> {
+  fn user_name_for_domain(domain_name: &'_ str) -> String {
-    domain_name.split('.').rev().fold(String::new(), |result, part| if result.is_empty() { result } else { result + "_" } + part).into()
+    domain_name.split('.').rev().fold(String::new(), |result, part| if result.is_empty() { result } else { result + "_" } + part)
   }
 
   #[must_use]
@@ -37,8 +36,8 @@ pub trait Policy {
   }
 
   #[must_use]
-  fn path_for_data(name: impl Display) -> Rc<Path> {
+  fn path_for_data(name: impl Display) -> PathBuf {
-    Path::new("/root/data").join(format!("_{name}")).into()
+    Path::new("/root/data").join(format!("_{name}"))
   }
 }
 
@@ -60,37 +59,37 @@ pub struct DefaultLocator<P = DefaultPolicy> {
 }
 
 impl<P, D: AsRef<str>> ResourceLocator<Key<D>> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(resource: &Key<D>) -> (<Key<D> as Resource>::Artifact, Self::Prerequisites) {
     (
       PathArtifact::from(format!("/etc/ssl/private/{}.key", resource.0.as_ref())),
-      Dir::new("/etc/ssl/private"),
+      Dir("/etc/ssl/private".into()),
     )
   }
 }
 
 impl<P, D: AsRef<str>> ResourceLocator<Csr<D>> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(resource: &Csr<D>) -> (<Csr<D> as Resource>::Artifact, Self::Prerequisites) {
     (
       PathArtifact::from(format!("/etc/ssl/local_certs/{}.csr", resource.0.as_ref())),
-      Dir::new("/etc/ssl/local_certs"),
+      Dir("/etc/ssl/local_certs".into()),
     )
   }
 }
 
 impl<P, D: AsRef<str>> ResourceLocator<Cert<D>> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(resource: &Cert<D>) -> (<Cert<D> as Resource>::Artifact, Self::Prerequisites) {
     (
       PathArtifact::from(format!("/etc/ssl/local_certs/{}.crt", resource.0.as_ref())),
-      Dir::new("/etc/ssl/local_certs"),
+      Dir("/etc/ssl/local_certs".into()),
     )
   }
 }
 
 impl<P, D: AsRef<str>> ResourceLocator<CertChain<D>> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     resource: &CertChain<D>,
   ) -> (<CertChain<D> as Resource>::Artifact, Self::Prerequisites) {
@@ -99,13 +98,13 @@ impl<P, D: AsRef<str>> ResourceLocator<CertChain<D>> for DefaultLocator<P> {
         "/etc/ssl/local_certs/{}.chained.crt",
         resource.0.as_ref()
       )),
-      Dir::new("/etc/ssl/local_certs"),
+      Dir("/etc/ssl/local_certs".into()),
     )
   }
 }
 
 impl<P, D: AsRef<str>> ResourceLocator<KeyAndCertBundle<D>> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     resource: &KeyAndCertBundle<D>,
   ) -> (
@@ -117,34 +116,34 @@ impl<P, D: AsRef<str>> ResourceLocator<KeyAndCertBundle<D>> for DefaultLocator<P
         "/etc/ssl/private/{}.with_key.crt",
         resource.0.as_ref()
       )),
-      Dir::new("/etc/ssl/private"),
+      Dir("/etc/ssl/private".into()),
     )
   }
 }
 
 impl<POLICY, P: AsRef<Path>> ResourceLocator<File<P>> for DefaultLocator<POLICY> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(resource: &File<P>) -> (<File<P> as Resource>::Artifact, Self::Prerequisites) {
-    ((), Dir::new(resource.0.as_ref().parent().unwrap()))
+    ((), Dir(resource.0.as_ref().parent().unwrap().into()))
   }
 }
 
 impl<'a, POLICY, P: AsRef<Path>> ResourceLocator<GitCheckout<'a, P>> for DefaultLocator<POLICY> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     resource: &GitCheckout<'a, P>,
   ) -> (
     <GitCheckout<'a, P> as Resource>::Artifact,
     Self::Prerequisites,
   ) {
-    ((), Dir::new(resource.0.as_ref().parent().unwrap()))
+    ((), Dir(resource.0.as_ref().parent().unwrap().into()))
   }
 }
 
 impl<POLICY, P: Clone + AsRef<Path>> ResourceLocator<Dir<P>> for DefaultLocator<POLICY> {
-  type Prerequisites = Option<Dir<Rc<Path>>>;
+  type Prerequisites = Option<Dir<PathBuf>>;
   fn locate(resource: &Dir<P>) -> (<Dir<P> as Resource>::Artifact, Self::Prerequisites) {
-    ((), resource.0.as_ref().parent().map(Dir::new))
+    ((), resource.0.as_ref().parent().map(|p| Dir(p.into())))
   }
 }
 
@@ -174,7 +173,7 @@ impl<POLICY: Policy, P: AsRef<Path>> ResourceLocator<StoredDirectory<P>>
 impl<POLICY: Policy, P: AsRef<Path>> ResourceLocator<LoadedDirectory<P>>
   for DefaultLocator<POLICY>
 {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     resource: &LoadedDirectory<P>,
   ) -> (
@@ -183,13 +182,13 @@ impl<POLICY: Policy, P: AsRef<Path>> ResourceLocator<LoadedDirectory<P>>
   ) {
     (
       PathArtifact::from(POLICY::path_for_data(resource.0)),
-      Dir::new(resource.1.as_ref().parent().unwrap()),
+      Dir(resource.1.as_ref().parent().unwrap().into()),
     )
   }
 }
 
 impl<P: Policy> ResourceLocator<AcmeAccountKey> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     _resource: &AcmeAccountKey,
   ) -> (<AcmeAccountKey as Resource>::Artifact, Self::Prerequisites) {
@@ -208,7 +207,7 @@ impl<P: Policy> ResourceLocator<AcmeUser> for DefaultLocator<P> {
 }
 
 impl<P: Policy> ResourceLocator<AcmeChallengesDir> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     _resource: &AcmeChallengesDir,
   ) -> (
@@ -237,7 +236,7 @@ impl<P: Policy> ResourceLocator<AcmeChallengesNginxSnippet> for DefaultLocator<P
 }
 
 impl<P: Policy> ResourceLocator<AcmeRootCert> for DefaultLocator<P> {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     _resource: &AcmeRootCert,
   ) -> (<AcmeRootCert as Resource>::Artifact, Self::Prerequisites) {
@@ -371,7 +370,7 @@ impl<D: Clone + AsRef<str>, P: Policy> ResourceLocator<PhpFpmPool<D>> for Defaul
           php_version, user.0
         )),
         user,
-        ServiceNameArtifact(format!("php{php_version}-fpm").into()),
+        ServiceNameArtifact(format!("php{php_version}-fpm")),
       ),
       (),
     )
@@ -381,7 +380,7 @@ impl<D: Clone + AsRef<str>, P: Policy> ResourceLocator<PhpFpmPool<D>> for Defaul
 impl<D: Clone + AsRef<str>, P, POLICY: Policy> ResourceLocator<SystemdSocketService<D, P>>
   for DefaultLocator<POLICY>
 {
-  type Prerequisites = Dir<Rc<Path>>;
+  type Prerequisites = Dir<PathBuf>;
   fn locate(
     resource: &SystemdSocketService<D, P>,
   ) -> (
@@ -397,7 +396,7 @@ impl<D: Clone + AsRef<str>, P, POLICY: Policy> ResourceLocator<SystemdSocketServ
         PathArtifact::from(service_dir_path.join(format!("{}.service", resource.1))),
         user_name,
       ),
-      Dir::new(service_dir_path),
+      Dir(service_dir_path),
     )
   }
 }

src/resources/mod.rs

@@ -4,7 +4,7 @@ use crate::artifacts::{
 };
 use crate::templates::php::FpmPoolConfig;
 use std::hash::Hash;
-use std::path::Path;
+use std::path::PathBuf;
 
 pub trait Resource {
   type Artifact;
@@ -41,41 +41,23 @@ impl<D> Resource for KeyAndCertBundle<D> {
 }
 
 #[derive(Debug, Hash, PartialEq, Eq)]
-pub struct File<P>(pub P, pub Rc<str>);
+pub struct File<P>(pub P, pub String);
 impl<P> Resource for File<P> {
   type Artifact = ();
 }
 
-impl File<Rc<Path>> {
-  pub fn new(p: impl Into<Rc<Path>>, content: impl AsRef<str>) -> Self {
-    Self(p.into(), content.as_ref().into())
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
 pub struct GitCheckout<'a, P>(pub P, pub &'a str, pub &'a str);
 impl<'a, P> Resource for GitCheckout<'a, P> {
   type Artifact = ();
 }
 
-impl<'a> GitCheckout<'a, Rc<Path>> {
-  pub fn new(target: impl Into<Rc<Path>>, src: &'a str, head: &'a str) -> Self {
-    Self(target.into(), src, head)
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
 pub struct Dir<P>(pub P);
 impl<P> Resource for Dir<P> {
   type Artifact = ();
 }
 
-impl Dir<Rc<Path>> {
-  pub fn new(p: impl AsRef<Path>) -> Self {
-    Self(p.as_ref().into())
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
 pub struct UserForDomain<D>(pub D);
 impl<D> Resource for UserForDomain<D> {
@@ -124,11 +106,10 @@ impl<P> Resource for LoadedDirectory<P> {
   type Artifact = PathArtifact;
 }
 
-pub fn get_saved_directory(
+pub fn get_saved_directory<P: Clone>(
   storage_name: &'static str,
-  target: impl Into<Rc<Path>>,
+  target: P,
-) -> (StoredDirectory<Rc<Path>>, LoadedDirectory<Rc<Path>>) {
+) -> (StoredDirectory<P>, LoadedDirectory<P>) {
-  let target = target.into();
   (
     StoredDirectory(storage_name, target.clone()),
     LoadedDirectory(storage_name, target),
@@ -136,7 +117,7 @@ pub fn get_saved_directory(
 }
 
 #[derive(Debug, Hash, PartialEq, Eq)]
-pub struct User(pub Rc<str>);
+pub struct User(pub String);
 impl Resource for User {
   type Artifact = ();
 }
@@ -153,32 +134,20 @@ impl<P> Resource for NpmInstall<P> {
   type Artifact = ();
 }
 
-impl NpmInstall<Rc<Path>> {
-  pub fn new(path: impl Into<Rc<Path>>) -> Self {
-    Self(path.into())
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
-pub struct Owner<P>(pub Rc<str>, pub P);
+pub struct Owner<P>(pub String, pub P);
 impl<P> Resource for Owner<P> {
   type Artifact = ();
 }
 
-impl Owner<Rc<Path>> {
-  pub fn new(user: &UserNameArtifact, p: impl Into<Rc<Path>>) -> Self {
-    Self(user.0.clone(), p.into())
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
-pub struct ServeCustom<D>(pub D, pub Rc<str>);
+pub struct ServeCustom<D>(pub D, pub String);
 impl<D> Resource for ServeCustom<D> {
   type Artifact = PathArtifact;
 }
 
 #[derive(Debug, Hash, PartialEq, Eq)]
-pub struct ServePhp<D, P, C>(pub D, pub P, pub &'static str, pub Rc<str>, pub C);
+pub struct ServePhp<D, P, C>(pub D, pub P, pub &'static str, pub String, pub C);
 impl<D, P, C> Resource for ServePhp<D, P, C> {
   type Artifact = PathArtifact;
 }
@@ -189,25 +158,6 @@ pub struct ServeService<D, P>(pub D, pub &'static str, pub P, pub P, pub P, pub
 impl<D, P> Resource for ServeService<D, P> {
   type Artifact = PathArtifact;
 }
-impl<D> ServeService<D, Rc<Path>> {
-  pub fn new(
-    domain: D,
-    service_name: &'static str,
-    exec: impl Into<Rc<Path>>,
-    static_path: impl Into<Rc<Path>>,
-    working_directory: impl Into<Rc<Path>>,
-    is_nodejs: bool,
-  ) -> Self {
-    Self(
-      domain,
-      service_name,
-      exec.into(),
-      static_path.into(),
-      working_directory.into(),
-      is_nodejs,
-    )
-  }
-}
 
 #[derive(Debug, Hash, PartialEq, Eq)]
 pub struct ServeRedir<D>(pub D, pub D);
@@ -221,12 +171,6 @@ impl<D, P> Resource for ServeStatic<D, P> {
   type Artifact = PathArtifact;
 }
 
-impl<D> ServeStatic<D, Rc<Path>> {
-  pub fn new(domain: D, path: impl Into<Rc<Path>>) -> Self {
-    Self(domain, path.into())
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
 pub struct DefaultServer;
 impl Resource for DefaultServer {
@@ -269,26 +213,14 @@ impl<P> Resource for WordpressPlugin<P> {
   type Artifact = ();
 }
 
-impl WordpressPlugin<Rc<Path>> {
-  pub fn new(path: impl Into<Rc<Path>>, name: &'static str) -> Self {
-    Self(path.into(), name)
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
 pub struct WordpressTranslation<P>(pub P, pub &'static str, pub &'static str);
 impl<P> Resource for WordpressTranslation<P> {
   type Artifact = ();
 }
 
-impl WordpressTranslation<Rc<Path>> {
-  pub fn new(path: impl Into<Rc<Path>>, version: &'static str, lang: &'static str) -> Self {
-    Self(path.into(), version, lang)
-  }
-}
-
 #[derive(Debug, Hash, PartialEq, Eq)]
-pub struct Cron<D>(pub D, pub Rc<str>);
+pub struct Cron<D>(pub D, pub String);
 impl<D> Resource for Cron<D> {
   type Artifact = ();
 }
@@ -355,38 +287,38 @@ default_resources!(
   Cron: Cron<D>,
   Csr: Csr<D>,
   DefaultServer: DefaultServer,
-  Dir: Dir<Rc<Path>>,
+  Dir: Dir<PathBuf>,
-  File: File<Rc<Path>>,
+  File: File<PathBuf>,
-  GitCheckout: GitCheckout<'a, Rc<Path>>,
+  GitCheckout: GitCheckout<'a, PathBuf>,
   Key: Key<D>,
   KeyAndCertBundle: KeyAndCertBundle<D>,
-  LoadedDirectory: LoadedDirectory<Rc<Path>>,
+  LoadedDirectory: LoadedDirectory<PathBuf>,
   MariaDbDatabase: MariaDbDatabase<D>,
   MariaDbUser: MariaDbUser<D>,
   PostgresqlDatabase: PostgresqlDatabase<D>,
-  SystemdSocketService: SystemdSocketService<D, Rc<Path>>,
+  SystemdSocketService: SystemdSocketService<D, PathBuf>,
-  NpmInstall: NpmInstall<Rc<Path>>,
+  NpmInstall: NpmInstall<PathBuf>,
-  Owner: Owner<Rc<Path>>,
+  Owner: Owner<PathBuf>,
   PhpFpmPool: PhpFpmPool<D>,
   ServeCustom: ServeCustom<D>,
-  ServeService: ServeService<D, Rc<Path>>,
+  ServeService: ServeService<D, PathBuf>,
-  ServePhp: ServePhp<D, Rc<Path>, FpmPoolConfig>,
+  ServePhp: ServePhp<D, PathBuf, FpmPoolConfig>,
   ServeRedir: ServeRedir<D>,
-  ServeStatic: ServeStatic<D, Rc<Path>>,
+  ServeStatic: ServeStatic<D, PathBuf>,
-  StoredDirectory: StoredDirectory<Rc<Path>>,
+  StoredDirectory: StoredDirectory<PathBuf>,
   User: User,
   UserForDomain: UserForDomain<D>,
-  WordpressPlugin: WordpressPlugin<Rc<Path>>,
+  WordpressPlugin: WordpressPlugin<PathBuf>,
-  WordpressTranslation: WordpressTranslation<Rc<Path>>,
+  WordpressTranslation: WordpressTranslation<PathBuf>,
 );
 
-pub fn serve_php<D, C: Into<FpmPoolConfig>>(
+pub fn serve_php<D, P: Into<PathBuf>, C: Into<FpmPoolConfig>>(
   domain: D,
-  path: impl Into<Rc<Path>>,
+  path: P,
   root_filename: &'static str,
-  nginx_config: impl Into<Rc<str>>,
+  nginx_config: impl Into<String>,
   pool_config: C,
-) -> ServePhp<D, Rc<Path>, FpmPoolConfig> {
+) -> ServePhp<D, PathBuf, FpmPoolConfig> {
   ServePhp(
     domain,
     path.into(),

src/setup/mod.rs

@@ -169,7 +169,7 @@ impl<
 
 #[cfg(test)]
 mod test {
-  use super::symbol_runner::TestSymbolRunner;
+  use super::SymbolRunner;
   use crate::async_utils::run;
   use crate::loggers::{Entry, StoringLogger};
   use crate::resources::{FromArtifact, FromResource, Resource};
@@ -178,11 +178,33 @@ mod test {
   use crate::{ImplementationBuilder, ResourceLocator, Setup};
   use async_trait::async_trait;
   use regex::Regex;
+  use slog::{info, Logger};
   use std::cell::RefCell;
   use std::error::Error;
   use std::fmt::Debug;
   use std::rc::{Rc, Weak};
 
+  struct TestSymbolRunner {
+    count: Rc<RefCell<usize>>,
+  }
+
+  #[async_trait(?Send)]
+  impl SymbolRunner for TestSymbolRunner {
+    async fn run_symbol<S: Symbol + Debug>(
+      &self,
+      symbol: &S,
+      logger: &Logger,
+      force: bool,
+    ) -> Result<bool, Box<dyn Error>> {
+      info!(logger, "run");
+      let run = force || !symbol.target_reached().await?;
+      if run {
+        *self.count.borrow_mut() += 1;
+      }
+      Ok(run)
+    }
+  }
+
   #[derive(Debug, PartialEq, Eq, Hash)]
   struct TestResource<T>(&'static str, T);
   impl<T> Resource for TestResource<T> {
@@ -286,7 +308,10 @@ mod test {
     >,
     StoringLogger,
   ) {
-    let (count, runner) = TestSymbolRunner::new();
+    let count = Rc::new(RefCell::new(0));
+    let runner = TestSymbolRunner {
+      count: Rc::clone(&count),
+    };
     let logger = StoringLogger::new();
     (count, Setup::new_with(runner, logger.clone()), logger)
   }

src/setup/runnable.rs

@@ -53,10 +53,10 @@ for_each_tuple!(runnable_for_tuple);
 
 #[cfg(test)]
 mod test {
-  use super::super::symbol_runner::TestSymbolRunner;
   use super::Runnable;
   use crate::async_utils::run;
   use crate::symbols::Symbol;
+  use crate::SymbolRunner;
   use async_trait::async_trait;
   use slog::{o, Discard, Logger};
   use std::cell::RefCell;
@@ -103,11 +103,39 @@ mod test {
     }
   }
 
+  struct TestSymbolRunner {
+    count: Rc<RefCell<usize>>,
+  }
+
+  fn get_runner() -> (Rc<RefCell<usize>>, TestSymbolRunner) {
+    let count = Rc::new(RefCell::new(0));
+    let runner = TestSymbolRunner {
+      count: Rc::clone(&count),
+    };
+    (count, runner)
+  }
+
+  #[async_trait(?Send)]
+  impl SymbolRunner for TestSymbolRunner {
+    async fn run_symbol<S: Symbol + Debug>(
+      &self,
+      symbol: &S,
+      _logger: &Logger,
+      force: bool,
+    ) -> Result<bool, Box<dyn Error>> {
+      let run = force || !symbol.target_reached().await?;
+      if run {
+        *self.count.borrow_mut() += 1;
+      }
+      Ok(run)
+    }
+  }
+
   fn run_symbol(
     runnable: impl Runnable,
     force: bool,
   ) -> (Rc<RefCell<usize>>, Result<bool, Box<dyn Error>>) {
-    let (count, runner) = TestSymbolRunner::new();
+    let (count, runner) = get_runner();
     let res = run(runnable.run(&runner, &Logger::root(Discard, o!()), force));
     (count, res)
   }

src/setup/symbol_runner.rs

@@ -2,13 +2,9 @@ use crate::async_utils::sleep;
 use crate::symbols::Symbol;
 use async_trait::async_trait;
 use slog::{debug, info, o, trace, Logger};
-#[cfg(test)]
-use std::cell::RefCell;
 use std::error::Error;
 use std::fmt;
 use std::fmt::Debug;
-#[cfg(test)]
-use std::rc::Rc;
 use std::time::Duration;
 
 #[async_trait(?Send)]
@@ -202,40 +198,6 @@ where
   }
 }
 
-#[cfg(test)]
-pub struct TestSymbolRunner {
-  count: Rc<RefCell<usize>>,
-}
-
-#[cfg(test)]
-impl TestSymbolRunner {
-  pub fn new() -> (Rc<RefCell<usize>>, Self) {
-    let count = Rc::new(RefCell::new(0));
-    let runner = TestSymbolRunner {
-      count: Rc::clone(&count),
-    };
-    (count, runner)
-  }
-}
-
-#[cfg(test)]
-#[async_trait(?Send)]
-impl SymbolRunner for TestSymbolRunner {
-  async fn run_symbol<S: Symbol + Debug>(
-    &self,
-    symbol: &S,
-    logger: &Logger,
-    force: bool,
-  ) -> Result<bool, Box<dyn Error>> {
-    info!(logger, "run");
-    let run = force || !symbol.target_reached().await?;
-    if run {
-      *self.count.borrow_mut() += 1;
-    }
-    Ok(run)
-  }
-}
-
 #[cfg(test)]
 mod test {
   use super::{DrySymbolRunner, InitializingSymbolRunner, ReportingSymbolRunner, SymbolRunner};

src/storage.rs

@@ -1,46 +1,49 @@
 use std::error::Error;
 use std::fs::read_dir;
-use std::path::Path;
+use std::path::PathBuf;
-use std::rc::Rc;
 use std::str::FromStr;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 pub trait Storage {
-  fn write_filename(&self) -> Box<Path>;
+  fn write_filename(&self) -> PathBuf;
-  fn read_filename(&self) -> Result<Box<Path>, Box<dyn Error>>;
+  fn read_filename(&self) -> Result<PathBuf, Box<dyn Error>>;
   fn recent_date(&self) -> Result<u64, Box<dyn Error>>;
 }
 
 #[derive(Debug, Clone)]
-pub struct SimpleStorage(Rc<Path>);
+pub struct SimpleStorage(PathBuf);
 
 impl SimpleStorage {
   #[must_use]
-  pub const fn new(base: Rc<Path>) -> Self {
+  pub const fn new(base: PathBuf) -> Self {
     Self(base)
   }
 
-  fn get_path(&self, date: u64) -> Box<Path> {
+  fn get_path(&self, date: Option<u64>) -> PathBuf {
-    self.0.join(date.to_string()).into()
+    match date {
+      Some(d) => self.0.join(d.to_string()),
+      None => self.0.clone(),
+    }
   }
 }
 
 impl Storage for SimpleStorage {
-  fn write_filename(&self) -> Box<Path> {
+  fn write_filename(&self) -> PathBuf {
-    self.get_path(
+    self.get_path(Some(
       SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .unwrap()
         .as_secs(),
-    )
+    ))
   }
 
-  fn read_filename(&self) -> Result<Box<Path>, Box<dyn Error>> {
+  fn read_filename(&self) -> Result<PathBuf, Box<dyn Error>> {
-    Ok(self.get_path(self.recent_date()?))
+    Ok(self.get_path(Some(self.recent_date()?)))
   }
 
   fn recent_date(&self) -> Result<u64, Box<dyn Error>> {
-    read_dir(&self.0)?
+    let dir = self.get_path(None);
+    read_dir(dir)?
       .map(|entry| {
         entry
           .ok()

src/symbols/acme/cert.rs

@@ -102,7 +102,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, D: AsRef<str>, P: AsRef<Path>> Symbol for
     {
       Ok(false)
     } else {
-      Err(std::str::from_utf8(&output.stderr)?.into())
+      Err(String::from_utf8(output.stderr)?.into())
     }
   }
 

src/symbols/cron.rs

@@ -10,11 +10,11 @@ pub struct Cron<'r, C, U, R> {
   command_runner: &'r R,
 }
 
-impl<'r, U, R> Cron<'r, Box<str>, U, R> {
+impl<'r, U, R> Cron<'r, String, U, R> {
   pub fn new<C: AsRef<str>>(user: U, content: C, command_runner: &'r R) -> Self {
     Self {
       user,
-      content: (String::from(content.as_ref()) + "\n").into(),
+      content: String::from(content.as_ref()) + "\n",
       command_runner,
     }
   }

src/symbols/git/submodules.rs

@@ -42,14 +42,15 @@ impl<P: AsRef<Path>, C: CommandRunner> Symbol for GitSubmodules<'_, P, C> {
     if !self.target.as_ref().exists() {
       return Ok(false);
     }
+    let output = String::from_utf8(
+      self
+        ._run_in_target_repo(args!["submodule", "status"])
+        .await?,
+    )?;
     Ok(
-      std::str::from_utf8(
+      output
-        &self
+        .lines()
-          ._run_in_target_repo(args!["submodule", "status"])
+        .all(|line| line.is_empty() || line.starts_with(' ')),
-          .await?,
-      )?
-      .lines()
-      .all(|line| line.is_empty() || line.starts_with(' ')),
     )
   }
 

src/symbols/mariadb/database.rs

@@ -11,7 +11,7 @@ pub struct Database<'a, D, S, C> {
   command_runner: &'a C,
 }
 
-impl<'a, D, S, C> Database<'a, D, S, C> {
+impl<'a, D, S, C: CommandRunner> Database<'a, D, S, C> {
   pub const fn new(db_name: D, seed_file: S, command_runner: &'a C) -> Self {
     Self {
       db_name,
@@ -19,9 +19,7 @@ impl<'a, D, S, C> Database<'a, D, S, C> {
       command_runner,
     }
   }
-}
 
-impl<'a, D, S, C: CommandRunner> Database<'a, D, S, C> {
   async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
     let b = self
       .command_runner

src/symbols/mariadb/dump.rs

@@ -12,7 +12,7 @@ pub struct Dump<'a, N, C, S> {
   command_runner: &'a C,
 }
 
-impl<'a, N, C, S> Dump<'a, N, C, S> {
+impl<'a, N, C: CommandRunner, S> Dump<'a, N, C, S> {
   pub const fn new(db_name: N, storage: S, command_runner: &'a C) -> Self {
     Self {
       db_name,
@@ -20,9 +20,7 @@ impl<'a, N, C, S> Dump<'a, N, C, S> {
       command_runner,
     }
   }
-}
 
-impl<'a, N, C: CommandRunner, S> Dump<'a, N, C, S> {
   async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
     let b = self
       .command_runner

src/symbols/mariadb/user.rs

@@ -9,16 +9,14 @@ pub struct User<'a, U, C> {
   command_runner: &'a C,
 }
 
-impl<'a, U: AsRef<str>, C> User<'a, U, C> {
+impl<'a, U: AsRef<str>, C: CommandRunner> User<'a, U, C> {
   pub const fn new(user_name: U, command_runner: &'a C) -> Self {
     Self {
       user_name,
       command_runner,
     }
   }
-}
 
-impl<'a, U: AsRef<str>, C: CommandRunner> User<'a, U, C> {
   async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
     let b = self
       .command_runner

src/symbols/npm.rs

@@ -6,12 +6,12 @@ use std::fmt;
 use std::path::Path;
 
 #[derive(Debug)]
-pub struct Install<'a, T: AsRef<Path>, C> {
+pub struct Install<'a, T: AsRef<Path>, C: CommandRunner> {
   target: T,
   command_runner: &'a C,
 }
 
-impl<'a, T: AsRef<Path>, C> Install<'a, T, C> {
+impl<'a, T: AsRef<Path>, C: CommandRunner> Install<'a, T, C> {
   pub const fn new(target: T, command_runner: &'a C) -> Self {
     Self {
       target,
@@ -51,7 +51,7 @@ impl<T: AsRef<Path>, C: CommandRunner> Symbol for Install<'_, T, C> {
       .await?;
     Ok(
       result.status.success()
-        && !std::str::from_utf8(&result.stdout)
+        && !String::from_utf8(result.stdout)
           .unwrap()
           .contains("(empty)"),
     )

src/symbols/postgresql/database.rs

@@ -5,23 +5,21 @@ use std::error::Error;
 use std::fmt;
 
 #[derive(Debug)]
-pub struct PostgreSQLDatabase<'a, N, S, C> {
+pub struct PostgreSQLDatabase<'a, N: AsRef<str>, S: AsRef<str>, C: CommandRunner> {
   name: N,
   seed_file: S,
   command_runner: &'a C,
 }
 
-impl<'a, N, S, C> PostgreSQLDatabase<'a, N, S, C> {
+impl<'a, N: AsRef<str>, S: AsRef<str>, C: CommandRunner> PostgreSQLDatabase<'a, N, S, C> {
   pub const fn new(name: N, seed_file: S, command_runner: &'a C) -> Self {
-    Self {
+    PostgreSQLDatabase {
       name,
       seed_file,
       command_runner,
     }
   }
-}
 
-impl<'a, N: AsRef<str>, S: AsRef<str>, C: CommandRunner> PostgreSQLDatabase<'a, N, S, C> {
   async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
     let b = self
       .command_runner

src/symbols/saved_directory.rs

@@ -73,7 +73,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
         ],
       )
       .await?;
-    let modified_date = u64::from_str(std::str::from_utf8(&output)?.trim_end())?;
+    let modified_date = u64::from_str(String::from_utf8(output)?.trim_end())?;
     if if self.dir == StorageDirection::Store {
       modified_date > dump_date
     } else {
@@ -84,17 +84,13 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
         .borrow()
         .run_with_args(
           "diff",
-          args![
+          args!["-rq", self.storage.read_filename()?, self.path.as_ref()],
-            "-rq",
-            self.storage.read_filename()?.as_os_str(),
-            self.path.as_ref()
-          ],
         )
         .await?;
       match output.status.code() {
         Some(0) => Ok(true),
         Some(1) => Ok(false),
-        _ => Err(std::str::from_utf8(&output.stderr)?.into()),
+        _ => Err(String::from_utf8(output.stderr)?.into()),
       }
     } else {
       Ok(true)
@@ -113,11 +109,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
         .borrow()
         .run_successfully(
           "cp",
-          args![
+          args!["-a", self.storage.read_filename()?, self.path.as_ref()],
-            "-a",
-            self.storage.read_filename()?.as_os_str(),
-            self.path.as_ref()
-          ],
         )
         .await
     } else {
@@ -126,11 +118,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
         .borrow()
         .run_successfully(
           "cp",
-          args![
+          args!["-a", self.path.as_ref(), self.storage.write_filename()],
-            "-a",
-            self.path.as_ref(),
-            self.storage.write_filename().as_os_str()
-          ],
         )
         .await
     }

src/symbols/systemd/user_service.rs

@@ -30,9 +30,9 @@ impl<S: AsRef<Path>, U: AsRef<str>> UserService<'_, S, U> {
     loop {
       let result = self.command_runner.run_with_args("systemctl", args).await?;
       if result.status.success() {
-        return Ok(std::str::from_utf8(&result.stdout)?.trim_end().to_string());
+        return Ok(String::from_utf8(result.stdout)?.trim_end().to_string());
       }
-      let raw_stderr = std::str::from_utf8(&result.stderr)?;
+      let raw_stderr = String::from_utf8(result.stderr)?;
       let stderr = raw_stderr.trim_end();
       if stderr != "Failed to connect to bus: No such file or directory" {
         return Err(stderr.into());
@@ -61,8 +61,8 @@ impl<S: AsRef<Path>, U: AsRef<str>> UserService<'_, S, U> {
         "ActiveState=active" => return Ok(true),
         "ActiveState=failed" => {
           return Err(
-            std::str::from_utf8(
+            String::from_utf8(
-              &self
+              self
                 .command_runner
                 .get_output(
                   "journalctl",

src/symbols/tls/key.rs

@@ -1,16 +1,14 @@
 use crate::command_runner::CommandRunner;
 use crate::symbols::Symbol;
 use async_trait::async_trait;
-use nonzero_ext::nonzero;
 use std::error::Error;
-use std::num::NonZeroU32;
 use std::path::Path;
 
 #[derive(Debug)]
 pub struct Key<C, P> {
   file_path: P,
   command_runner: C,
-  bits: NonZeroU32,
+  bits: u32,
 }
 
 impl<C, P> Key<C, P> {
@@ -18,7 +16,7 @@ impl<C, P> Key<C, P> {
     Self {
       file_path,
       command_runner,
-      bits: nonzero!(4096u32), // FIXME: Policy
+      bits: 4096,
     }
   }
 }

src/symbols/wordpress/plugin.rs

@@ -6,7 +6,7 @@ use std::error::Error;
 use std::fs::File as FsFile;
 use std::io;
 use std::io::{BufRead, BufReader};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 #[derive(Debug)]
 pub struct Plugin<'a, P, N, R> {
@@ -15,7 +15,7 @@ pub struct Plugin<'a, P, N, R> {
   command_runner: &'a R,
 }
 
-impl<'a, P: AsRef<Path>, N: AsRef<str>, R> Plugin<'a, P, N, R> {
+impl<'a, P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Plugin<'a, P, N, R> {
   pub const fn new(base: P, name: N, command_runner: &'a R) -> Self {
     Self {
       base,
@@ -24,13 +24,12 @@ impl<'a, P: AsRef<Path>, N: AsRef<str>, R> Plugin<'a, P, N, R> {
     }
   }
 
-  fn get_path(&self) -> Box<Path> {
+  fn get_path(&self) -> PathBuf {
     self
       .base
       .as_ref()
       .join("wp-content/plugins")
       .join(self.name.as_ref())
-      .into()
   }
 }
 
@@ -42,8 +41,8 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
       return Ok(false);
     }
     let path = base_path.join(self.name.as_ref().to_owned() + ".php");
-    let mut version: Option<Box<str>> = None;
+    let mut version = String::new();
-    let mut plugin_uri: Option<Box<str>> = None;
+    let mut plugin_uri = String::new();
     match FsFile::open(path) {
       Err(e) => {
         // Check if file exists
@@ -57,12 +56,11 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
         let reader = BufReader::new(file);
         let regex = Regex::new("(?m)^(Plugin URI|Version): (.+)$")?;
         for content in reader.lines() {
-          let content = content?;
+          for matches in regex.captures_iter(&(content?)) {
-          for matches in regex.captures_iter(&content) {
             if &matches[1] == "Plugin URI" {
-              plugin_uri = Some(matches[2].into());
+              plugin_uri = matches[2].to_string();
             } else {
-              version = Some(matches[2].into());
+              version = matches[2].to_string();
             }
           }
         }
@@ -77,14 +75,14 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
           format!(
             r###"plugins={{"plugins":{{"{0}/{0}.php":{{"Version":"{1}", "PluginURI":"{2}"}}}}}}"###,
             self.name.as_ref(),
-            version.as_deref().unwrap_or_default(),
+            version,
-            plugin_uri.as_deref().unwrap_or_default()
+            plugin_uri
           ),
           "https://api.wordpress.org/plugins/update-check/1.1/",
         ],
       )
       .await?;
-    Ok(std::str::from_utf8(&upstream)?.contains(r###""plugins":[]"###))
+    Ok(String::from_utf8(upstream)?.contains(r###""plugins":[]"###))
   }
 
   async fn execute(&self) -> Result<(), Box<dyn Error>> {
@@ -99,7 +97,7 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
       .await?;
     self
       .command_runner
-      .run_successfully("rm", args!["-rf", self.get_path().as_os_str()])
+      .run_successfully("rm", args!["-rf", self.get_path()])
       .await?;
     self
       .command_runner

src/symbols/wordpress/translation.rs

@@ -8,6 +8,7 @@ use std::fs::File as FsFile;
 use std::io;
 use std::io::{BufRead, BufReader};
 use std::path::Path;
+use std::path::PathBuf;
 
 #[derive(Debug)]
 pub struct Translation<'a, C, D, R> {
@@ -17,7 +18,7 @@ pub struct Translation<'a, C, D, R> {
   command_runner: &'a R,
 }
 
-impl<'a, D, C: AsRef<str>, R> Translation<'a, C, D, R> {
+impl<'a, D, C: AsRef<str>, R: CommandRunner> Translation<'a, C, D, R> {
   pub const fn new(path: D, version: &'a str, locale: C, command_runner: &'a R) -> Self {
     Self {
       path,
@@ -29,7 +30,7 @@ impl<'a, D, C: AsRef<str>, R> Translation<'a, C, D, R> {
 }
 
 impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Translation<'_, C, D, R> {
-  fn get_pairs(&self) -> impl Iterator<Item = (Box<str>, Box<Path>)> + '_ {
+  fn get_pairs(&self) -> Vec<(String, PathBuf)> {
     let version_x = self
       .version
       .trim_end_matches(|c: char| c.is_ascii_digit())
@@ -41,19 +42,21 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Translation<'_, C, D, R> {
     } else {
       locale.to_lowercase().replace('_', "-")
     };
-    [
+    let mut res = vec![];
+    for &(in_slug, out_slug) in &[
       ("", ""),
       ("cc/", "continents-cities-"),
       ("admin/", "admin-"),
       ("admin/network/", "admin-network-"),
-    ].into_iter().flat_map(move |(in_slug, out_slug)|{
+    ] {
-      ["po", "mo"].map(|format|
+      for format in &["po", "mo"] {
-        (
+        res.push((
-          format!("https://translate.wordpress.org/projects/wp/{version_x}/{in_slug}{path_locale}/default/export-translations?format={format}").into(),
+          format!("https://translate.wordpress.org/projects/wp/{version_x}/{in_slug}{path_locale}/default/export-translations?format={format}"),
-          self.path.as_ref().join(format!("{}{}.{}", out_slug, self.locale.as_ref(), format)).into()
+          [self.path.as_ref(), format!("{}{}.{}", out_slug, self.locale.as_ref(), format).as_ref()].iter().collect()
-        ))
+        ));
       }
-    )
+    }
+    res
   }
 }
 
@@ -77,7 +80,7 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Symbol for Translation<'_,
             let reader = BufReader::new(file);
             for content in reader.lines() {
               if let Some(match_result) = match_date.captures(&content?) {
-                newest = max(newest, match_result[1].into());
+                newest = max(newest, match_result[1].to_string());
                 break;
               }
             }
@@ -96,7 +99,7 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Symbol for Translation<'_,
         )],
       )
       .await?;
-    Ok(std::str::from_utf8(&upstream)?.contains(&format!(
+    Ok(String::from_utf8(upstream)?.contains(&format!(
       r###"language":"{}","version":"{}","updated":"{}"###,
       self.locale.as_ref(),
       self.version,
@@ -108,10 +111,7 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Symbol for Translation<'_,
     for (source, target) in self.get_pairs() {
       self
         .command_runner
-        .run_successfully(
+        .run_successfully("curl", args!["--compressed", "-o", target, source,])
-          "curl",
-          args!["--compressed", "-o", target.as_os_str(), source.as_ref(),],
-        )
         .await?;
     }
     Ok(())

src/templates/nginx/server.rs

@@ -1,5 +1,4 @@
 use std::fmt::Display;
-use std::num::NonZeroUsize;
 use std::path::Path;
 
 #[must_use]
@@ -102,11 +101,11 @@ impl<T: AsRef<Path>> SocketSpec for T {
 }
 
 #[derive(Debug)]
-pub struct LocalTcpSocket(NonZeroUsize);
+pub struct LocalTcpSocket(usize);
 
 impl LocalTcpSocket {
   #[must_use]
-  pub const fn new(x: NonZeroUsize) -> Self {
+  pub const fn new(x: usize) -> Self {
     Self(x)
   }
 }

src/templates/php.rs

@@ -1,11 +1,10 @@
 use std::fmt::{Display, Error, Formatter};
-use std::num::NonZeroUsize;
 use std::path::Path;
 
 #[derive(Clone, Debug, PartialEq, Hash, Eq)]
 pub struct FpmPoolConfig {
-  max_children: NonZeroUsize,
+  max_children: usize,
-  custom: Option<Box<str>>,
+  custom: Option<String>,
 }
 
 impl Display for FpmPoolConfig {
@@ -20,14 +19,14 @@ impl Display for FpmPoolConfig {
 impl From<usize> for FpmPoolConfig {
   fn from(max_children: usize) -> Self {
     Self {
-      max_children: NonZeroUsize::try_from(max_children).unwrap(),
+      max_children,
       custom: None,
     }
   }
 }
 
 impl FpmPoolConfig {
-  pub fn new(max_children: NonZeroUsize, custom: impl Into<Box<str>>) -> Self {
+  pub fn new(max_children: usize, custom: impl Into<String>) -> Self {
     Self {
       max_children,
       custom: Some(custom.into()),

tests/file.rs

@@ -3,7 +3,7 @@ use schematics::symbols::file::File as FileSymbol;
 use schematics::symbols::Symbol;
 use std::fs::File;
 use std::io::Write;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use tempfile::{tempdir, TempDir};
 
 fn get_dir(content: Option<&str>) -> TempDir {
@@ -19,8 +19,8 @@ fn get_dir(content: Option<&str>) -> TempDir {
   tmp_dir
 }
 
-fn get_symbol(path: &Path) -> FileSymbol<Box<Path>, &str> {
+fn get_symbol(path: &Path) -> FileSymbol<PathBuf, &str> {
-  FileSymbol::new(path.join("filename").into(), "target content")
+  FileSymbol::new(path.join("filename"), "target content")
 }
 
 // Normal cases

tests/setup.rs

@@ -9,7 +9,6 @@ use schematics::SymbolRunner;
 use slog::{info, Logger as SlogLogger};
 use std::error::Error;
 use std::fmt::Debug;
-use std::path::Path;
 use std::time::Duration;
 
 #[derive(Clone, Debug)]
@@ -61,7 +60,7 @@ fn test(
 #[test]
 fn can_create_an_acme_user() {
   let mut result = test(1, |setup| {
-    assert_eq!(&*(run(setup.add(AcmeUser)).unwrap().0).0, "acme");
+    assert_eq!((run(setup.add(AcmeUser)).unwrap().0).0, "acme");
   });
   let entry = result
     .pop()
@@ -134,8 +133,8 @@ fn can_create_an_acme_cert() {
 #[test]
 fn can_create_a_git_checkout() {
   let mut result = test(1, |setup| {
-    run(setup.add(GitCheckout::new(
+    run(setup.add(GitCheckout(
-      "/tmp/somepath".as_ref() as &Path,
+      "/tmp/somepath".into(),
       "/tmp/some_src_repo",
       "master",
     )))

tests/storage.rs

@@ -16,7 +16,7 @@ fn get_dir<'a, I: IntoIterator<Item = &'a &'a str>>(content: I) -> TempDir {
 }
 
 fn get_storage(path: &Path) -> SimpleStorage {
-  SimpleStorage::new(path.join("_filename").into())
+  SimpleStorage::new(path.join("_filename"))
 }
 
 // Normal cases
@@ -33,7 +33,7 @@ fn single_file() {
   );
   assert_eq!(
     dir.path().join("_filename").join("12345"),
-    Path::new(&*storage.read_filename().unwrap())
+    Path::new(&storage.read_filename().unwrap())
   );
   assert_eq!(storage.recent_date().unwrap(), 12345);
 }
@@ -50,7 +50,7 @@ fn two_files() {
   );
   assert_eq!(
     dir.path().join("_filename").join("23456"),
-    Path::new(&*storage.read_filename().unwrap())
+    Path::new(&storage.read_filename().unwrap())
   );
   assert_eq!(storage.recent_date().unwrap(), 23456);
 }
@@ -67,7 +67,7 @@ fn another_two_files() {
   );
   assert_eq!(
     dir.path().join("_filename").join("23456"),
-    Path::new(&*storage.read_filename().unwrap())
+    Path::new(&storage.read_filename().unwrap())
   );
   assert_eq!(storage.recent_date().unwrap(), 23456);
 }
@@ -84,7 +84,7 @@ fn three_files() {
   );
   assert_eq!(
     dir.path().join("_filename").join("23456"),
-    Path::new(&*storage.read_filename().unwrap())
+    Path::new(&storage.read_filename().unwrap())
   );
   assert_eq!(storage.recent_date().unwrap(), 23456);
 }