Re-export from PubGrub module (#226)

crates/puffin-resolver/src/candidate_selector.rs

@@ -6,7 +6,7 @@ use puffin_package::package_name::PackageName;
 
 use crate::distribution::DistributionFile;
 use crate::prerelease_mode::PreReleaseStrategy;
-use crate::pubgrub::version::PubGrubVersion;
+use crate::pubgrub::PubGrubVersion;
 use crate::resolution_mode::ResolutionStrategy;
 use crate::resolver::VersionMap;
 use crate::Manifest;

crates/puffin-resolver/src/error.rs

@@ -3,8 +3,7 @@ use thiserror::Error;
 
 use pep508_rs::Requirement;
 
-use crate::pubgrub::package::PubGrubPackage;
-use crate::pubgrub::version::PubGrubVersion;
+use crate::pubgrub::{PubGrubPackage, PubGrubVersion};
 
 #[derive(Error, Debug)]
 pub enum ResolveError {

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

@@ -5,14 +5,15 @@ use pep508_rs::{MarkerEnvironment, Requirement};
 use puffin_package::dist_info_name::DistInfoName;
 use puffin_package::package_name::PackageName;
 
-use crate::pubgrub::package::PubGrubPackage;
-use crate::pubgrub::specifier::PubGrubSpecifier;
-use crate::pubgrub::version::{PubGrubVersion, MAX_VERSION};
+pub(crate) use crate::pubgrub::package::PubGrubPackage;
+pub(crate) use crate::pubgrub::priority::{PubGrubPriorities, PubGrubPriority};
+pub(crate) use crate::pubgrub::specifier::PubGrubSpecifier;
+pub(crate) use crate::pubgrub::version::{PubGrubVersion, MAX_VERSION, MIN_VERSION};
 
-pub(crate) mod package;
-pub(crate) mod priority;
+mod package;
+mod priority;
 mod specifier;
-pub(crate) mod version;
+mod version;
 
 /// Convert a set of requirements to a set of `PubGrub` packages and ranges.
 pub(crate) fn iter_requirements<'a>(

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

@@ -1,3 +1,30 @@
+use crate::pubgrub::package::PubGrubPackage;
+use fxhash::FxHashMap;
+use puffin_package::package_name::PackageName;
 use std::cmp::Reverse;
 
+#[derive(Debug, Default)]
+pub(crate) struct PubGrubPriorities(FxHashMap<PackageName, usize>);
+
+impl PubGrubPriorities {
+    /// Add a package to the priority map.
+    pub(crate) fn add(&mut self, package: PackageName) {
+        let priority = self.0.len();
+        self.0.entry(package).or_insert(priority);
+    }
+
+    /// 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::Package(name, _) => self
+                .0
+                .get(name)
+                .copied()
+                .map(|priority| priority + 1)
+                .map(Reverse),
+        }
+    }
+}
+
 pub(crate) type PubGrubPriority = Reverse<usize>;

crates/puffin-resolver/src/resolution.rs

@@ -12,9 +12,7 @@ use pep508_rs::{Requirement, VersionOrUrl};
 use puffin_client::File;
 use puffin_package::package_name::PackageName;
 
-use crate::pubgrub::package::PubGrubPackage;
-use crate::pubgrub::priority::PubGrubPriority;
-use crate::pubgrub::version::PubGrubVersion;
+use crate::pubgrub::{PubGrubPackage, PubGrubPriority, PubGrubVersion};
 
 /// A package pinned at a specific version.
 #[derive(Debug)]

crates/puffin-resolver/src/resolver.rs

@@ -1,6 +1,5 @@
 //! Given a set of requirements, find a set of compatible packages.
 
-use std::cmp::Reverse;
 use std::collections::hash_map::Entry;
 use std::collections::BTreeMap;
 use std::future::Future;
@@ -33,10 +32,8 @@ use crate::candidate_selector::CandidateSelector;
 use crate::distribution::{DistributionFile, SdistFile, WheelFile};
 use crate::error::ResolveError;
 use crate::manifest::Manifest;
-use crate::pubgrub::package::PubGrubPackage;
-use crate::pubgrub::priority::PubGrubPriority;
-use crate::pubgrub::version::{PubGrubVersion, MIN_VERSION};
 use crate::pubgrub::{iter_requirements, version_range};
+use crate::pubgrub::{PubGrubPackage, PubGrubPriorities, PubGrubVersion, MIN_VERSION};
 use crate::resolution::Graph;
 use crate::source_distribution::{download_and_build_sdist, read_dist_info};
 use crate::BuiltSourceDistributionCache;
@@ -53,28 +50,6 @@ pub struct Resolver<'a, Context: BuildContext + Sync> {
     reporter: Option<Box<dyn Reporter>>,
 }
 
-#[derive(Debug, Default)]
-struct Priorities(FxHashMap<PackageName, usize>);
-
-impl Priorities {
-    fn add(&mut self, package: PackageName) {
-        let priority = self.0.len();
-        self.0.entry(package).or_insert(priority);
-    }
-
-    fn get(&self, package: &PubGrubPackage) -> Option<PubGrubPriority> {
-        match package {
-            PubGrubPackage::Root => Some(Reverse(0)),
-            PubGrubPackage::Package(name, _) => self
-                .0
-                .get(name)
-                .copied()
-                .map(|priority| priority + 1)
-                .map(Reverse),
-        }
-    }
-}
-
 impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
     /// Initialize a new resolver.
     pub fn new(
@@ -148,7 +123,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
         let mut requested_packages = FxHashSet::default();
         let mut requested_versions = FxHashSet::default();
         let mut pins = FxHashMap::default();
-        let mut priorities = Priorities::default();
+        let mut priorities = PubGrubPriorities::default();
 
         // Push all the requirements into the package sink.
         for requirement in &self.requirements {
@@ -404,7 +379,7 @@ impl<'a, Context: BuildContext + Sync> Resolver<'a, Context> {
         package: &PubGrubPackage,
         version: &PubGrubVersion,
         pins: &mut FxHashMap<PackageName, FxHashMap<pep440_rs::Version, File>>,
-        priorities: &mut Priorities,
+        priorities: &mut PubGrubPriorities,
         requested_packages: &mut FxHashSet<PackageName>,
         request_sink: &futures::channel::mpsc::UnboundedSender<Request>,
     ) -> Result<Dependencies, ResolveError> {