feat: add utility function to reduce code duplication

src/cli/commands/publish.rs

@@ -19,7 +19,7 @@ use pesde::{
         },
         PackageSources, IGNORED_DIRS, IGNORED_FILES,
     },
-    Project, RefreshedSources, DEFAULT_INDEX_NAME, MANIFEST_FILE_NAME, PACKAGES_CONTAINER_NAME,
+    Project, RefreshedSources, DEFAULT_INDEX_NAME, MANIFEST_FILE_NAME,
 };
 use reqwest::{header::AUTHORIZATION, StatusCode};
 use semver::VersionReq;
@@ -121,15 +121,11 @@ impl PublishCommand {
                         .filter(|(_, node)| node.direct.is_some())
                         .map(|(id, node)| {
                             let project = project.clone();
-                            let base_folder = manifest
-                                .target
-                                .kind()
-                                .packages_folder(id.version_id().target());
-                            let container_folder = project
-                                .package_dir()
-                                .join(base_folder)
-                                .join(PACKAGES_CONTAINER_NAME)
-                                .join(node.container_folder(id));
+                            let container_folder = node.container_folder_from_project(
+                                id,
+                                &project,
+                                manifest.target.kind(),
+                            );
 
                             let id = Arc::new(id.clone());
                             let node = node.clone();

src/cli/commands/run.rs

@@ -7,7 +7,7 @@ use pesde::{
     linking::generator::generate_bin_linking_module,
     names::{PackageName, PackageNames},
     source::traits::{GetTargetOptions, PackageRef, PackageSource, RefreshOptions},
-    Project, MANIFEST_FILE_NAME, PACKAGES_CONTAINER_NAME,
+    Project, MANIFEST_FILE_NAME,
 };
 use relative_path::RelativePathBuf;
 use std::{
@@ -86,17 +86,16 @@ impl RunCommand {
                 _ => anyhow::bail!("multiple versions found. use the package's alias instead."),
             };
 
-            let base_folder = project
-                .deser_manifest()
-                .await?
-                .target
-                .kind()
-                .packages_folder(id.version_id().target());
-            let container_folder = project
-                .package_dir()
-                .join(base_folder)
-                .join(PACKAGES_CONTAINER_NAME)
-                .join(node.container_folder(&id));
+            let container_folder = node.container_folder_from_project(
+                &id,
+                &project,
+                project
+                    .deser_manifest()
+                    .await
+                    .context("failed to deserialize manifest")?
+                    .target
+                    .kind(),
+            );
 
             let source = node.pkg_ref.source();
             source

src/download_and_link.rs

@@ -4,13 +4,13 @@ use crate::{
         DependencyGraph, DependencyGraphNode, DependencyGraphNodeWithTarget,
         DependencyGraphWithTarget,
     },
-    manifest::DependencyType,
+    manifest::{target::TargetKind, DependencyType},
     reporters::DownloadsReporter,
     source::{
         ids::PackageId,
         traits::{GetTargetOptions, PackageRef, PackageSource},
     },
-    Project, RefreshedSources, PACKAGES_CONTAINER_NAME,
+    Project, RefreshedSources,
 };
 use fs_err::tokio as fs;
 use futures::TryStreamExt;
@@ -19,7 +19,6 @@ use std::{
     convert::Infallible,
     future::{self, Future},
     num::NonZeroUsize,
-    path::PathBuf,
     sync::Arc,
 };
 use tokio::{pin, task::JoinSet};
@@ -187,22 +186,14 @@ impl Project {
             let mut tasks = JoinSet::new();
 
             while let Some((id, node, fs)) = downloaded.try_next().await? {
-                let container_folder = self
-                    .package_dir()
-                    .join(
-                        manifest
-                            .target
-                            .kind()
-                            .packages_folder(id.version_id().target()),
-                    )
-                    .join(PACKAGES_CONTAINER_NAME)
-                    .join(node.container_folder(&id));
+                let container_folder =
+                    node.container_folder_from_project(&id, self, manifest.target.kind());
 
                 if prod && node.resolved_ty == DependencyType::Dev {
                     continue;
                 }
 
-                downloaded_graph.insert(id, (node, container_folder.clone()));
+                downloaded_graph.insert(id, node);
 
                 let cas_dir = self.cas_dir().to_path_buf();
                 tasks.spawn(async move {
@@ -220,20 +211,24 @@ impl Project {
 
         let (downloaded_wally_graph, downloaded_other_graph) = downloaded_graph
             .into_iter()
-            .partition::<HashMap<_, _>, _>(|(_, (node, _))| node.pkg_ref.is_wally_package());
+            .partition::<HashMap<_, _>, _>(|(_, node)| node.pkg_ref.is_wally_package());
 
         let mut graph = Arc::new(DependencyGraphWithTarget::new());
 
         async fn get_graph_targets<Hooks: DownloadAndLinkHooks>(
             graph: &mut Arc<DependencyGraphWithTarget>,
             project: &Project,
-            downloaded_graph: HashMap<PackageId, (DependencyGraphNode, PathBuf)>,
+            manifest_target_kind: TargetKind,
+            downloaded_graph: HashMap<PackageId, DependencyGraphNode>,
         ) -> Result<(), errors::DownloadAndLinkError<Hooks::Error>> {
             let mut tasks = downloaded_graph
                 .into_iter()
-                .map(|(id, (node, container_folder))| {
+                .map(|(id, node)| {
                     let source = node.pkg_ref.source();
-                    let path = Arc::from(container_folder.as_path());
+                    let path = Arc::from(
+                        node.container_folder_from_project(&id, project, manifest_target_kind)
+                            .as_path(),
+                    );
                     let id = Arc::new(id.clone());
                     let project = project.clone();
 
@@ -266,9 +261,14 @@ impl Project {
         }
 
         // step 2. get targets for non Wally packages (Wally packages require the scripts packages to be downloaded first)
-        get_graph_targets::<Hooks>(&mut graph, self, downloaded_other_graph)
-            .instrument(tracing::debug_span!("get targets (non-wally)"))
-            .await?;
+        get_graph_targets::<Hooks>(
+            &mut graph,
+            self,
+            manifest.target.kind(),
+            downloaded_other_graph,
+        )
+        .instrument(tracing::debug_span!("get targets (non-wally)"))
+        .await?;
 
         self.link_dependencies(graph.clone(), false)
             .instrument(tracing::debug_span!("link (non-wally)"))
@@ -287,9 +287,14 @@ impl Project {
         }
 
         // step 3. get targets for Wally packages
-        get_graph_targets::<Hooks>(&mut graph, self, downloaded_wally_graph)
-            .instrument(tracing::debug_span!("get targets (wally)"))
-            .await?;
+        get_graph_targets::<Hooks>(
+            &mut graph,
+            self,
+            manifest.target.kind(),
+            downloaded_wally_graph,
+        )
+        .instrument(tracing::debug_span!("get targets (wally)"))
+        .await?;
 
         // step 4. link ALL dependencies. do so with types
         self.link_dependencies(graph.clone(), true)

src/graph.rs

@@ -9,6 +9,7 @@ use crate::{
         specifiers::DependencySpecifiers,
         traits::PackageRef,
     },
+    Project, PACKAGES_CONTAINER_NAME,
 };
 use serde::{Deserialize, Serialize};
 use std::{collections::BTreeMap, path::PathBuf};
@@ -61,6 +62,20 @@ impl DependencyGraphNode {
             .join(version.to_string())
             .join(name.as_str().1)
     }
+
+    /// Returns the folder to store the contents of the package in starting from the project's package directory
+    pub fn container_folder_from_project(
+        &self,
+        package_id: &PackageId,
+        project: &Project,
+        manifest_target_kind: TargetKind,
+    ) -> PathBuf {
+        project
+            .package_dir()
+            .join(manifest_target_kind.packages_folder(package_id.version_id().target()))
+            .join(PACKAGES_CONTAINER_NAME)
+            .join(self.container_folder(package_id))
+    }
 }
 
 /// A graph of `DependencyGraphNode`s

src/linking/mod.rs

@@ -91,13 +91,11 @@ impl Project {
                         return Ok((package_id, vec![]));
                     };
 
-                    let container_folder = project
-                        .package_dir()
-                        .join(
-                            manifest_target_kind.packages_folder(package_id.version_id().target()),
-                        )
-                        .join(PACKAGES_CONTAINER_NAME)
-                        .join(node.node.container_folder(&package_id));
+                    let container_folder = node.node.container_folder_from_project(
+                        &package_id,
+                        &project,
+                        manifest_target_kind,
+                    );
 
                     let types = if lib_file.as_str() != LINK_LIB_NO_FILE_FOUND {
                         let lib_file = lib_file.to_path(&container_folder);

src/patches.rs

@@ -2,7 +2,7 @@ use crate::{
     graph::DependencyGraph,
     reporters::{PatchProgressReporter, PatchesReporter},
     source::ids::PackageId,
-    Project, MANIFEST_FILE_NAME, PACKAGES_CONTAINER_NAME,
+    Project, MANIFEST_FILE_NAME,
 };
 use fs_err::tokio as fs;
 use futures::TryFutureExt;
@@ -102,16 +102,8 @@ impl Project {
                     continue;
                 };
 
-                let container_folder = self
-                    .package_dir()
-                    .join(
-                        manifest
-                            .target
-                            .kind()
-                            .packages_folder(package_id.version_id().target()),
-                    )
-                    .join(PACKAGES_CONTAINER_NAME)
-                    .join(node.container_folder(&package_id));
+                let container_folder =
+                    node.container_folder_from_project(&package_id, self, manifest.target.kind());
 
                 let reporter = reporter.clone();
                 let span = tracing::info_span!("apply patch", package_id = package_id.to_string());