Metadata refactor 3

Author: ksew1

crates/forge/src/clean.rs

@@ -2,7 +2,7 @@ use crate::{CleanArgs, CleanComponent};
 use anyhow::{Context, Result, ensure};
 use camino::Utf8PathBuf;
 use foundry_ui::UI;
-use scarb_api::metadata::get_metadata;
+use scarb_api::metadata::{MetadataOpts, get_metadata_with_opts};
 use std::fs;
 
 const COVERAGE_DIR: &str = "coverage";
@@ -26,7 +26,10 @@ pub fn clean(args: CleanArgs, ui: &UI) -> Result<()> {
         args.clean_components
     };
 
-    let scarb_metadata = get_metadata()?;
+    let scarb_metadata = get_metadata_with_opts(MetadataOpts {
+        no_deps: true,
+        ..MetadataOpts::default()
+    })?;
     let workspace_root = scarb_metadata.workspace.root;
 
     let packages_root: Vec<Utf8PathBuf> = scarb_metadata

crates/forge/src/run_tests/workspace.rs

@@ -17,12 +17,12 @@ use anyhow::{Context, Result};
 use forge_runner::test_case_summary::AnyTestCaseSummary;
 use forge_runner::{CACHE_DIR, test_target_summary::TestTargetSummary};
 use foundry_ui::UI;
+use scarb_api::metadata::{MetadataOpts, get_metadata_with_opts};
 use scarb_api::{
     ScarbCommand,
-    metadata::{Metadata, MetadataCommandExt, PackageMetadata},
+    metadata::{Metadata, PackageMetadata},
     target_dir_for_workspace,
 };
-use scarb_metadata::MetadataCommand;
 use scarb_ui::args::PackagesFilter;
 use shared::consts::SNFORGE_TEST_FILTER;
 use std::env;
@@ -38,11 +38,10 @@ pub async fn run_for_workspace(args: TestArgs, ui: Arc<UI>) -> Result<ExitStatus
         ColorOption::Auto => (),
     }
 
-    let mut metadata_command = MetadataCommand::new();
-    if let Some(profile) = &args.scarb_args.profile.specified() {
-        metadata_command.profile(profile.clone());
-    }
-    let scarb_metadata = metadata_command.inherit_stderr().run()?;
+    let scarb_metadata = get_metadata_with_opts(MetadataOpts {
+        profile: args.scarb_args.profile.specified(),
+        ..MetadataOpts::default()
+    })?;
 
     check_profile_compatibility(&args, &scarb_metadata)?;
 

crates/forge/tests/e2e/clean.rs

@@ -1,7 +1,7 @@
 use super::common::runner::{runner, setup_package, test_runner};
 use assert_fs::TempDir;
 use camino::Utf8PathBuf;
-use scarb_api::metadata::get_metadata_for_dir;
+use scarb_api::metadata::{MetadataOpts, get_metadata_with_opts};
 use shared::test_utils::output_assert::assert_stdout_contains;
 use std::path::Path;
 
@@ -230,7 +230,12 @@ fn generate_clean_components(state: CleanComponentsState, temp_dir: &TempDir) {
 }
 
 fn check_clean_components_state(path: &Path) -> CleanComponentsState {
-    let scarb_metadata = get_metadata_for_dir(path).unwrap();
+    let scarb_metadata = get_metadata_with_opts(MetadataOpts {
+        no_deps: true,
+        current_dir: Some(path.into()),
+        ..MetadataOpts::default()
+    })
+    .unwrap();
 
     let workspace_root = scarb_metadata.workspace.root;
 

crates/scarb-api/src/metadata.rs

@@ -1,34 +1,48 @@
+use crate::ScarbCommand;
 use anyhow::{Context, Result};
 pub use scarb_metadata::{Metadata, MetadataCommand, MetadataCommandError, PackageMetadata};
 use std::path::PathBuf;
 
-pub trait MetadataCommandExt {
-    fn run(&mut self) -> Result<Metadata>;
-}
-
-impl MetadataCommandExt for MetadataCommand {
-    fn run(&mut self) -> Result<Metadata> {
-        self.inherit_stdout()
-            .exec()
-            .context("error: could not gather project metadata from Scarb due to previous error")
-    }
+#[derive(Default)]
+pub struct MetadataOpts {
+    pub current_dir: Option<PathBuf>,
+    pub no_deps: bool,
+    pub profile: Option<String>,
 }
 
 pub fn get_metadata_for_dir(dir: impl Into<PathBuf>) -> Result<Metadata> {
-    get_metadata_inner(Some(dir))
+    get_metadata_with_opts(MetadataOpts {
+        current_dir: Some(dir.into()),
+        ..MetadataOpts::default()
+    })
 }
 
 pub fn get_metadata() -> Result<Metadata> {
-    get_metadata_inner(None::<PathBuf>)
+    get_metadata_with_opts(MetadataOpts::default())
 }
 
-fn get_metadata_inner(current_dir: Option<impl Into<PathBuf>>) -> Result<Metadata> {
+pub fn get_metadata_with_opts(
+    MetadataOpts {
+        current_dir,
+        no_deps,
+        profile,
+    }: MetadataOpts,
+) -> Result<Metadata> {
+    ScarbCommand::new().ensure_available()?;
     let mut command = MetadataCommand::new();
 
     if let Some(dir) = current_dir {
         command.current_dir(dir);
     }
 
+    if let Some(profile) = profile {
+        command.profile(profile);
+    }
+
+    if no_deps {
+        command.no_deps();
+    }
+
     command
         .inherit_stderr()
         .inherit_stdout()

crates/sncast/src/helpers/scarb_utils.rs

@@ -2,16 +2,16 @@ use crate::helpers::artifacts::CastStarknetContractArtifacts;
 use anyhow::{Context, Result, anyhow};
 use camino::{Utf8Path, Utf8PathBuf};
 use foundry_ui::{UI, components::warning::WarningMessage};
+use scarb_api::metadata::{MetadataOpts, get_metadata_for_dir, get_metadata_with_opts};
 use scarb_api::{
     CompilationOpts, ScarbCommand, ScarbCommandError,
     get_contracts_artifacts_and_source_sierra_paths,
-    metadata::{Metadata, MetadataCommand, PackageMetadata},
+    metadata::{Metadata, PackageMetadata},
     target_dir_for_workspace,
 };
 use scarb_ui::args::PackagesFilter;
 use shared::command::CommandExt;
 use std::collections::HashMap;
-use std::env;
 use std::str::FromStr;
 
 pub fn get_scarb_manifest() -> Result<Utf8PathBuf> {
@@ -37,34 +37,21 @@ pub fn get_scarb_manifest_for(dir: &Utf8Path) -> Result<Utf8PathBuf> {
     Ok(path)
 }
 
-fn get_scarb_metadata_command(manifest_path: &Utf8PathBuf) -> Result<MetadataCommand> {
-    ScarbCommand::new().ensure_available()?;
-
-    let mut command = MetadataCommand::new();
-    command.inherit_stderr().manifest_path(manifest_path);
-    Ok(command)
-}
-
-fn execute_scarb_metadata_command(command: &MetadataCommand) -> Result<Metadata> {
-    command.exec().context(format!(
-        "Failed to read the `Scarb.toml` manifest file. Doesn't exist in the current or parent directories = {}",
-        env::current_dir()
-            .expect("Failed to access the current directory")
-            .into_os_string()
-            .into_string()
-            .expect("Failed to convert current directory into a string")
-    ))
-}
-
 pub fn get_scarb_metadata(manifest_path: &Utf8PathBuf) -> Result<Metadata> {
-    let mut command = get_scarb_metadata_command(manifest_path)?;
-    let command = command.no_deps();
-    execute_scarb_metadata_command(command)
+    get_metadata_with_opts(MetadataOpts {
+        current_dir: Some(
+            manifest_path
+                .parent()
+                .expect("manifest should have parent")
+                .into(),
+        ),
+        no_deps: true,
+        ..MetadataOpts::default()
+    })
 }
 
 pub fn get_scarb_metadata_with_deps(manifest_path: &Utf8PathBuf) -> Result<Metadata> {
-    let command = get_scarb_metadata_command(manifest_path)?;
-    execute_scarb_metadata_command(&command)
+    get_metadata_for_dir(manifest_path.parent().expect("manifest should have parent"))
 }
 
 pub fn get_cairo_version(manifest_path: &Utf8PathBuf) -> Result<String> {