backend: add methods for reading and writing copy objects

This patch implements the methods only in the test backend. That
should enough for us to start implementing diffing and merging on top,
including tests for that functionality. Support in the Git backend can
come once we've seen that the model works.

Author: martinvonz

cli/examples/custom-backend/main.rs

@@ -32,6 +32,8 @@ use jj_lib::backend::Commit;
 use jj_lib::backend::CommitId;
 use jj_lib::backend::Conflict;
 use jj_lib::backend::ConflictId;
+use jj_lib::backend::CopyHistory;
+use jj_lib::backend::CopyId;
 use jj_lib::backend::CopyRecord;
 use jj_lib::backend::FileId;
 use jj_lib::backend::SigningFn;
@@ -171,6 +173,18 @@ impl Backend for JitBackend {
         self.inner.write_symlink(path, target).await
     }
 
+    async fn read_copy(&self, id: &CopyId) -> BackendResult<CopyHistory> {
+        self.inner.read_copy(id).await
+    }
+
+    async fn write_copy(&self, contents: &CopyHistory) -> BackendResult<CopyId> {
+        self.inner.write_copy(contents).await
+    }
+
+    async fn get_related_copies(&self, copy_id: &CopyId) -> BackendResult<Vec<CopyHistory>> {
+        self.inner.get_related_copies(copy_id).await
+    }
+
     async fn read_tree(&self, path: &RepoPath, id: &TreeId) -> BackendResult<Tree> {
         self.inner.read_tree(path, id).await
     }

lib/src/backend.rs

@@ -51,6 +51,7 @@ id_type!(pub TreeId { hex() });
 id_type!(pub FileId { hex() });
 id_type!(pub SymlinkId { hex() });
 id_type!(pub ConflictId { hex() });
+id_type!(pub CopyId { hex() });
 
 impl ChangeId {
     /// Returns the hex string representation of this ID, which uses `z-k`
@@ -196,6 +197,24 @@ pub struct CopyRecord {
     pub source_commit: CommitId,
 }
 
+/// Describes the copy history of a file. The copy object is unchanged when a
+/// file is modified.
+#[derive(ContentHash, Debug, PartialEq, Eq, Clone, PartialOrd, Ord)]
+pub struct CopyHistory {
+    /// The file's current path.
+    pub current_path: RepoPathBuf,
+    /// IDs of the files that became the current incarnation of this file.
+    ///
+    /// A newly created file has no parents. A regular copy or rename has one
+    /// parent. A merge of multiple files has multiple parents.
+    pub parents: Vec<CopyId>,
+    /// An optional piece of data to give the Copy object a different ID. May be
+    /// randomly generated. This allows a commit to say that a file was replaced
+    /// by a new incarnation of it, indicating a logically distinct file
+    /// taking the place of the previous file at the path.
+    pub salt: Vec<u8>,
+}
+
 /// Error that may occur during backend initialization.
 #[derive(Debug, Error)]
 #[error(transparent)]
@@ -269,6 +288,8 @@ pub type BackendResult<T> = Result<T, BackendError>;
 
 #[derive(ContentHash, Debug, PartialEq, Eq, Clone, Hash)]
 pub enum TreeValue {
+    // TODO: When there's a CopyId here, the copy object's path must match
+    // the path identified by the tree.
     File { id: FileId, executable: bool },
     Symlink(SymlinkId),
     Tree(TreeId),
@@ -440,6 +461,29 @@ pub trait Backend: Send + Sync + Debug {
 
     async fn write_symlink(&self, path: &RepoPath, target: &str) -> BackendResult<SymlinkId>;
 
+    /// Read the specified `CopyHistory` object.
+    ///
+    /// Backends that don't support copy tracking may return
+    /// `BackendError::Unsupported`.
+    async fn read_copy(&self, id: &CopyId) -> BackendResult<CopyHistory>;
+
+    /// Write the `CopyHistory` object and return its ID.
+    ///
+    /// Backends that don't support copy tracking may return
+    /// `BackendError::Unsupported`.
+    async fn write_copy(&self, copy: &CopyHistory) -> BackendResult<CopyId>;
+
+    /// Find all copy histories that are related to the specified one. This is
+    /// defined as those that are ancestors of the given specified one, plus
+    /// their descendants. Children must be returned before parents.
+    ///
+    /// It is valid (but wasteful) to include other copy histories, such as
+    /// siblings, or even completely unrelated copy histories.
+    ///
+    /// Backends that don't support copy tracking may return
+    /// `BackendError::Unsupported`.
+    async fn get_related_copies(&self, copy_id: &CopyId) -> BackendResult<Vec<CopyHistory>>;
+
     async fn read_tree(&self, path: &RepoPath, id: &TreeId) -> BackendResult<Tree>;
 
     async fn write_tree(&self, path: &RepoPath, contents: &Tree) -> BackendResult<TreeId>;

lib/src/git_backend.rs

@@ -60,6 +60,8 @@ use crate::backend::CommitId;
 use crate::backend::Conflict;
 use crate::backend::ConflictId;
 use crate::backend::ConflictTerm;
+use crate::backend::CopyHistory;
+use crate::backend::CopyId;
 use crate::backend::CopyRecord;
 use crate::backend::FileId;
 use crate::backend::MergedTreeId;
@@ -1022,6 +1024,24 @@ impl Backend for GitBackend {
         Ok(SymlinkId::new(oid.as_bytes().to_vec()))
     }
 
+    async fn read_copy(&self, _id: &CopyId) -> BackendResult<CopyHistory> {
+        Err(BackendError::Unsupported(
+            "The Git backend doesn't support tracked copies yet".to_string(),
+        ))
+    }
+
+    async fn write_copy(&self, _contents: &CopyHistory) -> BackendResult<CopyId> {
+        Err(BackendError::Unsupported(
+            "The Git backend doesn't support tracked copies yet".to_string(),
+        ))
+    }
+
+    async fn get_related_copies(&self, _copy_id: &CopyId) -> BackendResult<Vec<CopyHistory>> {
+        Err(BackendError::Unsupported(
+            "The Git backend doesn't support tracked copies yet".to_string(),
+        ))
+    }
+
     async fn read_tree(&self, _path: &RepoPath, id: &TreeId) -> BackendResult<Tree> {
         if id == &self.empty_tree_id {
             return Ok(Tree::default());

lib/src/repo_path.rs

@@ -199,15 +199,15 @@ impl DoubleEndedIterator for RepoPathComponentsIter<'_> {
 impl FusedIterator for RepoPathComponentsIter<'_> {}
 
 /// Owned repository path.
-#[derive(Clone, Eq, Hash, PartialEq)]
+#[derive(ContentHash, Clone, Eq, Hash, PartialEq)]
 pub struct RepoPathBuf {
     // Don't add more fields. Eq, Hash, and Ord must be compatible with the
     // borrowed RepoPath type.
     value: String,
 }
 
 /// Borrowed repository path.
-#[derive(Eq, Hash, PartialEq, RefCastCustom)]
+#[derive(ContentHash, Eq, Hash, PartialEq, RefCastCustom)]
 #[repr(transparent)]
 pub struct RepoPath {
     value: str,

lib/src/secret_backend.rs

@@ -32,6 +32,8 @@ use crate::backend::Commit;
 use crate::backend::CommitId;
 use crate::backend::Conflict;
 use crate::backend::ConflictId;
+use crate::backend::CopyHistory;
+use crate::backend::CopyId;
 use crate::backend::CopyRecord;
 use crate::backend::FileId;
 use crate::backend::SigningFn;
@@ -161,6 +163,24 @@ impl Backend for SecretBackend {
         self.inner.write_symlink(path, target).await
     }
 
+    async fn read_copy(&self, _id: &CopyId) -> BackendResult<CopyHistory> {
+        Err(BackendError::Unsupported(
+            "The secret backend doesn't support copies".to_string(),
+        ))
+    }
+
+    async fn write_copy(&self, _contents: &CopyHistory) -> BackendResult<CopyId> {
+        Err(BackendError::Unsupported(
+            "The secret backend doesn't support copies".to_string(),
+        ))
+    }
+
+    async fn get_related_copies(&self, _copy_id: &CopyId) -> BackendResult<Vec<CopyHistory>> {
+        Err(BackendError::Unsupported(
+            "The secret backend doesn't support copies".to_string(),
+        ))
+    }
+
     async fn read_tree(&self, path: &RepoPath, id: &TreeId) -> BackendResult<Tree> {
         self.inner.read_tree(path, id).await
     }

lib/src/simple_backend.rs

@@ -47,6 +47,8 @@ use crate::backend::CommitId;
 use crate::backend::Conflict;
 use crate::backend::ConflictId;
 use crate::backend::ConflictTerm;
+use crate::backend::CopyHistory;
+use crate::backend::CopyId;
 use crate::backend::CopyRecord;
 use crate::backend::FileId;
 use crate::backend::MergedTreeId;
@@ -253,6 +255,24 @@ impl Backend for SimpleBackend {
         Ok(id)
     }
 
+    async fn read_copy(&self, _id: &CopyId) -> BackendResult<CopyHistory> {
+        Err(BackendError::Unsupported(
+            "The simple backend doesn't support copies".to_string(),
+        ))
+    }
+
+    async fn write_copy(&self, _contents: &CopyHistory) -> BackendResult<CopyId> {
+        Err(BackendError::Unsupported(
+            "The simple backend doesn't support copies".to_string(),
+        ))
+    }
+
+    async fn get_related_copies(&self, _copy_id: &CopyId) -> BackendResult<Vec<CopyHistory>> {
+        Err(BackendError::Unsupported(
+            "The simple backend doesn't support copies".to_string(),
+        ))
+    }
+
     async fn read_tree(&self, _path: &RepoPath, id: &TreeId) -> BackendResult<Tree> {
         let path = self.tree_path(id);
         let buf = fs::read(path).map_err(|err| map_not_found_err(err, id))?;

lib/testutils/src/test_backend.rs

@@ -38,13 +38,16 @@ use jj_lib::backend::Commit;
 use jj_lib::backend::CommitId;
 use jj_lib::backend::Conflict;
 use jj_lib::backend::ConflictId;
+use jj_lib::backend::CopyHistory;
+use jj_lib::backend::CopyId;
 use jj_lib::backend::CopyRecord;
 use jj_lib::backend::FileId;
 use jj_lib::backend::SecureSig;
 use jj_lib::backend::SigningFn;
 use jj_lib::backend::SymlinkId;
 use jj_lib::backend::Tree;
 use jj_lib::backend::TreeId;
+use jj_lib::dag_walk::topo_order_forward;
 use jj_lib::index::Index;
 use jj_lib::object_id::ObjectId as _;
 use jj_lib::repo_path::RepoPath;
@@ -68,6 +71,7 @@ pub struct TestBackendData {
     files: HashMap<RepoPathBuf, HashMap<FileId, Vec<u8>>>,
     symlinks: HashMap<RepoPathBuf, HashMap<SymlinkId, String>>,
     conflicts: HashMap<RepoPathBuf, HashMap<ConflictId, Conflict>>,
+    copies: HashMap<CopyId, CopyHistory>,
 }
 
 #[derive(Clone, Default)]
@@ -249,6 +253,47 @@ impl Backend for TestBackend {
         Ok(id)
     }
 
+    async fn read_copy(&self, id: &CopyId) -> BackendResult<CopyHistory> {
+        let copy = self.locked_data().copies.get(id).cloned().ok_or_else(|| {
+            BackendError::ObjectNotFound {
+                object_type: "copy".to_string(),
+                hash: id.hex(),
+                source: "".into(),
+            }
+        })?;
+        Ok(copy)
+    }
+
+    async fn write_copy(&self, contents: &CopyHistory) -> BackendResult<CopyId> {
+        let id = CopyId::new(get_hash(contents));
+        self.locked_data()
+            .copies
+            .insert(id.clone(), contents.clone());
+        Ok(id)
+    }
+
+    async fn get_related_copies(&self, copy_id: &CopyId) -> BackendResult<Vec<CopyHistory>> {
+        let copies = &self.locked_data().copies;
+        if !copies.contains_key(copy_id) {
+            return Err(BackendError::ObjectNotFound {
+                object_type: "copy history".to_string(),
+                hash: copy_id.hex(),
+                source: "".into(),
+            });
+        }
+        // Return all copy histories to test that the caller correctly ignores histories
+        // that are not relevant to the trees they're working with.
+        let mut histories = vec![];
+        for id in topo_order_forward(
+            copies.keys(),
+            |id| *id,
+            |id| copies.get(*id).unwrap().parents.iter(),
+        ) {
+            histories.push(copies.get(id).unwrap().clone());
+        }
+        Ok(histories)
+    }
+
     async fn read_tree(&self, path: &RepoPath, id: &TreeId) -> BackendResult<Tree> {
         if id == &self.empty_tree_id {
             return Ok(Tree::default());
@@ -356,3 +401,46 @@ impl Backend for TestBackend {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use pollster::FutureExt as _;
+
+    use super::*;
+    use crate::repo_path_buf;
+
+    fn copy_history(path: &str, parents: &[CopyId]) -> CopyHistory {
+        CopyHistory {
+            current_path: repo_path_buf(path),
+            parents: parents.to_vec(),
+            salt: vec![],
+        }
+    }
+
+    #[test]
+    fn get_related_copies() {
+        let backend = TestBackend::with_data(Arc::new(Mutex::new(TestBackendData::default())));
+
+        // Test with a single chain so the resulting order is deterministic
+        let copy1 = copy_history("foo1", &[]);
+        let copy1_id = backend.write_copy(&copy1).block_on().unwrap();
+        let copy2 = copy_history("foo2", &[copy1_id.clone()]);
+        let copy2_id = backend.write_copy(&copy2).block_on().unwrap();
+        let copy3 = copy_history("foo3", &[copy2_id.clone()]);
+        let copy3_id = backend.write_copy(&copy3).block_on().unwrap();
+
+        // Error when looking up by non-existent id
+        assert!(backend
+            .get_related_copies(&CopyId::from_hex("abcd"))
+            .block_on()
+            .is_err());
+
+        // Looking up by any id returns the related copies in the same order (children
+        // before parents)
+        let related = backend.get_related_copies(&copy1_id).block_on().unwrap();
+        assert_eq!(related, vec![copy3.clone(), copy2.clone(), copy1.clone()]);
+        let related: Vec<CopyHistory> = backend.get_related_copies(&copy3_id).block_on().unwrap();
+        assert_eq!(related, vec![copy3.clone(), copy2.clone(), copy1.clone()]);
+    }
+}