Switch from TryFrom to FromStr for Manifest

src/manifest.rs

@@ -18,6 +18,7 @@ use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
     fmt::{self, Display},
+    str::FromStr,
 };
 use tokio::fs;
 
@@ -54,11 +55,11 @@ impl From<Manifest> for RawManifest {
     }
 }
 
-impl TryFrom<String> for RawManifest {
-    type Error = toml::de::Error;
+impl FromStr for RawManifest {
+    type Err = toml::de::Error;
 
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        toml::from_str::<RawManifest>(&value)
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        toml::from_str(input)
     }
 }
 
@@ -89,7 +90,7 @@ impl Manifest {
             .await
             .wrap_err("Failed to read manifest")?;
 
-        let raw: RawManifest = toml::from_str(&toml).wrap_err("Failed to parse manifest")?;
+        let raw: RawManifest = toml.parse().wrap_err("Failed to parse manifest")?;
 
         Ok(raw.into())
     }
@@ -122,11 +123,11 @@ impl From<RawManifest> for Manifest {
     }
 }
 
-impl TryFrom<String> for Manifest {
-    type Error = toml::de::Error;
+impl FromStr for Manifest {
+    type Err = toml::de::Error;
 
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        Ok(RawManifest::try_from(value)?.into())
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        input.parse::<RawManifest>().map(Self::from)
     }
 }
 

src/package.rs

@@ -121,9 +121,9 @@ impl PackageStore {
             "Failed to locate local manifest for package: {package}"
         ))?;
 
-        Manifest::try_from(manifest)
+        manifest
+            .parse()
             .wrap_err(format!("Malformed manifest of package {package}"))
-            .map(Manifest::from)
     }
 
     /// Packages a release from the local file system state
@@ -334,7 +334,8 @@ impl TryFrom<Bytes> for Package {
             .wrap_err("Failed to find manifest in package")?;
 
         let manifest = manifest.bytes().collect::<io::Result<Vec<_>>>()?;
-        let manifest = Manifest::try_from(String::from_utf8(manifest)?)
+        let manifest = String::from_utf8(manifest)?
+            .parse()
             .wrap_err("Failed to parse manifest")?;
 
         Ok(Self { manifest, tgz })

src/registry/local.rs

@@ -105,10 +105,8 @@ mod tests {
     use crate::manifest::{Dependency, Manifest, PackageManifest};
     use crate::package::{Package, PackageType};
     use crate::registry::local::LocalRegistry;
-    use crate::registry::RegistryUri;
     use bytes::Bytes;
     use std::path::PathBuf;
-    use std::str::FromStr;
     use std::{env, fs};
 
     #[tokio::test]
@@ -145,7 +143,8 @@ mod tests {
             package_bytes
         );
 
-        let registry_uri = RegistryUri::from_str("http://some-registry/artifactory")
+        let registry_uri = "http://some-registry/artifactory"
+            .parse()
             .expect("Failed to parse registry URL");
 
         // Download package from local registry and assert the tgz bytes and the metadata match what we