subrepo.rs 90.9%

211 of 232 lines run, 14 of 34 functions · run #416 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 {
    /// Whether two pins name the same state: the same repository at the
    /// same heads, in any order, or the same Git commit. The bookmark or
    /// branch each names does not count (#147): a subrepo at its pinned
    /// state is at it whatever bookmark it sits on.
    pub fn same_state(&self, other: &Pin) -> bool {
        match (self, other) {
            (
                Pin::Oxy {
                    repo: r1,
                    heads: h1,
                    ..
                },
                Pin::Oxy {
                    repo: r2,
                    heads: h2,
                    ..
                },
            ) => {
                let (mut a, mut b) = (h1.clone(), h2.clone());
                a.sort();
                a.dedup();
                b.sort();
                b.dedup();
                r1 == r2 && a == b
            }
            (Pin::Git { sha: a, .. }, Pin::Git { sha: b, .. }) => a == b,
            _ => false,
        }
    }

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

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

Keyboard