repoverse 0.1.1

Multi-repo workspace tool: keep many git repos in sync and roll changes up across dependency boundaries
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Workspace = root dir + config + lock. Project discovery & target resolution.

use crate::config::{Config, Project};
use crate::lock::Lock;
use anyhow::{bail, Result};
use std::path::{Path, PathBuf};

pub struct Workspace {
    pub root: PathBuf,
    pub config: Config,
    #[allow(dead_code)]
    pub config_path: PathBuf,
    pub lock_path: PathBuf,
}

impl Workspace {
    /// Discover the workspace from the current dir upward.
    pub fn discover() -> Result<Workspace> {
        let cwd = std::env::current_dir()?;
        Self::discover_from(&cwd)
    }

    pub fn discover_from(start: &Path) -> Result<Workspace> {
        let config_path = Config::discover(start).ok_or_else(|| {
            anyhow::anyhow!(
                "no {} found (run `rv adopt` or `rv init`)",
                crate::config::CONFIG_FILE
            )
        })?;
        let root = config_path.parent().unwrap().to_path_buf();
        let config = Config::load(&config_path)?;
        let lock_path = root.join(crate::lock::LOCK_FILE);
        Ok(Workspace {
            root,
            config,
            config_path,
            lock_path,
        })
    }

    pub fn lock(&self) -> Result<Lock> {
        Lock::load_or_default(&self.lock_path)
    }

    pub fn project_dir(&self, p: &Project) -> PathBuf {
        if p.path == "." {
            self.root.clone()
        } else {
            self.root.join(&p.path)
        }
    }

    /// Resolve user targets (paths, names, or "all"/empty) to projects.
    pub fn resolve_targets<'a>(&'a self, targets: &[String]) -> Result<Vec<&'a Project>> {
        if targets.is_empty() || targets == ["all"] {
            return Ok(self.config.projects.iter().collect());
        }
        let mut out = Vec::new();
        for t in targets {
            let matches: Vec<&Project> = self
                .config
                .projects
                .iter()
                .filter(|p| {
                    &p.path == t || &p.name == t || p.name.rsplit('/').next() == Some(t.as_str())
                })
                .collect();
            match matches.as_slice() {
                [p] => out.push(*p),
                [] => bail!("unknown target `{t}`"),
                _ => bail!("ambiguous target `{t}`; use a full path or owner/repo name"),
            }
        }
        Ok(out)
    }
}