Add support for moving selections above and below

ref: helix-editor/helix#2245
ref: helix-editor/helix#4545

Co-authored-by: JJ <[email protected]>

Author: sireliah

book/src/generated/static-cmd.md

@@ -124,6 +124,8 @@
 | `goto_declaration` | Goto declaration | normal: `` gD ``, select: `` gD `` |
 | `add_newline_above` | Add newline above | normal: `` [<space> ``, select: `` [<space> `` |
 | `add_newline_below` | Add newline below | normal: `` ]<space> ``, select: `` ]<space> `` |
+| `move_selection_above` | Move current line selection up | normal: `` <C-k> ``, select: `` <C-k> `` |
+| `move_selection_below` | Move current line selection down | normal: `` <C-j> ``, select: `` <C-j> `` |
 | `goto_type_definition` | Goto type definition | normal: `` gy ``, select: `` gy `` |
 | `goto_implementation` | Goto implementation | normal: `` gi ``, select: `` gi `` |
 | `goto_file_start` | Goto line number <n> else file start | normal: `` gg ``, select: `` gg `` |

helix-term/src/commands.rs

@@ -417,6 +417,8 @@ impl MappableCommand {
         goto_declaration, "Goto declaration",
         add_newline_above, "Add newline above",
         add_newline_below, "Add newline below",
+        move_selection_above, "Move current line selection up",
+        move_selection_below, "Move current line selection down",
         goto_type_definition, "Goto type definition",
         goto_implementation, "Goto implementation",
         goto_file_start, "Goto line number <n> else file start",
@@ -6253,6 +6255,209 @@ fn add_newline_impl(cx: &mut Context, open: Open) {
     doc.apply(&transaction, view.id);
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum MoveSelection {
+    Below,
+    Above,
+}
+
+#[derive(Clone)]
+struct ExtendedChange {
+    line_start: usize,
+    line_end: usize,
+    line_text: Option<Tendril>,
+    line_selection: Option<(usize, usize)>,
+}
+/// Move line or block of text in specified direction.
+/// The function respects single line, single selection, multiple lines using
+/// several cursors and multiple selections.
+fn move_selection(cx: &mut Context, direction: MoveSelection) {
+    let (view, doc) = current!(cx.editor);
+    let selection = doc.selection(view.id);
+    let text = doc.text();
+    let slice = text.slice(..);
+    let mut last_step_changes: Vec<ExtendedChange> = vec![];
+    let mut at_doc_edge = false;
+    let all_changes = selection.into_iter().map(|range| {
+        let (start, end) = range.line_range(slice);
+        let line_start = text.line_to_char(start);
+        let line_end = line_end_char_index(&slice, end);
+        let line_text = text.slice(line_start..line_end).to_string();
+        let next_line = match direction {
+            MoveSelection::Above => start.saturating_sub(1),
+            MoveSelection::Below => end + 1,
+        };
+        let rel_pos_anchor = range.anchor - line_start;
+        let rel_pos_head = range.head - line_start;
+        let cursor_rel_pos = (rel_pos_anchor, rel_pos_head);
+        if next_line == start || next_line >= text.len_lines() || at_doc_edge {
+            at_doc_edge = true;
+            let changes = vec![ExtendedChange {
+                line_start,
+                line_end,
+                line_text: Some(line_text.into()),
+                line_selection: Some(cursor_rel_pos),
+            }];
+            last_step_changes = changes.clone();
+            changes
+        } else {
+            let next_line_start = text.line_to_char(next_line);
+            let next_line_end = line_end_char_index(&slice, next_line);
+            let next_line_text = text.slice(next_line_start..next_line_end).to_string();
+            let changes = match direction {
+                MoveSelection::Above => vec![
+                    ExtendedChange {
+                        line_start: next_line_start,
+                        line_end: next_line_end,
+                        line_text: Some(line_text.into()),
+                        line_selection: Some(cursor_rel_pos),
+                    },
+                    ExtendedChange {
+                        line_start,
+                        line_end,
+                        line_text: Some(next_line_text.into()),
+                        line_selection: None,
+                    },
+                ],
+                MoveSelection::Below => vec![
+                    ExtendedChange {
+                        line_start,
+                        line_end,
+                        line_text: Some(next_line_text.into()),
+                        line_selection: None,
+                    },
+                    ExtendedChange {
+                        line_start: next_line_start,
+                        line_end: next_line_end,
+                        line_text: Some(line_text.into()),
+                        line_selection: Some(cursor_rel_pos),
+                    },
+                ],
+            };
+            let changes = if last_step_changes.len() > 1 {
+                evaluate_changes(last_step_changes.clone(), changes, &direction)
+            } else {
+                changes
+            };
+            last_step_changes = changes.clone();
+            changes
+        }
+    });
+    /// Merge changes from subsequent cursors
+    fn evaluate_changes(
+        mut last_changes: Vec<ExtendedChange>,
+        current_changes: Vec<ExtendedChange>,
+        direction: &MoveSelection,
+    ) -> Vec<ExtendedChange> {
+        let mut current_it = current_changes.into_iter();
+        if let (Some(mut last), Some(mut current_first), Some(current_last)) =
+            (last_changes.pop(), current_it.next(), current_it.next())
+        {
+            if last.line_start == current_first.line_start {
+                match direction {
+                    MoveSelection::Above => {
+                        last.line_start = current_last.line_start;
+                        last.line_end = current_last.line_end;
+                        if let Some(first) = last_changes.pop() {
+                            last_changes.push(first)
+                        }
+                        last_changes.extend(vec![current_first, last]);
+                        last_changes
+                    }
+                    MoveSelection::Below => {
+                        current_first.line_start = last_changes[0].line_start;
+                        current_first.line_end = last_changes[0].line_end;
+                        last_changes[0] = current_first;
+                        last_changes.extend(vec![last, current_last]);
+                        last_changes
+                    }
+                }
+            } else {
+                if let Some(first) = last_changes.pop() {
+                    last_changes.push(first)
+                }
+                last_changes.extend(vec![last, current_first, current_last]);
+                last_changes
+            }
+        } else {
+            last_changes
+        }
+    }
+    let mut flattened: Vec<Vec<ExtendedChange>> = all_changes.into_iter().collect();
+    let last_changes = flattened.pop().unwrap_or_default();
+    let acc_cursors = get_adjusted_selection(doc, &last_changes, direction, at_doc_edge);
+    let changes = last_changes
+        .into_iter()
+        .map(|change| (change.line_start, change.line_end, change.line_text));
+    let new_sel = Selection::new(acc_cursors.into(), 0);
+    let transaction = Transaction::change(doc.text(), changes);
+    doc.apply(&transaction, view.id);
+    doc.set_selection(view.id, new_sel);
+}
+/// Returns selection range that is valid for the updated document
+/// This logic is necessary because it's not possible to apply changes
+/// to the document first and then set selection.
+fn get_adjusted_selection(
+    doc: &Document,
+    last_changes: &[ExtendedChange],
+    direction: MoveSelection,
+    at_doc_edge: bool,
+) -> Vec<Range> {
+    let mut first_change_len = 0;
+    let mut next_start = 0;
+    let mut acc_cursors: Vec<Range> = vec![];
+    for change in last_changes.iter() {
+        let change_len = change.line_text.as_ref().map_or(0, |x| x.chars().count());
+        if let Some((rel_anchor, rel_head)) = change.line_selection {
+            let (anchor, head) = if at_doc_edge {
+                let anchor = change.line_start + rel_anchor;
+                let head = change.line_start + rel_head;
+                (anchor, head)
+            } else {
+                match direction {
+                    MoveSelection::Above => {
+                        if next_start == 0 {
+                            next_start = change.line_start;
+                        }
+                        let anchor = next_start + rel_anchor;
+                        let head = next_start + rel_head;
+                        // If there is next cursor below, selection position should be adjusted
+                        // according to the length of the current line.
+                        next_start += change_len + doc.line_ending.len_chars();
+                        (anchor, head)
+                    }
+                    MoveSelection::Below => {
+                        let anchor = change.line_start + first_change_len + rel_anchor - change_len;
+                        let head = change.line_start + first_change_len + rel_head - change_len;
+                        (anchor, head)
+                    }
+                }
+            };
+            let cursor = Range::new(anchor, head);
+            if let Some(last) = acc_cursors.pop() {
+                if cursor.overlaps(&last) {
+                    acc_cursors.push(last);
+                } else {
+                    acc_cursors.push(last);
+                    acc_cursors.push(cursor);
+                };
+            } else {
+                acc_cursors.push(cursor);
+            };
+        } else {
+            first_change_len = change.line_text.as_ref().map_or(0, |x| x.chars().count());
+            next_start = 0;
+        };
+    }
+    acc_cursors
+}
+fn move_selection_below(cx: &mut Context) {
+    move_selection(cx, MoveSelection::Below)
+}
+fn move_selection_above(cx: &mut Context) {
+    move_selection(cx, MoveSelection::Above)
+}
+
 enum IncrementDirection {
     Increase,
     Decrease,

helix-term/src/keymap/default.rs

@@ -186,6 +186,8 @@ pub fn default() -> HashMap<Mode, KeyTrie> {
         "C-f" | "pagedown" => page_down,
         "C-u" => page_cursor_half_up,
         "C-d" => page_cursor_half_down,
+        "C-k" => move_selection_above,
+        "C-j" => move_selection_below,
 
         "C-w" => { "Window"
             "C-w" | "w" => rotate_view,

helix-term/tests/test/commands.rs

@@ -793,3 +793,143 @@ fn foo() {
 
     Ok(())
 }
+
+// Line selection movement tests
+#[tokio::test(flavor = "multi_thread")]
+async fn test_move_selection_single_selection_up() -> anyhow::Result<()> {
+    test((
+        indoc! {"
+            aaaaaa
+            bbbbbb
+            cc#[|c]#ccc
+            dddddd
+            "},
+        "<C-k>",
+        indoc! {"
+            aaaaaa
+            cc#[|c]#ccc
+            bbbbbb
+            dddddd
+            "},
+    ))
+    .await?;
+    Ok(())
+}
+#[tokio::test(flavor = "multi_thread")]
+async fn test_move_selection_single_selection_down() -> anyhow::Result<()> {
+    test((
+        indoc! {"
+            aa#[|a]#aaa
+            bbbbbb
+            cccccc
+            dddddd
+            "},
+        "<C-j>",
+        indoc! {"
+            bbbbbb
+            aa#[|a]#aaa
+            cccccc
+            dddddd
+            "},
+    ))
+    .await?;
+    Ok(())
+}
+#[tokio::test(flavor = "multi_thread")]
+async fn test_move_selection_single_selection_top_up() -> anyhow::Result<()> {
+    // if already on top of the file and going up, nothing should change
+    test((
+        indoc! {"
+            aa#[|a]#aaa
+            bbbbbb
+            cccccc
+            dddddd"},
+        "<C-k>",
+        indoc! {"
+            aa#[|a]#aaa
+            bbbbbb
+            cccccc
+            dddddd"},
+    ))
+    .await?;
+    Ok(())
+}
+// #[tokio::test(flavor = "multi_thread")]
+// async fn test_move_selection_single_selection_bottom_down() -> anyhow::Result<()> {
+//     // If going down on the bottom line, nothing should change
+//     // Note that this test is broken, due to the testing framework
+//     // implicitly entering a trailing newline. How to fix?
+//     test((
+//         "aaaaaa\nbbbbbb\ncccccc\ndd#[|d]#ddd",
+//         "<C-j><C-j>",
+//         "aaaaaa\nbbbbbb\ncccccc\ndd#[|d]#ddd",
+//     ))
+//     .await?;
+//     Ok(())
+// }
+#[tokio::test(flavor = "multi_thread")]
+async fn test_move_selection_block_up() -> anyhow::Result<()> {
+    test((
+        indoc! {"
+            aaaaaa
+            bb#[bbbb
+            ccc|]#ccc
+            dddddd
+            eeeeee
+            "},
+        "<C-k>",
+        indoc! {"
+            bb#[bbbb
+            ccc|]#ccc
+            aaaaaa
+            dddddd
+            eeeeee
+            "},
+    ))
+    .await?;
+    Ok(())
+}
+#[tokio::test(flavor = "multi_thread")]
+async fn test_move_selection_block_down() -> anyhow::Result<()> {
+    test((
+        indoc! {"
+            #[|aaaaaa
+            bbbbbb
+            ccc]#ccc
+            dddddd
+            eeeeee
+            "},
+        "<C-j>",
+        indoc! {"
+            dddddd
+            #[|aaaaaa
+            bbbbbb
+            ccc]#ccc
+            eeeeee
+            "},
+    ))
+    .await?;
+    Ok(())
+}
+#[tokio::test(flavor = "multi_thread")]
+async fn test_move_two_cursors_down() -> anyhow::Result<()> {
+    test((
+        indoc! {"
+            aaaaaa
+            bb#[|b]#bbb
+            cccccc
+            d#(dd|)#ddd
+            eeeeee
+            "},
+        "<C-j>",
+        indoc! {"
+            aaaaaa
+            cccccc
+            bb#[|b]#bbb
+            eeeeee
+            d#(dd|)#ddd
+            "},
+    ))
+    .await?;
+    Ok(())
+}