use iced::{
Alignment, Element, Length,
widget::{Space, column, container, row, text},
};
use knotra_ui::widget::{
BUTTON_HEIGHT, NoticeTone, Tokens, Tone, body_badge_diameter, centered_button_label, list,
notice,
overlay::{OverlayWidth, surface},
reasoned, status_badge, status_symbol, style,
};
use knotra_vcs::{ProjectId, VcsKind};
use crate::{
message::{ConflictOpsMessage, Message},
state::{
AppState,
focus::{FocusTarget, LayerFocus},
},
};
mod focus_target {
pub const CLOSE: &str = "resolve.close";
pub const FOOTER_CLOSE: &str = "resolve.footer_close";
pub const DETAILS_TOGGLE: &str = "resolve.details_toggle";
pub const STOP_ATTEMPT: &str = "resolve.stop_attempt";
pub const CONFIRM_KEEP: &str = "resolve.confirm_keep";
pub const CONFIRM_STOP: &str = "resolve.confirm_stop";
}
pub fn layer_focus(state: &AppState, project_id: &ProjectId) -> LayerFocus<Message> {
use crate::state::conflict_ops::ConflictPhase;
let ops = &state.conflict_ops;
if let ConflictPhase::ConfirmStop { project_id: id, .. } = &ops.phase
&& id == project_id
{
let keep = FocusTarget::control(focus_target::CONFIRM_KEEP);
return LayerFocus {
order: vec![
(
FocusTarget::control(focus_target::CLOSE),
Some(Message::ConflictOps(ConflictOpsMessage::StopCancelled)),
),
(
keep.clone(),
Some(Message::ConflictOps(ConflictOpsMessage::StopCancelled)),
),
(
FocusTarget::control(focus_target::CONFIRM_STOP),
Some(Message::ConflictOps(
ConflictOpsMessage::AbortMergeRequested(project_id.clone()),
)),
),
],
entry: Some(keep),
};
}
let close_msg = close_message(state, project_id).map(Message::ConflictOps);
let close_target = FocusTarget::control(focus_target::CLOSE);
let footer_close_target = FocusTarget::control(focus_target::FOOTER_CLOSE);
match &ops.phase {
ConflictPhase::Operating { project_id: id, .. } if id == project_id => LayerFocus {
order: Vec::new(),
entry: None,
},
ConflictPhase::Done { project_id: id, .. } if id == project_id => {
let details_target = FocusTarget::control(focus_target::DETAILS_TOGGLE);
LayerFocus {
order: vec![
(close_target, close_msg.clone()),
(details_target, Some(Message::ToggleOpDetails)),
(footer_close_target.clone(), close_msg),
],
entry: Some(footer_close_target),
}
}
_ => {
let detail = match &ops.phase {
ConflictPhase::Browsing {
project_id: id,
detail,
} if id == project_id => Some(detail),
_ => ops.cached.get(project_id),
};
let vcs_kind = conflict_vcs_kind_for_project(state, project_id);
let editor_configured = state.config.external_editor.is_some();
let merge_tool_configured = state.config.external_merge_tool.is_some();
let abort_supported =
vcs_kind == Some(VcsKind::Git) && project_has_git_merge_state(state, project_id);
let mut order = vec![(close_target, close_msg.clone())];
let mut first_file_target = None;
if let Some(detail) = detail {
for (i, f) in detail.conflicted_files.iter().enumerate() {
let editor_target =
FocusTarget::control_dynamic(format!("resolve.file.{i}.open_editor"));
let editor_msg = editor_configured.then_some(Message::ConflictOps(
ConflictOpsMessage::OpenInEditorRequested(f.path.clone()),
));
if first_file_target.is_none() {
first_file_target = Some(editor_target.clone());
}
order.push((editor_target, editor_msg));
let tool_target =
FocusTarget::control_dynamic(format!("resolve.file.{i}.open_tool"));
let tool_msg = merge_tool_configured.then_some(Message::ConflictOps(
ConflictOpsMessage::OpenInMergeToolRequested(f.path.clone()),
));
order.push((tool_target, tool_msg));
if vcs_kind == Some(VcsKind::Git) {
let mark_target =
FocusTarget::control_dynamic(format!("resolve.file.{i}.mark_done"));
order.push((
mark_target,
Some(Message::ConflictOps(
ConflictOpsMessage::MarkResolvedRequested {
project_id: project_id.clone(),
file_path: f.path.clone(),
},
)),
));
}
}
}
if abort_supported {
let stop_reason = stop_control_reason(state);
order.push((
FocusTarget::control(focus_target::STOP_ATTEMPT),
stop_reason.is_none().then_some(Message::ConflictOps(
ConflictOpsMessage::StopRequested(project_id.clone()),
)),
));
}
order.push((footer_close_target.clone(), close_msg));
let entry = first_file_target.or(Some(footer_close_target));
LayerFocus { order, entry }
}
}
}
pub(crate) fn close_message(
state: &AppState,
project_id: &ProjectId,
) -> Option<ConflictOpsMessage> {
match &state.conflict_ops.phase {
crate::state::conflict_ops::ConflictPhase::Operating { .. } => None,
crate::state::conflict_ops::ConflictPhase::ConfirmStop { project_id: id, .. }
if id == project_id =>
{
Some(ConflictOpsMessage::StopCancelled)
}
_ => Some(ConflictOpsMessage::PanelClosed),
}
}
pub fn resolve_panel<'a>(state: &'a AppState, project_id: &'a ProjectId) -> Element<'a, Message> {
let tokens = &state.theme.tokens;
let name = project_name_for(state, project_id);
let ops = &state.conflict_ops;
let vcs_kind = conflict_vcs_kind_for_project(state, project_id);
let git_actions_supported = vcs_kind == Some(VcsKind::Git);
let abort_supported = git_actions_supported && project_has_git_merge_state(state, project_id);
let editor_configured = state.config.external_editor.is_some();
let merge_tool_configured = state.config.external_merge_tool.is_some();
let close_msg = close_message(state, project_id).map(Message::ConflictOps);
if let crate::state::conflict_ops::ConflictPhase::ConfirmStop { project_id: id, .. } =
&ops.phase
&& id == project_id
{
let body = column![
text(state.t("plain.resolve.stop_confirm_title"))
.size(snora::design::style::text::title_size(tokens)),
text(state.t("plain.resolve.stop_confirm_body"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens)),
]
.spacing(14);
let footer = row![
Space::new().width(Length::Fill),
styled_button(
tokens,
state.t("plain.resolve.stop_confirm_keep"),
Some(Message::ConflictOps(ConflictOpsMessage::StopCancelled)),
crate::app::ring(state, &FocusTarget::control(focus_target::CONFIRM_KEEP)),
style::ghost,
),
styled_button(
tokens,
state.t("plain.resolve.stop_confirm_stop"),
Some(Message::ConflictOps(
ConflictOpsMessage::AbortMergeRequested(project_id.clone(),)
)),
crate::app::ring(state, &FocusTarget::control(focus_target::CONFIRM_STOP)),
style::danger,
),
]
.align_y(Alignment::Center)
.spacing(8);
return surface(
tokens,
OverlayWidth::Large.resolve(state.window_width),
format!("{} — {}", state.t("plain.resolve.title"), name),
close_msg,
crate::app::ring(state, &FocusTarget::control(focus_target::CLOSE)),
body,
footer,
);
}
let content: Element<'_, Message> = match &ops.phase {
crate::state::conflict_ops::ConflictPhase::Loading(id) if id == project_id => {
text(state.t("plain.resolve.loading"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens))
.into()
}
crate::state::conflict_ops::ConflictPhase::Operating {
project_id: id,
action,
} if id == project_id => column![
text(action)
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens)),
text(state.t("plain.resolve.working_hint"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens)),
]
.spacing(8)
.into(),
crate::state::conflict_ops::ConflictPhase::Done {
project_id: id,
success,
message,
result,
} if id == project_id => {
let tone = if *success {
NoticeTone::Success
} else {
NoticeTone::Danger
};
let banner = notice(tokens, tone, None, message.as_str(), None);
let details_label = if state.show_op_details {
state.t("plain.hide_details")
} else {
state.t("plain.show_details")
};
let mut result_col = column![
banner,
styled_button(
tokens,
details_label,
Some(Message::ToggleOpDetails),
crate::app::ring(state, &FocusTarget::control(focus_target::DETAILS_TOGGLE)),
style::ghost,
),
]
.spacing(8);
if state.show_op_details
&& let Some(result) = result
{
for command in &result.commands_executed {
result_col = result_col.push(
text(format!("command: {command}"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens)),
);
}
if !result.stdout.is_empty() {
result_col =
result_col.extend(labelled_lines(tokens, "stdout: ", &result.stdout));
}
if !result.stderr.is_empty() {
result_col =
result_col.extend(labelled_lines(tokens, "stderr: ", &result.stderr));
}
if let Some(error) = &result.error_message {
result_col = result_col.push(
text(format!("error: {error}"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens)),
);
}
}
result_col.into()
}
_ => {
let detail = match &ops.phase {
crate::state::conflict_ops::ConflictPhase::Browsing {
project_id: id,
detail,
} if id == project_id => Some(detail),
_ => ops.cached.get(project_id),
};
if let Some(detail) = detail {
if detail.conflicted_files.is_empty() {
text(state.t("plain.resolve.no_files"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens))
.into()
} else {
let file_rows: Vec<Element<'_, Message>> = detail
.conflicted_files
.iter()
.enumerate()
.map(|(i, f)| {
let editor_target = FocusTarget::control_dynamic(format!(
"resolve.file.{i}.open_editor"
));
let tool_target =
FocusTarget::control_dynamic(format!("resolve.file.{i}.open_tool"));
let mark_target =
FocusTarget::control_dynamic(format!("resolve.file.{i}.mark_done"));
let editor_reason = (!editor_configured)
.then_some(state.t("plain.resolve.editor_not_configured"));
let open_editor_msg =
editor_configured.then_some(Message::ConflictOps(
ConflictOpsMessage::OpenInEditorRequested(f.path.clone()),
));
let merge_tool_reason = (!merge_tool_configured)
.then_some(state.t("plain.resolve.merge_tool_not_configured"));
let open_merge_tool_msg =
merge_tool_configured.then_some(Message::ConflictOps(
ConflictOpsMessage::OpenInMergeToolRequested(f.path.clone()),
));
let line1 = row![
status_badge(
tokens,
Tone::Danger,
&status_symbol::alert(),
body_badge_diameter(tokens)
),
text(&f.path)
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(
tokens
))
.width(Length::Fill),
]
.align_y(Alignment::Center)
.spacing(6);
let mut line2_controls = row![
container(reasoned(
tokens,
state.t("plain.resolve.open_editor"),
open_editor_msg,
editor_reason,
crate::app::ring(state, &editor_target),
style::secondary,
))
.width(Length::Fill),
container(reasoned(
tokens,
state.t("plain.resolve.open_merge_tool"),
open_merge_tool_msg,
merge_tool_reason,
crate::app::ring(state, &tool_target),
style::secondary,
))
.width(Length::Fill),
]
.align_y(Alignment::Start)
.spacing(6);
let mut file_col = column![line1].spacing(4);
match third_slot_for(
state,
tokens,
vcs_kind,
project_id,
&f.path,
crate::app::ring(state, &mark_target),
) {
ThirdSlot::Button(control) => {
line2_controls = line2_controls.push(control);
file_col = file_col.push(row![
Space::new().width(Length::Fixed(28.0)),
line2_controls.wrap(),
]);
}
ThirdSlot::Prose(sentence) => {
file_col = file_col.push(row![
Space::new().width(Length::Fixed(28.0)),
line2_controls.wrap(),
]);
file_col = file_col.push(row![
Space::new().width(Length::Fixed(28.0)),
text(sentence)
.size(snora::design::style::text::body_size(tokens))
.line_height(
snora::design::style::text::body_line_height(
tokens
)
)
.width(Length::Fill),
]);
}
}
file_col.into()
})
.collect();
list(tokens, file_rows)
}
} else {
text(state.t("plain.resolve.loading"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens))
.into()
}
}
};
let stop_control: Element<'_, Message> =
if abort_supported {
let reason = stop_control_reason(state);
reasoned(
tokens,
state.t("plain.resolve.stop_attempt"),
reason.is_none().then_some(Message::ConflictOps(
ConflictOpsMessage::StopRequested(project_id.clone()),
)),
reason,
crate::app::ring(state, &FocusTarget::control(focus_target::STOP_ATTEMPT)),
style::danger,
)
} else {
Space::new().width(Length::Fixed(0.0)).into()
};
let footer_close_focused =
crate::app::ring(state, &FocusTarget::control(focus_target::FOOTER_CLOSE));
let footer = row![
stop_control,
Space::new().width(Length::Fill),
styled_button(
tokens,
state.t("action.close"),
close_msg.clone(),
footer_close_focused,
style::ghost
),
]
.align_y(Alignment::Center);
let body = column![
text(state.t("plain.resolve.instruction"))
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens)),
content,
]
.spacing(14);
surface(
tokens,
OverlayWidth::Large.resolve(state.window_width),
format!("{} — {}", state.t("plain.resolve.title"), name),
close_msg,
crate::app::ring(state, &FocusTarget::control(focus_target::CLOSE)),
body,
footer,
)
}
fn labelled_line_strings(label: &str, content: &str) -> Vec<String> {
let indent = " ".repeat(label.chars().count());
content
.lines()
.enumerate()
.map(|(i, line)| {
let prefix = if i == 0 { label } else { indent.as_str() };
format!("{prefix}{line}")
})
.collect()
}
fn labelled_lines<'a>(
tokens: &Tokens,
label: &'static str,
content: &str,
) -> Vec<Element<'a, Message>> {
labelled_line_strings(label, content)
.into_iter()
.map(|line| {
text(line)
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens))
.into()
})
.collect()
}
fn styled_button<'a>(
tokens: &Tokens,
label: &'a str,
on_press: Option<Message>,
is_focused: bool,
style_fn: fn(&Tokens, iced::widget::button::Status) -> iced::widget::button::Style,
) -> Element<'a, Message> {
let t = tokens.clone();
iced::widget::button(centered_button_label(
text(label)
.size(snora::design::style::text::body_size(tokens))
.line_height(snora::design::style::text::body_line_height(tokens)),
))
.height(BUTTON_HEIGHT)
.padding([0, 18])
.on_press_maybe(on_press)
.style(move |_theme, status| style::with_focus_ring(&t, is_focused, style_fn(&t, status)))
.into()
}
enum ThirdSlot<'a> {
Button(Element<'a, Message>),
Prose(String),
}
fn third_slot_for<'a>(
state: &'a AppState,
tokens: &Tokens,
vcs_kind: Option<VcsKind>,
project_id: &ProjectId,
file_path: &str,
is_focused: bool,
) -> ThirdSlot<'a> {
match vcs_kind {
Some(VcsKind::Git) => {
ThirdSlot::Button(reasoned(
tokens,
state.t("plain.resolve.mark_done"),
Some(Message::ConflictOps(
ConflictOpsMessage::MarkResolvedRequested {
project_id: project_id.clone(),
file_path: file_path.to_owned(),
},
)),
None,
is_focused,
style::secondary,
))
}
Some(VcsKind::Jujutsu) => ThirdSlot::Prose(jj_finish_hint(state, file_path)),
None => ThirdSlot::Prose(state.t("plain.resolve.unsupported").to_owned()),
}
}
fn conflict_vcs_kind_for_project(state: &AppState, project_id: &ProjectId) -> Option<VcsKind> {
state
.workspace_status
.as_ref()
.and_then(|ws| {
ws.projects
.iter()
.find(|status| &status.project_id == project_id)
})
.map(|status| status.identity.vcs_kind)
.or_else(|| {
state
.workspace
.as_ref()
.and_then(|ws| ws.projects.iter().find(|project| &project.id == project_id))
.and_then(|project| {
let path = std::path::Path::new(&project.path);
if path.join(".jj").is_dir() {
Some(VcsKind::Jujutsu)
} else if path.join(".git").exists() {
Some(VcsKind::Git)
} else {
None
}
})
})
}
fn jj_finish_hint(state: &AppState, file_path: &str) -> String {
format!(
"{} `jj resolve {file_path}`",
state.t("plain.resolve.jj_finish_hint")
)
}
fn stop_control_reason(state: &AppState) -> Option<&str> {
state
.operation_interlock
.is_busy()
.then_some(state.t("plain.activity.busy"))
}
fn project_has_git_merge_state(state: &AppState, project_id: &ProjectId) -> bool {
state
.workspace
.as_ref()
.and_then(|ws| ws.projects.iter().find(|project| &project.id == project_id))
.map(|project| {
let path = std::path::Path::new(&project.path);
path.join(".git").join("MERGE_HEAD").exists()
})
.unwrap_or(false)
}
fn project_name_for(state: &AppState, id: &ProjectId) -> String {
state
.workspace
.as_ref()
.and_then(|ws| ws.projects.iter().find(|p| &p.id == id))
.map(|p| p.name.clone())
.unwrap_or_else(|| id.to_string())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::AppConfig;
use crate::state::OperationOwner;
use knotra_vcs::{
ConflictStatus, RemoteStatus, RepositoryIdentity, WorkingTreeStatus, WorkspaceStatus,
};
#[test]
fn labelled_line_strings_indents_every_line_after_the_first() {
let lines =
labelled_line_strings("stderr: ", "error: failed to push\nhint: try fetch first");
assert_eq!(
lines,
vec![
"stderr: error: failed to push".to_owned(),
" hint: try fetch first".to_owned(),
]
);
}
fn status_for(project_id: ProjectId, vcs_kind: VcsKind) -> knotra_vcs::ProjectStatus {
knotra_vcs::ProjectStatus {
project_id,
identity: RepositoryIdentity {
path: "/tmp".into(),
vcs_kind,
},
context: None,
remote: RemoteStatus::default(),
working_tree: WorkingTreeStatus::default(),
conflict: ConflictStatus::default(),
refreshed_at: jiff::Timestamp::now(),
read_error: None,
}
}
fn state_with_status(vcs_kind: VcsKind) -> (AppState, ProjectId) {
let mut state = AppState::new(AppConfig::default());
let project_id = ProjectId::new();
state.workspace_status = Some(WorkspaceStatus {
projects: vec![status_for(project_id.clone(), vcs_kind)],
last_refresh: None,
});
(state, project_id)
}
#[test]
fn conflict_vcs_kind_for_project_reports_jujutsu_for_a_jj_project() {
let (state, project_id) = state_with_status(VcsKind::Jujutsu);
assert_eq!(
conflict_vcs_kind_for_project(&state, &project_id),
Some(VcsKind::Jujutsu)
);
}
#[test]
fn conflict_vcs_kind_for_project_reports_git_for_a_git_project() {
let (state, project_id) = state_with_status(VcsKind::Git);
assert_eq!(
conflict_vcs_kind_for_project(&state, &project_id),
Some(VcsKind::Git)
);
}
#[test]
fn conflict_vcs_kind_for_project_reports_none_with_neither_marker_present() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let mut state = AppState::new(AppConfig::default());
let project = knotra_vcs::Project::new("svc", tmp.path().to_string_lossy());
let project_id = project.id.clone();
state.workspace = Some(knotra_vcs::Workspace {
projects: vec![project],
..knotra_vcs::Workspace::new("Test")
});
assert_eq!(conflict_vcs_kind_for_project(&state, &project_id), None);
}
#[test]
fn conflict_vcs_kind_for_project_reports_none_when_absent_from_both_sources() {
let state = AppState::new(AppConfig::default());
let project_id = ProjectId::new();
assert_eq!(conflict_vcs_kind_for_project(&state, &project_id), None);
}
#[test]
fn jj_finish_hint_names_the_command_with_the_files_path() {
let state = AppState::new(AppConfig::default());
let hint = jj_finish_hint(&state, "src/lib.rs");
assert_eq!(hint, "Finish with: `jj resolve src/lib.rs`");
}
#[test]
fn third_slot_is_a_button_for_git_and_prose_for_jujutsu_and_none() {
let state = AppState::new(AppConfig::default());
let tokens = &state.theme.tokens;
let project_id = ProjectId::new();
assert!(matches!(
third_slot_for(
&state,
tokens,
Some(VcsKind::Git),
&project_id,
"src/lib.rs",
false
),
ThirdSlot::Button(_)
));
assert!(matches!(
third_slot_for(
&state,
tokens,
Some(VcsKind::Jujutsu),
&project_id,
"src/lib.rs",
false
),
ThirdSlot::Prose(_)
));
assert!(matches!(
third_slot_for(&state, tokens, None, &project_id, "src/lib.rs", false),
ThirdSlot::Prose(_)
));
}
#[test]
fn stop_control_reason_is_none_when_idle() {
let state = AppState::new(AppConfig::default());
assert_eq!(stop_control_reason(&state), None);
}
#[test]
fn stop_control_reason_is_busy_while_interlock_is_held() {
let mut state = AppState::new(AppConfig::default());
state
.operation_interlock
.try_acquire(OperationOwner::SmartPullExecution)
.expect("acquire lease");
assert_eq!(
stop_control_reason(&state),
Some(state.t("plain.activity.busy"))
);
}
}