Report all version changes

Author: lpil

compiler-cli/src/add.rs

@@ -27,7 +27,7 @@ pub fn command(paths: &ProjectPaths, packages_to_add: Vec<String>, dev: bool) ->
 
     // Insert the new packages into the manifest and perform dependency
     // resolution to determine suitable versions
-    let manifest = dependencies::download(
+    let manifest = dependencies::resolve_and_download(
         paths,
         cli::Reporter::new(),
         Some((new_package_requirements.clone(), dev)),
@@ -84,8 +84,6 @@ pub fn command(paths: &ProjectPaths, packages_to_add: Vec<String>, dev: bool) ->
                 .as_inline_table_mut()
                 .expect("Invalid manifest format")["version"] = range.into();
         }
-
-        cli::print_added(&format!("{added_package} v{version}"));
     }
 
     // Write the updated config

compiler-cli/src/build.rs

@@ -15,7 +15,7 @@ use crate::{
 };
 
 pub fn download_dependencies(paths: &ProjectPaths, telemetry: impl Telemetry) -> Result<Manifest> {
-    dependencies::download(
+    dependencies::resolve_and_download(
         paths,
         telemetry,
         None,

compiler-cli/src/cli.rs

@@ -1,6 +1,7 @@
 use gleam_core::{
     build::Telemetry,
     error::{Error, StandardIoAction},
+    manifest::Resolved,
 };
 use hexpm::version::Version;
 use std::{
@@ -54,6 +55,10 @@ impl Telemetry for Reporter {
     fn waiting_for_build_directory_lock(&self) {
         print_waiting_for_build_directory_lock()
     }
+
+    fn resolved_package_versions(&self, resolved: &Resolved) {
+        print_resolved(resolved)
+    }
 }
 
 pub fn ask(question: &str) -> Result<String, Error> {
@@ -148,11 +153,27 @@ pub(crate) fn print_running(text: &str) {
     print_colourful_prefix("Running", text)
 }
 
-pub(crate) fn print_added(text: &str) {
+pub(crate) fn print_resolved(resolved: &Resolved) {
+    for (name, version) in &resolved.added {
+        print_added(&format!("{name} v{version}"));
+    }
+    for (name, old, new) in &resolved.changed {
+        print_changed(&format!("{name} v{old} -> v{new}"));
+    }
+    for name in &resolved.removed {
+        print_removed(name);
+    }
+}
+
+fn print_added(text: &str) {
     print_colourful_prefix("Added", text)
 }
 
-pub(crate) fn print_removed(text: &str) {
+fn print_changed(text: &str) {
+    print_colourful_prefix("Changed", text)
+}
+
+fn print_removed(text: &str) {
     print_colourful_prefix("Removed", text)
 }
 

compiler-cli/src/dependencies.rs

@@ -19,7 +19,7 @@ use gleam_core::{
     error::{FileIoAction, FileKind, ShellCommandFailureReason, StandardIoAction},
     hex::{self, HEXPM_PUBLIC_KEY},
     io::{HttpClient as _, TarUnpacker, WrappedReader},
-    manifest::{Base16Checksum, Manifest, ManifestPackage, ManifestPackageSource},
+    manifest::{Base16Checksum, Manifest, ManifestPackage, ManifestPackageSource, Resolved},
     paths::ProjectPaths,
     requirement::Requirement,
 };
@@ -228,7 +228,7 @@ pub fn update(paths: &ProjectPaths, packages: Vec<String>) -> Result<()> {
     };
 
     // Update specific packages
-    _ = download(
+    _ = resolve_and_download(
         paths,
         cli::Reporter::new(),
         None,
@@ -257,7 +257,8 @@ pub fn cleanup<Telem: Telemetry>(paths: &ProjectPaths, telemetry: Telem) -> Resu
 
     // Read the project config
     let config = crate::root_config(paths)?;
-    let mut manifest = read_manifest_from_disc(paths)?;
+    let old_manifest = read_manifest_from_disc(paths)?;
+    let mut manifest = old_manifest.clone();
 
     remove_extra_requirements(&config, &mut manifest)?;
 
@@ -270,7 +271,10 @@ pub fn cleanup<Telem: Telemetry>(paths: &ProjectPaths, telemetry: Telem) -> Resu
     write_manifest_to_disc(paths, &manifest)?;
     LocalPackages::from_manifest(&manifest).write_to_disc(paths)?;
 
-    Ok(manifest)
+    let resolved = Resolved::with_updates(&old_manifest, manifest);
+    telemetry.resolved_package_versions(&resolved);
+
+    Ok(resolved.manifest)
 }
 
 /// Remove requirements and unneeded packages from manifest that are no longer present in config.
@@ -367,7 +371,7 @@ pub fn parse_gleam_add_specifier(package: &str) -> Result<(EcoString, Requiremen
     Ok((package.into(), requirement))
 }
 
-pub fn download<Telem: Telemetry>(
+pub fn resolve_and_download<Telem: Telemetry>(
     paths: &ProjectPaths,
     telemetry: Telem,
     new_package: Option<(Vec<(EcoString, Requirement)>, bool)>,
@@ -385,7 +389,7 @@ pub fn download<Telem: Telemetry>(
         Mode::Dev,
     );
 
-    dependency_manager.download(paths, new_package, packages_to_update)
+    dependency_manager.resolve_and_download_versions(paths, new_package, packages_to_update)
 }
 
 fn pretty_print_major_versions_available(versions: dependency::PackageVersionDiffs) -> String {

compiler-cli/src/dependencies/dependency_manager.rs

@@ -1,16 +1,15 @@
-use std::collections::HashMap;
-
 use ecow::EcoString;
 use futures::future;
 use gleam_core::{
     Error, Result,
     build::{Mode, Telemetry},
     config::PackageConfig,
     dependency,
-    manifest::Manifest,
+    manifest::{Manifest, Resolved},
     paths::ProjectPaths,
     requirement::Requirement,
 };
+use std::collections::HashMap;
 
 use crate::{
     build_lock::BuildLock,
@@ -54,23 +53,6 @@ impl DependencyManagerConfig {
     }
 }
 
-pub struct Resolved {
-    pub manifest: Manifest,
-    pub versions_changed: bool,
-}
-
-impl Resolved {
-    /// Create a `Resolved`, comparing the old and new versions of the manifest to work out
-    /// if resolution resulted in any changes.
-    pub fn with_updates(old: &Manifest, new: Manifest) -> Self {
-        let versions_changed = old.packages != new.packages;
-        Self {
-            manifest: new,
-            versions_changed,
-        }
-    }
-}
-
 pub struct DependencyManager<Telem, P> {
     runtime: tokio::runtime::Handle,
     package_fetcher: P,
@@ -99,10 +81,7 @@ where
         if !paths.manifest().exists() {
             tracing::debug!("manifest_not_present");
             let manifest = self.perform_version_resolution(paths, config, None, Vec::new())?;
-            return Ok(Resolved {
-                manifest,
-                versions_changed: true,
-            });
+            return Ok(Resolved::add_added(manifest));
         }
 
         let existing_manifest = read_manifest_from_disc(paths)?;
@@ -121,10 +100,7 @@ where
                         paths.root(),
                     )?
                 {
-                    return Ok(Resolved {
-                        manifest: existing_manifest,
-                        versions_changed: false,
-                    });
+                    return Ok(Resolved::no_change(existing_manifest));
                 }
 
                 // Otherwise, use the manifest to inform resolution.
@@ -142,7 +118,7 @@ where
         Ok(Resolved::with_updates(&existing_manifest, new_manifest))
     }
 
-    pub fn download(
+    pub fn resolve_and_download_versions(
         &self,
         paths: &ProjectPaths,
         new_package: Option<(Vec<(EcoString, Requirement)>, bool)>,
@@ -176,36 +152,35 @@ where
         }
 
         // Determine what versions we need
-        let Resolved {
-            manifest,
-            versions_changed: manifest_updated,
-        } = self.resolve_versions(paths, &config, packages_to_update)?;
+        let resolved = self.resolve_versions(paths, &config, packages_to_update)?;
         let local = LocalPackages::read_from_disc(paths)?;
 
         // Remove any packages that are no longer required due to gleam.toml changes
-        remove_extra_packages(paths, &local, &manifest, &self.telemetry)?;
+        remove_extra_packages(paths, &local, &resolved.manifest, &self.telemetry)?;
 
         // Download them from Hex to the local cache
         self.runtime.block_on(add_missing_packages(
             paths,
             fs,
-            &manifest,
+            &resolved.manifest,
             &local,
             project_name,
             &self.telemetry,
         ))?;
 
-        if manifest_updated {
+        if resolved.any_changes() {
             // Record new state of the packages directory
             // TODO: test
             tracing::debug!("writing_manifest_toml");
-            write_manifest_to_disc(paths, &manifest)?;
+            write_manifest_to_disc(paths, &resolved.manifest)?;
         }
-        LocalPackages::from_manifest(&manifest).write_to_disc(paths)?;
+        LocalPackages::from_manifest(&resolved.manifest).write_to_disc(paths)?;
 
         if let CheckMajorVersions::Yes = self.check_major_versions {
-            let major_versions_available =
-                dependency::check_for_major_version_updates(&manifest, &self.package_fetcher);
+            let major_versions_available = dependency::check_for_major_version_updates(
+                &resolved.manifest,
+                &self.package_fetcher,
+            );
             if !major_versions_available.is_empty() {
                 eprintln!(
                     "{}",
@@ -214,7 +189,8 @@ where
             }
         }
 
-        Ok(manifest)
+        self.telemetry.resolved_package_versions(&resolved);
+        Ok(resolved.manifest)
     }
 
     fn perform_version_resolution(

compiler-cli/src/fs.rs

@@ -246,7 +246,7 @@ impl MakeLocker for ProjectIO {
 
 impl DownloadDependencies for ProjectIO {
     fn download_dependencies(&self, paths: &ProjectPaths) -> Result<Manifest> {
-        dependencies::download(
+        dependencies::resolve_and_download(
             paths,
             NullTelemetry,
             None,

compiler-cli/src/lib.rs

@@ -774,7 +774,7 @@ fn project_paths_at_current_directory_without_toml() -> ProjectPaths {
 }
 
 fn download_dependencies(paths: &ProjectPaths) -> Result<()> {
-    _ = dependencies::download(
+    _ = dependencies::resolve_and_download(
         paths,
         cli::Reporter::new(),
         None,

compiler-cli/src/remove.rs

@@ -46,9 +46,5 @@ pub fn command(paths: &ProjectPaths, packages: Vec<String>) -> Result<()> {
     fs::write(root_config.as_path(), &toml.to_string())?;
     _ = crate::dependencies::cleanup(paths, cli::Reporter::new())?;
 
-    for package_to_remove in packages {
-        cli::print_removed(&package_to_remove);
-    }
-
     Ok(())
 }

compiler-core/src/build/telemetry.rs

@@ -3,12 +3,13 @@ use std::{
     time::{Duration, Instant},
 };
 
-use crate::Warning;
+use crate::{Warning, manifest::Resolved};
 
 pub trait Telemetry: Debug {
     fn waiting_for_build_directory_lock(&self);
     fn running(&self, name: &str);
     fn resolving_package_versions(&self);
+    fn resolved_package_versions(&self, resolved: &Resolved);
     fn downloading_package(&self, name: &str);
     fn packages_downloaded(&self, start: Instant, count: usize);
     fn compiled_package(&self, duration: Duration);
@@ -30,4 +31,5 @@ impl Telemetry for NullTelemetry {
     fn checked_package(&self, _duration: Duration) {}
     fn checking_package(&self, _name: &str) {}
     fn packages_downloaded(&self, _start: Instant, _count: usize) {}
+    fn resolved_package_versions(&self, _resolved: &Resolved) {}
 }