oplog.rs 90.6%

269 of 297 lines run, 43 of 61 functions · run #384 on main · run missed

//! Operation log objects (spec §12.1): every mutation of local repository
//! state records an `Op` whose `view` is the complete set of references and
//! workspaces afterwards.
//!
//! Encoding: `bookmarks` is an array of `[name, state_ref]` sorted by name and
//! `workspaces` an array of `[workspace_id, change_hash]` sorted by id, since
//! canonical maps carry only integer keys. Repository format 1 encoded a
//! bookmark as `[name, [heads]]`; `Op::decode_format1` reads that for migration.

use crate::cbor::{self, Value};
use crate::hash::{hash_object, ChangeHash, ObjectRef, ObjectType};
use crate::ids::WorkspaceId;
use crate::objects::{
    array, bytes, check_version, field, oref, text, Hlc, ObjectError, FORMAT_VERSION,
};
use std::collections::BTreeMap;

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct View {
    /// Bookmark name → ObjectRef of a `state` object (spec §10.1).
    pub bookmarks: BTreeMap<String, ObjectRef>,
    pub workspaces: BTreeMap<WorkspaceId, ChangeHash>,
    /// `remotes/<remote>/bookmarks/<name>`: remote → bookmark → state ObjectRef.
    pub remotes: BTreeMap<String, BTreeMap<String, ObjectRef>>,
    /// The `policy` reference (spec §10.1, §14.5): ObjectRef of the current policy.
    pub policy: Option<ObjectRef>,
    /// `tags/<name>`: immutable states (spec §10.1).
    pub tags: BTreeMap<String, ObjectRef>,
}

/// A format-1 view, only produced by `Op::decode_format1`.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Format1View {
    pub bookmarks: BTreeMap<String, Vec<ChangeHash>>,
    pub workspaces: BTreeMap<WorkspaceId, ChangeHash>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Op {
    pub parents: Vec<ObjectRef>,
    pub hlc: Hlc,
    pub command: String,
    pub view: View,
    /// The workspace whose command recorded it (oxygen#99); absent in
    /// operations written before it was kept.
    pub workspace: Option<WorkspaceId>,
    /// For an undo that reverted an older operation in place: that
    /// operation, so a further undo goes on past it.
    pub undoes: Option<ObjectRef>,
}

impl View {
    fn to_value(&self) -> Value {
        Value::map([
            (
                0,
                Value::Array(
                    self.bookmarks
                        .iter()
                        .map(|(n, st)| {
                            Value::Array(vec![Value::Text(n.clone()), Value::Bytes(st.0.to_vec())])
                        })
                        .collect(),
                ),
            ),
            (
                1,
                Value::Array(
                    self.workspaces
                        .iter()
                        .map(|(w, h)| {
                            Value::Array(vec![
                                Value::Bytes(w.0.to_vec()),
                                Value::Bytes(h.0.to_vec()),
                            ])
                        })
                        .collect(),
                ),
            ),
            (
                2,
                Value::Array(
                    self.remotes
                        .iter()
                        .map(|(r, bms)| {
                            Value::Array(vec![
                                Value::Text(r.clone()),
                                Value::Array(
                                    bms.iter()
                                        .map(|(n, st)| {
                                            Value::Array(vec![
                                                Value::Text(n.clone()),
                                                Value::Bytes(st.0.to_vec()),
                                            ])
                                        })
                                        .collect(),
                                ),
                            ])
                        })
                        .collect(),
                ),
            ),
            (
                3,
                self.policy
                    .map(|p| Value::Bytes(p.0.to_vec()))
                    .unwrap_or(Value::Null),
            ),
            (
                4,
                Value::Array(
                    self.tags
                        .iter()
                        .map(|(n, st)| {
                            Value::Array(vec![Value::Text(n.clone()), Value::Bytes(st.0.to_vec())])
                        })
                        .collect(),
                ),
            ),
        ])
    }

    fn from_value(v: &Value) -> Result<View, ObjectError> {
        let m = v
            .as_map()
            .ok_or_else(|| ObjectError::Schema("view: expected map".into()))?;
        let mut view = View::default();
        for b in array(field(m, 0, "bookmarks")?, "bookmarks")? {
            let pair = array(b, "bookmark")?;
            if pair.len() != 2 {
                return Err(ObjectError::Schema(
                    "bookmark: expected [name, heads]".into(),
                ));
            }
            let name = text(&pair[0], "bookmark name")?.to_owned();
            view.bookmarks
                .insert(name, oref(&pair[1], "bookmark state")?);
        }
        view.workspaces = workspaces_from_value(field(m, 1, "workspaces")?)?;
        if let Some(rs) = m.get(&2) {
            for r in array(rs, "remotes")? {
                let pair = array(r, "remote")?;
                if pair.len() != 2 {
                    return Err(ObjectError::Schema(
                        "remote: expected [name, bookmarks]".into(),
                    ));
                }
                let name = text(&pair[0], "remote name")?.to_owned();
                let mut bms = BTreeMap::new();
                for b in array(&pair[1], "remote bookmarks")? {
                    let bp = array(b, "remote bookmark")?;
                    if bp.len() != 2 {
                        return Err(ObjectError::Schema(
                            "remote bookmark: expected [name, state]".into(),
                        ));
                    }
                    bms.insert(
                        text(&bp[0], "bookmark name")?.to_owned(),
                        oref(&bp[1], "bookmark state")?,
                    );
                }
                view.remotes.insert(name, bms);
            }
        }
        if let Some(p) = m.get(&3) {
            view.policy = if p.is_null() {
                None
            } else {
                Some(oref(p, "policy")?)
            };
        }
        if let Some(ts) = m.get(&4) {
            for t in array(ts, "tags")? {
                let pair = array(t, "tag")?;
                if pair.len() != 2 {
                    return Err(ObjectError::Schema("tag: expected [name, state]".into()));
                }
                view.tags.insert(
                    text(&pair[0], "tag name")?.to_owned(),
                    oref(&pair[1], "tag state")?,
                );
            }
        }
        Ok(view)
    }
}

fn workspaces_from_value(v: &Value) -> Result<BTreeMap<WorkspaceId, ChangeHash>, ObjectError> {
    let mut out = BTreeMap::new();
    for w in array(v, "workspaces")? {
        let pair = array(w, "workspace")?;
        if pair.len() != 2 {
            return Err(ObjectError::Schema(
                "workspace: expected [id, change]".into(),
            ));
        }
        let id = WorkspaceId::from_slice(bytes(&pair[0], "workspace id")?)
            .ok_or_else(|| ObjectError::Schema("workspace id: expected 16 bytes".into()))?;
        out.insert(id, oref(&pair[1], "workspace change")?);
    }
    Ok(out)
}

impl Format1View {
    fn from_value(v: &Value) -> Result<Format1View, ObjectError> {
        let m = v
            .as_map()
            .ok_or_else(|| ObjectError::Schema("view: expected map".into()))?;
        let mut view = Format1View::default();
        for b in array(field(m, 0, "bookmarks")?, "bookmarks")? {
            let pair = array(b, "bookmark")?;
            if pair.len() != 2 {
                return Err(ObjectError::Schema(
                    "bookmark: expected [name, heads]".into(),
                ));
            }
            let name = text(&pair[0], "bookmark name")?.to_owned();
            let mut heads = array(&pair[1], "heads")?
                .iter()
                .map(|h| oref(h, "head"))
                .collect::<Result<Vec<_>, _>>()?;
            heads.sort();
            heads.dedup();
            view.bookmarks.insert(name, heads);
        }
        view.workspaces = workspaces_from_value(field(m, 1, "workspaces")?)?;
        Ok(view)
    }

    /// Format-1 encoding, kept for the migration test.
    #[cfg(test)]
    pub(crate) fn to_value(&self) -> Value {
        Value::map([
            (
                0,
                Value::Array(
                    self.bookmarks
                        .iter()
                        .map(|(n, hs)| {
                            Value::Array(vec![
                                Value::Text(n.clone()),
                                Value::Array(
                                    hs.iter().map(|h| Value::Bytes(h.0.to_vec())).collect(),
                                ),
                            ])
                        })
                        .collect(),
                ),
            ),
            (
                1,
                Value::Array(
                    self.workspaces
                        .iter()
                        .map(|(w, h)| {
                            Value::Array(vec![
                                Value::Bytes(w.0.to_vec()),
                                Value::Bytes(h.0.to_vec()),
                            ])
                        })
                        .collect(),
                ),
            ),
        ])
    }
}

/// A format-1 operation as read for migration.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Format1Op {
    pub parents: Vec<ObjectRef>,
    pub hlc: Hlc,
    pub command: String,
    pub view: Format1View,
}

impl Format1Op {
    #[cfg(test)]
    pub(crate) fn encode(&self) -> Vec<u8> {
        cbor::encode(&Value::map([
            (0, Value::Uint(FORMAT_VERSION)),
            (
                1,
                Value::Array(
                    self.parents
                        .iter()
                        .map(|p| Value::Bytes(p.0.to_vec()))
                        .collect(),
                ),
            ),
            (2, self.hlc.to_value()),
            (3, Value::Text(self.command.clone())),
            (4, self.view.to_value()),
        ]))
    }
}

/// Suffix on the `command` of operations recorded by an automatic
/// working-copy snapshot rather than by a user command.
pub const SNAPSHOT_SUFFIX: &str = " (snapshot)";

impl Op {
    /// Whether this operation only recorded a working-copy snapshot.
    pub fn is_snapshot(&self) -> bool {
        self.command.ends_with(SNAPSHOT_SUFFIX)
    }

    pub fn to_value(&self) -> Value {
        let mut fields = vec![
            (0, Value::Uint(FORMAT_VERSION)),
            (
                1,
                Value::Array(
                    self.parents
                        .iter()
                        .map(|p| Value::Bytes(p.0.to_vec()))
                        .collect(),
                ),
            ),
            (2, self.hlc.to_value()),
            (3, Value::Text(self.command.clone())),
            (4, self.view.to_value()),
        ];
        // Absent when unknown, so older operations keep their encoding.
        if let Some(w) = &self.workspace {
            fields.push((5, Value::Bytes(w.0.to_vec())));
        }
        if let Some(u) = &self.undoes {
            fields.push((6, Value::Bytes(u.0.to_vec())));
        }
        Value::map(fields)
    }
    pub fn encode(&self) -> Vec<u8> {
        cbor::encode(&self.to_value())
    }
    pub fn hash(&self) -> ObjectRef {
        hash_object(ObjectType::Op, &self.encode())
    }
    pub fn decode(b: &[u8]) -> Result<Op, ObjectError> {
        let v = cbor::decode(b)?;
        let m = v
            .as_map()
            .ok_or_else(|| ObjectError::Schema("op: expected map".into()))?;
        check_version(m)?;
        Ok(Op {
            parents: array(field(m, 1, "parents")?, "parents")?
                .iter()
                .map(|p| oref(p, "parent"))
                .collect::<Result<Vec<_>, _>>()?,
            hlc: Hlc::from_value(field(m, 2, "hlc")?)?,
            command: text(field(m, 3, "command")?, "command")?.to_owned(),
            view: View::from_value(field(m, 4, "view")?)?,
            workspace: match m.get(&5) {
                Some(v) => Some(
                    WorkspaceId::from_slice(bytes(v, "workspace")?).ok_or_else(|| {
                        ObjectError::Schema("workspace: expected 16 bytes".into())
                    })?,
                ),
                None => None,
            },
            undoes: m.get(&6).map(|v| oref(v, "undoes")).transpose()?,
        })
    }

    /// Read an operation written by repository format 1.
    pub fn decode_format1(b: &[u8]) -> Result<Format1Op, ObjectError> {
        let v = cbor::decode(b)?;
        let m = v
            .as_map()
            .ok_or_else(|| ObjectError::Schema("op: expected map".into()))?;
        check_version(m)?;
        Ok(Format1Op {
            parents: array(field(m, 1, "parents")?, "parents")?
                .iter()
                .map(|p| oref(p, "parent"))
                .collect::<Result<Vec<_>, _>>()?,
            hlc: Hlc::from_value(field(m, 2, "hlc")?)?,
            command: text(field(m, 3, "command")?, "command")?.to_owned(),
            view: Format1View::from_value(field(m, 4, "view")?)?,
        })
    }
}

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

    #[test]
    fn op_round_trip() {
        let mut view = View::default();
        view.bookmarks.insert("main".into(), ObjectRef([2; 32]));
        view.bookmarks.insert("dev".into(), ObjectRef([3; 32]));
        view.workspaces
            .insert(WorkspaceId([5; 16]), ObjectRef([9; 32]));
        view.remotes
            .entry("origin".into())
            .or_default()
            .insert("main".into(), ObjectRef([4; 32]));
        view.policy = Some(ObjectRef([6; 32]));
        view.tags.insert("v1".into(), ObjectRef([8; 32]));
        let op = Op {
            parents: vec![ObjectRef([7; 32])],
            hlc: Hlc {
                wall_ms: 5,
                logical: 1,
            },
            command: "oxy commit".into(),
            view,
            workspace: None,
            undoes: None,
        };
        let d = Op::decode(&op.encode()).unwrap();
        assert_eq!(d, op);
        // The workspace and an undo's target travel when known.
        let mut known = op.clone();
        known.workspace = Some(WorkspaceId([3; 16]));
        known.undoes = Some(ObjectRef([1; 32]));
        assert_eq!(Op::decode(&known.encode()).unwrap(), known);
        assert_ne!(known.hash(), op.hash());
        assert_eq!(d.hash(), Op::decode(&d.encode()).unwrap().hash());
        // A format-1 op does not decode as format 2, but does through the migration reader.
        let mut v1 = Format1View::default();
        v1.bookmarks
            .insert("main".into(), vec![ObjectRef([2; 32]), ObjectRef([1; 32])]);
        v1.workspaces
            .insert(WorkspaceId([5; 16]), ObjectRef([9; 32]));
        let old = Format1Op {
            parents: vec![],
            hlc: Hlc::default(),
            command: "oxy init".into(),
            view: v1,
        };
        assert!(Op::decode(&old.encode()).is_err());
        let back = Op::decode_format1(&old.encode()).unwrap();
        assert_eq!(
            back.view.bookmarks["main"],
            vec![ObjectRef([1; 32]), ObjectRef([2; 32])]
        );
    }
}

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

1		//! Operation log objects (spec §12.1): every mutation of local repository
2		//! state records an `Op` whose `view` is the complete set of references and
3		//! workspaces afterwards.
4		//!
5		//! Encoding: `bookmarks` is an array of `[name, state_ref]` sorted by name and
6		//! `workspaces` an array of `[workspace_id, change_hash]` sorted by id, since
7		//! canonical maps carry only integer keys. Repository format 1 encoded a
8		//! bookmark as `[name, [heads]]`; `Op::decode_format1` reads that for migration.
9
10		use crate::cbor::{self, Value};
11		use crate::hash::{hash_object, ChangeHash, ObjectRef, ObjectType};
12		use crate::ids::WorkspaceId;
13		use crate::objects::{
14		array, bytes, check_version, field, oref, text, Hlc, ObjectError, FORMAT_VERSION,
15		};
16		use std::collections::BTreeMap;
17
18		#[derive(Clone, Debug, Default, PartialEq, Eq)]
19		pub struct View {
20		/// Bookmark name → ObjectRef of a `state` object (spec §10.1).
21		pub bookmarks: BTreeMap<String, ObjectRef>,
22		pub workspaces: BTreeMap<WorkspaceId, ChangeHash>,
23		/// `remotes/<remote>/bookmarks/<name>`: remote → bookmark → state ObjectRef.
24		pub remotes: BTreeMap<String, BTreeMap<String, ObjectRef>>,
25		/// The `policy` reference (spec §10.1, §14.5): ObjectRef of the current policy.
26		pub policy: Option<ObjectRef>,
27		/// `tags/<name>`: immutable states (spec §10.1).
28		pub tags: BTreeMap<String, ObjectRef>,
29		}
30
31		/// A format-1 view, only produced by `Op::decode_format1`.
32		#[derive(Clone, Debug, Default, PartialEq, Eq)]
33		pub struct Format1View {
34		pub bookmarks: BTreeMap<String, Vec<ChangeHash>>,
35		pub workspaces: BTreeMap<WorkspaceId, ChangeHash>,
36		}
37
38		#[derive(Clone, Debug, PartialEq, Eq)]
39		pub struct Op {
40		pub parents: Vec<ObjectRef>,
41		pub hlc: Hlc,
42		pub command: String,
43		pub view: View,
44		/// The workspace whose command recorded it (oxygen#99); absent in
45		/// operations written before it was kept.
46		pub workspace: Option<WorkspaceId>,
47		/// For an undo that reverted an older operation in place: that
48		/// operation, so a further undo goes on past it.
49		pub undoes: Option<ObjectRef>,
50		}
51
52		impl View {
53	3928×	fn to_value(&self) -> Value {
54	3928×	Value::map([
55		(
56		0,
57		Value::Array(
58	3928×	self.bookmarks
59	3928×	.iter()
60	4258×	.map(\|(n, st)\| {
61	4258×	Value::Array(vec![Value::Text(n.clone()), Value::Bytes(st.0.to_vec())])
62	4258×	})
63	3928×	.collect(),
64		),
65		),
66		(
67		1,
68		Value::Array(
69	3928×	self.workspaces
70	3928×	.iter()
71	3928×	.map(\|(w, h)\| {
72	3865×	Value::Array(vec![
73	3865×	Value::Bytes(w.0.to_vec()),
74	3865×	Value::Bytes(h.0.to_vec()),
75	3865×	])
76	3865×	})
77	3928×	.collect(),
78		),
79		),
80		(
81		2,
82		Value::Array(
83	3928×	self.remotes
84	3928×	.iter()
85	3928×	.map(\|(r, bms)\| {
86	2105×	Value::Array(vec![
87	2105×	Value::Text(r.clone()),
88		Value::Array(
89	2105×	bms.iter()
90	2181×	.map(\|(n, st)\| {
91	2181×	Value::Array(vec![
92	2181×	Value::Text(n.clone()),
93	2181×	Value::Bytes(st.0.to_vec()),
94	2181×	])
95	2181×	})
96	2105×	.collect(),
97		),
98		])
99	2105×	})
100	3928×	.collect(),
101		),
102		),
103		(
104		3,
105	3928×	self.policy
106	3928×	.map(\|p\| Value::Bytes(p.0.to_vec()))
107	3928×	.unwrap_or(Value::Null),
108		),
109		(
110		4,
111		Value::Array(
112	3928×	self.tags
113	3928×	.iter()
114	3928×	.map(\|(n, st)\| {
115	192×	Value::Array(vec![Value::Text(n.clone()), Value::Bytes(st.0.to_vec())])
116	192×	})
117	3928×	.collect(),
118		),
119		),
120		])
121	3928×	}
122
123	21193×	fn from_value(v: &Value) -> Result<View, ObjectError> {
124	21193×	let m = v
125	21193×	.as_map()
126	21193×	.ok_or_else(\|\| ObjectError::Schema("view: expected map".into()))?;
127	21193×	let mut view = View::default();
128	22915×	for b in array(field(m, 0, "bookmarks")?, "bookmarks")? {
129	22915×	let pair = array(b, "bookmark")?;
130	22915×	if pair.len() != 2 {
131	0×	return Err(ObjectError::Schema(
132	0×	"bookmark: expected [name, heads]".into(),
133	0×	));
134	22915×	}
135	22915×	let name = text(&pair[0], "bookmark name")?.to_owned();
136	22915×	view.bookmarks
137	22915×	.insert(name, oref(&pair[1], "bookmark state")?);
138		}
139	21192×	view.workspaces = workspaces_from_value(field(m, 1, "workspaces")?)?;
140	21192×	if let Some(rs) = m.get(&2) {
141	21192×	for r in array(rs, "remotes")? {
142	8356×	let pair = array(r, "remote")?;
143	8356×	if pair.len() != 2 {
144	0×	return Err(ObjectError::Schema(
145	0×	"remote: expected [name, bookmarks]".into(),
146	0×	));
147	8356×	}
148	8356×	let name = text(&pair[0], "remote name")?.to_owned();
149	8356×	let mut bms = BTreeMap::new();
150	8598×	for b in array(&pair[1], "remote bookmarks")? {
151	8598×	let bp = array(b, "remote bookmark")?;
152	8598×	if bp.len() != 2 {
153	0×	return Err(ObjectError::Schema(
154	0×	"remote bookmark: expected [name, state]".into(),
155	0×	));
156	8598×	}
157	8598×	bms.insert(
158	8598×	text(&bp[0], "bookmark name")?.to_owned(),
159	8598×	oref(&bp[1], "bookmark state")?,
160		);
161		}
162	8356×	view.remotes.insert(name, bms);
163		}
164	0×	}
165	21192×	if let Some(p) = m.get(&3) {
166	21192×	view.policy = if p.is_null() {
167	19323×	None
168		} else {
169	1869×	Some(oref(p, "policy")?)
170		};
171	0×	}
172	21192×	if let Some(ts) = m.get(&4) {
173	21192×	for t in array(ts, "tags")? {
174	1199×	let pair = array(t, "tag")?;
175	1199×	if pair.len() != 2 {
176	0×	return Err(ObjectError::Schema("tag: expected [name, state]".into()));
177	1199×	}
178	1199×	view.tags.insert(
179	1199×	text(&pair[0], "tag name")?.to_owned(),
180	1199×	oref(&pair[1], "tag state")?,
181		);
182		}
183	0×	}
184	21192×	Ok(view)
185	21193×	}
186		}
187
188	21195×	fn workspaces_from_value(v: &Value) -> Result<BTreeMap<WorkspaceId, ChangeHash>, ObjectError> {
189	21195×	let mut out = BTreeMap::new();
190	21195×	for w in array(v, "workspaces")? {
191	20373×	let pair = array(w, "workspace")?;
192	20373×	if pair.len() != 2 {
193	0×	return Err(ObjectError::Schema(
194	0×	"workspace: expected [id, change]".into(),
195	0×	));
196	20373×	}
197	20373×	let id = WorkspaceId::from_slice(bytes(&pair[0], "workspace id")?)
198	20373×	.ok_or_else(\|\| ObjectError::Schema("workspace id: expected 16 bytes".into()))?;
199	20373×	out.insert(id, oref(&pair[1], "workspace change")?);
200		}
201	21195×	Ok(out)
202	21195×	}
203
204		impl Format1View {
205	3×	fn from_value(v: &Value) -> Result<Format1View, ObjectError> {
206	3×	let m = v
207	3×	.as_map()
208	3×	.ok_or_else(\|\| ObjectError::Schema("view: expected map".into()))?;
209	3×	let mut view = Format1View::default();
210	3×	for b in array(field(m, 0, "bookmarks")?, "bookmarks")? {
211	3×	let pair = array(b, "bookmark")?;
212	3×	if pair.len() != 2 {
213	0×	return Err(ObjectError::Schema(
214	0×	"bookmark: expected [name, heads]".into(),
215	0×	));
216	3×	}
217	3×	let name = text(&pair[0], "bookmark name")?.to_owned();
218	3×	let mut heads = array(&pair[1], "heads")?
219	3×	.iter()
220	3×	.map(\|h\| oref(h, "head"))
221	3×	.collect::<Result<Vec<_>, _>>()?;
222	3×	heads.sort();
223	3×	heads.dedup();
224	3×	view.bookmarks.insert(name, heads);
225		}
226	3×	view.workspaces = workspaces_from_value(field(m, 1, "workspaces")?)?;
227	3×	Ok(view)
228	3×	}
229
230		/// Format-1 encoding, kept for the migration test.
231		#[cfg(test)]
232	4×	pub(crate) fn to_value(&self) -> Value {
233	4×	Value::map([
234		(
235		0,
236		Value::Array(
237	4×	self.bookmarks
238	4×	.iter()
239	4×	.map(\|(n, hs)\| {
240	4×	Value::Array(vec![
241	4×	Value::Text(n.clone()),
242		Value::Array(
243	5×	hs.iter().map(\|h\| Value::Bytes(h.0.to_vec())).collect(),
244		),
245		])
246	4×	})
247	4×	.collect(),
248		),
249		),
250		(
251		1,
252		Value::Array(
253	4×	self.workspaces
254	4×	.iter()
255	4×	.map(\|(w, h)\| {
256	4×	Value::Array(vec![
257	4×	Value::Bytes(w.0.to_vec()),
258	4×	Value::Bytes(h.0.to_vec()),
259	4×	])
260	4×	})
261	4×	.collect(),
262		),
263		),
264		])
265	4×	}
266		}
267
268		/// A format-1 operation as read for migration.
269		#[derive(Clone, Debug, PartialEq, Eq)]
270		pub struct Format1Op {
271		pub parents: Vec<ObjectRef>,
272		pub hlc: Hlc,
273		pub command: String,
274		pub view: Format1View,
275		}
276
277		impl Format1Op {
278		#[cfg(test)]
279	4×	pub(crate) fn encode(&self) -> Vec<u8> {
280	4×	cbor::encode(&Value::map([
281	4×	(0, Value::Uint(FORMAT_VERSION)),
282		(
283		1,
284		Value::Array(
285	4×	self.parents
286	4×	.iter()
287	4×	.map(\|p\| Value::Bytes(p.0.to_vec()))
288	4×	.collect(),
289		),
290		),
291	4×	(2, self.hlc.to_value()),
292	4×	(3, Value::Text(self.command.clone())),
293	4×	(4, self.view.to_value()),
294		]))
295	4×	}
296		}
297
298		/// Suffix on the `command` of operations recorded by an automatic
299		/// working-copy snapshot rather than by a user command.
300		pub const SNAPSHOT_SUFFIX: &str = " (snapshot)";
301
302		impl Op {
303		/// Whether this operation only recorded a working-copy snapshot.
304	57×	pub fn is_snapshot(&self) -> bool {
305	57×	self.command.ends_with(SNAPSHOT_SUFFIX)
306	57×	}
307
308	3928×	pub fn to_value(&self) -> Value {
309	3928×	let mut fields = vec![
310	3928×	(0, Value::Uint(FORMAT_VERSION)),
311		(
312		1,
313		Value::Array(
314	3928×	self.parents
315	3928×	.iter()
316	3928×	.map(\|p\| Value::Bytes(p.0.to_vec()))
317	3928×	.collect(),
318		),
319		),
320	3928×	(2, self.hlc.to_value()),
321	3928×	(3, Value::Text(self.command.clone())),
322	3928×	(4, self.view.to_value()),
323		];
324		// Absent when unknown, so older operations keep their encoding.
325	3928×	if let Some(w) = &self.workspace {
326	3921×	fields.push((5, Value::Bytes(w.0.to_vec())));
327	3921×	}
328	3928×	if let Some(u) = &self.undoes {
329	5×	fields.push((6, Value::Bytes(u.0.to_vec())));
330	3923×	}
331	3928×	Value::map(fields)
332	3928×	}
333	3928×	pub fn encode(&self) -> Vec<u8> {
334	3928×	cbor::encode(&self.to_value())
335	3928×	}
336	4×	pub fn hash(&self) -> ObjectRef {
337	4×	hash_object(ObjectType::Op, &self.encode())
338	4×	}
339	21193×	pub fn decode(b: &[u8]) -> Result<Op, ObjectError> {
340	21193×	let v = cbor::decode(b)?;
341	21193×	let m = v
342	21193×	.as_map()
343	21193×	.ok_or_else(\|\| ObjectError::Schema("op: expected map".into()))?;
344	21193×	check_version(m)?;
345		Ok(Op {
346	21193×	parents: array(field(m, 1, "parents")?, "parents")?
347	21193×	.iter()
348	21193×	.map(\|p\| oref(p, "parent"))
349	21193×	.collect::<Result<Vec<_>, _>>()?,
350	21193×	hlc: Hlc::from_value(field(m, 2, "hlc")?)?,
351	21193×	command: text(field(m, 3, "command")?, "command")?.to_owned(),
352	21193×	view: View::from_value(field(m, 4, "view")?)?,
353	21192×	workspace: match m.get(&5) {
354	21183×	Some(v) => Some(
355	21183×	WorkspaceId::from_slice(bytes(v, "workspace")?).ok_or_else(\|\| {
356	0×	ObjectError::Schema("workspace: expected 16 bytes".into())
357	0×	})?,
358		),
359	9×	None => None,
360		},
361	21192×	undoes: m.get(&6).map(\|v\| oref(v, "undoes")).transpose()?,
362		})
363	21193×	}
364
365		/// Read an operation written by repository format 1.
366	3×	pub fn decode_format1(b: &[u8]) -> Result<Format1Op, ObjectError> {
367	3×	let v = cbor::decode(b)?;
368	3×	let m = v
369	3×	.as_map()
370	3×	.ok_or_else(\|\| ObjectError::Schema("op: expected map".into()))?;
371	3×	check_version(m)?;
372		Ok(Format1Op {
373	3×	parents: array(field(m, 1, "parents")?, "parents")?
374	3×	.iter()
375	3×	.map(\|p\| oref(p, "parent"))
376	3×	.collect::<Result<Vec<_>, _>>()?,
377	3×	hlc: Hlc::from_value(field(m, 2, "hlc")?)?,
378	3×	command: text(field(m, 3, "command")?, "command")?.to_owned(),
379	3×	view: Format1View::from_value(field(m, 4, "view")?)?,
380		})
381	3×	}
382		}
383
384		#[cfg(test)]
385		mod tests {
386		use super::*;
387
388		#[test]
389	1×	fn op_round_trip() {
390	1×	let mut view = View::default();
391	1×	view.bookmarks.insert("main".into(), ObjectRef([2; 32]));
392	1×	view.bookmarks.insert("dev".into(), ObjectRef([3; 32]));
393	1×	view.workspaces
394	1×	.insert(WorkspaceId([5; 16]), ObjectRef([9; 32]));
395	1×	view.remotes
396	1×	.entry("origin".into())
397	1×	.or_default()
398	1×	.insert("main".into(), ObjectRef([4; 32]));
399	1×	view.policy = Some(ObjectRef([6; 32]));
400	1×	view.tags.insert("v1".into(), ObjectRef([8; 32]));
401	1×	let op = Op {
402	1×	parents: vec![ObjectRef([7; 32])],
403	1×	hlc: Hlc {
404	1×	wall_ms: 5,
405	1×	logical: 1,
406	1×	},
407	1×	command: "oxy commit".into(),
408	1×	view,
409	1×	workspace: None,
410	1×	undoes: None,
411	1×	};
412	1×	let d = Op::decode(&op.encode()).unwrap();
413	1×	assert_eq!(d, op);
414		// The workspace and an undo's target travel when known.
415	1×	let mut known = op.clone();
416	1×	known.workspace = Some(WorkspaceId([3; 16]));
417	1×	known.undoes = Some(ObjectRef([1; 32]));
418	1×	assert_eq!(Op::decode(&known.encode()).unwrap(), known);
419	1×	assert_ne!(known.hash(), op.hash());
420	1×	assert_eq!(d.hash(), Op::decode(&d.encode()).unwrap().hash());
421		// A format-1 op does not decode as format 2, but does through the migration reader.
422	1×	let mut v1 = Format1View::default();
423	1×	v1.bookmarks
424	1×	.insert("main".into(), vec![ObjectRef([2; 32]), ObjectRef([1; 32])]);
425	1×	v1.workspaces
426	1×	.insert(WorkspaceId([5; 16]), ObjectRef([9; 32]));
427	1×	let old = Format1Op {
428	1×	parents: vec![],
429	1×	hlc: Hlc::default(),
430	1×	command: "oxy init".into(),
431	1×	view: v1,
432	1×	};
433	1×	assert!(Op::decode(&old.encode()).is_err());
434	1×	let back = Op::decode_format1(&old.encode()).unwrap();
435	1×	assert_eq!(
436	1×	back.view.bookmarks["main"],
437	1×	vec![ObjectRef([1; 32]), ObjectRef([2; 32])]
438		);
439	1×	}
440		}

Coverage / crates/oxy-core/src/oplog.rs 90.6%

Keyboard