use jujube_lib::repo_path::{DirRepoPath, RepoPath};
use jujube_lib::store::{StoreError, TreeId, TreeValue};
use jujube_lib::store_wrapper::StoreWrapper;
use jujube_lib::tree::Tree;
use jujube_lib::tree_builder::TreeBuilder;
use jujube_lib::trees::merge_trees;
use jujube_lib::working_copy::{CheckoutError, TreeState};
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::Arc;
use tempfile::tempdir;
use thiserror::Error;
#[derive(Debug, Error, PartialEq, Eq)]
pub enum DiffEditError {
#[error("The diff tool exited with a non-zero code")]
DifftoolAborted,
#[error("Failed to write directories to diff: {0:?}")]
CheckoutError(CheckoutError),
#[error("Internal error: {0:?}")]
InternalStoreError(StoreError),
}
impl From<CheckoutError> for DiffEditError {
fn from(err: CheckoutError) -> Self {
DiffEditError::CheckoutError(err)
}
}
impl From<StoreError> for DiffEditError {
fn from(err: StoreError) -> Self {
DiffEditError::InternalStoreError(err)
}
}
fn add_to_tree(
store: &StoreWrapper,
tree_builder: &mut TreeBuilder,
repo_path: &RepoPath,
value: &TreeValue,
) -> Result<(), StoreError> {
match value {
TreeValue::Conflict(conflict_id) => {
let conflict = store.read_conflict(conflict_id)?;
let materialized_value =
jujube_lib::conflicts::conflict_to_materialized_value(store, repo_path, &conflict);
tree_builder.set(repo_path.clone(), materialized_value);
}
_ => {
tree_builder.set(repo_path.clone(), (*value).clone());
}
}
Ok(())
}
fn check_out(
store: Arc<StoreWrapper>,
wc_dir: PathBuf,
state_dir: PathBuf,
tree_id: TreeId,
) -> Result<TreeState, DiffEditError> {
std::fs::create_dir(&wc_dir).unwrap();
std::fs::create_dir(&state_dir).unwrap();
let mut tree_state = TreeState::init(store, wc_dir, state_dir);
tree_state.check_out(tree_id)?;
Ok(tree_state)
}
fn set_readonly_recursively(path: &Path) {
if path.is_dir() {
for entry in path.read_dir().unwrap() {
set_readonly_recursively(&entry.unwrap().path());
}
}
let mut perms = std::fs::metadata(path).unwrap().permissions();
perms.set_readonly(true);
std::fs::set_permissions(path, perms).unwrap();
}
pub fn edit_diff(left_tree: &Tree, right_tree: &Tree) -> Result<TreeId, DiffEditError> {
let store = left_tree.store();
let mut left_tree_builder = store.tree_builder(store.empty_tree_id().clone());
let mut right_tree_builder = store.tree_builder(store.empty_tree_id().clone());
left_tree.diff(&right_tree, &mut |file_path, diff| {
let (left_value, right_value) = diff.as_options();
let repo_path = file_path.to_repo_path();
if let Some(value) = left_value {
add_to_tree(store, &mut left_tree_builder, &repo_path, value).unwrap();
}
if let Some(value) = right_value {
add_to_tree(store, &mut right_tree_builder, &repo_path, value).unwrap();
}
});
let left_partial_tree_id = left_tree_builder.write_tree();
let right_partial_tree_id = right_tree_builder.write_tree();
let right_partial_tree = store.get_tree(&DirRepoPath::root(), &right_partial_tree_id)?;
let temp_dir = tempdir().unwrap();
let left_wc_dir = temp_dir.path().join("left");
let left_state_dir = temp_dir.path().join("left_state");
let right_wc_dir = temp_dir.path().join("right");
let right_state_dir = temp_dir.path().join("right_state");
check_out(
store.clone(),
left_wc_dir.clone(),
left_state_dir,
left_partial_tree_id,
)?;
set_readonly_recursively(&left_wc_dir);
let mut right_tree_state = check_out(
store.clone(),
right_wc_dir.clone(),
right_state_dir,
right_partial_tree_id,
)?;
let exit_status = Command::new("meld")
.arg(&left_wc_dir)
.arg(&right_wc_dir)
.status()
.expect("failed to run diff editor");
if !exit_status.success() {
return Err(DiffEditError::DifftoolAborted);
}
let new_right_partial_tree_id = right_tree_state.write_tree();
let new_right_partial_tree =
store.get_tree(&DirRepoPath::root(), &new_right_partial_tree_id)?;
let new_tree_id = merge_trees(right_tree, &right_partial_tree, &new_right_partial_tree)?;
Ok(new_tree_id)
}