a06673b
//! conflict Operation trait implementation for GitRepository.
use std::collections::HashMap;
use gix::object::tree::diff::ChangeDetached;
use crate::GitRepository;
use crate::conflict::impls::ConflictOps;
use crate::conflict::types::{ConflictDetail, ConflictFile, MergeStatus};
fn resolve_tree_id(repo: &gix::Repository, rev: &str) -> Result<gix::hash::ObjectId, crate::Error> {
let id = repo
.rev_parse_single(rev.as_bytes())
.map_err(|e| crate::Error::RevParse(e.to_string()))?
.detach();
let commit = repo
.find_commit(id)
.map_err(|e| crate::Error::Find(e.to_string()))?;
Ok(commit
.tree_id()
.map_err(|e| crate::Error::Find(e.to_string()))?
.detach())
}
fn changes_to_conflicts(changes: &[ChangeDetached]) -> Vec<ConflictFile> {
let mut out: Vec<ConflictFile> = Vec::new();
for change in changes {
match change {
ChangeDetached::Addition { location, id, .. } => {
out.push(ConflictFile {
path: location.to_string(),
our_oid: Some(*id),
their_oid: None,
base_oid: None,
});
}
ChangeDetached::Deletion { location, id, .. } => {
out.push(ConflictFile {
path: location.to_string(),
our_oid: None,
their_oid: None,
base_oid: Some(*id),
});
}
ChangeDetached::Modification {
location,
previous_id,
id,
..
} => {
out.push(ConflictFile {
path: location.to_string(),
our_oid: Some(*id),
their_oid: None,
base_oid: Some(*previous_id),
});
}
ChangeDetached::Rewrite {
source_location,
source_id,
location,
id,
..
} => {
out.push(ConflictFile {
path: format!("{} -> {}", source_location, location),
our_oid: Some(*id),
their_oid: None,
base_oid: Some(*source_id),
});
}
}
}
out
}
fn changes_to_oid_map(changes: &[ChangeDetached]) -> HashMap<String, Option<gix::hash::ObjectId>> {
let mut out: HashMap<String, Option<gix::hash::ObjectId>> = HashMap::new();
for change in changes {
match change {
ChangeDetached::Addition { location, id, .. } => {
out.insert(location.to_string(), Some(*id));
}
ChangeDetached::Deletion { location, .. } => {
out.insert(location.to_string(), None);
}
ChangeDetached::Modification { location, id, .. } => {
out.insert(location.to_string(), Some(*id));
}
ChangeDetached::Rewrite { location, id, .. } => {
out.insert(location.to_string(), Some(*id));
}
}
}
out
}
impl ConflictOps for GitRepository {
fn conflict_check(&self, base: &str, head: &str) -> Result<MergeStatus, crate::Error> {
let tip = self.tip_id()?;
let key = format!("{base}.{head}");
if let Some(hit) = self.cache_get_rev::<MergeStatus>("conflict", "check", &key, tip) {
return Ok(hit);
}
let repo = self.repo()?;
let h = repo
.rev_parse_single(head.as_bytes())
.map_err(|e| crate::Error::RevParse(e.to_string()))?
.detach();
let b = repo
.rev_parse_single(base.as_bytes())
.map_err(|e| crate::Error::RevParse(e.to_string()))?
.detach();
let head_commit = repo
.find_commit(h)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let head_tree_id = head_commit
.tree_id()
.map_err(|e| crate::Error::Find(e.to_string()))?
.detach();
let base_tree_id = resolve_tree_id(&repo, base)?;
let fast_forwardable = repo
.merge_base(b, h)
.map(|mb| mb.detach() == b)
.unwrap_or(false);
let conflicts = if base_tree_id == head_tree_id {
Vec::new()
} else {
let base_tree = repo
.find_tree(base_tree_id)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let head_tree = repo
.find_tree(head_tree_id)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let changes = repo
.diff_tree_to_tree(Some(&base_tree), Some(&head_tree), None)
.map_err(|e| crate::Error::Find(e.to_string()))?;
changes_to_conflicts(&changes)
};
let v = MergeStatus {
mergeable: conflicts.is_empty(),
conflicts,
fast_forwardable,
};
self.cache_put_rev("conflict", "check", &key, tip, &v);
Ok(v)
}
fn conflict_check_threeway(
&self,
ours: &str,
theirs: &str,
ancestor: &str,
) -> Result<MergeStatus, crate::Error> {
let repo = self.repo()?;
let ours_id = repo
.rev_parse_single(ours.as_bytes())
.map_err(|e| crate::Error::RevParse(e.to_string()))?
.detach();
let theirs_id = repo
.rev_parse_single(theirs.as_bytes())
.map_err(|e| crate::Error::RevParse(e.to_string()))?
.detach();
let fast_forwardable = repo
.merge_base(ours_id, theirs_id)
.map(|mb| mb.detach() == ours_id)
.unwrap_or(false);
let ancestor_tree_id = resolve_tree_id(&repo, ancestor)?;
let ours_tree_id = resolve_tree_id(&repo, ours)?;
let theirs_tree_id = resolve_tree_id(&repo, theirs)?;
if ours_tree_id == theirs_tree_id {
return Ok(MergeStatus {
mergeable: true,
conflicts: Vec::new(),
fast_forwardable,
});
}
let ancestor_tree = repo
.find_tree(ancestor_tree_id)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let ours_tree = repo
.find_tree(ours_tree_id)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let theirs_tree = repo
.find_tree(theirs_tree_id)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let ancestor_to_ours = repo
.diff_tree_to_tree(Some(&ancestor_tree), Some(&ours_tree), None)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let ancestor_to_theirs = repo
.diff_tree_to_tree(Some(&ancestor_tree), Some(&theirs_tree), None)
.map_err(|e| crate::Error::Find(e.to_string()))?;
let ours_map = changes_to_oid_map(&ancestor_to_ours);
let theirs_map = changes_to_oid_map(&ancestor_to_theirs);
let mut conflicts: Vec<ConflictFile> = Vec::new();
for (path, their_oid) in &theirs_map {
if let Some(our_oid) = ours_map.get(path)
&& our_oid != their_oid
{
conflicts.push(ConflictFile {
path: path.clone(),
our_oid: *our_oid,
their_oid: *their_oid,
base_oid: None,
});
}
}
Ok(MergeStatus {
mergeable: conflicts.is_empty(),
conflicts,
fast_forwardable,
})
}
fn conflict_conflicted_files(
&self,
base: &str,
head: &str,
) -> Result<Vec<String>, crate::Error> {
let tip = self.tip_id()?;
let key = format!("{base}.{head}");
if let Some(hit) = self.cache_get_rev::<Vec<String>>("conflict", "files", &key, tip) {
return Ok(hit);
}
let status = self.conflict_check(base, head)?;
let v: Vec<String> = status.conflicts.into_iter().map(|c| c.path).collect();
self.cache_put_rev("conflict", "files", &key, tip, &v);
Ok(v)
}
fn conflict_detail(
&self,
base: &str,
head: &str,
path: &str,
) -> Result<ConflictDetail, crate::Error> {
let tip = self.tip_id()?;
let key = format!("{base}.{head}.{path}");
if let Some(hit) = self.cache_get_rev::<ConflictDetail>("conflict", "detail", &key, tip) {
return Ok(hit);
}
let status = self.conflict_check(base, head)?;
let _conflict = status.conflicts.into_iter().find(|c| c.path == path);
let v = ConflictDetail {
path: path.to_string(),
diff: Vec::new(),
};
self.cache_put_rev("conflict", "detail", &key, tip, &v);
Ok(v)
}
}