mirror of
https://github.com/pesde-pkg/pesde.git
synced 2025-04-18 19:03:48 +01:00
106 lines
3.2 KiB
Rust
106 lines
3.2 KiB
Rust
use crate::{
|
|
manifest::{
|
|
target::{Target, TargetKind},
|
|
DependencyType,
|
|
},
|
|
source::{
|
|
ids::{PackageId, VersionId},
|
|
refs::PackageRefs,
|
|
specifiers::DependencySpecifiers,
|
|
traits::PackageRef,
|
|
},
|
|
Project, PACKAGES_CONTAINER_NAME,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{collections::BTreeMap, path::PathBuf};
|
|
|
|
/// A graph of dependencies
|
|
pub type Graph<Node> = BTreeMap<PackageId, Node>;
|
|
|
|
/// A dependency graph node
|
|
#[derive(Serialize, Deserialize, Debug, Clone)]
|
|
pub struct DependencyGraphNode {
|
|
/// The alias, specifier, and original (as in the manifest) type for the dependency, if it is a direct dependency (i.e. used by the current project)
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub direct: Option<(String, DependencySpecifiers, DependencyType)>,
|
|
/// The dependencies of the package
|
|
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
|
pub dependencies: BTreeMap<PackageId, String>,
|
|
/// The resolved (transformed, for example Peer -> Standard) type of the dependency
|
|
pub resolved_ty: DependencyType,
|
|
/// Whether the resolved type should be Peer if this isn't depended on
|
|
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
|
pub is_peer: bool,
|
|
/// The package reference
|
|
pub pkg_ref: PackageRefs,
|
|
}
|
|
|
|
impl DependencyGraphNode {
|
|
pub(crate) fn base_folder(&self, version_id: &VersionId, project_target: TargetKind) -> String {
|
|
if self.pkg_ref.use_new_structure() {
|
|
version_id.target().packages_folder(&project_target)
|
|
} else {
|
|
"..".to_string()
|
|
}
|
|
}
|
|
|
|
/// Returns the folder to store the contents of the package in
|
|
pub fn container_folder(&self, package_id: &PackageId) -> PathBuf {
|
|
let (name, version) = package_id.parts();
|
|
|
|
if self.pkg_ref.is_wally_package() {
|
|
return PathBuf::from(format!(
|
|
"{}_{}@{}",
|
|
name.as_str().0,
|
|
name.as_str().1,
|
|
version
|
|
))
|
|
.join(name.as_str().1);
|
|
}
|
|
|
|
PathBuf::from(name.escaped())
|
|
.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
|
|
pub type DependencyGraph = Graph<DependencyGraphNode>;
|
|
|
|
/// A dependency graph node with a `Target`
|
|
#[derive(Debug, Clone)]
|
|
pub struct DependencyGraphNodeWithTarget {
|
|
/// The target of the package
|
|
pub target: Target,
|
|
/// The node
|
|
pub node: DependencyGraphNode,
|
|
}
|
|
|
|
/// A graph of `DownloadedDependencyGraphNode`s
|
|
pub type DependencyGraphWithTarget = Graph<DependencyGraphNodeWithTarget>;
|
|
|
|
/// A trait for converting a graph to a different type of graph
|
|
pub trait ConvertableGraph<Node> {
|
|
/// Converts the graph to a different type of graph
|
|
fn convert(self) -> Graph<Node>;
|
|
}
|
|
|
|
impl ConvertableGraph<DependencyGraphNode> for DependencyGraphWithTarget {
|
|
fn convert(self) -> Graph<DependencyGraphNode> {
|
|
self.into_iter().map(|(id, node)| (id, node.node)).collect()
|
|
}
|
|
}
|