use continuity_buffer::Buffer;
use crate::edit_line_text_helpers::{indent_text, sort_in_place};
use crate::edit_lines::{lines_covered, rewrite_covered_lines};
use crate::edit_planning::{finalize_specs, line_content_end, EditSpec};
use crate::selection_edit::SelectionEditPlan;
use crate::Error;
use crate::{IndentUnit, LineEnding, SortKind};
pub(crate) fn plan_sort_lines(
buffer: &Buffer,
kind: SortKind,
) -> Result<Option<SelectionEditPlan>, Error> {
rewrite_covered_lines(buffer, |lines| {
let mut sorted = lines;
sort_in_place(&mut sorted, kind);
sorted
})
}
pub(crate) fn plan_reverse_lines(buffer: &Buffer) -> Result<Option<SelectionEditPlan>, Error> {
rewrite_covered_lines(buffer, |lines| {
let mut rev = lines;
rev.reverse();
rev
})
}
pub(crate) fn plan_unique_lines(buffer: &Buffer) -> Result<Option<SelectionEditPlan>, Error> {
rewrite_covered_lines(buffer, |lines| {
let mut seen = std::collections::HashSet::new();
lines
.into_iter()
.filter(|l| seen.insert(l.clone()))
.collect()
})
}
pub(crate) fn plan_shuffle_lines(
buffer: &Buffer,
seed: u64,
) -> Result<Option<SelectionEditPlan>, Error> {
rewrite_covered_lines(buffer, |mut lines| {
let mut state = seed.wrapping_add(0x9E37_79B9_7F4A_7C15);
for i in (1..lines.len()).rev() {
state = state
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1);
let j = (state >> 33) as usize % (i + 1);
lines.swap(i, j);
}
lines
})
}
mod trim;
pub(crate) use trim::{
plan_trim_trailing_whitespace, plan_trim_trailing_whitespace_all, plan_trim_whitespace_all,
};
pub(crate) fn plan_indent(
buffer: &Buffer,
unit: IndentUnit,
) -> Result<Option<SelectionEditPlan>, Error> {
let rope = buffer.rope();
let prefix = indent_text(unit);
let selections_before = buffer.selections().to_vec();
let lines = lines_covered(buffer);
let mut specs = Vec::new();
for &line in &lines {
let start = rope.line_to_byte(line);
specs.push(EditSpec::insert(rope, start, prefix.clone())?);
}
let prefix_len = prefix.len() as u32;
let selections_after: Vec<continuity_text::Selection> = selections_before
.iter()
.map(|sel| continuity_text::Selection {
anchor: shift_after_indent(sel.anchor, &lines, prefix_len),
head: shift_after_indent(sel.head, &lines, prefix_len),
kind: sel.kind,
})
.collect();
Ok(finalize_specs(specs, selections_before, selections_after))
}
use crate::edit_indent_shift::{shift_after_indent, shift_after_outdent};
pub(crate) fn plan_outdent(
buffer: &Buffer,
unit: IndentUnit,
) -> Result<Option<SelectionEditPlan>, Error> {
let rope = buffer.rope();
let selections_before = buffer.selections().to_vec();
let lines = lines_covered(buffer);
let mut specs = Vec::new();
let mut drops: Vec<(usize, u32)> = Vec::new();
for &line in &lines {
let start = rope.line_to_byte(line);
let end = line_content_end(rope, line);
let slice = rope.byte_slice(start..end).to_string();
let drop_len = outdent_drop_len(&slice, unit);
if drop_len > 0 {
specs.push(EditSpec::delete(rope, start, start + drop_len)?);
drops.push((line, drop_len as u32));
}
}
let selections_after: Vec<continuity_text::Selection> = selections_before
.iter()
.map(|sel| continuity_text::Selection {
anchor: shift_after_outdent(sel.anchor, &drops),
head: shift_after_outdent(sel.head, &drops),
kind: sel.kind,
})
.collect();
Ok(finalize_specs(specs, selections_before, selections_after))
}
pub(crate) fn plan_spaces_to_tabs(
buffer: &Buffer,
width: u32,
) -> Result<Option<SelectionEditPlan>, Error> {
let width = width.max(1) as usize;
let space_run: String = " ".repeat(width);
rewrite_covered_lines(buffer, |lines| {
lines
.into_iter()
.map(|line| line.replace(&space_run, "\t"))
.collect()
})
}
pub(crate) fn plan_tabs_to_spaces(
buffer: &Buffer,
width: u32,
) -> Result<Option<SelectionEditPlan>, Error> {
let spaces: String = " ".repeat(width as usize);
rewrite_covered_lines(buffer, |lines| {
lines
.into_iter()
.map(|line| line.replace('\t', &spaces))
.collect()
})
}
pub(crate) fn plan_convert_line_endings(
buffer: &Buffer,
eol: LineEnding,
) -> Result<Option<SelectionEditPlan>, Error> {
let rope = buffer.rope();
let selections_before = buffer.selections().to_vec();
let target = match eol {
LineEnding::Lf => "\n",
LineEnding::Crlf => "\r\n",
};
let lines = lines_covered(buffer);
let mut specs = Vec::new();
for &line in &lines {
if line + 1 >= rope.len_lines() {
continue;
}
let content_end = line_content_end(rope, line);
let next_start = rope.line_to_byte(line + 1);
if next_start <= content_end {
continue;
}
let current = rope.byte_slice(content_end..next_start).to_string();
if current != target {
specs.push(EditSpec::replace(
rope,
content_end,
next_start,
target.to_string(),
)?);
}
}
Ok(finalize_specs(
specs,
selections_before.clone(),
selections_before,
))
}
use crate::edit_indent_shift::outdent_drop_len;
#[cfg(test)]
mod tests {
use continuity_buffer::Buffer;
use continuity_text::{Position, Selection};
use super::*;
use crate::selection_edit::{apply_plan, plan, SelectionEdit};
fn at(line: u32, col: u32) -> Selection {
Selection::caret_at(Position::new(line, col))
}
fn build(text: &str, selections: Vec<Selection>) -> Buffer {
let mut buffer = Buffer::from_text(text);
buffer.set_selections(selections);
buffer
}
fn run(buffer: &mut Buffer, edit: SelectionEdit) {
let plan = plan(buffer, &edit).expect("plan ok").expect("plan some");
apply_plan(buffer, &plan).expect("apply ok");
}
#[test]
fn sort_lines_ascending() {
let mut b = Buffer::from_text("c\nb\na");
b.set_selections(vec![Selection::new(
Position::new(0, 0),
Position::new(2, 1),
continuity_text::SelectionKind::Caret,
)]);
run(&mut b, SelectionEdit::SortLines(SortKind::Asc));
assert_eq!(b.rope().to_string(), "a\nb\nc");
}
#[test]
fn indent_list_line_caret_shifts_preserves_offset() {
let mut b = Buffer::from_text("- foo");
b.set_selections(vec![Selection::caret_at(Position::new(0, 4))]);
run(
&mut b,
SelectionEdit::Indent {
unit: IndentUnit::Spaces(2),
},
);
assert_eq!(b.rope().to_string(), " - foo");
let head = b.selections()[0].head;
assert_eq!(head.byte_in_line, 6);
}
#[test]
fn indent_non_list_line_adds_line_prefix() {
let mut b = Buffer::from_text("plain");
b.set_selections(vec![Selection::caret_at(Position::new(0, 3))]);
run(
&mut b,
SelectionEdit::Indent {
unit: IndentUnit::Spaces(2),
},
);
assert_eq!(b.rope().to_string(), " plain");
assert_eq!(b.selections()[0].head, Position::new(0, 5));
}
#[test]
fn indent_multicursor_adds_one_prefix_per_covered_line() {
let mut b = Buffer::from_text("alpha\nbeta");
b.set_selections(vec![
Selection::caret_at(Position::new(0, 2)),
Selection::caret_at(Position::new(1, 3)),
]);
run(
&mut b,
SelectionEdit::Indent {
unit: IndentUnit::Tab,
},
);
assert_eq!(b.rope().to_string(), "\talpha\n\tbeta");
assert_eq!(
b.selections()
.iter()
.map(|selection| selection.head)
.collect::<Vec<_>>(),
vec![Position::new(0, 3), Position::new(1, 4)]
);
}
#[test]
fn trim_trailing_whitespace_all_covers_every_line() {
let mut b = Buffer::from_text("a \nb\t\nc d \n");
b.set_selections(vec![Selection::caret_at(Position::new(0, 0))]);
run(&mut b, SelectionEdit::TrimTrailingWhitespaceAll);
assert_eq!(b.rope().to_string(), "a\nb\nc d\n");
}
#[test]
fn indent_outdent_range_shifts_positions() {
let mut b = Buffer::from_text(" abc\n def\n ghi");
b.set_selections(vec![Selection::new(
Position::new(0, 4),
Position::new(2, 7),
continuity_text::SelectionKind::Caret,
)]);
run(
&mut b,
SelectionEdit::Outdent {
unit: IndentUnit::Spaces(4),
},
);
assert_eq!(b.rope().to_string(), "abc\ndef\nghi");
let s = b.selections()[0];
assert_eq!(
(s.anchor, s.head),
(Position::new(0, 0), Position::new(2, 3))
);
let mut b = Buffer::from_text("abc\ndef");
b.set_selections(vec![Selection::new(
Position::new(0, 1),
Position::new(1, 2),
continuity_text::SelectionKind::Caret,
)]);
run(
&mut b,
SelectionEdit::Indent {
unit: IndentUnit::Spaces(2),
},
);
assert_eq!(b.rope().to_string(), " abc\n def");
let s = b.selections()[0];
assert_eq!(
(s.anchor, s.head),
(Position::new(0, 3), Position::new(1, 4))
);
}
#[test]
fn outdent_list_line_caret_shifts_left() {
let mut b = Buffer::from_text(" - foo");
b.set_selections(vec![Selection::caret_at(Position::new(0, 8))]);
run(
&mut b,
SelectionEdit::Outdent {
unit: IndentUnit::Spaces(2),
},
);
assert_eq!(b.rope().to_string(), " - foo");
let head = b.selections()[0].head;
assert_eq!(head.byte_in_line, 6);
}
#[test]
fn reverse_lines_flips_block() {
let mut b = Buffer::from_text("1\n2\n3");
b.set_selections(vec![Selection::new(
Position::new(0, 0),
Position::new(2, 1),
continuity_text::SelectionKind::Caret,
)]);
run(&mut b, SelectionEdit::ReverseLines);
assert_eq!(b.rope().to_string(), "3\n2\n1");
}
#[test]
fn unique_lines_drops_dupes() {
let mut b = Buffer::from_text("a\nb\na");
b.set_selections(vec![Selection::new(
Position::new(0, 0),
Position::new(2, 1),
continuity_text::SelectionKind::Caret,
)]);
run(&mut b, SelectionEdit::UniqueLines);
assert_eq!(b.rope().to_string(), "a\nb");
}
#[test]
fn shuffle_lines_is_deterministic() {
let make = || {
let mut buf = Buffer::from_text("1\n2\n3\n4\n5");
buf.set_selections(vec![Selection::new(
Position::new(0, 0),
Position::new(4, 1),
continuity_text::SelectionKind::Caret,
)]);
buf
};
let mut a = make();
let mut b = make();
run(&mut a, SelectionEdit::ShuffleLines(7));
run(&mut b, SelectionEdit::ShuffleLines(7));
assert_eq!(a.rope().to_string(), b.rope().to_string());
}
#[test]
fn trim_trailing_whitespace_only_trailing() {
let mut b = build("foo \nbar", vec![at(0, 0)]);
run(&mut b, SelectionEdit::TrimTrailingWhitespace);
assert_eq!(b.rope().to_string(), "foo\nbar");
}
#[test]
fn indent_inserts_prefix() {
let mut b = build("a", vec![at(0, 0)]);
run(
&mut b,
SelectionEdit::Indent {
unit: IndentUnit::Spaces(2),
},
);
assert_eq!(b.rope().to_string(), " a");
}
#[test]
fn outdent_drops_prefix() {
let mut b = build(" a", vec![at(0, 0)]);
run(
&mut b,
SelectionEdit::Outdent {
unit: IndentUnit::Spaces(2),
},
);
assert_eq!(b.rope().to_string(), " a");
}
#[test]
fn outdent_tab_unit_drops_leading_spaces_too() {
let mut b = Buffer::from_text("\tabc\n def\n ghi");
b.set_selections(vec![Selection::new(
Position::new(0, 0),
Position::new(2, 5),
continuity_text::SelectionKind::Caret,
)]);
run(
&mut b,
SelectionEdit::Outdent {
unit: IndentUnit::Tab,
},
);
assert_eq!(b.rope().to_string(), "abc\ndef\nghi");
}
#[test]
fn spaces_to_tabs_converts_runs() {
let mut b = build(" foo", vec![at(0, 0)]);
run(&mut b, SelectionEdit::SpacesToTabs { tab_width: 4 });
assert_eq!(b.rope().to_string(), "\tfoo");
}
#[test]
fn tabs_to_spaces_converts() {
let mut b = build("\tfoo", vec![at(0, 0)]);
run(&mut b, SelectionEdit::TabsToSpaces { tab_width: 2 });
assert_eq!(b.rope().to_string(), " foo");
}
#[test]
fn convert_line_endings_lf_to_crlf() {
let mut b = Buffer::from_text("a\nb");
b.set_selections(vec![Selection::new(
Position::new(0, 0),
Position::new(1, 1),
continuity_text::SelectionKind::Caret,
)]);
run(&mut b, SelectionEdit::ConvertLineEndings(LineEnding::Crlf));
assert_eq!(b.rope().to_string(), "a\r\nb");
}
}