feat: Split InputManifest::load* into attached/detached forms

Previously, the `load`, `load_async` and `sha256` constructors for
`InputManifest` all took a second parameter that was an `Option` that could
be a value used to identify the target artifact, such as a `&Path`. In practice,
this lead to awkward type inference errors, requiring callers to do things like
`None::<&String>`, which we don't really want them to have to do.

These 3 constructors have now been split into 3 pairs of constructors, a regular
one which takes a non-optional target (which, because it's not optional, means
inference should always have enough information to give useful errors), and
another which does not take a target and is explicitly for constructing a
"detached" manifest.

Signed-off-by: Andrew Lilley Brinker <[email protected]>

Author: alilleybrinker

omnibor-cli/src/cmd/manifest/find.rs

@@ -58,7 +58,7 @@ async fn open_and_match_manifests(
     pin_mut!(path_rx);
 
     while let Some(path) = path_rx.next().await {
-        if let Ok(manifest) = InputManifest::sha256(&path, None) {
+        if let Ok(manifest) = InputManifest::sha256_detached(&path) {
             if manifest.contains_artifact(target_aid).map_err(|source| {
                 Error::FileFailedToIdDuringSearch {
                     path: path.to_path_buf(),

omnibor-cli/src/cmd/store/add.rs

@@ -3,7 +3,7 @@ use crate::{
     cli::StoreAddArgs,
     error::{Error, Result},
 };
-use omnibor::{hash_algorithm::Sha256, storage::Storage, InputManifest};
+use omnibor::{storage::Storage, InputManifest};
 
 /// Run the `store add` subcommand.
 pub async fn run(app: &App, args: &StoreAddArgs) -> Result<()> {
@@ -21,8 +21,11 @@ pub async fn run(app: &App, args: &StoreAddArgs) -> Result<()> {
         None => None,
     };
 
-    let manifest = InputManifest::<Sha256>::load(&args.manifest, target_aid)
-        .map_err(Error::UnableToReadManifest)?;
+    let manifest = match target_aid {
+        Some(target_aid) => InputManifest::load(&args.manifest, target_aid),
+        None => InputManifest::load_detached(&args.manifest),
+    }
+    .map_err(Error::UnableToReadManifest)?;
 
     storage
         .write_manifest(&manifest)

omnibor/src/input_manifest.rs

@@ -55,32 +55,39 @@ where
 
 impl InputManifest<Sha256> {
     /// Load the input manifest at the path with the SHA-256 hash function.
-    pub fn sha256<I>(
-        source: I,
-        target: Option<ArtifactId<Sha256>>,
-    ) -> Result<Self, InputManifestError>
+    pub fn sha256<M, I>(source: M, target: I) -> Result<Self, InputManifestError>
     where
-        I: ManifestSource<Sha256>,
+        M: ManifestSource<Sha256>,
+        I: Identify<Sha256>,
     {
         InputManifest::load(source, target)
     }
 
-    /// Load the input manifest at the path with the SHA-256 hash function asynchronously.
-    pub async fn sha256_async<I, A>(
-        source: I,
-        target: Option<A>,
-    ) -> Result<Self, InputManifestError>
+    /// Load the input manifest at the path with the SHA-256 hash function, detached.
+    pub fn sha256_detached<M>(source: M) -> Result<Self, InputManifestError>
     where
-        I: ManifestSourceAsync<Sha256>,
-        A: IdentifyAsync<Sha256>,
+        M: ManifestSource<Sha256>,
     {
-        let target = match target {
-            Some(t) => Some(t.identify_async().await?),
-            None => None,
-        };
+        InputManifest::load_detached(source)
+    }
 
+    /// Load the input manifest at the path with the SHA-256 hash function asynchronously.
+    pub async fn sha256_async<M, I>(source: M, target: I) -> Result<Self, InputManifestError>
+    where
+        M: ManifestSourceAsync<Sha256>,
+        I: IdentifyAsync<Sha256>,
+    {
+        let target = target.identify_async().await?;
         InputManifest::load_async(source, target).await
     }
+
+    /// Load the input manifest at the path with the SHA-256 hash function asynchronously, detached.
+    pub async fn sha256_detached_async<M>(source: M) -> Result<Self, InputManifestError>
+    where
+        M: ManifestSourceAsync<Sha256>,
+    {
+        InputManifest::load_detached_async(source).await
+    }
 }
 
 impl<H: HashAlgorithm> InputManifest<H> {
@@ -151,27 +158,39 @@ impl<H: HashAlgorithm> InputManifest<H> {
     }
 
     /// Construct an [`InputManifest`] from a source.
-    pub fn load<M, I>(source: M, target: Option<I>) -> Result<Self, InputManifestError>
+    pub fn load<M, I>(source: M, target: I) -> Result<Self, InputManifestError>
     where
         M: ManifestSource<H>,
         I: Identify<H>,
     {
-        let target = target.map(|t| t.identify()).transpose()?;
-        source.resolve(target)
+        let target = target.identify()?;
+        source.resolve(Some(target))
+    }
+
+    /// Construct an [`InputManifest`] from a source, without a target.
+    pub fn load_detached<M>(source: M) -> Result<Self, InputManifestError>
+    where
+        M: ManifestSource<H>,
+    {
+        source.resolve(None)
     }
 
     /// Construct an [`InputManifest`] from a source, asynchronously.
-    pub async fn load_async<M, I>(source: M, target: Option<I>) -> Result<Self, InputManifestError>
+    pub async fn load_async<M, I>(source: M, target: I) -> Result<Self, InputManifestError>
     where
         M: ManifestSourceAsync<H>,
         I: IdentifyAsync<H>,
     {
-        let target = match target {
-            Some(t) => Some(t.identify_async().await?),
-            None => None,
-        };
+        let target = target.identify_async().await?;
+        source.resolve_async(Some(target)).await
+    }
 
-        source.resolve_async(target).await
+    /// Construct an [`InputManifest`] from a source, asynchronously, without a target.
+    pub async fn load_detached_async<M>(source: M) -> Result<Self, InputManifestError>
+    where
+        M: ManifestSourceAsync<H>,
+    {
+        source.resolve_async(None).await
     }
 
     /// Get the manifest as bytes.

omnibor/src/lib.rs

@@ -160,7 +160,7 @@
 //! 6e87984feca6b64467f9028fd6b76a4ec8d13ee23f0ae3b99b548ca0c2d0230b
 //! 726eb0db4f3130fb4caef53ee9d103b6bc2d732e665dd88f53efce4c7b59818b
 //! "#;
-//!     let input_manifest = InputManifest::<Sha256>::load(manifest_txt, None::<&String>)?;
+//!     let input_manifest = InputManifest::sha256_detached(manifest_txt)?;
 //!
 //!     if input_manifest.contains_artifact("./test/data/c/main.c")? {
 //!         println!("found a match!");

omnibor/src/storage/file_system_storage.rs

@@ -309,7 +309,10 @@ struct ManifestsEntry<H: HashAlgorithm> {
 impl<H: HashAlgorithm> ManifestsEntry<H> {
     /// Load the [`InputManifest`] represented by this entry.
     fn manifest(&self) -> Result<InputManifest<H>, InputManifestError> {
-        InputManifest::load(&self.manifest_path, self.target_aid)
+        match self.target_aid {
+            Some(target) => InputManifest::load(&self.manifest_path, target),
+            None => InputManifest::load_detached(&self.manifest_path),
+        }
     }
 }