newgit-core 0.1.0

Core domain model for newgit: branch instances, tracker lanes, and resource lifecycles
Documentation 
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use camino::{Utf8Path, Utf8PathBuf};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};

use crate::store::expand_home;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ProjectConfig {
    pub project: ProjectSection,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace: Option<WorkspaceSection>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ProjectSection {
    pub name: String,
    pub source: SourceSubstrate,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum SourceSubstrate {
    Git,
    Jj,
}

/// Optional overrides; omitted from the generated config so a committed
/// file never bakes in one user's absolute paths.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WorkspaceSection {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub root: Option<Utf8PathBuf>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub materializer: Option<String>,
}

impl ProjectConfig {
    pub fn new(project_name: impl Into<String>, source: SourceSubstrate) -> Self {
        Self {
            project: ProjectSection {
                name: project_name.into(),
                source,
            },
            workspace: None,
        }
    }

    /// Where this project's workspaces live. Defaults to
    /// `~/.newgit/workspaces/<name>-<hash>/`, where the hash disambiguates
    /// same-named projects at different paths.
    pub fn workspace_root(&self, project_root: &Utf8Path) -> Utf8PathBuf {
        if let Some(root) = self.workspace.as_ref().and_then(|ws| ws.root.as_ref()) {
            return expand_home(root);
        }
        default_workspace_root(&self.project.name, project_root)
    }
}

pub fn default_workspace_root(project_name: &str, project_root: &Utf8Path) -> Utf8PathBuf {
    let digest = Sha256::digest(project_root.as_str().as_bytes());
    let hash: String = digest[..4]
        .iter()
        .map(|byte| format!("{byte:02x}"))
        .collect();
    expand_home(Utf8Path::new("~/.newgit/workspaces")).join(format!("{project_name}-{hash}"))
}

#[cfg(test)]
mod tests {
    use camino::Utf8Path;

    use super::{ProjectConfig, SourceSubstrate, default_workspace_root};

    #[test]
    fn default_root_disambiguates_same_named_projects() {
        let a = default_workspace_root("api", Utf8Path::new("/home/u/work/api"));
        let b = default_workspace_root("api", Utf8Path::new("/home/u/other/api"));
        assert_ne!(a, b);
    }

    #[test]
    fn workspace_override_wins() {
        let mut config = ProjectConfig::new("api", SourceSubstrate::Git);
        config.workspace = Some(super::WorkspaceSection {
            root: Some("/data/ws".into()),
            materializer: None,
        });
        assert_eq!(
            config.workspace_root(Utf8Path::new("/home/u/api")),
            Utf8Path::new("/data/ws")
        );
    }
}