editor: Add rotation commands for selections and lines

Introduces RotateForward and RotateBackward actions that rotate content
in a circular fashion across multiple cursors.

Behavior based on context:
- With selections: rotates the selected text at each cursor position
  (e.g., x=1, y=2, z=3 becomes x=3, y=1, z=2)
- With just cursors: rotates entire lines at cursor positions
  (e.g., three lines cycle to line3, line1, line2)

Selections are preserved after rotation, allowing repeated cycling.
Useful for quickly rearranging values, lines, or arguments.

Fixes #5315

Author: scorphus

crates/editor/src/actions.rs

@@ -666,6 +666,10 @@ actions!(
         ReloadFile,
         /// Rewraps text to fit within the preferred line length.
         Rewrap,
+        /// Rotates selections or lines backward.
+        RotateBackward,
+        /// Rotates selections or lines forward.
+        RotateForward,
         /// Runs flycheck diagnostics.
         RunFlycheck,
         /// Scrolls the cursor to the bottom of the viewport.

crates/editor/src/editor.rs

@@ -11015,6 +11015,129 @@ impl Editor {
         self.manipulate_immutable_lines(window, cx, |lines| lines.shuffle(&mut rand::rng()))
     }
 
+    pub fn rotate_forward(
+        &mut self,
+        _: &RotateForward,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.rotate(window, cx, false)
+    }
+
+    pub fn rotate_backward(
+        &mut self,
+        _: &RotateBackward,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.rotate(window, cx, true)
+    }
+
+    fn rotate(&mut self, window: &mut Window, cx: &mut Context<Self>, reverse: bool) {
+        self.hide_mouse_cursor(HideMouseCursorOrigin::TypingAction, cx);
+        let display_snapshot = self.display_snapshot(cx);
+        let selections = self.selections.all::<usize>(&display_snapshot);
+
+        if selections.len() < 2 {
+            return;
+        }
+
+        let (edits, new_selections) = {
+            let buffer = self.buffer.read(cx).read(cx);
+            let has_selections = selections.iter().any(|s| !s.is_empty());
+            if has_selections {
+                let mut selected_texts: Vec<String> = selections
+                    .iter()
+                    .map(|selection| {
+                        buffer
+                            .text_for_range(selection.start..selection.end)
+                            .collect()
+                    })
+                    .collect();
+
+                if reverse {
+                    selected_texts.rotate_left(1);
+                } else {
+                    selected_texts.rotate_right(1);
+                }
+
+                let mut offset_delta = 0i64;
+                let mut new_sels = Vec::new();
+                let edits: Vec<_> = selections
+                    .iter()
+                    .zip(selected_texts.iter())
+                    .map(|(selection, new_text)| {
+                        let old_len = (selection.end - selection.start) as i64;
+                        let new_len = new_text.len() as i64;
+                        let adjusted_start = (selection.start as i64 + offset_delta) as usize;
+                        let adjusted_end = (adjusted_start as i64 + new_len) as usize;
+
+                        new_sels.push(Selection {
+                            id: selection.id,
+                            start: adjusted_start,
+                            end: adjusted_end,
+                            reversed: selection.reversed,
+                            goal: selection.goal,
+                        });
+
+                        offset_delta += new_len - old_len;
+                        (selection.start..selection.end, new_text.clone())
+                    })
+                    .collect();
+                (edits, Some(new_sels))
+            } else {
+                let mut all_rows: Vec<u32> = selections
+                    .iter()
+                    .map(|selection| buffer.offset_to_point(selection.start).row)
+                    .collect();
+                all_rows.sort_unstable();
+                all_rows.dedup();
+
+                if all_rows.len() < 2 {
+                    return;
+                }
+
+                let line_ranges: Vec<Range<usize>> = all_rows
+                    .iter()
+                    .map(|&row| {
+                        let start = Point::new(row, 0);
+                        let end = Point::new(row, buffer.line_len(MultiBufferRow(row)));
+                        buffer.point_to_offset(start)..buffer.point_to_offset(end)
+                    })
+                    .collect();
+
+                let mut line_texts: Vec<String> = line_ranges
+                    .iter()
+                    .map(|range| buffer.text_for_range(range.clone()).collect())
+                    .collect();
+
+                if reverse {
+                    line_texts.rotate_left(1);
+                } else {
+                    line_texts.rotate_right(1);
+                }
+
+                let edits = line_ranges
+                    .iter()
+                    .zip(line_texts.iter())
+                    .map(|(range, new_text)| (range.clone(), new_text.clone()))
+                    .collect();
+                (edits, None)
+            }
+        };
+
+        self.transact(window, cx, |this, window, cx| {
+            this.buffer.update(cx, |buffer, cx| {
+                buffer.edit(edits, None, cx);
+            });
+            if let Some(new_sels) = new_selections {
+                this.change_selections(Default::default(), window, cx, |s| {
+                    s.select(new_sels);
+                });
+            }
+        });
+    }
+
     fn manipulate_lines<M>(
         &mut self,
         window: &mut Window,

crates/editor/src/editor_tests.rs

@@ -5719,6 +5719,120 @@ fn test_duplicate_line(cx: &mut TestAppContext) {
     });
 }
 
+#[gpui::test]
+fn test_rotate(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+
+    // Rotate text selections (horizontal)
+    let (text, selection_ranges) = marked_text_ranges("x=«1ˇ», y=«2ˇ», z=«3ˇ»", true);
+    _ = cx.add_window(|window, cx| {
+        let buffer = MultiBuffer::build_simple(&text, cx);
+        let mut editor = build_editor(buffer, window, cx);
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_ranges(selection_ranges)
+        });
+        editor.rotate_forward(&RotateForward, window, cx);
+        assert_eq!(editor.display_text(cx), "x=3, y=1, z=2");
+        assert_eq!(
+            editor.selections.display_ranges(cx),
+            vec![
+                DisplayPoint::new(DisplayRow(0), 2)..DisplayPoint::new(DisplayRow(0), 3),
+                DisplayPoint::new(DisplayRow(0), 7)..DisplayPoint::new(DisplayRow(0), 8),
+                DisplayPoint::new(DisplayRow(0), 12)..DisplayPoint::new(DisplayRow(0), 13),
+            ]
+        );
+
+        editor.rotate_backward(&RotateBackward, window, cx);
+        assert_eq!(editor.display_text(cx), "x=1, y=2, z=3");
+
+        editor
+    });
+
+    // Rotate text selections (vertical)
+    let (text, selection_ranges) = marked_text_ranges("x=«1ˇ»\ny=«2ˇ»\nz=«3ˇ»\n", true);
+    _ = cx.add_window(|window, cx| {
+        let buffer = MultiBuffer::build_simple(&text, cx);
+        let mut editor = build_editor(buffer, window, cx);
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_ranges(selection_ranges)
+        });
+        editor.rotate_forward(&RotateForward, window, cx);
+        assert_eq!(editor.display_text(cx), "x=3\ny=1\nz=2\n");
+        assert_eq!(
+            editor.selections.display_ranges(cx),
+            vec![
+                DisplayPoint::new(DisplayRow(0), 2)..DisplayPoint::new(DisplayRow(0), 3),
+                DisplayPoint::new(DisplayRow(1), 2)..DisplayPoint::new(DisplayRow(1), 3),
+                DisplayPoint::new(DisplayRow(2), 2)..DisplayPoint::new(DisplayRow(2), 3),
+            ]
+        );
+
+        editor.rotate_backward(&RotateBackward, window, cx);
+        assert_eq!(editor.display_text(cx), "x=1\ny=2\nz=3\n");
+
+        editor
+    });
+
+    // Rotate text selections (vertical, different lengths)
+    let (text, selection_ranges) = marked_text_ranges("x=\"«ˇ»\"\ny=\"«aˇ»\"\nz=\"«aaˇ»\"\n", true);
+    _ = cx.add_window(|window, cx| {
+        let buffer = MultiBuffer::build_simple(&text, cx);
+        let mut editor = build_editor(buffer, window, cx);
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_ranges(selection_ranges)
+        });
+        editor.rotate_forward(&RotateForward, window, cx);
+        assert_eq!(editor.display_text(cx), "x=\"aa\"\ny=\"\"\nz=\"a\"\n");
+        assert_eq!(
+            editor.selections.display_ranges(cx),
+            vec![
+                DisplayPoint::new(DisplayRow(0), 3)..DisplayPoint::new(DisplayRow(0), 5),
+                DisplayPoint::new(DisplayRow(1), 3)..DisplayPoint::new(DisplayRow(1), 3),
+                DisplayPoint::new(DisplayRow(2), 3)..DisplayPoint::new(DisplayRow(2), 4),
+            ]
+        );
+
+        editor.rotate_backward(&RotateBackward, window, cx);
+        assert_eq!(editor.display_text(cx), "x=\"\"\ny=\"a\"\nz=\"aa\"\n");
+
+        editor
+    });
+
+    // Rotate whole lines
+    let (text, selection_ranges) = marked_text_ranges("ˇline1\nˇline2\nˇline3\n", true);
+    _ = cx.add_window(|window, cx| {
+        let buffer = MultiBuffer::build_simple(&text, cx);
+        let mut editor = build_editor(buffer, window, cx);
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_ranges(selection_ranges)
+        });
+        editor.rotate_forward(&RotateForward, window, cx);
+        assert_eq!(editor.display_text(cx), "line3\nline1\nline2\n");
+
+        editor.rotate_backward(&RotateBackward, window, cx);
+        assert_eq!(editor.display_text(cx), "line1\nline2\nline3\n");
+
+        editor
+    });
+
+    // Rotate whole lines, multiple cursors per line
+    let (text, selection_ranges) = marked_text_ranges("ˇlinˇe1\nˇline2\nˇline3\n", true);
+    _ = cx.add_window(|window, cx| {
+        let buffer = MultiBuffer::build_simple(&text, cx);
+        let mut editor = build_editor(buffer, window, cx);
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_ranges(selection_ranges)
+        });
+        editor.rotate_forward(&RotateForward, window, cx);
+        assert_eq!(editor.display_text(cx), "line3\nline1\nline2\n");
+
+        editor.rotate_backward(&RotateBackward, window, cx);
+        assert_eq!(editor.display_text(cx), "line1\nline2\nline3\n");
+
+        editor
+    });
+}
+
 #[gpui::test]
 fn test_move_line_up_down(cx: &mut TestAppContext) {
     init_test(cx, |_| {});

crates/editor/src/element.rs

@@ -243,6 +243,8 @@ impl EditorElement {
         register_action(editor, window, Editor::sort_lines_case_insensitive);
         register_action(editor, window, Editor::reverse_lines);
         register_action(editor, window, Editor::shuffle_lines);
+        register_action(editor, window, Editor::rotate_forward);
+        register_action(editor, window, Editor::rotate_backward);
         register_action(editor, window, Editor::convert_indentation_to_spaces);
         register_action(editor, window, Editor::convert_indentation_to_tabs);
         register_action(editor, window, Editor::convert_to_upper_case);