Update command for dependencies

Author: RogueMacro

src/commands/update.rs

@@ -1,6 +1,11 @@
 use std::path::Path;
 
-use crate::prelude::*;
+use crate::{
+    index,
+    lock::{self, Lock},
+    prelude::*,
+};
+use console::style;
 
 pub fn cli() -> App {
     App::new("update")
@@ -18,10 +23,91 @@ pub fn exec(args: &ArgMatches) -> Result<()> {
     if args.is_present("grill") {
         todo!()
     } else if args.is_present("index") {
-        crate::index::update(!args.is_present("quiet"), false)
+        index::update(!args.is_present("quiet"), false)
     } else {
-        crate::index::update(!args.is_present("quiet"), false)?;
-        crate::lock::generate(Path::new("."), true)?;
+        index::update(!args.is_present("quiet"), false)?;
+
+        let lock_path = Path::new(".").join(crate::paths::LOCK_FILENAME);
+        let old_lock = if lock_path.exists() {
+            Some(lock::read(lock_path)?)
+        } else {
+            None
+        };
+
+        let lock = lock::generate(Path::new("."), true, false)?;
+
+        if !args.is_present("quiet") {
+            if let Some(old_lock) = old_lock {
+                print_altered_deps(&old_lock, &lock);
+            } else {
+                for (dep, versions) in lock {
+                    for version in versions {
+                        println!(
+                            "{:>12} {} v{}",
+                            style("Added").bright().cyan(),
+                            dep,
+                            version
+                        );
+                    }
+                }
+            }
+        }
+
         Ok(())
     }
 }
+
+fn print_altered_deps(old_lock: &Lock, new_lock: &Lock) {
+    for (dep, versions) in new_lock {
+        for version in versions {
+            if old_lock.get(dep).map_or(true, |old_versions| {
+                !old_versions.iter().any(|v| v.major == version.major)
+            }) {
+                println!(
+                    "{:>12} {} v{}",
+                    style("Added").bright().cyan(),
+                    dep,
+                    version
+                );
+            }
+        }
+    }
+
+    for (dep, new_versions) in new_lock {
+        for new_version in new_versions {
+            if let Some(old_version) = old_lock.get(dep).and_then(|old_versions| {
+                if let Some(old_version) = old_versions
+                    .iter()
+                    .find(|&v| v.major == new_version.major && v != new_version)
+                {
+                    Some(old_version)
+                } else {
+                    None
+                }
+            }) {
+                println!(
+                    "{:>12} {} v{} -> v{}",
+                    style("Updated").bright().green(),
+                    dep,
+                    old_version,
+                    new_version
+                );
+            }
+        }
+    }
+
+    for (dep, versions) in old_lock {
+        for version in versions {
+            if !new_lock.get(dep).map_or(false, |new_versions| {
+                new_versions.iter().any(|v| v.major == version.major)
+            }) {
+                println!(
+                    "{:>12} {} v{}",
+                    style("Removed").bright().red(),
+                    dep,
+                    version
+                );
+            }
+        }
+    }
+}

src/index.rs

@@ -26,7 +26,7 @@ pub struct VersionMetadata {
 pub fn update(with_spinner: bool, clear_after: bool) -> Result<()> {
     log::trace!("Updating index");
 
-    rm_rf::ensure_removed(paths::tmp())?;
+    rm_rf::ensure_removed(paths::tmp()).context("Failed to remove tmp folder")?;
 
     let spinner = ProgressBar::new_spinner();
     if with_spinner {
@@ -37,8 +37,10 @@ pub fn update(with_spinner: bool, clear_after: bool) -> Result<()> {
         spinner.enable_steady_tick(Duration::from_millis(100));
     }
 
-    Repository::clone("https://github.com/RogueMacro/grill-index", paths::tmp())?;
-    fs::copy(paths::tmp().join("index.toml"), paths::index())?;
+    Repository::clone("https://github.com/RogueMacro/grill-index", paths::tmp())
+        .context("Failed to clone repository")?;
+    fs::copy(paths::tmp().join("index.toml"), paths::index())
+        .context("Failed to move index file")?;
 
     if with_spinner {
         if clear_after {

src/lock.rs

@@ -4,13 +4,39 @@ use std::{
     path::Path,
 };
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use semver::Version;
 
 use crate::{manifest::Manifest, resolver::resolve};
 
 pub type Lock = HashMap<String, HashSet<Version>>;
 
+pub fn read<P>(path: P) -> Result<Lock>
+where
+    P: AsRef<Path>,
+{
+    Ok(
+        toml::from_str(&fs::read_to_string(path.as_ref()).with_context(|| {
+            format!(
+                "Failed to read lock file: {}",
+                path.as_ref().to_string_lossy()
+            )
+        })?)
+        .context("Failed to deserialize lock file")?,
+    )
+}
+
+pub fn write<P>(path: P, lock: &Lock) -> Result<()>
+where
+    P: AsRef<Path>,
+{
+    Ok(fs::write(
+        path,
+        toml::to_string(lock).context("Failed to serialize lock")?,
+    )
+    .context("Failed to write lock file")?)
+}
+
 pub fn validate(pkg_path: &Path) -> Result<bool> {
     let manifest = Manifest::from_pkg(pkg_path)?;
 
@@ -19,44 +45,48 @@ pub fn validate(pkg_path: &Path) -> Result<bool> {
         return Ok(false);
     }
 
-    let lock: Lock = toml::from_str(&fs::read_to_string(file_path)?)?;
+    let lock: Lock = self::read(file_path)?;
     Ok(validate_lock(&manifest, &lock))
 }
 
-fn validate_lock<'a>(manifest: &Manifest, lock: &Lock) -> bool {
+fn validate_lock(manifest: &Manifest, lock: &Lock) -> bool {
     log::trace!("Validating lock");
 
-    if manifest.dependencies.len() != lock.len() {
-        log::trace!("Length doesn't match");
-        return false;
-    }
-
     for (dep, req) in manifest.simple_deps() {
         if !lock.get(dep).map_or(false, |locked_versions| {
             locked_versions.iter().any(|v| req.matches(v))
         }) {
-            log::trace!("No match for {} {} in lock", dep, req);
+            log::trace!("Invalid lock: No match for {} {}", dep, req);
             return false;
         }
     }
 
-    for (_, versions) in lock {
-        for v in versions.iter() {
-            if versions.iter().any(|v2| v.major == v2.major) {
-                return false;
+    for (dep, versions) in lock {
+        for v1 in versions.iter() {
+            for v2 in versions.iter() {
+                if v1.major == v2.major && v1 != v2 {
+                    log::trace!(
+                        "Invalid lock: {} v{} is incompatible with {} v{}",
+                        dep,
+                        v1,
+                        dep,
+                        v2
+                    );
+                    return false;
+                }
             }
         }
     }
 
     true
 }
 
-pub fn generate(pkg_path: &Path, write_lock: bool) -> Result<Lock> {
-    let manifest = Manifest::from_pkg(pkg_path)?;
+pub fn generate(pkg_path: &Path, write_lock: bool, try_keep_lock: bool) -> Result<Lock> {
+    let manifest = Manifest::from_pkg(pkg_path).context("Failed to read manifest")?;
 
     let lock_path = pkg_path.join(crate::paths::LOCK_FILENAME);
-    let previous_lock = if lock_path.exists() {
-        let lock = toml::from_str(&fs::read_to_string(lock_path)?)?;
+    let previous_lock = if try_keep_lock && lock_path.exists() {
+        let lock = self::read(lock_path)?;
         if validate_lock(&manifest, &lock) {
             Some(lock)
         } else {
@@ -68,12 +98,11 @@ pub fn generate(pkg_path: &Path, write_lock: bool) -> Result<Lock> {
 
     let index = crate::index::parse(false, false)?;
 
-    let resolved = resolve(&manifest, previous_lock.as_ref(), &index)?;
+    let lock = resolve(&manifest, previous_lock.as_ref(), &index)?;
 
     if write_lock {
-        let lock_file = toml::to_string(&resolved)?;
-        fs::write(pkg_path.join(crate::paths::LOCK_FILENAME), lock_file)?;
+        self::write(pkg_path.join(crate::paths::LOCK_FILENAME), &lock)?;
     }
 
-    Ok(resolved)
+    Ok(lock)
 }

src/main.rs

@@ -41,11 +41,15 @@ fn main() -> Result<()> {
 
     if let Err(err) = result {
         println!();
-        if let Some(source) = err.source() {
-            log::error!("{}\n\nCaused by:\n    {}", err, source);
-        } else {
-            log::error!("{}", err);
-        }
+
+        // if let Some(source) = err.source() {
+        //     log::error!("{}\n\nCaused by:\n    {}", err, source);
+        // } else {
+        //     log::error!("{}", err);
+        // }
+
+        log::error!("{}\n\nCaused by:\n    {}", err, err.root_cause());
+
         println!();
     }
 

src/ops/make.rs

@@ -5,17 +5,10 @@ use std::{
     time::Duration,
 };
 
-use anyhow::Context;
 use console::Emoji;
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 
-use crate::{
-    beef,
-    index::{self},
-    lock::{self, Lock},
-    manifest::Manifest,
-    prelude::*,
-};
+use crate::{beef, index, lock, manifest::Manifest, prelude::*};
 
 const COMPASS: Emoji = Emoji("🧭 ", "");
 const LOOKING_GLASS: Emoji = Emoji("🔍 ", "");
@@ -61,12 +54,9 @@ pub fn make(path: &Path, silent: bool) -> Result<()> {
         silent,
         |_, _| {
             if !lock::validate(&path)? {
-                lock::generate(&path, false)
+                lock::generate(&path, false, true)
             } else {
-                let lock: Lock =
-                    toml::from_str(&fs::read_to_string(path.join(crate::paths::LOCK_FILENAME))?)
-                        .context("Invalid lock")?;
-                Ok(lock)
+                lock::read(path.join(crate::paths::LOCK_FILENAME))
             }
         },
     )?;

src/resolver.rs

@@ -10,14 +10,10 @@ use crate::{
     manifest::{self, Manifest},
 };
 
-pub fn resolve(manifest: &Manifest, previous_lock: Option<&Lock>, index: &Index) -> Result<Lock> {
+pub fn resolve(manifest: &Manifest, lock: Option<&Lock>, index: &Index) -> Result<Lock> {
     log::trace!(
         "Resolving dependency tree{}",
-        if previous_lock.is_some() {
-            " with previous lock"
-        } else {
-            ""
-        }
+        if lock.is_some() { " with lock" } else { "" }
     );
 
     // Add the root dependencies.
@@ -26,7 +22,7 @@ pub fn resolve(manifest: &Manifest, previous_lock: Option<&Lock>, index: &Index)
         .iter()
         .filter_map(|(name, dep)| {
             if let manifest::Dependency::Simple(req) = dep {
-                Some(Candidate::new(name, req, index))
+                Some(Candidate::new(name, req, index, lock))
             } else {
                 None
             }
@@ -85,7 +81,7 @@ pub fn resolve(manifest: &Manifest, previous_lock: Option<&Lock>, index: &Index)
 
                 candidates.extend(
                     deps.iter()
-                        .map(|(dep, req)| Candidate::new(dep, req, index)),
+                        .map(|(dep, req)| Candidate::new(dep, req, index, lock)),
                 );
 
                 // "Commit" this candidate to the list of candidates.
@@ -111,7 +107,7 @@ pub fn resolve(manifest: &Manifest, previous_lock: Option<&Lock>, index: &Index)
                     // unset the version and make sure it is ready for
                     // picking another version.
                     candidates[i].version = None;
-                    candidates[i].update_available_versions(index);
+                    candidates[i].update_available_versions(index, lock);
                 }
 
                 i -= 1;
@@ -162,7 +158,7 @@ pub fn resolve(manifest: &Manifest, previous_lock: Option<&Lock>, index: &Index)
             candidates.extend(
                 missing_dependencies
                     .iter()
-                    .map(|(dep, req)| Candidate::new(dep, req, index)),
+                    .map(|(dep, req)| Candidate::new(dep, req, index, lock)),
             );
         }
     }
@@ -192,18 +188,18 @@ struct Candidate {
 }
 
 impl Candidate {
-    pub fn new(name: &str, req: &VersionReq, index: &Index) -> Self {
+    pub fn new(name: &str, req: &VersionReq, index: &Index, lock: Option<&Lock>) -> Self {
         let mut candidate = Self {
             name: name.to_owned(),
             req: req.clone(),
             version: None,
             available_versions: Vec::new(),
         };
-        candidate.update_available_versions(index);
+        candidate.update_available_versions(index, lock);
         candidate
     }
 
-    pub fn update_available_versions(&mut self, index: &Index) {
+    pub fn update_available_versions(&mut self, index: &Index, lock: Option<&Lock>) {
         self.available_versions.clear();
         if let Some(entry) = index.get(&self.name) {
             self.available_versions.extend(
@@ -215,6 +211,14 @@ impl Candidate {
                     .sorted_unstable_by(|v1, v2| v1.cmp(&v2)),
             );
         }
+
+        if let Some(version) = lock
+            .and_then(|lock| lock.get(&self.name))
+            .and_then(|locked_versions| locked_versions.iter().find(|&v| self.req.matches(v)))
+        {
+            // Push the locked version to the top so it gets tried first.
+            self.available_versions.push(version.clone());
+        }
     }
 }