Define Registry trait

Author: mkaput

murek/src/core/registry/cache.rs

@@ -1,26 +1,31 @@
 use anyhow::Result;
+use async_trait::async_trait;
 
+use crate::core::registry::source_map::SourceMap;
 use crate::core::registry::Registry;
 use crate::core::{ManifestDependency, Package, PackageId, Summary};
 
 // TODO(mkaput): Really implement what is promised here.
-/// A caching wrapper over [`Registry`] which memorizes all queries and downloads.
+/// A caching wrapper over another [`Registry`] which memorizes all queries and downloads.
 pub struct RegistryCache<'c> {
-    registry: Registry<'c>,
+    registry: SourceMap<'c>,
 }
 
 impl<'c> RegistryCache<'c> {
-    pub fn new(registry: Registry<'c>) -> Self {
+    pub fn new(registry: SourceMap<'c>) -> Self {
         Self { registry }
     }
+}
 
+#[async_trait(?Send)]
+impl<'c> Registry for RegistryCache<'c> {
     /// Attempt to find the packages that match dependency request.
-    pub async fn query(&mut self, dependency: &ManifestDependency) -> Result<Vec<Summary>> {
+    async fn query(&mut self, dependency: &ManifestDependency) -> Result<Vec<Summary>> {
         self.registry.query(dependency).await
     }
 
     /// Fetch full package by its ID.
-    pub async fn download(&mut self, package_id: PackageId) -> Result<Package> {
+    async fn download(&mut self, package_id: PackageId) -> Result<Package> {
         self.registry.download(package_id).await
     }
 }

murek/src/core/registry/mod.rs

@@ -1,71 +1,16 @@
-use std::collections::HashMap;
-use std::ops::DerefMut;
-
 use anyhow::Result;
-use itertools::Itertools;
-use tracing::trace;
+use async_trait::async_trait;
 
-use crate::core::source::Source;
-#[cfg(doc)]
-use crate::core::Workspace;
-use crate::core::{Config, ManifestDependency, Package, PackageId, SourceId, Summary};
-use crate::sources::PathSource;
+use crate::core::{ManifestDependency, Package, PackageId, Summary};
 
 pub mod cache;
+pub mod source_map;
 
-/// Source of information about a group of packages.
-pub struct Registry<'c> {
-    config: &'c Config,
-    sources: HashMap<SourceId, Box<dyn Source + 'c>>,
-}
-
-impl<'c> Registry<'c> {
-    /// Preload the registry with already loaded [`Package`]s.
-    ///
-    /// For example, a [`Workspace`] may load packages during construction/parsing/early phases
-    /// for various operations, and this preload step avoids doubly-loading and
-    /// parsing packages on the filesystem by inserting them all into the registry
-    /// with their in-memory formats.
-    pub fn preloaded(packages: impl Iterator<Item = Package>, config: &'c Config) -> Self {
-        let sources = packages
-            .sorted_by_key(|pkg| pkg.id.source_id)
-            .group_by(|pkg| pkg.id.source_id);
-        let sources = sources.into_iter().map(|(source_id, packages)| {
-            let packages = packages.collect::<Vec<_>>();
-            let source = PathSource::preloaded(&packages, config);
-            let source: Box<dyn Source + 'c> = Box::new(source);
-            (source_id, source)
-        });
-        let sources = HashMap::from_iter(sources);
-
-        Self { config, sources }
-    }
-
-    fn ensure_loaded(&mut self, source_id: SourceId) -> Result<&mut (dyn Source + 'c)> {
-        // We can't use Entry API here because `load` usage of &self conflicts with it.
-        #[allow(clippy::map_entry)]
-        if !self.sources.contains_key(&source_id) {
-            let source = self.load(source_id)?;
-            self.sources.insert(source_id, source);
-        }
-
-        Ok(self.sources.get_mut(&source_id).unwrap().deref_mut())
-    }
-
-    fn load(&self, source_id: SourceId) -> Result<Box<dyn Source + 'c>> {
-        trace!("loading source: {source_id}");
-        source_id.load(self.config)
-    }
-
+#[async_trait(?Send)]
+pub trait Registry {
     /// Attempt to find the packages that match a dependency request.
-    pub async fn query(&mut self, dependency: &ManifestDependency) -> Result<Vec<Summary>> {
-        let source = self.ensure_loaded(dependency.source_id)?;
-        source.query(dependency).await
-    }
+    async fn query(&mut self, dependency: &ManifestDependency) -> Result<Vec<Summary>>;
 
     /// Fetch full package by its ID.
-    pub async fn download(&mut self, package_id: PackageId) -> Result<Package> {
-        let source = self.ensure_loaded(package_id.source_id)?;
-        source.download(package_id).await
-    }
+    async fn download(&mut self, package_id: PackageId) -> Result<Package>;
 }

murek/src/core/registry/source_map.rs

@@ -0,0 +1,74 @@
+use std::collections::HashMap;
+use std::ops::DerefMut;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use itertools::Itertools;
+use tracing::trace;
+
+use crate::core::registry::Registry;
+use crate::core::source::Source;
+#[cfg(doc)]
+use crate::core::Workspace;
+use crate::core::{Config, ManifestDependency, Package, PackageId, SourceId, Summary};
+use crate::sources::PathSource;
+
+/// Source of information about a group of packages.
+pub struct SourceMap<'c> {
+    config: &'c Config,
+    sources: HashMap<SourceId, Box<dyn Source + 'c>>,
+}
+
+impl<'c> SourceMap<'c> {
+    /// Preload the registry with already loaded [`Package`]s.
+    ///
+    /// For example, a [`Workspace`] may load packages during construction/parsing/early phases
+    /// for various operations, and this preload step avoids doubly-loading and
+    /// parsing packages on the filesystem by inserting them all into the registry
+    /// with their in-memory formats.
+    pub fn preloaded(packages: impl Iterator<Item = Package>, config: &'c Config) -> Self {
+        let sources = packages
+            .sorted_by_key(|pkg| pkg.id.source_id)
+            .group_by(|pkg| pkg.id.source_id);
+        let sources = sources.into_iter().map(|(source_id, packages)| {
+            let packages = packages.collect::<Vec<_>>();
+            let source = PathSource::preloaded(&packages, config);
+            let source: Box<dyn Source + 'c> = Box::new(source);
+            (source_id, source)
+        });
+        let sources = HashMap::from_iter(sources);
+
+        Self { config, sources }
+    }
+
+    fn ensure_loaded(&mut self, source_id: SourceId) -> Result<&mut (dyn Source + 'c)> {
+        // We can't use Entry API here because `load` usage of &self conflicts with it.
+        #[allow(clippy::map_entry)]
+        if !self.sources.contains_key(&source_id) {
+            let source = self.load(source_id)?;
+            self.sources.insert(source_id, source);
+        }
+
+        Ok(self.sources.get_mut(&source_id).unwrap().deref_mut())
+    }
+
+    fn load(&self, source_id: SourceId) -> Result<Box<dyn Source + 'c>> {
+        trace!("loading source: {source_id}");
+        source_id.load(self.config)
+    }
+}
+
+#[async_trait(?Send)]
+impl<'c> Registry for SourceMap<'c> {
+    /// Attempt to find the packages that match a dependency request.
+    async fn query(&mut self, dependency: &ManifestDependency) -> Result<Vec<Summary>> {
+        let source = self.ensure_loaded(dependency.source_id)?;
+        source.query(dependency).await
+    }
+
+    /// Fetch full package by its ID.
+    async fn download(&mut self, package_id: PackageId) -> Result<Package> {
+        let source = self.ensure_loaded(package_id.source_id)?;
+        source.download(package_id).await
+    }
+}

murek/src/ops/resolve.rs

@@ -5,6 +5,7 @@ use anyhow::Result;
 use crate::core::package::{Package, PackageId};
 use crate::core::registry::cache::RegistryCache;
 use crate::core::registry::Registry;
+use crate::core::registry::source_map::SourceMap;
 use crate::core::resolver::Resolve;
 use crate::core::workspace::Workspace;
 use crate::internal::asyncx::AwaitSync;
@@ -23,8 +24,8 @@ pub struct WorkspaceResolution {
 )]
 pub fn resolve_workspace(ws: &Workspace<'_>) -> Result<WorkspaceResolution> {
     async {
-        let registry = Registry::preloaded(ws.members(), ws.config());
-        let mut registry_cache = RegistryCache::new(registry);
+        let source_map = SourceMap::preloaded(ws.members(), ws.config());
+        let mut registry_cache = RegistryCache::new(source_map);
 
         let members_summaries = ws
             .members()

murek/src/resolver/mod.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use anyhow::{anyhow, Result};
 use petgraph::graphmap::DiGraphMap;
 
-use crate::core::registry::cache::RegistryCache;
+use crate::core::registry::Registry;
 use crate::core::resolver::Resolve;
 use crate::core::{Config, PackageId, Summary};
 
@@ -18,12 +18,14 @@ use crate::core::{Config, PackageId, Summary};
 /// * `registry` - this is the source from which all package summaries are loaded.
 ///     It is expected that this is extensively configured ahead of time and is idempotent with
 ///     our requests to it (aka returns the same results for the same query every time).
+///     It is also advised to implement internal caching, as the resolver may frequently ask
+///     repetitive queries.
 ///
 /// * `config` - [`Config`] object.
 #[tracing::instrument(level = "trace", skip_all)]
 pub async fn resolve(
     summaries: &[Summary],
-    registry: &mut RegistryCache<'_>,
+    registry: &mut dyn Registry,
     _config: &Config,
 ) -> Result<Resolve> {
     let mut graph = DiGraphMap::new();