subrepo.rs 90.8%

197 of 217 lines run, 13 of 32 functions · run #381 on main · run missed

//! Subrepositories (spec §7.8): the pin stored as a `subrepo` node's
//! content, and the `.oxymodules` file mapping paths to remotes.
//!
//! Pin encoding: `{0: 1, 1: kind, 2: locator, 3: pin, 4: bookmark}`; kind 0
//! is an Oxygen repository (locator = repository id, pin = sorted heads),
//! kind 1 a Git repository (locator = null, pin = commit sha as text).

use crate::cbor::{self, Value};
use crate::hash::ChangeHash;
use crate::objects::{
    array, bytes, check_version, field, oref, text, uint, ObjectError, FORMAT_VERSION,
};
use std::collections::BTreeMap;

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Pin {
    Oxy {
        repo: [u8; 16],
        heads: Vec<ChangeHash>,
        bookmark: String,
    },
    Git {
        sha: String,
        branch: String,
    },
}

impl Pin {
    pub fn encode(&self) -> Vec<u8> {
        let v = match self {
            Pin::Oxy {
                repo,
                heads,
                bookmark,
            } => {
                let mut heads = heads.clone();
                heads.sort();
                heads.dedup();
                Value::map([
                    (0, Value::Uint(FORMAT_VERSION)),
                    (1, Value::Uint(0)),
                    (2, Value::Bytes(repo.to_vec())),
                    (
                        3,
                        Value::Array(heads.iter().map(|h| Value::Bytes(h.0.to_vec())).collect()),
                    ),
                    (4, Value::Text(bookmark.clone())),
                ])
            }
            Pin::Git { sha, branch } => Value::map([
                (0, Value::Uint(FORMAT_VERSION)),
                (1, Value::Uint(1)),
                (2, Value::Null),
                (3, Value::Text(sha.clone())),
                (4, Value::Text(branch.clone())),
            ]),
        };
        cbor::encode(&v)
    }

    pub fn decode(b: &[u8]) -> Result<Pin, ObjectError> {
        let v = cbor::decode(b)?;
        let m = v
            .as_map()
            .ok_or_else(|| ObjectError::Schema("pin: expected map".into()))?;
        check_version(m)?;
        let bookmark = text(field(m, 4, "bookmark")?, "bookmark")?.to_owned();
        match uint(field(m, 1, "kind")?, "kind")? {
            0 => {
                let repo: [u8; 16] = bytes(field(m, 2, "repo")?, "repo")?
                    .try_into()
                    .map_err(|_| ObjectError::Schema("pin: repo id must be 16 bytes".into()))?;
                let heads = array(field(m, 3, "heads")?, "heads")?
                    .iter()
                    .map(|h| oref(h, "head"))
                    .collect::<Result<Vec<_>, _>>()?;
                Ok(Pin::Oxy {
                    repo,
                    heads,
                    bookmark,
                })
            }
            1 => Ok(Pin::Git {
                sha: text(field(m, 3, "sha")?, "sha")?.to_owned(),
                branch: bookmark,
            }),
            k => Err(ObjectError::Schema(format!("pin: unknown kind {k}"))),
        }
    }

    /// A one-line description for listings.
    pub fn summary(&self) -> String {
        match self {
            Pin::Oxy {
                heads, bookmark, ..
            } => format!(
                "oxy {bookmark} {}",
                heads
                    .iter()
                    .map(|h| h.short(12))
                    .collect::<Vec<_>>()
                    .join(" ")
            ),
            Pin::Git { sha, branch } => format!("git {branch} {}", &sha[..sha.len().min(12)]),
        }
    }

    pub fn is_git(&self) -> bool {
        matches!(self, Pin::Git { .. })
    }
}

/// One `.oxymodules` entry.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Module {
    pub url: String,
    /// Oxygen bookmark or Git branch to track.
    pub bookmark: Option<String>,
    pub git: bool,
}

/// `.oxymodules`: `[path]` sections with `url`, and `bookmark` (Oxygen) or
/// `branch` (Git) keys.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Modules {
    pub entries: BTreeMap<String, Module>,
}

impl Modules {
    pub fn parse(text: &str) -> Modules {
        let mut out = Modules::default();
        let mut current: Option<String> = None;
        for line in text.lines() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                continue;
            }
            if let Some(inner) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {
                let path = inner
                    .trim()
                    .trim_matches('"')
                    .trim_end_matches('/')
                    .to_string();
                out.entries.entry(path.clone()).or_default();
                current = Some(path);
                continue;
            }
            let (Some(path), Some((k, v))) = (&current, line.split_once('=')) else {
                continue;
            };
            let v = v.trim().trim_matches('"').to_string();
            let m = out.entries.get_mut(path).unwrap();
            match k.trim() {
                "url" => m.url = v,
                "bookmark" => {
                    m.bookmark = Some(v);
                    m.git = false;
                }
                "branch" => {
                    m.bookmark = Some(v);
                    m.git = true;
                }
                "kind" => m.git = v == "git",
                _ => {}
            }
        }
        out
    }

    pub fn to_text(&self) -> String {
        let mut s = String::new();
        for (path, m) in &self.entries {
            s.push_str(&format!("[{path}]\nurl = {}\n", m.url));
            if m.git {
                s.push_str("kind = git\n");
            }
            if let Some(b) = &m.bookmark {
                s.push_str(&format!(
                    "{} = {b}\n",
                    if m.git { "branch" } else { "bookmark" }
                ));
            }
            s.push('\n');
        }
        s
    }

    /// From Git's `.gitmodules` (`[submodule "name"]` with `path`, `url`, `branch`).
    pub fn from_gitmodules(text: &str) -> Modules {
        let mut out = Modules::default();
        let mut path: Option<String> = None;
        let mut url = String::new();
        let mut branch: Option<String> = None;
        let flush =
            |out: &mut Modules, path: &Option<String>, url: &str, branch: &Option<String>| {
                if let Some(p) = path {
                    out.entries.insert(
                        p.clone(),
                        Module {
                            url: url.to_string(),
                            bookmark: branch.clone(),
                            git: true,
                        },
                    );
                }
            };
        for line in text.lines() {
            let line = line.trim();
            if line.starts_with("[submodule") {
                flush(&mut out, &path, &url, &branch);
                path = None;
                url.clear();
                branch = None;
                continue;
            }
            if let Some((k, v)) = line.split_once('=') {
                let v = v.trim().to_string();
                match k.trim() {
                    "path" => path = Some(v.trim_end_matches('/').to_string()),
                    "url" => url = v,
                    "branch" => branch = Some(v),
                    _ => {}
                }
            }
        }
        flush(&mut out, &path, &url, &branch);
        out
    }

    /// Git's `.gitmodules` form of the Git-kind entries.
    pub fn to_gitmodules(&self) -> String {
        let mut s = String::new();
        for (path, m) in &self.entries {
            if !m.git {
                continue;
            }
            s.push_str(&format!(
                "[submodule \"{path}\"]\n\tpath = {path}\n\turl = {}\n",
                m.url
            ));
            if let Some(b) = &m.bookmark {
                s.push_str(&format!("\tbranch = {b}\n"));
            }
        }
        s
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::hash::ObjectRef;

    #[test]
    fn pins_round_trip() {
        let o = Pin::Oxy {
            repo: [7; 16],
            heads: vec![ObjectRef([2; 32]), ObjectRef([1; 32])],
            bookmark: "main".into(),
        };
        let back = Pin::decode(&o.encode()).unwrap();
        assert_eq!(
            back,
            Pin::Oxy {
                repo: [7; 16],
                heads: vec![ObjectRef([1; 32]), ObjectRef([2; 32])],
                bookmark: "main".into()
            }
        );
        let g = Pin::Git {
            sha: "0cb4742f64cf204e5fafd0963749d84afc561892".into(),
            branch: "main".into(),
        };
        assert_eq!(Pin::decode(&g.encode()).unwrap(), g);
        assert!(g.is_git() && !o.is_git());
    }

    #[test]
    fn modules_files() {
        let text = "[libs/sub]\nurl = ../sub\nbookmark = main\n\n[vendor/x]\nurl = https://example.org/x.git\nkind = git\nbranch = trunk\n";
        let m = Modules::parse(text);
        assert_eq!(
            m.entries["libs/sub"],
            Module {
                url: "../sub".into(),
                bookmark: Some("main".into()),
                git: false
            }
        );
        assert_eq!(
            m.entries["vendor/x"],
            Module {
                url: "https://example.org/x.git".into(),
                bookmark: Some("trunk".into()),
                git: true
            }
        );
        assert_eq!(Modules::parse(&m.to_text()), m);
        let gm = "[submodule \"rstar-api\"]\n\tpath = rstar-api\n\turl = https://github.com/x/rstar-api.git\n[submodule \"c\"]\n\tpath = cstar-api\n\turl = https://github.com/x/cstar-api.git\n\tbranch = dev\n";
        let g = Modules::from_gitmodules(gm);
        assert_eq!(g.entries.len(), 2);
        assert!(g.entries["rstar-api"].git && g.entries["rstar-api"].bookmark.is_none());
        assert_eq!(g.entries["cstar-api"].bookmark.as_deref(), Some("dev"));
        assert!(
            g.to_gitmodules().contains("[submodule \"cstar-api\"]")
                && g.to_gitmodules().contains("branch = dev")
        );
    }
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Subrepositories (spec §7.8): the pin stored as a `subrepo` node's
2		//! content, and the `.oxymodules` file mapping paths to remotes.
3		//!
4		//! Pin encoding: `{0: 1, 1: kind, 2: locator, 3: pin, 4: bookmark}`; kind 0
5		//! is an Oxygen repository (locator = repository id, pin = sorted heads),
6		//! kind 1 a Git repository (locator = null, pin = commit sha as text).
7
8		use crate::cbor::{self, Value};
9		use crate::hash::ChangeHash;
10		use crate::objects::{
11		array, bytes, check_version, field, oref, text, uint, ObjectError, FORMAT_VERSION,
12		};
13		use std::collections::BTreeMap;
14
15		#[derive(Clone, Debug, PartialEq, Eq)]
16		pub enum Pin {
17		Oxy {
18		repo: [u8; 16],
19		heads: Vec<ChangeHash>,
20		bookmark: String,
21		},
22		Git {
23		sha: String,
24		branch: String,
25		},
26		}
27
28		impl Pin {
29	52×	pub fn encode(&self) -> Vec<u8> {
30	52×	let v = match self {
31		Pin::Oxy {
32	49×	repo,
33	49×	heads,
34	49×	bookmark,
35		} => {
36	49×	let mut heads = heads.clone();
37	49×	heads.sort();
38	49×	heads.dedup();
39	49×	Value::map([
40	49×	(0, Value::Uint(FORMAT_VERSION)),
41	49×	(1, Value::Uint(0)),
42	49×	(2, Value::Bytes(repo.to_vec())),
43		(
44		3,
45	55×	Value::Array(heads.iter().map(\|h\| Value::Bytes(h.0.to_vec())).collect()),
46		),
47	49×	(4, Value::Text(bookmark.clone())),
48		])
49		}
50	3×	Pin::Git { sha, branch } => Value::map([
51	3×	(0, Value::Uint(FORMAT_VERSION)),
52	3×	(1, Value::Uint(1)),
53	3×	(2, Value::Null),
54	3×	(3, Value::Text(sha.clone())),
55	3×	(4, Value::Text(branch.clone())),
56	3×	]),
57		};
58	52×	cbor::encode(&v)
59	52×	}
60
61	26×	pub fn decode(b: &[u8]) -> Result<Pin, ObjectError> {
62	26×	let v = cbor::decode(b)?;
63	26×	let m = v
64	26×	.as_map()
65	26×	.ok_or_else(\|\| ObjectError::Schema("pin: expected map".into()))?;
66	26×	check_version(m)?;
67	26×	let bookmark = text(field(m, 4, "bookmark")?, "bookmark")?.to_owned();
68	26×	match uint(field(m, 1, "kind")?, "kind")? {
69		0 => {
70	21×	let repo: [u8; 16] = bytes(field(m, 2, "repo")?, "repo")?
71	21×	.try_into()
72	21×	.map_err(\|_\| ObjectError::Schema("pin: repo id must be 16 bytes".into()))?;
73	21×	let heads = array(field(m, 3, "heads")?, "heads")?
74	21×	.iter()
75	22×	.map(\|h\| oref(h, "head"))
76	21×	.collect::<Result<Vec<_>, _>>()?;
77	21×	Ok(Pin::Oxy {
78	21×	repo,
79	21×	heads,
80	21×	bookmark,
81	21×	})
82		}
83		1 => Ok(Pin::Git {
84	5×	sha: text(field(m, 3, "sha")?, "sha")?.to_owned(),
85	5×	branch: bookmark,
86		}),
87	0×	k => Err(ObjectError::Schema(format!("pin: unknown kind {k}"))),
88		}
89	26×	}
90
91		/// A one-line description for listings.
92	0×	pub fn summary(&self) -> String {
93	0×	match self {
94		Pin::Oxy {
95	0×	heads, bookmark, ..
96	0×	} => format!(
97		"oxy {bookmark} {}",
98	0×	heads
99	0×	.iter()
100	0×	.map(\|h\| h.short(12))
101	0×	.collect::<Vec<_>>()
102	0×	.join(" ")
103		),
104	0×	Pin::Git { sha, branch } => format!("git {branch} {}", &sha[..sha.len().min(12)]),
105		}
106	0×	}
107
108	2×	pub fn is_git(&self) -> bool {
109	2×	matches!(self, Pin::Git { .. })
110	2×	}
111		}
112
113		/// One `.oxymodules` entry.
114		#[derive(Clone, Debug, Default, PartialEq, Eq)]
115		pub struct Module {
116		pub url: String,
117		/// Oxygen bookmark or Git branch to track.
118		pub bookmark: Option<String>,
119		pub git: bool,
120		}
121
122		/// `.oxymodules`: `[path]` sections with `url`, and `bookmark` (Oxygen) or
123		/// `branch` (Git) keys.
124		#[derive(Clone, Debug, Default, PartialEq, Eq)]
125		pub struct Modules {
126		pub entries: BTreeMap<String, Module>,
127		}
128
129		impl Modules {
130	88×	pub fn parse(text: &str) -> Modules {
131	88×	let mut out = Modules::default();
132	88×	let mut current: Option<String> = None;
133	276×	for line in text.lines() {
134	276×	let line = line.trim();
135	276×	if line.is_empty() \|\| line.starts_with('#') {
136	85×	continue;
137	191×	}
138	191×	if let Some(inner) = line.strip_prefix('[').and_then(\|l\| l.strip_suffix(']')) {
139	90×	let path = inner
140	90×	.trim()
141	90×	.trim_matches('"')
142	90×	.trim_end_matches('/')
143	90×	.to_string();
144	90×	out.entries.entry(path.clone()).or_default();
145	90×	current = Some(path);
146	90×	continue;
147	101×	}
148	101×	let (Some(path), Some((k, v))) = (&current, line.split_once('=')) else {
149	0×	continue;
150		};
151	101×	let v = v.trim().trim_matches('"').to_string();
152	101×	let m = out.entries.get_mut(path).unwrap();
153	101×	match k.trim() {
154	101×	"url" => m.url = v,
155	11×	"bookmark" => {
156	2×	m.bookmark = Some(v);
157	2×	m.git = false;
158	2×	}
159	9×	"branch" => {
160	2×	m.bookmark = Some(v);
161	2×	m.git = true;
162	2×	}
163	7×	"kind" => m.git = v == "git",
164	0×	_ => {}
165		}
166		}
167	88×	out
168	88×	}
169
170	12×	pub fn to_text(&self) -> String {
171	12×	let mut s = String::new();
172	13×	for (path, m) in &self.entries {
173	13×	s.push_str(&format!("[{path}]\nurl = {}\n", m.url));
174	13×	if m.git {
175	2×	s.push_str("kind = git\n");
176	11×	}
177	13×	if let Some(b) = &m.bookmark {
178	2×	s.push_str(&format!(
179		"{} = {b}\n",
180	2×	if m.git { "branch" } else { "bookmark" }
181		));
182	11×	}
183	13×	s.push('\n');
184		}
185	12×	s
186	12×	}
187
188		/// From Git's `.gitmodules` (`[submodule "name"]` with `path`, `url`, `branch`).
189	2×	pub fn from_gitmodules(text: &str) -> Modules {
190	2×	let mut out = Modules::default();
191	2×	let mut path: Option<String> = None;
192	2×	let mut url = String::new();
193	2×	let mut branch: Option<String> = None;
194	2×	let flush =
195	5×	\|out: &mut Modules, path: &Option<String>, url: &str, branch: &Option<String>\| {
196	5×	if let Some(p) = path {
197	3×	out.entries.insert(
198	3×	p.clone(),
199	3×	Module {
200	3×	url: url.to_string(),
201	3×	bookmark: branch.clone(),
202	3×	git: true,
203	3×	},
204	3×	);
205	3×	}
206	5×	};
207	10×	for line in text.lines() {
208	10×	let line = line.trim();
209	10×	if line.starts_with("[submodule") {
210	3×	flush(&mut out, &path, &url, &branch);
211	3×	path = None;
212	3×	url.clear();
213	3×	branch = None;
214	3×	continue;
215	7×	}
216	7×	if let Some((k, v)) = line.split_once('=') {
217	7×	let v = v.trim().to_string();
218	7×	match k.trim() {
219	7×	"path" => path = Some(v.trim_end_matches('/').to_string()),
220	4×	"url" => url = v,
221	1×	"branch" => branch = Some(v),
222	0×	_ => {}
223		}
224	0×	}
225		}
226	2×	flush(&mut out, &path, &url, &branch);
227	2×	out
228	2×	}
229
230		/// Git's `.gitmodules` form of the Git-kind entries.
231	2×	pub fn to_gitmodules(&self) -> String {
232	2×	let mut s = String::new();
233	4×	for (path, m) in &self.entries {
234	4×	if !m.git {
235	0×	continue;
236	4×	}
237	4×	s.push_str(&format!(
238	4×	"[submodule \"{path}\"]\n\tpath = {path}\n\turl = {}\n",
239	4×	m.url
240	4×	));
241	4×	if let Some(b) = &m.bookmark {
242	2×	s.push_str(&format!("\tbranch = {b}\n"));
243	2×	}
244		}
245	2×	s
246	2×	}
247		}
248
249		#[cfg(test)]
250		mod tests {
251		use super::*;
252		use crate::hash::ObjectRef;
253
254		#[test]
255	1×	fn pins_round_trip() {
256	1×	let o = Pin::Oxy {
257	1×	repo: [7; 16],
258	1×	heads: vec![ObjectRef([2; 32]), ObjectRef([1; 32])],
259	1×	bookmark: "main".into(),
260	1×	};
261	1×	let back = Pin::decode(&o.encode()).unwrap();
262	1×	assert_eq!(
263		back,
264	1×	Pin::Oxy {
265	1×	repo: [7; 16],
266	1×	heads: vec![ObjectRef([1; 32]), ObjectRef([2; 32])],
267	1×	bookmark: "main".into()
268	1×	}
269		);
270	1×	let g = Pin::Git {
271	1×	sha: "0cb4742f64cf204e5fafd0963749d84afc561892".into(),
272	1×	branch: "main".into(),
273	1×	};
274	1×	assert_eq!(Pin::decode(&g.encode()).unwrap(), g);
275	1×	assert!(g.is_git() && !o.is_git());
276	1×	}
277
278		#[test]
279	1×	fn modules_files() {
280	1×	let text = "[libs/sub]\nurl = ../sub\nbookmark = main\n\n[vendor/x]\nurl = https://example.org/x.git\nkind = git\nbranch = trunk\n";
281	1×	let m = Modules::parse(text);
282	1×	assert_eq!(
283	1×	m.entries["libs/sub"],
284	1×	Module {
285	1×	url: "../sub".into(),
286	1×	bookmark: Some("main".into()),
287	1×	git: false
288	1×	}
289		);
290	1×	assert_eq!(
291	1×	m.entries["vendor/x"],
292	1×	Module {
293	1×	url: "https://example.org/x.git".into(),
294	1×	bookmark: Some("trunk".into()),
295	1×	git: true
296	1×	}
297		);
298	1×	assert_eq!(Modules::parse(&m.to_text()), m);
299	1×	let gm = "[submodule \"rstar-api\"]\n\tpath = rstar-api\n\turl = https://github.com/x/rstar-api.git\n[submodule \"c\"]\n\tpath = cstar-api\n\turl = https://github.com/x/cstar-api.git\n\tbranch = dev\n";
300	1×	let g = Modules::from_gitmodules(gm);
301	1×	assert_eq!(g.entries.len(), 2);
302	1×	assert!(g.entries["rstar-api"].git && g.entries["rstar-api"].bookmark.is_none());
303	1×	assert_eq!(g.entries["cstar-api"].bookmark.as_deref(), Some("dev"));
304	1×	assert!(
305	1×	g.to_gitmodules().contains("[submodule \"cstar-api\"]")
306	1×	&& g.to_gitmodules().contains("branch = dev")
307		);
308	1×	}
309		}

Coverage / crates/oxy-core/src/subrepo.rs 90.8%

Keyboard