Report project name instead of root when using pyproject.toml files (#295)

Part of https://github.com/astral-sh/puffin/issues/214

Adds a `project: Option<PackageName>` to the `Manifest`, `Resolver`, and
`RequirementsSpecification`.
To populate an optional `name` for `PubGubPackage::Root`.

I'll work on removing the version number next.

Should we consider using the parent directory name when a
`pyproject.toml` file is not present?

crates/puffin-resolver/src/manifest.rs

@@ -1,4 +1,5 @@
 use pep508_rs::Requirement;
+use puffin_normalize::PackageName;
 
 use crate::prerelease_mode::PreReleaseMode;
 use crate::resolution_mode::ResolutionMode;
@@ -11,6 +12,7 @@ pub struct Manifest {
     pub(crate) preferences: Vec<Requirement>,
     pub(crate) resolution_mode: ResolutionMode,
     pub(crate) prerelease_mode: PreReleaseMode,
+    pub(crate) project: Option<PackageName>,
 }
 
 impl Manifest {
@@ -20,6 +22,7 @@ impl Manifest {
         preferences: Vec<Requirement>,
         resolution_mode: ResolutionMode,
         prerelease_mode: PreReleaseMode,
+        project: Option<PackageName>,
     ) -> Self {
         Self {
             requirements,
@@ -27,6 +30,7 @@ impl Manifest {
             preferences,
             resolution_mode,
             prerelease_mode,
+            project,
         }
     }
 }

crates/puffin-resolver/src/pubgrub/package.rs

@@ -13,7 +13,7 @@ use puffin_normalize::{ExtraName, PackageName};
 #[derive(Debug, Clone, Eq, Derivative)]
 #[derivative(PartialEq, Hash)]
 pub enum PubGrubPackage {
-    Root,
+    Root(Option<PackageName>),
     Package(
         PackageName,
         Option<ExtraName>,
@@ -27,7 +27,13 @@ pub enum PubGrubPackage {
 impl std::fmt::Display for PubGrubPackage {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            PubGrubPackage::Root => write!(f, "root"),
+            PubGrubPackage::Root(name) => {
+                if let Some(name) = name {
+                    write!(f, "{}", name.as_ref())
+                } else {
+                    write!(f, "root")
+                }
+            }
             PubGrubPackage::Package(name, None, ..) => write!(f, "{name}"),
             PubGrubPackage::Package(name, Some(extra), ..) => {
                 write!(f, "{name}[{extra}]")

crates/puffin-resolver/src/pubgrub/priority.rs

@@ -19,7 +19,7 @@ impl PubGrubPriorities {
     /// Return the priority of the given package, if it exists.
     pub(crate) fn get(&self, package: &PubGrubPackage) -> Option<PubGrubPriority> {
         match package {
-            PubGrubPackage::Root => Some(Reverse(0)),
+            PubGrubPackage::Root(_) => Some(Reverse(0)),
             PubGrubPackage::Package(name, _, _) => self
                 .0
                 .get(name)

crates/puffin-resolver/src/resolver.rs

@@ -37,6 +37,7 @@ use crate::pubgrub::{PubGrubPackage, PubGrubPriorities, PubGrubVersion, MIN_VERS
 use crate::resolution::Graph;
 
 pub struct Resolver<'a, Context: BuildContext + Sync> {
+    project: Option<PackageName>,
     requirements: Vec<Requirement>,
     constraints: Vec<Requirement>,
     markers: &'a MarkerEnvironment,
@@ -60,6 +61,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
         Self {
             selector: CandidateSelector::from(&manifest),
             index: Arc::new(Index::default()),
+            project: manifest.project,
             requirements: manifest.requirements,
             constraints: manifest.constraints,
             markers,
@@ -115,7 +117,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
         &self,
         request_sink: &futures::channel::mpsc::UnboundedSender<Request>,
     ) -> Result<Graph, ResolveError> {
-        let root = PubGrubPackage::Root;
+        let root = PubGrubPackage::Root(self.project.clone());
 
         // Keep track of the packages for which we've requested metadata.
         let mut in_flight = InFlight::default();
@@ -284,7 +286,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
         request_sink: &futures::channel::mpsc::UnboundedSender<Request>,
     ) -> Result<(), ResolveError> {
         match package {
-            PubGrubPackage::Root => {}
+            PubGrubPackage::Root(_) => {}
             PubGrubPackage::Package(package_name, _extra, None) => {
                 // Emit a request to fetch the metadata for this package.
                 if in_flight.insert_package(package_name) {
@@ -371,7 +373,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
         request_sink: &futures::channel::mpsc::UnboundedSender<Request>,
     ) -> Result<Option<PubGrubVersion>, ResolveError> {
         return match package {
-            PubGrubPackage::Root => Ok(Some(MIN_VERSION.clone())),
+            PubGrubPackage::Root(_) => Ok(Some(MIN_VERSION.clone())),
 
             PubGrubPackage::Package(package_name, _extra, Some(url)) => {
                 debug!("Searching for a compatible version of {package_name} @ {url} ({range})",);
@@ -461,7 +463,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
         request_sink: &futures::channel::mpsc::UnboundedSender<Request>,
     ) -> Result<Dependencies, ResolveError> {
         match package {
-            PubGrubPackage::Root => {
+            PubGrubPackage::Root(_) => {
                 let mut constraints =
                     DependencyConstraints::<PubGrubPackage, Range<PubGrubVersion>>::default();
 
@@ -754,7 +756,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
     fn on_progress(&self, package: &PubGrubPackage, version: &PubGrubVersion) {
         if let Some(reporter) = self.reporter.as_ref() {
             match package {
-                PubGrubPackage::Root => {}
+                PubGrubPackage::Root(_) => {}
                 PubGrubPackage::Package(package_name, extra, Some(url)) => {
                     reporter.on_progress(package_name, extra.as_ref(), VersionOrUrl::Url(url));
                 }

crates/puffin-resolver/tests/resolver.rs

@@ -70,6 +70,7 @@ async fn black() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -92,6 +93,7 @@ async fn black_colorama() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -114,6 +116,7 @@ async fn black_python_310() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_310, &TAGS_310, &client, &DummyContext);
@@ -138,6 +141,7 @@ async fn black_mypy_extensions() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -162,6 +166,7 @@ async fn black_mypy_extensions_extra() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -186,6 +191,7 @@ async fn black_flake8() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -208,6 +214,7 @@ async fn black_lowest() -> Result<()> {
         vec![],
         ResolutionMode::Lowest,
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -230,6 +237,7 @@ async fn black_lowest_direct() -> Result<()> {
         vec![],
         ResolutionMode::LowestDirect,
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -252,6 +260,7 @@ async fn black_respect_preference() -> Result<()> {
         vec![Requirement::from_str("black==23.9.0").unwrap()],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -274,6 +283,7 @@ async fn black_ignore_preference() -> Result<()> {
         vec![Requirement::from_str("black==23.9.2").unwrap()],
         ResolutionMode::default(),
         PreReleaseMode::default(),
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -296,6 +306,7 @@ async fn black_disallow_prerelease() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::Disallow,
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -318,6 +329,7 @@ async fn black_allow_prerelease_if_necessary() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::IfNecessary,
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -340,6 +352,7 @@ async fn pylint_disallow_prerelease() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::Disallow,
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -362,6 +375,7 @@ async fn pylint_allow_prerelease() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::Allow,
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -387,6 +401,7 @@ async fn pylint_allow_explicit_prerelease_without_marker() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::Explicit,
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);
@@ -412,6 +427,7 @@ async fn pylint_allow_explicit_prerelease_with_marker() -> Result<()> {
         vec![],
         ResolutionMode::default(),
         PreReleaseMode::Explicit,
+        None,
     );
 
     let resolver = Resolver::new(manifest, &MARKERS_311, &TAGS_311, &client, &DummyContext);