Add server-owned stacked panes with vertical navigation
This commit is contained in:
+650
-40
@@ -86,6 +86,24 @@ fn clean_title(title: String) -> Option<String> {
|
||||
let title = title.trim();
|
||||
(!title.is_empty()).then(|| title.to_owned())
|
||||
}
|
||||
fn single_pane_stack(pane: PaneId) -> StackInfo {
|
||||
StackInfo {
|
||||
panes: vec![StackPaneInfo {
|
||||
id: pane,
|
||||
title: "Shell".into(),
|
||||
}],
|
||||
active_pane: pane,
|
||||
}
|
||||
}
|
||||
|
||||
fn flatten_panes(tab: &mut TabInfo) {
|
||||
tab.panes = tab
|
||||
.stacks
|
||||
.iter()
|
||||
.flat_map(|stack| stack.panes.iter().map(|pane| pane.id))
|
||||
.collect();
|
||||
}
|
||||
|
||||
struct Client {
|
||||
authenticated: bool,
|
||||
attached: bool,
|
||||
@@ -563,44 +581,63 @@ impl Server {
|
||||
self.dirty = true;
|
||||
}
|
||||
ClientMessage::Split { pane, cwd } => {
|
||||
let tab = self
|
||||
.tabs
|
||||
.iter()
|
||||
.position(|tab| tab.panes.contains(&pane))
|
||||
.context("unknown pane")?;
|
||||
let occupied: usize = self.tabs[tab]
|
||||
.panes
|
||||
.iter()
|
||||
.filter_map(|id| self.panes.get(id))
|
||||
.map(|pane| {
|
||||
let size = pane.session.size();
|
||||
size.num_cols as usize * size.num_lines as usize
|
||||
})
|
||||
.sum();
|
||||
ensure!(
|
||||
occupied + 80 * 24 <= MAX_GRID_CELLS,
|
||||
"tab grid exceeds {MAX_GRID_CELLS} cells"
|
||||
);
|
||||
let (tab_index, stack_index, _) = self.pane_position(pane)?;
|
||||
self.ensure_new_pane_fits(tab_index)?;
|
||||
let pane = self.new_pane(cwd)?;
|
||||
self.tabs[tab].panes.push(pane);
|
||||
self.tabs[tab].active_pane = pane;
|
||||
self.active_tab = self.tabs[tab].id;
|
||||
let tab = &mut self.tabs[tab_index];
|
||||
tab.stacks.insert(stack_index + 1, single_pane_stack(pane));
|
||||
flatten_panes(tab);
|
||||
tab.active_pane = pane;
|
||||
self.active_tab = tab.id;
|
||||
self.dirty = true;
|
||||
}
|
||||
ClientMessage::NewStackPane {
|
||||
pane,
|
||||
direction,
|
||||
cwd,
|
||||
} => {
|
||||
let pane = pane
|
||||
.or_else(|| {
|
||||
self.tabs
|
||||
.iter()
|
||||
.find(|tab| tab.id == self.active_tab)
|
||||
.map(|tab| tab.active_pane)
|
||||
})
|
||||
.context("no active pane")?;
|
||||
let (tab_index, stack_index, pane_index) = self.pane_position(pane)?;
|
||||
self.ensure_new_pane_fits(tab_index)?;
|
||||
let pane = self.new_pane(cwd)?;
|
||||
let tab = &mut self.tabs[tab_index];
|
||||
let stack = &mut tab.stacks[stack_index];
|
||||
let insert_at = pane_index + usize::from(direction == VerticalDirection::Down);
|
||||
stack.panes.insert(
|
||||
insert_at,
|
||||
StackPaneInfo {
|
||||
id: pane,
|
||||
title: "Shell".into(),
|
||||
},
|
||||
);
|
||||
stack.active_pane = pane;
|
||||
tab.active_pane = pane;
|
||||
flatten_panes(tab);
|
||||
self.active_tab = tab.id;
|
||||
self.dirty = true;
|
||||
}
|
||||
ClientMessage::FocusStackPane { pane, direction } => {
|
||||
self.focus_stack_pane(pane, direction)?;
|
||||
}
|
||||
ClientMessage::FocusDirection { direction } => {
|
||||
self.focus_direction(direction)?;
|
||||
}
|
||||
ClientMessage::CycleTab { forward } => self.cycle_tab(forward),
|
||||
ClientMessage::CyclePane { forward } => self.cycle_pane(forward)?,
|
||||
ClientMessage::FocusTab { tab } => {
|
||||
ensure!(self.tabs.iter().any(|entry| entry.id == tab), "unknown tab");
|
||||
self.active_tab = tab;
|
||||
self.dirty = true;
|
||||
}
|
||||
ClientMessage::FocusPane { pane } => {
|
||||
let tab = self
|
||||
.tabs
|
||||
.iter_mut()
|
||||
.find(|tab| tab.panes.contains(&pane))
|
||||
.context("unknown pane")?;
|
||||
tab.active_pane = pane;
|
||||
self.active_tab = tab.id;
|
||||
self.dirty = true;
|
||||
self.focus_pane(pane)?;
|
||||
}
|
||||
ClientMessage::ClosePane { pane } => {
|
||||
ensure!(self.remove_pane(pane), "unknown pane");
|
||||
@@ -615,23 +652,147 @@ impl Server {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn pane_position(&self, pane: PaneId) -> Result<(usize, usize, usize)> {
|
||||
for (tab_index, tab) in self.tabs.iter().enumerate() {
|
||||
for (stack_index, stack) in tab.stacks.iter().enumerate() {
|
||||
if let Some(pane_index) = stack.panes.iter().position(|entry| entry.id == pane) {
|
||||
return Ok((tab_index, stack_index, pane_index));
|
||||
}
|
||||
}
|
||||
}
|
||||
anyhow::bail!("unknown pane")
|
||||
}
|
||||
|
||||
fn ensure_new_pane_fits(&self, tab_index: usize) -> Result<()> {
|
||||
let occupied: usize = self.tabs[tab_index]
|
||||
.panes
|
||||
.iter()
|
||||
.filter_map(|id| self.panes.get(id))
|
||||
.map(|pane| {
|
||||
let size = pane.session.size();
|
||||
size.num_cols as usize * size.num_lines as usize
|
||||
})
|
||||
.sum();
|
||||
ensure!(
|
||||
occupied + 80 * 24 <= MAX_GRID_CELLS,
|
||||
"tab grid exceeds {MAX_GRID_CELLS} cells"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn focus_pane(&mut self, pane: PaneId) -> Result<()> {
|
||||
let (tab_index, stack_index, _) = self.pane_position(pane)?;
|
||||
let tab = &mut self.tabs[tab_index];
|
||||
tab.stacks[stack_index].active_pane = pane;
|
||||
tab.active_pane = pane;
|
||||
self.active_tab = tab.id;
|
||||
self.dirty = true;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn focus_stack_pane(&mut self, pane: PaneId, direction: VerticalDirection) -> Result<()> {
|
||||
let (tab_index, stack_index, pane_index) = self.pane_position(pane)?;
|
||||
let stack = &self.tabs[tab_index].stacks[stack_index];
|
||||
let next = match direction {
|
||||
VerticalDirection::Up => pane_index.checked_sub(1),
|
||||
VerticalDirection::Down => {
|
||||
(pane_index + 1 < stack.panes.len()).then_some(pane_index + 1)
|
||||
}
|
||||
};
|
||||
if let Some(index) = next {
|
||||
self.focus_pane(stack.panes[index].id)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn cycle_tab(&mut self, forward: bool) {
|
||||
let Some(index) = self.tabs.iter().position(|tab| tab.id == self.active_tab) else {
|
||||
return;
|
||||
};
|
||||
let count = self.tabs.len();
|
||||
let next = if forward {
|
||||
(index + 1) % count
|
||||
} else {
|
||||
(index + count - 1) % count
|
||||
};
|
||||
self.active_tab = self.tabs[next].id;
|
||||
self.dirty = true;
|
||||
}
|
||||
|
||||
fn cycle_pane(&mut self, forward: bool) -> Result<()> {
|
||||
let Some(tab) = self.tabs.iter().find(|tab| tab.id == self.active_tab) else {
|
||||
return Ok(());
|
||||
};
|
||||
let index = tab
|
||||
.stacks
|
||||
.iter()
|
||||
.position(|stack| stack.active_pane == tab.active_pane)
|
||||
.context("focused pane is not expanded")?;
|
||||
let count = tab.stacks.len();
|
||||
let next = if forward {
|
||||
(index + 1) % count
|
||||
} else {
|
||||
(index + count - 1) % count
|
||||
};
|
||||
self.focus_pane(tab.stacks[next].active_pane)
|
||||
}
|
||||
|
||||
fn focus_direction(&mut self, direction: Direction) -> Result<()> {
|
||||
let Some(tab_index) = self.tabs.iter().position(|tab| tab.id == self.active_tab) else {
|
||||
return Ok(());
|
||||
};
|
||||
let pane = self.tabs[tab_index].active_pane;
|
||||
match direction {
|
||||
Direction::Up => self.focus_stack_pane(pane, VerticalDirection::Up),
|
||||
Direction::Down => self.focus_stack_pane(pane, VerticalDirection::Down),
|
||||
Direction::Left | Direction::Right => {
|
||||
let (_, stack_index, _) = self.pane_position(pane)?;
|
||||
let tab = &self.tabs[tab_index];
|
||||
let next = if direction == Direction::Left {
|
||||
stack_index.checked_sub(1)
|
||||
} else {
|
||||
(stack_index + 1 < tab.stacks.len()).then_some(stack_index + 1)
|
||||
};
|
||||
if let Some(index) = next {
|
||||
self.focus_pane(tab.stacks[index].active_pane)?;
|
||||
} else {
|
||||
self.cycle_tab(direction == Direction::Right);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The same lifecycle path serves explicit close and a shell's natural exit.
|
||||
fn remove_pane(&mut self, pane: PaneId) -> bool {
|
||||
let Some(removed) = self.panes.remove(&pane) else {
|
||||
return false;
|
||||
};
|
||||
if let Some(tab_index) = self.tabs.iter().position(|tab| tab.panes.contains(&pane)) {
|
||||
if let Ok((tab_index, stack_index, pane_index)) = self.pane_position(pane) {
|
||||
let tab = &mut self.tabs[tab_index];
|
||||
let pane_index = tab.panes.iter().position(|id| *id == pane).unwrap();
|
||||
tab.panes.remove(pane_index);
|
||||
if tab.active_pane == pane {
|
||||
tab.active_pane = tab
|
||||
let stack = &mut tab.stacks[stack_index];
|
||||
stack.panes.remove(pane_index);
|
||||
if stack.active_pane == pane {
|
||||
stack.active_pane = stack
|
||||
.panes
|
||||
.get(pane_index.min(tab.panes.len().saturating_sub(1)))
|
||||
.copied()
|
||||
.unwrap_or(0);
|
||||
.get(pane_index.min(stack.panes.len().saturating_sub(1)))
|
||||
.map_or(0, |entry| entry.id);
|
||||
}
|
||||
if tab.panes.is_empty() {
|
||||
let replacement = stack.active_pane;
|
||||
if stack.panes.is_empty() {
|
||||
tab.stacks.remove(stack_index);
|
||||
}
|
||||
if tab.active_pane == pane {
|
||||
tab.active_pane = if replacement != 0 {
|
||||
replacement
|
||||
} else {
|
||||
tab.stacks
|
||||
.get(stack_index.min(tab.stacks.len().saturating_sub(1)))
|
||||
.map_or(0, |stack| stack.active_pane)
|
||||
};
|
||||
}
|
||||
flatten_panes(tab);
|
||||
if tab.stacks.is_empty() {
|
||||
let removed_tab = self.tabs.remove(tab_index);
|
||||
if self.active_tab == removed_tab.id {
|
||||
self.active_tab = self
|
||||
@@ -722,6 +883,7 @@ impl Server {
|
||||
title: "Shell".into(),
|
||||
panes: vec![pane],
|
||||
active_pane: pane,
|
||||
stacks: vec![single_pane_stack(pane)],
|
||||
});
|
||||
self.active_tab = id;
|
||||
Ok(())
|
||||
@@ -736,7 +898,17 @@ impl Server {
|
||||
return;
|
||||
};
|
||||
match event {
|
||||
Event::Wakeup => pane.session.acknowledge_wakeup(),
|
||||
Event::Wakeup => {
|
||||
// Hidden PTYs still parse output and must rearm their wakeups,
|
||||
// but their grids are absent from the current client snapshot.
|
||||
pane.session.acknowledge_wakeup();
|
||||
self.dirty |= self
|
||||
.tabs
|
||||
.iter()
|
||||
.find(|tab| tab.id == self.active_tab)
|
||||
.is_some_and(|tab| tab.stacks.iter().any(|stack| stack.active_pane == id));
|
||||
return;
|
||||
}
|
||||
Event::Title(title) => pane.program_title = clean_title(title),
|
||||
Event::ResetTitle => pane.program_title = None,
|
||||
Event::PtyWrite(text) => pane.session.write(text.into_bytes()),
|
||||
@@ -770,12 +942,24 @@ impl Server {
|
||||
if let Some(pane) = self.panes.get(&tab.active_pane) {
|
||||
tab.title = pane.title();
|
||||
}
|
||||
for stack in &mut tab.stacks {
|
||||
for entry in &mut stack.panes {
|
||||
if let Some(pane) = self.panes.get(&entry.id) {
|
||||
entry.title = pane.title();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let visible = self
|
||||
.tabs
|
||||
.iter()
|
||||
.find(|tab| tab.id == self.active_tab)
|
||||
.map(|tab| tab.panes.clone())
|
||||
.map(|tab| {
|
||||
tab.stacks
|
||||
.iter()
|
||||
.map(|stack| stack.active_pane)
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let panes = visible
|
||||
.into_iter()
|
||||
@@ -1166,6 +1350,432 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
fn active_tab(snapshot: &Snapshot) -> &TabInfo {
|
||||
snapshot
|
||||
.tabs
|
||||
.iter()
|
||||
.find(|tab| tab.id == snapshot.active_tab)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn list_after_commands(client: &mut UnixStream) -> Snapshot {
|
||||
// A round trip separates older queued snapshots from this inspection.
|
||||
send(client, ClientMessage::Ping);
|
||||
loop {
|
||||
match protocol::read_message::<ServerMessage>(client).unwrap() {
|
||||
ServerMessage::Pong => break,
|
||||
ServerMessage::Error(error) => panic!("server error: {error}"),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
send(client, ClientMessage::List);
|
||||
snapshot(client, |_| true)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collapsed_output_rearms_wakeups_without_publishing_unchanged_grids() {
|
||||
let (sender, receiver) = mpsc::sync_channel(1024);
|
||||
let mut actor = Server {
|
||||
shell: Some(Shell::new("/bin/sh".into(), Vec::new())),
|
||||
panes: HashMap::new(),
|
||||
tabs: Vec::new(),
|
||||
active_tab: 0,
|
||||
next_id: 1,
|
||||
clients: HashMap::new(),
|
||||
sender,
|
||||
revision: 0,
|
||||
dirty: false,
|
||||
last_frame: Instant::now(),
|
||||
last_cwd_refresh: Instant::now(),
|
||||
};
|
||||
actor.new_tab(None).unwrap();
|
||||
let hidden = actor.tabs[0].active_pane;
|
||||
let visible = actor.new_pane(None).unwrap();
|
||||
let tab = &mut actor.tabs[0];
|
||||
tab.stacks[0].panes.push(StackPaneInfo {
|
||||
id: visible,
|
||||
title: "Visible".into(),
|
||||
});
|
||||
tab.stacks[0].active_pane = visible;
|
||||
tab.active_pane = visible;
|
||||
flatten_panes(tab);
|
||||
|
||||
// Drive actual PTY/parser events directly so absence of a publish is
|
||||
// tested through its dirty flag, without timing-dependent socket gaps.
|
||||
let output = |actor: &mut Server, suffix: &str, expect_dirty: bool| {
|
||||
actor.panes[&hidden]
|
||||
.session
|
||||
.write(format!("printf 'HIDDEN_%s\\n' '{suffix}'\n").into_bytes());
|
||||
let needle = format!("HIDDEN_{suffix}");
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
loop {
|
||||
let event = receiver
|
||||
.recv_timeout(deadline.saturating_duration_since(Instant::now()))
|
||||
.unwrap();
|
||||
if let Action::Terminal(id, event) = event {
|
||||
let target_wakeup = id == hidden && matches!(event, Event::Wakeup);
|
||||
actor.dirty = false;
|
||||
actor.terminal_event(id, event);
|
||||
if target_wakeup {
|
||||
assert_eq!(actor.dirty, expect_dirty);
|
||||
let term = actor.panes[&hidden].session.term.lock();
|
||||
let text = term
|
||||
.renderable_content()
|
||||
.display_iter
|
||||
.map(|cell| cell.cell.c)
|
||||
.collect::<String>();
|
||||
if text.contains(&needle) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
output(&mut actor, "FIRST", false);
|
||||
// A second burst verifies the first suppressed wakeup was acknowledged.
|
||||
output(&mut actor, "SECOND", false);
|
||||
let hidden_snapshot = actor.snapshot();
|
||||
assert_eq!(hidden_snapshot.panes.len(), 1);
|
||||
assert_eq!(hidden_snapshot.panes[0].id, visible);
|
||||
actor.focus_pane(hidden).unwrap();
|
||||
assert!(actor.dirty);
|
||||
assert!(contains(&actor.snapshot(), "HIDDEN_SECOND"));
|
||||
output(&mut actor, "VISIBLE", true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stacks_insert_in_both_directions_and_only_expand_one_grid() {
|
||||
let server = TestServer::start();
|
||||
let mut client = server.client();
|
||||
send(&mut client, ClientMessage::Attach);
|
||||
let initial = snapshot(&mut client, |s| s.panes.len() == 1);
|
||||
let first = initial.panes[0].id;
|
||||
input(
|
||||
&mut client,
|
||||
first,
|
||||
"stty -echo; printf '\\033[2J\\033[HSTACK_STATE\\n'\n",
|
||||
);
|
||||
snapshot(&mut client, |s| contains(s, "STACK_STATE"));
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::NewStackPane {
|
||||
pane: Some(first),
|
||||
direction: VerticalDirection::Down,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let second = snapshot(&mut client, |s| active_tab(s).panes.len() == 2);
|
||||
let bottom = active_tab(&second).active_pane;
|
||||
assert_eq!(active_tab(&second).panes, [first, bottom]);
|
||||
assert_eq!(active_tab(&second).stacks.len(), 1);
|
||||
assert_eq!(second.panes.len(), 1);
|
||||
assert_eq!(second.panes[0].id, bottom);
|
||||
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::RenamePane {
|
||||
pane: first,
|
||||
name: Some("Collapsed source".into()),
|
||||
},
|
||||
);
|
||||
snapshot(&mut client, |s| {
|
||||
active_tab(s).stacks[0].panes[0].title == "Collapsed source"
|
||||
});
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::NewStackPane {
|
||||
pane: Some(bottom),
|
||||
direction: VerticalDirection::Up,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let third = snapshot(&mut client, |s| active_tab(s).panes.len() == 3);
|
||||
let middle = active_tab(&third).active_pane;
|
||||
assert_eq!(active_tab(&third).panes, [first, middle, bottom]);
|
||||
assert_eq!(third.panes.len(), 1);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Up,
|
||||
},
|
||||
);
|
||||
let top = snapshot(&mut client, |s| active_tab(s).active_pane == first);
|
||||
assert!(contains(&top, "STACK_STATE"));
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Up,
|
||||
},
|
||||
);
|
||||
assert_eq!(
|
||||
active_tab(&list_after_commands(&mut client)).active_pane,
|
||||
first
|
||||
);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusStackPane {
|
||||
pane: first,
|
||||
direction: VerticalDirection::Down,
|
||||
},
|
||||
);
|
||||
snapshot(&mut client, |s| active_tab(s).active_pane == middle);
|
||||
send(&mut client, ClientMessage::FocusPane { pane: bottom });
|
||||
snapshot(&mut client, |s| active_tab(s).active_pane == bottom);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Down,
|
||||
},
|
||||
);
|
||||
assert_eq!(
|
||||
active_tab(&list_after_commands(&mut client)).active_pane,
|
||||
bottom
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn relative_commands_preserve_bursts_without_intermediate_snapshots() {
|
||||
let server = TestServer::start();
|
||||
// A control client does not attach, so the only snapshots are the
|
||||
// explicit List responses after each complete command burst.
|
||||
let mut client = server.client();
|
||||
let inspect = |client: &mut UnixStream| {
|
||||
send(client, ClientMessage::List);
|
||||
snapshot(client, |_| true)
|
||||
};
|
||||
for _ in 0..3 {
|
||||
send(&mut client, ClientMessage::NewTab { cwd: None });
|
||||
}
|
||||
let initial = inspect(&mut client);
|
||||
let first_tab = initial.tabs[0].id;
|
||||
let last_tab = initial.tabs[2].id;
|
||||
let first_pane = initial.tabs[0].active_pane;
|
||||
send(&mut client, ClientMessage::FocusTab { tab: first_tab });
|
||||
send(&mut client, ClientMessage::CycleTab { forward: true });
|
||||
send(&mut client, ClientMessage::CycleTab { forward: true });
|
||||
assert_eq!(inspect(&mut client).active_tab, last_tab);
|
||||
send(&mut client, ClientMessage::CycleTab { forward: false });
|
||||
send(&mut client, ClientMessage::CycleTab { forward: false });
|
||||
assert_eq!(inspect(&mut client).active_tab, first_tab);
|
||||
send(&mut client, ClientMessage::CycleTab { forward: false });
|
||||
assert_eq!(inspect(&mut client).active_tab, last_tab);
|
||||
|
||||
send(&mut client, ClientMessage::FocusTab { tab: first_tab });
|
||||
for _ in 0..2 {
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::NewStackPane {
|
||||
pane: None,
|
||||
direction: VerticalDirection::Down,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
}
|
||||
let down = inspect(&mut client);
|
||||
let order = &active_tab(&down).panes;
|
||||
assert_eq!(order.len(), 3);
|
||||
assert_eq!(order[0], first_pane);
|
||||
// Pane IDs grow with creation order: repeated Down appends in that
|
||||
// order, rather than repeatedly inserting after the stale first pane.
|
||||
assert!(order[1] < order[2]);
|
||||
let last_down = order[2];
|
||||
assert_eq!(active_tab(&down).active_pane, last_down);
|
||||
for _ in 0..2 {
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::NewStackPane {
|
||||
pane: None,
|
||||
direction: VerticalDirection::Up,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
}
|
||||
let up = inspect(&mut client);
|
||||
let order = &active_tab(&up).panes;
|
||||
assert_eq!(order.len(), 5);
|
||||
assert_eq!(order[4], last_down);
|
||||
assert!(order[2] > order[3]);
|
||||
let expanded = order[2];
|
||||
assert_eq!(active_tab(&up).active_pane, expanded);
|
||||
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::Split {
|
||||
pane: expanded,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let middle = active_tab(&inspect(&mut client)).active_pane;
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::Split {
|
||||
pane: middle,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let right = active_tab(&inspect(&mut client)).active_pane;
|
||||
send(&mut client, ClientMessage::FocusPane { pane: expanded });
|
||||
send(&mut client, ClientMessage::CyclePane { forward: true });
|
||||
send(&mut client, ClientMessage::CyclePane { forward: true });
|
||||
assert_eq!(active_tab(&inspect(&mut client)).active_pane, right);
|
||||
send(&mut client, ClientMessage::CyclePane { forward: true });
|
||||
assert_eq!(active_tab(&inspect(&mut client)).active_pane, expanded);
|
||||
send(&mut client, ClientMessage::CyclePane { forward: false });
|
||||
send(&mut client, ClientMessage::CyclePane { forward: false });
|
||||
assert_eq!(active_tab(&inspect(&mut client)).active_pane, middle);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn horizontal_navigation_moves_between_columns_and_then_tabs() {
|
||||
let server = TestServer::start();
|
||||
let mut client = server.client();
|
||||
send(&mut client, ClientMessage::Attach);
|
||||
let initial = snapshot(&mut client, |s| s.panes.len() == 1);
|
||||
let first = initial.panes[0].id;
|
||||
let first_tab = initial.active_tab;
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::NewStackPane {
|
||||
pane: Some(first),
|
||||
direction: VerticalDirection::Down,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let stacked = snapshot(&mut client, |s| active_tab(s).panes.len() == 2);
|
||||
let expanded = active_tab(&stacked).active_pane;
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::Split {
|
||||
pane: first,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let split = snapshot(&mut client, |s| s.panes.len() == 2);
|
||||
let right = active_tab(&split).active_pane;
|
||||
assert_eq!(active_tab(&split).panes, [first, expanded, right]);
|
||||
assert_eq!(active_tab(&split).stacks.len(), 2);
|
||||
assert_eq!(
|
||||
split.panes.iter().map(|pane| pane.id).collect::<Vec<_>>(),
|
||||
[expanded, right]
|
||||
);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Left,
|
||||
},
|
||||
);
|
||||
snapshot(&mut client, |s| active_tab(s).active_pane == expanded);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Up,
|
||||
},
|
||||
);
|
||||
snapshot(&mut client, |s| active_tab(s).active_pane == first);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Right,
|
||||
},
|
||||
);
|
||||
snapshot(&mut client, |s| active_tab(s).active_pane == right);
|
||||
send(&mut client, ClientMessage::NewTab { cwd: None });
|
||||
let next_tab = snapshot(&mut client, |s| s.tabs.len() == 2);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Left,
|
||||
},
|
||||
);
|
||||
let restored = snapshot(&mut client, |s| s.active_tab == first_tab);
|
||||
assert_eq!(active_tab(&restored).active_pane, right);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Right,
|
||||
},
|
||||
);
|
||||
snapshot(&mut client, |s| s.active_tab == next_tab.active_tab);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::FocusDirection {
|
||||
direction: Direction::Right,
|
||||
},
|
||||
);
|
||||
snapshot(&mut client, |s| s.active_tab == first_tab);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stack_state_and_collapsed_shells_survive_clients_and_exit_cleanly() {
|
||||
let server = TestServer::start();
|
||||
let mut first_client = server.client();
|
||||
send(&mut first_client, ClientMessage::Attach);
|
||||
let initial = snapshot(&mut first_client, |s| s.panes.len() == 1);
|
||||
let top = initial.panes[0].id;
|
||||
send(
|
||||
&mut first_client,
|
||||
ClientMessage::NewStackPane {
|
||||
pane: Some(top),
|
||||
direction: VerticalDirection::Down,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let stacked = snapshot(&mut first_client, |s| active_tab(s).panes.len() == 2);
|
||||
let middle = active_tab(&stacked).active_pane;
|
||||
send(
|
||||
&mut first_client,
|
||||
ClientMessage::NewStackPane {
|
||||
pane: Some(middle),
|
||||
direction: VerticalDirection::Down,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let three = snapshot(&mut first_client, |s| active_tab(s).panes.len() == 3);
|
||||
let bottom = active_tab(&three).active_pane;
|
||||
let mut other_client = server.client();
|
||||
send(&mut other_client, ClientMessage::Attach);
|
||||
let mirrored = snapshot(&mut other_client, |s| active_tab(s).panes.len() == 3);
|
||||
assert_eq!(active_tab(&mirrored).panes, [top, middle, bottom]);
|
||||
send(&mut other_client, ClientMessage::FocusPane { pane: middle });
|
||||
snapshot(&mut other_client, |s| active_tab(s).active_pane == middle);
|
||||
snapshot(&mut first_client, |s| active_tab(s).active_pane == middle);
|
||||
send(&mut first_client, ClientMessage::Detach);
|
||||
send(&mut other_client, ClientMessage::Detach);
|
||||
drop(first_client);
|
||||
drop(other_client);
|
||||
let mut client = server.client();
|
||||
send(&mut client, ClientMessage::Attach);
|
||||
let reattached = snapshot(&mut client, |s| active_tab(s).panes.len() == 3);
|
||||
assert_eq!(reattached.active_tab, initial.active_tab);
|
||||
assert_eq!(active_tab(&reattached).stacks[0].active_pane, middle);
|
||||
assert_eq!(reattached.panes[0].id, middle);
|
||||
|
||||
// A collapsed shell's exit leaves the focused/expanded pane alone.
|
||||
input(&mut client, top, "exit\n");
|
||||
let collapsed_exit = snapshot(&mut client, |s| active_tab(s).panes.len() == 2);
|
||||
assert_eq!(active_tab(&collapsed_exit).panes, [middle, bottom]);
|
||||
assert_eq!(collapsed_exit.panes[0].id, middle);
|
||||
// Explicit close uses the same adjacent fallback as natural exit.
|
||||
send(&mut client, ClientMessage::ClosePane { pane: middle });
|
||||
let closed = snapshot(&mut client, |s| active_tab(s).panes.len() == 1);
|
||||
assert_eq!(closed.panes[0].id, bottom);
|
||||
send(
|
||||
&mut client,
|
||||
ClientMessage::Split {
|
||||
pane: bottom,
|
||||
cwd: None,
|
||||
},
|
||||
);
|
||||
let split = snapshot(&mut client, |s| s.panes.len() == 2);
|
||||
let other = active_tab(&split).active_pane;
|
||||
input(&mut client, bottom, "exit\n");
|
||||
let removed_column = snapshot(&mut client, |s| active_tab(s).stacks.len() == 1);
|
||||
assert_eq!(removed_column.panes[0].id, other);
|
||||
input(&mut client, other, "exit\n");
|
||||
let empty = snapshot(&mut client, |s| s.tabs.is_empty());
|
||||
assert!(empty.panes.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn natural_shell_exit_removes_panes_and_empty_tabs_without_stealing_focus() {
|
||||
let server = TestServer::start();
|
||||
|
||||
Reference in New Issue
Block a user