Implement version resolution

Cargo.toml

@@ -40,22 +40,26 @@ validation = ["dep:anyhow", "dep:protobuf", "dep:protobuf-parse", "dep:diff-stru
 git = []
 
 [dependencies]
-async-recursion = "1.0.5"
 anyhow = { version = "1.0", optional = true }
+async-recursion = "1.0.5"
 bytes = "1.0"
 clap = { version = "4.3", features = ["cargo", "derive"] }
 diff-struct = { version = "0.5.3", optional = true }
 flate2 = "1"
+futures = "0.3"
 hex = "0.4.3"
 home = "0.5.5"
 human-panic = "1"
 miette = { version = "5.10.0", features = ["fancy"] }
 protobuf = { version = "3.3.0", optional = true }
 protobuf-parse = { version = "3.3.0", optional = true }
+pubgrub = "0.2"
 reqwest = { version = "0.11", features = ["rustls-tls-native-roots"], default-features = false }
 semver = { version = "1", features = ["serde"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+sha2 = "0.10.8"
+strum = { version = "0.26.2", features = ["derive"] }
 tar = "0.4"
 thiserror = "1.0.49"
 tokio = { version = "^1.26", features = ["fs", "rt", "macros", "process", "io-std", "tracing"] }
@@ -64,8 +68,6 @@ tracing = "0.1"
 tracing-subscriber = "0.3"
 url = { version = "2.4", features = ["serde"] }
 walkdir = "2"
-sha2 = "0.10.8"
-strum = { version = "0.26.2", features = ["derive"] }
 
 [dev-dependencies]
 assert_cmd = "2.0"

src/command.rs

@@ -13,16 +13,13 @@
 // limitations under the License.
 
 use crate::{
-    cache::Cache,
     credentials::Credentials,
-    lock::{LockedPackage, Lockfile},
+    lock::Lockfile,
     manifest::{Dependency, Manifest, PackageManifest, MANIFEST_FILE},
     package::{PackageName, PackageStore, PackageType},
     registry::{Artifactory, RegistryUri},
-    resolver::DependencyGraph,
 };
 
-use async_recursion::async_recursion;
 use miette::{bail, ensure, miette, Context as _, IntoDiagnostic};
 use semver::{Version, VersionReq};
 use std::{env, path::Path, str::FromStr};
@@ -293,10 +290,7 @@ pub async fn publish(
 /// Installs dependencies
 pub async fn install() -> miette::Result<()> {
     let manifest = Manifest::read().await?;
-    let lockfile = Lockfile::read_or_default().await?;
     let store = PackageStore::current().await?;
-    let credentials = Credentials::load().await?;
-    let cache = Cache::open().await?;
 
     store.clear().await?;
 
@@ -306,73 +300,9 @@ pub async fn install() -> miette::Result<()> {
         tracing::info!(":: installed {}@{}", pkg.name, pkg.version);
     }
 
-    let dependency_graph =
-        DependencyGraph::from_manifest(&manifest, &lockfile, &credentials.into(), &cache)
-            .await
-            .wrap_err(miette!("dependency resolution failed"))?;
-
-    let mut locked = Vec::new();
-
-    #[async_recursion]
-    async fn traverse_and_install(
-        name: &PackageName,
-        graph: &DependencyGraph,
-        store: &PackageStore,
-        locked: &mut Vec<LockedPackage>,
-        prefix: String,
-    ) -> miette::Result<()> {
-        let resolved = graph.get(name).ok_or(miette!(
-            "unexpected error: missing dependency in dependency graph"
-        ))?;
-
-        store.unpack(&resolved.package).await.wrap_err(miette!(
-            "failed to unpack package {}",
-            &resolved.package.name()
-        ))?;
-
-        tracing::info!(
-            "{} installed {}@{}",
-            if prefix.is_empty() { "::" } else { &prefix },
-            name,
-            resolved.package.version()
-        );
-
-        locked.push(resolved.package.lock(
-            resolved.registry.clone(),
-            resolved.repository.clone(),
-            resolved.dependants.len(),
-        ));
-
-        for (index, dependency) in resolved.depends_on.iter().enumerate() {
-            let tree_char = if index + 1 == resolved.depends_on.len() {
-                '┗'
-            } else {
-                '┣'
-            };
-
-            let new_prefix = format!(
-                "{} {tree_char}",
-                if prefix.is_empty() { "  " } else { &prefix }
-            );
-
-            traverse_and_install(dependency, graph, store, locked, new_prefix).await?;
-        }
+    //Lockfile::from_iter(locked.into_iter()).write().await
 
-        Ok(())
-    }
-
-    for dependency in manifest.dependencies {
-        traverse_and_install(
-            &dependency.package,
-            &dependency_graph,
-            &store,
-            &mut locked,
-            String::new(),
-        )
-        .await?;
-    }
-
-    Lockfile::from_iter(locked.into_iter()).write().await
+    Ok(())
 }
 
 /// Uninstalls dependencies

src/lock.rs

@@ -51,20 +51,11 @@ pub struct LockedPackage {
     pub version: Version,
     /// Names of dependency packages
     pub dependencies: Vec<PackageName>,
-    /// Count of dependant packages in the current graph
-    ///
-    /// This is used to detect when an entry can be safely removed from the lockfile.
-    pub dependants: usize,
 }
 
 impl LockedPackage {
     /// Captures the source, version and checksum of a Package for use in reproducible installs
-    pub fn lock(
-        package: &Package,
-        registry: RegistryUri,
-        repository: String,
-        dependants: usize,
-    ) -> Self {
+    pub fn lock(package: &Package, registry: RegistryUri, repository: String) -> Self {
         Self {
             name: package.name().to_owned(),
             registry,
@@ -77,7 +68,6 @@ impl LockedPackage {
                 .iter()
                 .map(|d| d.package.clone())
                 .collect(),
-            dependants,
         }
     }
 

src/package/compressed.rs

@@ -222,13 +222,8 @@ impl Package {
     }
 
     /// Lock this package
-    pub fn lock(
-        &self,
-        registry: RegistryUri,
-        repository: String,
-        dependants: usize,
-    ) -> LockedPackage {
-        LockedPackage::lock(self, registry, repository, dependants)
+    pub fn lock(&self, registry: RegistryUri, repository: String) -> LockedPackage {
+        LockedPackage::lock(self, registry, repository)
     }
 }