forge/cmd/

update.rs

use crate::{DepIdentifier, DepMap, Lockfile};
use alloy_primitives::map::HashMap;
use clap::{Parser, ValueHint};
use eyre::{Context, Result};
use foundry_cli::{
    opts::Dependency,
    utils::{Git, LoadConfig},
};
use foundry_common::fs::canonicalize_path;
use foundry_config::{Config, impl_figment_convert_basic};
use std::path::{Path, PathBuf};
use yansi::Paint;

/// CLI arguments for `forge update`.
#[derive(Clone, Debug, Parser)]
pub struct UpdateArgs {
    /// The dependencies you want to update.
    dependencies: Vec<Dependency>,

    /// The project's root path.
    ///
    /// By default root of the Git repository, if in one,
    /// or the current working directory.
    #[arg(long, value_hint = ValueHint::DirPath, value_name = "PATH")]
    root: Option<PathBuf>,

    /// Override the up-to-date check.
    #[arg(short, long)]
    force: bool,

    /// Recursively update submodules.
    #[arg(short, long)]
    recursive: bool,
}
impl_figment_convert_basic!(UpdateArgs);

impl UpdateArgs {
    pub fn run(self) -> Result<()> {
        let config = self.load_config()?;
        // dep_overrides consists of absolute paths of dependencies and their tags
        let (root, paths, dep_overrides) = dependencies_paths(&self.dependencies, &config)?;
        // Mapping of relative path of lib to its tag type
        // e.g "lib/forge-std" -> DepIdentifier::Tag { name: "v0.1.0", rev: "1234567" }
        let git = Git::new(&root);

        let mut foundry_lock = Lockfile::new(&config.root).with_git(&git);
        let out_of_sync_deps = foundry_lock.sync(config.install_lib_dir())?;
        let submodules = git.submodules_in(Path::new(""))?;
        if let Some(path) = foundry_lock
            .iter()
            .map(|(path, _)| path)
            .filter(|path| !submodules.iter().any(|submodule| submodule.path() == *path))
            .min()
        {
            eyre::bail!(
                "foundry.lock entry `{}` does not match an installed Git submodule",
                path.display()
            );
        }

        // Update selected branches without an explicit ref override.
        for (path, dep_id) in foundry_lock.iter_mut() {
            if dep_id.is_branch()
                && (paths.is_empty() || paths.contains(path))
                && !dep_overrides.contains_key(&root.join(path))
            {
                dep_id.mark_override();
            }
        }

        // Update the submodules' tags if any overrides are present.
        let mut prev_dep_ids: DepMap = HashMap::default();
        for (dep_path, override_tag) in &dep_overrides {
            let rel_path = dep_path
                .strip_prefix(&root)
                .wrap_err("Dependency path is not relative to the repository root")?;

            // Resolve every override before changing dependency worktrees or the lockfile.
            let mut dep_id = (|| -> Result<DepIdentifier> {
                let dependency_git = git.root(dep_path);
                let canonical_root = canonicalize_path(&root)?;
                if !dunce::canonicalize(dep_path).is_ok_and(|path| {
                    path.starts_with(&canonical_root)
                        && dependency_git.is_repo_root().unwrap_or(false)
                }) {
                    eyre::bail!(
                        "Dependency at `{}` is not an initialized Git submodule worktree",
                        rel_path.display()
                    );
                }
                let resolve = || -> Result<DepIdentifier> {
                    let remote_branch = format!("origin/{override_tag}");
                    if !git.has_tag(override_tag, dep_path)?
                        && dependency_git
                            .remote_branches()?
                            .lines()
                            .any(|branch| branch.trim() == remote_branch)
                    {
                        return Ok(DepIdentifier::Branch {
                            name: override_tag.clone(),
                            rev: git.get_rev(format!("refs/remotes/{remote_branch}"), dep_path)?,
                            r#override: false,
                        });
                    }
                    let dep_id = DepIdentifier::resolve_type(&git, dep_path, override_tag)?;
                    if dep_id.is_branch() {
                        // Branch updates below require a corresponding origin branch.
                        git.get_rev(format!("refs/remotes/{remote_branch}"), dep_path)?;
                    }
                    Ok(dep_id)
                };
                match resolve() {
                    Ok(dep_id) => Ok(dep_id),
                    Err(_) => {
                        // Newly published refs may not be available locally yet. Fetching must
                        // not check out anything before all overrides have been validated.
                        dependency_git.fetch(false, "origin", None::<&str>)?;
                        resolve()
                    }
                }
            })()
            .wrap_err_with(|| {
                format!(
                    "Failed to resolve ref `{override_tag}` for dependency `{}`",
                    rel_path.display()
                )
            })?;
            // Store the previous state before overriding
            let prev = foundry_lock.get(rel_path).cloned();

            // If it's a branch, mark it as overridden so it gets updated below
            if let DepIdentifier::Branch { .. } = dep_id {
                dep_id.mark_override();
            }

            // Update the lockfile
            foundry_lock.override_dep(rel_path, dep_id)?;

            // Only track as updated if there was a previous dependency
            if let Some(prev) = prev {
                prev_dep_ids.insert(rel_path.to_owned(), prev);
            }
        }

        // fetch the latest changes for each submodule (recursively if flag is set)
        let git = Git::new(&root);
        let mut update_paths = self.update_dep_paths(&foundry_lock);
        let initialize_nested = !update_paths.is_empty();
        // Include every selected dependency, including pins that need initialization or recursive
        // updates. With no selection, preserve the update-all behavior.
        if !paths.is_empty() {
            update_paths.clone_from(&paths);
        }
        trace!(?update_paths, "updating deps at");

        git.submodule_update(self.force, true, false, self.recursive, update_paths)?;

        if !self.recursive && initialize_nested && paths.is_empty() {
            git.submodule_foreach(false, "git submodule update --init --progress --recursive")?;
        }

        let canonical_root = canonicalize_path(&root)?;
        let mut checkout_paths = foundry_lock
            .iter()
            .map(|(path, _)| path)
            .filter(|path| paths.is_empty() || paths.contains(path))
            .collect::<Vec<_>>();
        checkout_paths.sort();
        for path in checkout_paths {
            let target = root.join(path);
            let initialized = dunce::canonicalize(&target).is_ok_and(|target| {
                target.starts_with(&canonical_root)
                    && Git::new(&target).is_repo_root().unwrap_or(false)
            });
            if !initialized {
                eyre::bail!(
                    "Dependency at `{}` is not an initialized Git submodule worktree",
                    path.display()
                );
            }
        }

        // Update branches to their latest commit from origin
        // This handles both explicit updates (forge update dep@branch) and
        // general updates (forge update) for branch-tracked dependencies
        let branch_overrides = foundry_lock
            .iter_mut()
            .filter_map(|(path, dep_id)| {
                if dep_id.is_branch() && dep_id.overridden() {
                    return Some((path, dep_id));
                }
                None
            })
            .collect::<Vec<_>>();

        for (path, dep_id) in branch_overrides {
            let submodule_path = root.join(path);
            let name = dep_id.name();

            // Fetch and checkout the latest commit from the remote branch
            git.fetch_and_checkout_branch(&submodule_path, name)?;

            // Now get the updated revision after syncing with origin
            let (updated_rev, _) = git.current_rev_branch(&submodule_path)?;

            // Update the lockfile entry to reflect the latest commit
            let prev = std::mem::replace(
                dep_id,
                DepIdentifier::Branch {
                    name: name.to_string(),
                    rev: updated_rev,
                    r#override: true,
                },
            );

            // Only insert if we don't already have a previous state for this path
            // (e.g., from explicit overrides where we converted tag to branch)
            if !prev_dep_ids.contains_key(path) {
                prev_dep_ids.insert(path.to_owned(), prev);
            }
        }

        // checkout the submodules at the correct tags
        // Skip branches that were already updated above to avoid reverting to local branch
        for (path, dep_id) in foundry_lock.iter() {
            // Ignore other dependencies if single update.
            if !paths.is_empty() && !paths.contains(path) {
                continue;
            }

            // Skip branches that were already updated
            if dep_id.is_branch() && dep_id.overridden() {
                continue;
            }
            git.checkout_at(dep_id.checkout_id(), &root.join(path))?;
        }

        if !self.recursive && initialize_nested {
            // Initialize nested submodules after restoring their selected parents' final revisions.
            for path in &paths {
                git.root(&root.join(path)).submodule_update(
                    false,
                    false,
                    false,
                    true,
                    std::iter::empty::<PathBuf>(),
                )?;
            }
        }

        if out_of_sync_deps.is_some_and(|o| !o.is_empty())
            || foundry_lock.iter().any(|(_, dep_id)| dep_id.overridden())
        {
            foundry_lock.write()?;
        }

        // Print updates from => to
        for (path, prev) in prev_dep_ids {
            let curr = foundry_lock.get(&path).unwrap();
            sh_status!(
                "Updated dep at '{}', (from: {prev}, to: {curr})",
                path.display().green(),
                prev = prev,
                curr = curr.yellow()
            )?;
        }

        Ok(())
    }

    /// Returns the `lib/paths` of the dependencies that have been updated/overridden.
    fn update_dep_paths(&self, foundry_lock: &Lockfile<'_>) -> Vec<PathBuf> {
        foundry_lock
            .iter()
            .filter_map(|(path, dep_id)| {
                if dep_id.overridden() {
                    return Some(path.clone());
                }
                None
            })
            .collect()
    }
}

/// Returns `(root, paths, overridden_deps_with_abosolute_paths)` where `root` is the root of the
/// Git repository and `paths` are the relative paths of the dependencies.
#[allow(clippy::type_complexity)]
pub fn dependencies_paths(
    deps: &[Dependency],
    config: &Config,
) -> Result<(PathBuf, Vec<PathBuf>, HashMap<PathBuf, String>)> {
    let git_root = Git::root_of(&config.root)?;
    let libs = config.install_lib_dir();

    if deps.is_empty() {
        return Ok((git_root, Vec::new(), HashMap::default()));
    }

    let mut paths = Vec::with_capacity(deps.len());
    let mut overrides = HashMap::with_capacity_and_hasher(deps.len(), Default::default());
    for dep in deps {
        let name = dep.name();
        let dep_path = libs.join(name);
        if !dep_path.exists() {
            eyre::bail!("Could not find dependency {name:?} in {}", dep_path.display());
        }
        let rel_path = dep_path
            .strip_prefix(&git_root)
            .wrap_err("Library directory is not relative to the repository root")?;

        if let Some(tag) = &dep.tag {
            overrides.insert(dep_path.clone(), tag.to_owned());
        }
        paths.push(rel_path.to_owned());
    }
    Ok((git_root, paths, overrides))
}