From 1acbe42962292b83c95bbbc635604e8e88fca58b Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 2 Jan 2021 19:33:26 +0100 Subject: [PATCH 1/7] implemented selection test DSL, added caret tests for move right --- Cargo.lock | 2 + editor/Cargo.toml | 2 + editor/editor-ideas.md | 4 +- editor/src/lib.rs | 5 + editor/src/selection.rs | 221 +++++++++++++++++++++++++++++++++++- editor/src/tea/model.rs | 1 - editor/src/util.rs | 2 +- editor/src/vec_result.rs | 1 + editor/tests/selection.pest | 11 ++ 9 files changed, 244 insertions(+), 5 deletions(-) create mode 100644 editor/tests/selection.pest diff --git a/Cargo.lock b/Cargo.lock index f493e55a6b..0af4e03703 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2672,6 +2672,8 @@ dependencies = [ "log", "maplit", "page_size", + "pest", + "pest_derive", "pretty_assertions", "quickcheck", "quickcheck_macros", diff --git a/editor/Cargo.toml b/editor/Cargo.toml index fd0b8f6d6e..fcfda19a8a 100644 --- a/editor/Cargo.toml +++ b/editor/Cargo.toml @@ -66,6 +66,8 @@ cgmath = "0.17.0" itertools = "0.9.0" snafu = { version = "0.6", features = ["backtraces"] } colored = "2" +pest = "2.1" +pest_derive = "2.1" [dependencies.bytemuck] diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index ab10bb43d1..55e00d488a 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -55,8 +55,8 @@ These are potentially inspirational resources for the editor's design. ### Productivity features * When refactoring; - - cutting and pasting code to a new file should automatically add imports to the new file and delete them from the old file. - - When renaming a function for example, references in comments should be brought to the user's attention. + - Cutting and pasting code to a new file should automatically add imports to the new file and delete them from the old file. + - Ability to link e.g. variable name in comments to actual variable name. Comment is automatically updated when variable name is changed. * Automatically create all "arms" when pattern matching after entering `when var is` based on the type. - All `when ... is` should be updated if the type is changed, e.g. adding Indigo to the Color type should add an arm everywhere where `when color is` is used. diff --git a/editor/src/lib.rs b/editor/src/lib.rs index 8835f556bc..3ecfb28da8 100644 --- a/editor/src/lib.rs +++ b/editor/src/lib.rs @@ -8,6 +8,11 @@ // See this link to learn wgpu: https://sotrh.github.io/learn-wgpu/ +extern crate pest; +#[cfg(test)] +#[macro_use] +extern crate pest_derive; + use crate::error::print_err; use crate::graphics::lowlevel::buffer::create_rect_buffers; use crate::graphics::lowlevel::ortho::{init_ortho, update_ortho_buffer, OrthoResources}; diff --git a/editor/src/selection.rs b/editor/src/selection.rs index bd5228d3e4..a03219bd9e 100644 --- a/editor/src/selection.rs +++ b/editor/src/selection.rs @@ -2,7 +2,7 @@ use crate::error::{EdResult, InvalidSelection}; use crate::graphics::colors; use crate::graphics::primitives::rect::Rect; use crate::tea::model::RawSelection; -use crate::vec_result::get_res; +use crate::vec_result::{get_res}; use bumpalo::collections::Vec as BumpVec; use bumpalo::Bump; use snafu::ensure; @@ -150,3 +150,222 @@ pub fn create_selection_rects<'a>( Ok(all_rects) } } + +#[cfg(test)] +mod test_parse { + use crate::tea::update::{move_caret_left, move_caret_right, move_caret_down, move_caret_up}; + use crate::tea::model::{RawSelection, Position}; + use crate::error::{EdResult, OutOfBounds}; + use crate::vec_result::{get_res}; + use snafu::OptionExt; + use std::slice::SliceIndex; + use pest::Parser; + + #[derive(Parser)] + #[grammar = "../tests/selection.pest"] + pub struct LineParser; + + fn convert_selection_to_dsl(raw_sel_opt: Option, caret_pos: Position, lines: &mut [String]) -> EdResult<&[String]> { + if let Some(raw_sel) = raw_sel_opt { + let mut to_insert = vec![(raw_sel.start_pos, '['), (raw_sel.end_pos, ']'), (caret_pos, '|')]; + to_insert.sort(); + + for i in 0..to_insert.len() { + let (pos, insert_char) = *get_res(i, &to_insert)?; + + insert_at_pos(lines, pos, insert_char)?; + + for j in i..to_insert.len() { + let (old_pos, _) = get_mut_res(j, &mut to_insert)?; + + if old_pos.line == pos.line { + old_pos.column += 1; + } + } + } + + } else { + insert_at_pos(lines, caret_pos, '|')?; + } + + Ok(lines) + } + + fn insert_at_pos(lines: &mut [String], pos: Position, insert_char: char) -> EdResult<()> { + let line = get_mut_res(pos.line, lines)?; + line.insert(pos.column, insert_char); + + Ok(()) + } + + fn get_mut_res(index: usize, vec: & mut [T]) -> EdResult<& mut >::Output> { + let vec_len = vec.len(); + + let elt_ref = vec.get_mut(index).context(OutOfBounds { + index, + vec_len, + })?; + + Ok(elt_ref) + } + + fn convert_dsl_to_selection(lines: &[String]) -> Result<(Option, Position), String> { + let lines_str: String = lines.join(""); + + let parsed = LineParser::parse(Rule::linesWithSelect, &lines_str).expect("Selection test DSL parsing failed"); + + let mut caret_opt: Option<(usize, usize)> = None; + let mut sel_start_opt: Option<(usize, usize)> = None; + let mut sel_end_opt: Option<(usize, usize)> = None; + let mut line_nr = 0; + let mut col_nr = 0; + + for line in parsed { + + for elt in line.into_inner() { + match elt.as_rule() { + Rule::optCaret => { + if elt.as_span().as_str() == "|" { + if caret_opt.is_some() { + return Err("Multiple carets found, there should be only one".to_owned()) + } else { + caret_opt = Some((line_nr, col_nr)); + col_nr += elt.as_span().as_str().len(); + } + } + }, + Rule::optSelStart => { + if sel_start_opt.is_some() { + if elt.as_span().as_str() == "[" { + return Err("Found start of selection more than once, there should be only one".to_owned()) + } + } else if elt.as_span().as_str() == "[" { + sel_start_opt = Some((line_nr, col_nr)); + col_nr += elt.as_span().as_str().len(); + } + }, + Rule::optSelEnd => { + if sel_end_opt.is_some() { + if elt.as_span().as_str() == "]" { + return Err("Found end of selection more than once, there should be only one".to_owned()) + } + } else if elt.as_span().as_str() == "]" { + sel_end_opt = Some((line_nr, col_nr)); + col_nr += elt.as_span().as_str().len(); + } + }, + Rule::text => { + let split_str = elt.as_span().as_str().split('\n').into_iter().collect::>(); + + if split_str.len() > 1 { + line_nr += split_str.len() - 1; + col_nr = 0 + } + if let Some(last_str) = split_str.last() { + col_nr += last_str.len() + } + + } + _ => {} + } + } + } + + if let Some((line, column)) = caret_opt { + let caret_pos = + Position { + line, + column + }; + if sel_start_opt.is_none() && sel_end_opt.is_none() { + Ok (( + None, + caret_pos + )) + } else if let Some((start_line, start_column)) = sel_start_opt { + if let Some((end_line, end_column)) = sel_end_opt { + Ok (( + Some ( + RawSelection { + start_pos : + Position { + line: start_line, + column: start_column + }, + end_pos : + Position { + line: end_line, + column: end_column + } + } + ), + caret_pos + )) + } else { + Err("Selection end ']' was not found, but selection start '[' was. Bad input string.".to_owned()) + } + } else { + Err("Selection start '[' was not found, but selection end ']' was. Bad input string.".to_owned()) + } + } else { + Err("No caret was found in lines.".to_owned()) + } + + } + + fn assert_move( + pre_lines_str: &[&str], + expected_post_lines_str: &[&str], + shift_pressed: bool, + move_fun: + fn(Position, Option, bool, &[String]) -> (Position, Option) + ) -> Result<(), String> { + let pre_lines: Vec = pre_lines_str.iter().map(|l| l.to_string()).collect(); + let expected_post_lines: Vec = expected_post_lines_str.iter().map(|l| l.to_string()).collect(); + + let (sel_opt, caret_pos) = convert_dsl_to_selection(&pre_lines)?; + + let mut clean_lines = + pre_lines.into_iter() + .map(|line| { + line.replace(&['[', ']', '|'][..], "") + }) + .collect::>(); + + let (new_caret_pos, new_sel_opt) = move_fun(caret_pos, sel_opt, shift_pressed, &clean_lines); + + let post_lines_res = + convert_selection_to_dsl(new_sel_opt, new_caret_pos, &mut clean_lines); + + match post_lines_res { + Ok(post_lines) => { + assert_eq!(expected_post_lines, post_lines); + Ok(()) + }, + Err(e) => Err(format!("{:?}", e)) + } + } + + #[test] + fn move_right() -> Result<(), String> { + assert_move(&["|"], &["|"], false, move_caret_right)?; + assert_move(&["a|"], &["a|"], false, move_caret_right)?; + assert_move(&["|A"], &["A|"], false, move_caret_right)?; + assert_move(&["|abc"], &["a|bc"], false, move_caret_right)?; + assert_move(&["a|bc"], &["ab|c"], false, move_caret_right)?; + assert_move(&["abc|"], &["abc|"], false, move_caret_right)?; + assert_move(&["| abc"], &[" |abc"], false, move_caret_right)?; + assert_move(&["abc| "], &["abc |"], false, move_caret_right)?; + assert_move(&["abc|\n","d"], &["abc\n","|d"], false, move_caret_right)?; + assert_move(&["abc|\n",""], &["abc\n","|"], false, move_caret_right)?; + assert_move(&["abc\n","|def"], &["abc\n","d|ef"], false, move_caret_right)?; + assert_move(&["abc\n","def| "], &["abc\n","def |"], false, move_caret_right)?; + assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def \n", "|ghi"], false, move_caret_right)?; + assert_move(&["abc\n","def|\n",""], &["abc\n","def\n", "|"], false, move_caret_right)?; + assert_move(&["abc\n","def\n", "ghi|\n","jkl"], &["abc\n","def\n", "ghi\n", "|jkl"], false, move_caret_right)?; + assert_move(&["abc\n","def\n", "|ghi\n","jkl"], &["abc\n","def\n", "g|hi\n", "jkl"], false, move_caret_right)?; + assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "gh|i\n", "jkl"], false, move_caret_right)?; + + Ok(()) + } +} diff --git a/editor/src/tea/model.rs b/editor/src/tea/model.rs index d7a314c03a..60219986f5 100644 --- a/editor/src/tea/model.rs +++ b/editor/src/tea/model.rs @@ -15,7 +15,6 @@ pub fn init_model() -> Model { } } -//Is model.rs the right place for these structs? #[derive(Debug, Copy, Clone)] pub struct Position { pub line: usize, diff --git a/editor/src/util.rs b/editor/src/util.rs index 3f49f32c79..8fba081a08 100644 --- a/editor/src/util.rs +++ b/editor/src/util.rs @@ -1,5 +1,5 @@ pub fn is_newline(char_ref: &char) -> bool { - let newline_codes = vec!['\u{d}']; + let newline_codes = vec!['\u{d}', '\n']; newline_codes.contains(char_ref) } diff --git a/editor/src/vec_result.rs b/editor/src/vec_result.rs index 202af28a96..0d8eb67c8a 100644 --- a/editor/src/vec_result.rs +++ b/editor/src/vec_result.rs @@ -13,3 +13,4 @@ pub fn get_res(index: usize, vec: &[T]) -> EdResult<& Date: Mon, 4 Jan 2021 14:42:24 +0100 Subject: [PATCH 2/7] tests for all caret movement, moving caret up now goes to beginning of line for first line --- editor/src/selection.rs | 113 ++++++++++++++++++++++++++++++++++++++- editor/src/tea/update.rs | 10 ++-- 2 files changed, 119 insertions(+), 4 deletions(-) diff --git a/editor/src/selection.rs b/editor/src/selection.rs index a03219bd9e..ac41c5a6bf 100644 --- a/editor/src/selection.rs +++ b/editor/src/selection.rs @@ -368,4 +368,115 @@ mod test_parse { Ok(()) } -} + + #[test] + fn move_left() -> Result<(), String> { + assert_move(&["|"], &["|"], false, move_caret_left)?; + assert_move(&["|a"], &["|a"], false, move_caret_left)?; + assert_move(&["|A"], &["|A"], false, move_caret_left)?; + assert_move(&["a|bc"], &["|abc"], false, move_caret_left)?; + assert_move(&["ab|c"], &["a|bc"], false, move_caret_left)?; + assert_move(&["abc|"], &["ab|c"], false, move_caret_left)?; + assert_move(&[" |abc"], &["| abc"], false, move_caret_left)?; + assert_move(&["abc |"], &["abc| "], false, move_caret_left)?; + assert_move(&["abc\n","|d"], &["abc|\n","d"], false, move_caret_left)?; + assert_move(&["abc\n","|"], &["abc|\n",""], false, move_caret_left)?; + assert_move(&["abc\n","d|ef"], &["abc\n","|def"], false, move_caret_left)?; + assert_move(&["abc\n","def |"], &["abc\n","def| "], false, move_caret_left)?; + assert_move(&["abc\n","def \n", "|ghi"], &["abc\n","def |\n", "ghi"], false, move_caret_left)?; + assert_move(&["abc\n","def\n","|"], &["abc\n","def|\n", ""], false, move_caret_left)?; + assert_move(&["abc\n","def\n", "ghi\n","|jkl"], &["abc\n","def\n", "ghi|\n", "jkl"], false, move_caret_left)?; + assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "|ghi\n", "jkl"], false, move_caret_left)?; + assert_move(&["abc\n","def\n", "gh|i\n","jkl"], &["abc\n","def\n", "g|hi\n", "jkl"], false, move_caret_left)?; + + Ok(()) + } + + #[test] + fn move_up() -> Result<(), String> { + assert_move(&["|"], &["|"], false, move_caret_up)?; + assert_move(&["|a"], &["|a"], false, move_caret_up)?; + assert_move(&["A|"], &["|A"], false, move_caret_up)?; + assert_move(&["a|bc"], &["|abc"], false, move_caret_up)?; + assert_move(&["ab|c"], &["|abc"], false, move_caret_up)?; + assert_move(&["abc|"], &["|abc"], false, move_caret_up)?; + assert_move(&["|abc\n","def"], &["|abc\n","def"], false, move_caret_up)?; + assert_move(&["abc\n","|def"], &["|abc\n","def"], false, move_caret_up)?; + assert_move(&["abc\n","d|ef"], &["a|bc\n","def"], false, move_caret_up)?; + assert_move(&["abc\n","de|f"], &["ab|c\n","def"], false, move_caret_up)?; + assert_move(&["abc\n","def|"], &["abc|\n","def"], false, move_caret_up)?; + assert_move(&["abc\n","def \n", "|ghi"], &["abc\n","|def \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","def \n", "g|hi"], &["abc\n","d|ef \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","def \n", "gh|i"], &["abc\n","de|f \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","def \n", "ghi|"], &["abc\n","def| \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","de\n", "ghi|"], &["abc\n","de|\n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","de|"], &["ab|c\n","de"], false, move_caret_up)?; + assert_move(&["abc\n","d|e"], &["a|bc\n","de"], false, move_caret_up)?; + assert_move(&["abc\n","|de"], &["|abc\n","de"], false, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], &["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], &[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], &["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","cde|f\n", "ghijkl\n","mnopqrst"], &["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","st|"], &["abcdefgh\n","ijklmn\n", "op|qr\n","st"], false, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijkl|mn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdef|gh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["abcdefg|h\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["a|bcdefgh\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["|abcdefgh\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["abc def gh |"], &["|abc def gh "], false, move_caret_up)?; + assert_move(&["abc de|f gh "], &["|abc def gh "], false, move_caret_up)?; + assert_move(&["ab|c def gh "], &["|abc def gh "], false, move_caret_up)?; + assert_move(&["a|bc def gh "], &["|abc def gh "], false, move_caret_up)?; + + Ok(()) + } + + #[test] + fn move_down() -> Result<(), String> { + assert_move(&["|"], &["|"], false, move_caret_down)?; + assert_move(&["|a"], &["a|"], false, move_caret_down)?; + assert_move(&["A|"], &["A|"], false, move_caret_down)?; + assert_move(&["a|bc"], &["abc|"], false, move_caret_down)?; + assert_move(&["ab|c"], &["abc|"], false, move_caret_down)?; + assert_move(&["abc|"], &["abc|"], false, move_caret_down)?; + assert_move(&["abc| "], &["abc |"], false, move_caret_down)?; + assert_move(&["abc\n","|def"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["abc\n","d|ef"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["abc\n","de|f"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["abc\n","def|"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["|abc\n","def"], &["abc\n","|def"], false, move_caret_down)?; + assert_move(&["a|bc\n","def"], &["abc\n","d|ef"], false, move_caret_down)?; + assert_move(&["ab|c\n","def"], &["abc\n","de|f"], false, move_caret_down)?; + assert_move(&["abc|\n","def"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["abc\n","|def \n", "ghi"], &["abc\n","def \n", "|ghi"], false, move_caret_down)?; + assert_move(&["abc\n","d|ef \n", "ghi"], &["abc\n","def \n", "g|hi"], false, move_caret_down)?; + assert_move(&["abc\n","de|f \n", "ghi"], &["abc\n","def \n", "gh|i"], false, move_caret_down)?; + assert_move(&["abc\n","def| \n", "ghi"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; + assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; + assert_move(&["abc\n","de|\n", "ghi"], &["abc\n","de\n", "gh|i"], false, move_caret_down)?; + assert_move(&["abc|\n","de"], &["abc\n","de|"], false, move_caret_down)?; + assert_move(&["ab|c\n","de"], &["abc\n","de|"], false, move_caret_down)?; + assert_move(&["a|bc\n","de"], &["abc\n","d|e"], false, move_caret_down)?; + assert_move(&["|abc\n","de"], &["abc\n","|de"], false, move_caret_down)?; + assert_move(&["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], &["ab\n","cd|ef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "ghij|kl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], false, move_caret_down)?; + assert_move(&[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], &[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","|cdef\n", "ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], false, move_caret_down)?; + assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["abcdefgh\n","ijklmn|\n", "opqr\n","st"], false, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdefgh\n","ijklmn\n", "opqr|\n","st"], false, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","|st"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; + assert_move(&["abc def gh |"], &["abc def gh |"], false, move_caret_down)?; + assert_move(&["abc de|f gh "], &["abc def gh |"], false, move_caret_down)?; + assert_move(&["ab|c def gh "], &["abc def gh |"], false, move_caret_down)?; + assert_move(&["a|bc def gh "], &["abc def gh |"], false, move_caret_down)?; + assert_move(&["|abc def gh "], &["abc def gh |"], false, move_caret_down)?; + + Ok(()) + } +} \ No newline at end of file diff --git a/editor/src/tea/update.rs b/editor/src/tea/update.rs index f542bfdf50..baeaa7939e 100644 --- a/editor/src/tea/update.rs +++ b/editor/src/tea/update.rs @@ -132,9 +132,9 @@ pub fn move_caret_up( let old_col_nr = old_caret_pos.column; let (line_nr, col_nr) = if old_line_nr == 0 { - (old_line_nr, old_col_nr) + (old_line_nr, 0) } else if let Some(prev_line) = lines.get(old_line_nr - 1) { - if prev_line.len() < old_col_nr { + if prev_line.len() <= old_col_nr { (old_line_nr - 1, prev_line.len() - 1) } else { (old_line_nr - 1, old_col_nr) @@ -179,7 +179,11 @@ pub fn move_caret_down( let old_col_nr = old_caret_pos.column; let (line_nr, col_nr) = if old_line_nr + 1 >= lines.len() { - (old_line_nr, old_col_nr) + if let Some(curr_line) = lines.get(old_line_nr) { + (old_line_nr, curr_line.len()) + } else { + unreachable!() + } } else if let Some(next_line) = lines.get(old_line_nr + 1) { if next_line.len() < old_col_nr { if let Some(last_char) = next_line.chars().last() { From 45296ba2e584a0a61024bb57e7f6328168dd34f1 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 4 Jan 2021 16:45:55 +0100 Subject: [PATCH 3/7] start selection tests --- editor/src/selection.rs | 153 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 152 insertions(+), 1 deletion(-) diff --git a/editor/src/selection.rs b/editor/src/selection.rs index ac41c5a6bf..ae5118111f 100644 --- a/editor/src/selection.rs +++ b/editor/src/selection.rs @@ -159,8 +159,11 @@ mod test_parse { use crate::vec_result::{get_res}; use snafu::OptionExt; use std::slice::SliceIndex; + use std::collections::HashMap; + use core::cmp::Ordering; use pest::Parser; + #[derive(Parser)] #[grammar = "../tests/selection.pest"] pub struct LineParser; @@ -168,7 +171,18 @@ mod test_parse { fn convert_selection_to_dsl(raw_sel_opt: Option, caret_pos: Position, lines: &mut [String]) -> EdResult<&[String]> { if let Some(raw_sel) = raw_sel_opt { let mut to_insert = vec![(raw_sel.start_pos, '['), (raw_sel.end_pos, ']'), (caret_pos, '|')]; - to_insert.sort(); + let symbol_map: HashMap = [('[', 2), (']', 0), ('|', 1)].iter().cloned().collect(); + + to_insert.sort_by( + |a, b| { + let pos_cmp = a.0.cmp(&b.0); + if pos_cmp == Ordering::Equal { + symbol_map.get(&a.1).cmp(&symbol_map.get(&b.1)) + } else { + pos_cmp + } + } + ); for i in 0..to_insert.len() { let (pos, insert_char) = *get_res(i, &to_insert)?; @@ -479,4 +493,141 @@ mod test_parse { Ok(()) } + + #[test] + fn start_selection_right() -> Result<(), String> { + assert_move(&["|"], &["|"], true, move_caret_right)?; + assert_move(&["a|"], &["a|"], true, move_caret_right)?; + assert_move(&["|A"], &["[A]|"], true, move_caret_right)?; + assert_move(&["|abc"], &["[a]|bc"], true, move_caret_right)?; + assert_move(&["a|bc"], &["a[b]|c"], true, move_caret_right)?; + assert_move(&["abc|"], &["abc|"], true, move_caret_right)?; + assert_move(&["| abc"], &["[ ]|abc"], true, move_caret_right)?; + assert_move(&["abc| "], &["abc[ ]|"], true, move_caret_right)?; + assert_move(&["abc|\n","d"], &["abc[\n","]|d"], true, move_caret_right)?; + assert_move(&["abc|\n",""], &["abc[\n","]|"], true, move_caret_right)?; + assert_move(&["abc\n","|def"], &["abc\n","[d]|ef"], true, move_caret_right)?; + assert_move(&["abc\n","def| "], &["abc\n","def[ ]|"], true, move_caret_right)?; + assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def [\n", "]|ghi"], true, move_caret_right)?; + assert_move(&["abc\n","def|\n",""], &["abc\n","def[\n", "]|"], true, move_caret_right)?; + assert_move(&["abc\n","def\n", "ghi|\n","jkl"], &["abc\n","def\n", "ghi[\n", "]|jkl"], true, move_caret_right)?; + assert_move(&["abc\n","def\n", "|ghi\n","jkl"], &["abc\n","def\n", "[g]|hi\n", "jkl"], true, move_caret_right)?; + assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "g[h]|i\n", "jkl"], true, move_caret_right)?; + + Ok(()) + } + + #[test] + fn start_selection_left() -> Result<(), String> { + assert_move(&["|"], &["|"], true, move_caret_left)?; + assert_move(&["a|"], &["|[a]"], true, move_caret_left)?; + assert_move(&["|A"], &["|A"], true, move_caret_left)?; + assert_move(&["|abc"], &["|abc"], true, move_caret_left)?; + assert_move(&["a|bc"], &["|[a]bc"], true, move_caret_left)?; + assert_move(&["abc|"], &["ab|[c]"], true, move_caret_left)?; + assert_move(&[" |abc"], &["|[ ]abc"], true, move_caret_left)?; + assert_move(&["abc |"], &["abc|[ ]"], true, move_caret_left)?; + assert_move(&["abc|\n","d"], &["ab|[c]\n","d"], true, move_caret_left)?; + assert_move(&["abc\n","|d"], &["abc|[\n","]d"], true, move_caret_left)?; + assert_move(&["abc\n","|"], &["abc|[\n","]"], true, move_caret_left)?; + assert_move(&["abc\n"," |def"], &["abc\n","|[ ]def"], true, move_caret_left)?; + assert_move(&["abc\n","d|ef"], &["abc\n","|[d]ef"], true, move_caret_left)?; + assert_move(&["abc\n","de|f "], &["abc\n","d|[e]f "], true, move_caret_left)?; + assert_move(&["abc\n","def\n","|"], &["abc\n","def|[\n", "]"], true, move_caret_left)?; + assert_move(&["abc\n","def\n", "|ghi\n","jkl"], &["abc\n","def|[\n", "]ghi\n", "jkl"], true, move_caret_left)?; + assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "|[g]hi\n", "jkl"], true, move_caret_left)?; + assert_move(&["abc\n","def\n", "gh|i\n","jkl"], &["abc\n","def\n", "g|[h]i\n", "jkl"], true, move_caret_left)?; + assert_move(&["abc\n","def\n", "ghi|\n","jkl"], &["abc\n","def\n", "gh|[i]\n", "jkl"], true, move_caret_left)?; + + Ok(()) + } + + #[test] + fn start_selection_down() -> Result<(), String> { + assert_move(&["|"], &["|"], true, move_caret_down)?; + assert_move(&["|a"], &["[a]|"], true, move_caret_down)?; + assert_move(&["A|"], &["A|"], true, move_caret_down)?; + assert_move(&["a|bc"], &["a[bc]|"], true, move_caret_down)?; + assert_move(&["ab|c"], &["ab[c]|"], true, move_caret_down)?; + assert_move(&["abc|"], &["abc|"], true, move_caret_down)?; + assert_move(&["abc| "], &["abc[ ]|"], true, move_caret_down)?; + assert_move(&["abc\n","|def"], &["abc\n","[def]|"], true, move_caret_down)?; + assert_move(&["abc\n","d|ef"], &["abc\n","d[ef]|"], true, move_caret_down)?; + assert_move(&["abc\n","de|f"], &["abc\n","de[f]|"], true, move_caret_down)?; + assert_move(&["abc\n","def|"], &["abc\n","def|"], true, move_caret_down)?; + assert_move(&["|abc\n","def"], &["[abc\n","]|def"], true, move_caret_down)?; + assert_move(&["a|bc\n","def"], &["a[bc\n","d]|ef"], true, move_caret_down)?; + assert_move(&["ab|c\n","def"], &["ab[c\n","de]|f"], true, move_caret_down)?; + assert_move(&["abc|\n","def"], &["abc[\n","def]|"], true, move_caret_down)?; + assert_move(&["abc\n","|def \n", "ghi"], &["abc\n","[def \n", "]|ghi"], true, move_caret_down)?; + assert_move(&["abc\n","d|ef \n", "ghi"], &["abc\n","d[ef \n", "g]|hi"], true, move_caret_down)?; + assert_move(&["abc\n","de|f \n", "ghi"], &["abc\n","de[f \n", "gh]|i"], true, move_caret_down)?; + assert_move(&["abc\n","def| \n", "ghi"], &["abc\n","def[ \n", "ghi]|"], true, move_caret_down)?; + assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def [\n", "ghi]|"], true, move_caret_down)?; + assert_move(&["abc\n","de|\n", "ghi"], &["abc\n","de[\n", "gh]|i"], true, move_caret_down)?; + assert_move(&["abc|\n","de"], &["abc[\n","de]|"], true, move_caret_down)?; + assert_move(&["ab|c\n","de"], &["ab[c\n","de]|"], true, move_caret_down)?; + assert_move(&["a|bc\n","de"], &["a[bc\n","d]|e"], true, move_caret_down)?; + assert_move(&["|abc\n","de"], &["[abc\n","]|de"], true, move_caret_down)?; + assert_move(&["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], &["ab[\n","cd]|ef\n", "ghijkl\n","mnopqrst"], true, move_caret_down)?; + assert_move(&["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], &["ab\n","cdef[\n", "ghij]|kl\n","mnopqrst"], true, move_caret_down)?; + assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef\n", "ghijkl[\n","mnopqr]|st"], true, move_caret_down)?; + assert_move(&[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], &[" [ab\n"," ]|cdef\n", "ghijkl\n","mnopqrst"], true, move_caret_down)?; + assert_move(&["ab\n","|cdef\n", "ghijkl\n","mnopqrst"], &["ab\n","[cdef\n", "]|ghijkl\n","mnopqrst"], true, move_caret_down)?; + assert_move(&["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "[ghijkl\n","]|mnopqrst"], true, move_caret_down)?; + assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["abcdefgh[\n","ijklmn]|\n", "opqr\n","st"], true, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdefgh\n","ijklmn[\n", "opqr]|\n","st"], true, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijklmn\n", "opqr[\n","st]|"], true, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","|st"], &["abcdefgh\n","ijklmn\n", "opqr\n","[st]|"], true, move_caret_down)?; + assert_move(&["abc def gh |"], &["abc def gh |"], true, move_caret_down)?; + assert_move(&["abc de|f gh "], &["abc de[f gh ]|"], true, move_caret_down)?; + assert_move(&["ab|c def gh "], &["ab[c def gh ]|"], true, move_caret_down)?; + assert_move(&["a|bc def gh "], &["a[bc def gh ]|"], true, move_caret_down)?; + assert_move(&["|abc def gh "], &["[abc def gh ]|"], true, move_caret_down)?; + + Ok(()) + } + + #[test] + fn start_selection_up() -> Result<(), String> { + assert_move(&["|"], &["|"], true, move_caret_up)?; + assert_move(&["|a"], &["|a"], true, move_caret_up)?; + assert_move(&["A|"], &["|[A]"], true, move_caret_up)?; + assert_move(&["a|bc"], &["|[a]bc"], true, move_caret_up)?; + assert_move(&["ab|c"], &["|[ab]c"], true, move_caret_up)?; + assert_move(&["abc|"], &["|[abc]"], true, move_caret_up)?; + assert_move(&["|abc\n","def"], &["|abc\n","def"], true, move_caret_up)?; + assert_move(&["abc\n","|def"], &["|[abc\n","]def"], true, move_caret_up)?; + assert_move(&["abc\n","d|ef"], &["a|[bc\n","d]ef"], true, move_caret_up)?; + assert_move(&["abc\n","de|f"], &["ab|[c\n","de]f"], true, move_caret_up)?; + assert_move(&["abc\n","def|"], &["abc|[\n","def]"], true, move_caret_up)?; + assert_move(&["abc\n","def \n", "|ghi"], &["abc\n","|[def \n", "]ghi"], true, move_caret_up)?; + assert_move(&["abc\n","def \n", "g|hi"], &["abc\n","d|[ef \n", "g]hi"], true, move_caret_up)?; + assert_move(&["abc\n","def \n", "gh|i"], &["abc\n","de|[f \n", "gh]i"], true, move_caret_up)?; + assert_move(&["abc\n","def \n", "ghi|"], &["abc\n","def|[ \n", "ghi]"], true, move_caret_up)?; + assert_move(&["abc\n","de\n", "ghi|"], &["abc\n","de|[\n", "ghi]"], true, move_caret_up)?; + assert_move(&["abc\n","de|"], &["ab|[c\n","de]"], true, move_caret_up)?; + assert_move(&["abc\n","d|e"], &["a|[bc\n","d]e"], true, move_caret_up)?; + assert_move(&["abc\n","|de"], &["|[abc\n","]de"], true, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], &["ab\n","cdef\n", "ghijkl|[\n","mnopqrst]"], true, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef|[\n", "ghijkl]\n","mnopqrst"], true, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], &["ab\n","cdef\n", "|[ghijkl\n","]mnopqrst"], true, move_caret_up)?; + assert_move(&[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], &[" |[ab\n"," ]cdef\n", "ghijkl\n","mnopqrst"], true, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], &["ab\n","cdef\n", "ghijkl|[\n","mnopqr]st"], true, move_caret_up)?; + assert_move(&["ab\n","cde|f\n", "ghijkl\n","mnopqrst"], &["ab|[\n","cde]f\n", "ghijkl\n","mnopqrst"], true, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","st|"], &["abcdefgh\n","ijklmn\n", "op|[qr\n","st]"], true, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijkl|[mn\n", "opqr]\n","st"], true, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdef|[gh\n","ijklmn]\n", "opqr\n","st"], true, move_caret_up)?; + assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["|[abcdefgh]\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; + assert_move(&["abcdefg|h\n","ijklmn\n", "opqr\n","st"], &["|[abcdefg]h\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; + assert_move(&["a|bcdefgh\n","ijklmn\n", "opqr\n","st"], &["|[a]bcdefgh\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; + assert_move(&["|abcdefgh\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; + assert_move(&["abc def gh |"], &["|[abc def gh ]"], true, move_caret_up)?; + assert_move(&["abc de|f gh "], &["|[abc de]f gh "], true, move_caret_up)?; + assert_move(&["ab|c def gh "], &["|[ab]c def gh "], true, move_caret_up)?; + assert_move(&["a|bc def gh "], &["|[a]bc def gh "], true, move_caret_up)?; + + Ok(()) + } + } \ No newline at end of file From 85553987eccc2c06afc29101eda6aa3bced6dc8a Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 4 Jan 2021 20:06:32 +0100 Subject: [PATCH 4/7] end selection tests --- editor/src/selection.rs | 147 ++++++++++++++++++++++++++++++++++++++- editor/src/tea/update.rs | 92 +++++++++++++++--------- 2 files changed, 202 insertions(+), 37 deletions(-) diff --git a/editor/src/selection.rs b/editor/src/selection.rs index ae5118111f..72d8df2ead 100644 --- a/editor/src/selection.rs +++ b/editor/src/selection.rs @@ -244,7 +244,6 @@ mod test_parse { return Err("Multiple carets found, there should be only one".to_owned()) } else { caret_opt = Some((line_nr, col_nr)); - col_nr += elt.as_span().as_str().len(); } } }, @@ -255,7 +254,6 @@ mod test_parse { } } else if elt.as_span().as_str() == "[" { sel_start_opt = Some((line_nr, col_nr)); - col_nr += elt.as_span().as_str().len(); } }, Rule::optSelEnd => { @@ -265,7 +263,6 @@ mod test_parse { } } else if elt.as_span().as_str() == "]" { sel_end_opt = Some((line_nr, col_nr)); - col_nr += elt.as_span().as_str().len(); } }, Rule::text => { @@ -630,4 +627,148 @@ mod test_parse { Ok(()) } + #[test] + fn end_selection_right() -> Result<(), String> { + assert_move(&["[A]|"], &["A|"], false, move_caret_right)?; + assert_move(&["[a]|bc"], &["a|bc"], false, move_caret_right)?; + assert_move(&["a[b]|c"], &["ab|c"], false, move_caret_right)?; + assert_move(&["ab[c]|"], &["abc|"], false, move_caret_right)?; + assert_move(&["[ ]|abc"], &[" |abc"], false, move_caret_right)?; + assert_move(&["|[ ]abc"], &[" |abc"], false, move_caret_right)?; + assert_move(&["a|[b]c"], &["ab|c"], false, move_caret_right)?; + assert_move(&["abc[\n","]|d"], &["abc\n","|d"], false, move_caret_right)?; + assert_move(&["abc|[\n","]d"], &["abc\n","|d"], false, move_caret_right)?; + assert_move(&["abc|[\n","]"], &["abc\n","|"], false, move_caret_right)?; + assert_move(&["abc\n","[d]|ef"], &["abc\n","d|ef"], false, move_caret_right)?; + assert_move(&["abc\n","def\n", "ghi[\n","]|jkl"], &["abc\n","def\n", "ghi\n", "|jkl"], false, move_caret_right)?; + assert_move(&["[ab]|c"], &["ab|c"], false, move_caret_right)?; + assert_move(&["[abc]|"], &["abc|"], false, move_caret_right)?; + assert_move(&["ab|[c\n","]def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; + assert_move(&["ab[c\n","]|def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; + assert_move(&["a|[bc\n","]def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; + assert_move(&["|[abc\n","]def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; + assert_move(&["a|[bc\n","d]ef\n","ghi"], &["abc\n","d|ef\n","ghi"], false, move_caret_right)?; + assert_move(&["|[abc\n","def]\n","ghi"], &["abc\n","def|\n","ghi"], false, move_caret_right)?; + assert_move(&["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], &["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], false, move_caret_right)?; + assert_move(&["|[ab\n","cdef\n", "ghijkl\n","mnopqrst]"], &["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], false, move_caret_right)?; + assert_move(&["ab\n","c[def\n", "ghijkl\n","mno]|pqrst"], &["ab\n","cdef\n", "ghijkl\n","mno|pqrst"], false, move_caret_right)?; + assert_move(&["ab\n","c|[def\n", "ghijkl\n","mno]pqrst"], &["ab\n","cdef\n", "ghijkl\n","mno|pqrst"], false, move_caret_right)?; + + Ok(()) + } + + #[test] + fn end_selection_left() -> Result<(), String> { + assert_move(&["[A]|"], &["|A"], false, move_caret_left)?; + assert_move(&["[a]|bc"], &["|abc"], false, move_caret_left)?; + assert_move(&["a[b]|c"], &["a|bc"], false, move_caret_left)?; + assert_move(&["ab[c]|"], &["ab|c"], false, move_caret_left)?; + assert_move(&["[ ]|abc"], &["| abc"], false, move_caret_left)?; + assert_move(&["|[ ]abc"], &["| abc"], false, move_caret_left)?; + assert_move(&["a|[b]c"], &["a|bc"], false, move_caret_left)?; + assert_move(&["abc[\n","]|d"], &["abc|\n","d"], false, move_caret_left)?; + assert_move(&["abc|[\n","]d"], &["abc|\n","d"], false, move_caret_left)?; + assert_move(&["abc|[\n","]"], &["abc|\n",""], false, move_caret_left)?; + assert_move(&["abc\n","[d]|ef"], &["abc\n","|def"], false, move_caret_left)?; + assert_move(&["abc\n","def\n", "ghi[\n","]|jkl"], &["abc\n","def\n", "ghi|\n", "jkl"], false, move_caret_left)?; + assert_move(&["[ab]|c"], &["|abc"], false, move_caret_left)?; + assert_move(&["[abc]|"], &["|abc"], false, move_caret_left)?; + assert_move(&["ab|[c\n","]def\n","ghi"], &["ab|c\n","def\n","ghi"], false, move_caret_left)?; + assert_move(&["ab[c\n","]|def\n","ghi"], &["ab|c\n","def\n","ghi"], false, move_caret_left)?; + assert_move(&["a|[bc\n","]def\n","ghi"], &["a|bc\n","def\n","ghi"], false, move_caret_left)?; + assert_move(&["|[abc\n","]def\n","ghi"], &["|abc\n","def\n","ghi"], false, move_caret_left)?; + assert_move(&["a|[bc\n","d]ef\n","ghi"], &["a|bc\n","def\n","ghi"], false, move_caret_left)?; + assert_move(&["|[abc\n","def]\n","ghi"], &["|abc\n","def\n","ghi"], false, move_caret_left)?; + assert_move(&["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], &["|ab\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; + assert_move(&["|[ab\n","cdef\n", "ghijkl\n","mnopqrst]"], &["|ab\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; + assert_move(&["ab\n","c[def\n", "ghijkl\n","mno]|pqrst"], &["ab\n","c|def\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; + assert_move(&["ab\n","c|[def\n", "ghijkl\n","mno]pqrst"], &["ab\n","c|def\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; + + Ok(()) + } + + #[test] + fn end_selection_down() -> Result<(), String> { + assert_move(&["[a]|"], &["a|"], false, move_caret_down)?; + assert_move(&["|[a]"], &["a|"], false, move_caret_down)?; + assert_move(&["a|[bc]"], &["abc|"], false, move_caret_down)?; + assert_move(&["ab[c]|"], &["abc|"], false, move_caret_down)?; + assert_move(&["abc|[ ]"], &["abc |"], false, move_caret_down)?; + assert_move(&["abc\n","|[def]"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["abc\n","d|[ef]"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["abc\n","de|[f]"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["[abc\n","]|def"], &["abc\n","|def"], false, move_caret_down)?; + assert_move(&["a[bc\n","d]|ef"], &["abc\n","d|ef"], false, move_caret_down)?; + assert_move(&["ab|[c\n","de]f"], &["abc\n","de|f"], false, move_caret_down)?; + assert_move(&["abc[\n","def]|"], &["abc\n","def|"], false, move_caret_down)?; + assert_move(&["abc\n","|[def \n", "]ghi"], &["abc\n","def \n", "|ghi"], false, move_caret_down)?; + assert_move(&["abc\n","d[ef \n", "g]|hi"], &["abc\n","def \n", "g|hi"], false, move_caret_down)?; + assert_move(&["abc\n","de[f \n", "gh]|i"], &["abc\n","def \n", "gh|i"], false, move_caret_down)?; + assert_move(&["abc\n","def[ \n", "ghi]|"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; + assert_move(&["abc\n","def [\n", "ghi]|"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; + assert_move(&["abc\n","de[\n", "gh]|i"], &["abc\n","de\n", "gh|i"], false, move_caret_down)?; + assert_move(&["abc|[\n","de]"], &["abc\n","de|"], false, move_caret_down)?; + assert_move(&["ab[c\n","de]|"], &["abc\n","de|"], false, move_caret_down)?; + assert_move(&["a|[bc\n","d]e"], &["abc\n","d|e"], false, move_caret_down)?; + assert_move(&["[abc\n","]|de"], &["abc\n","|de"], false, move_caret_down)?; + assert_move(&["ab[\n","cd]|ef\n", "ghijkl\n","mnopqrst"], &["ab\n","cd|ef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","cdef|[\n", "ghij]kl\n","mnopqrst"], &["ab\n","cdef\n", "ghij|kl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","cdef\n", "ghijkl[\n","mnopqr]|st"], &["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], false, move_caret_down)?; + assert_move(&[" [ab\n"," ]|cdef\n", "ghijkl\n","mnopqrst"], &[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","|[cdef\n", "]ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_down)?; + assert_move(&["ab\n","cdef\n", "[ghijkl\n","]|mnopqrst"], &["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], false, move_caret_down)?; + assert_move(&["abcdefgh[\n","ijklmn]|\n", "opqr\n","st"], &["abcdefgh\n","ijklmn|\n", "opqr\n","st"], false, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn[\n", "opqr]|\n","st"], &["abcdefgh\n","ijklmn\n", "opqr|\n","st"], false, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr[\n","st]|"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","[st]|"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; + assert_move(&["abc de[f gh ]|"], &["abc def gh |"], false, move_caret_down)?; + assert_move(&["ab|[c def gh ]"], &["abc def gh |"], false, move_caret_down)?; + assert_move(&["a[bc def gh ]|"], &["abc def gh |"], false, move_caret_down)?; + assert_move(&["[abc def gh ]|"], &["abc def gh |"], false, move_caret_down)?; + + Ok(()) + } + + #[test] + fn end_selection_up() -> Result<(), String> { + assert_move(&["[a]|"], &["|a"], false, move_caret_up)?; + assert_move(&["|[a]"], &["|a"], false, move_caret_up)?; + assert_move(&["a|[bc]"], &["a|bc"], false, move_caret_up)?; + assert_move(&["ab[c]|"], &["ab|c"], false, move_caret_up)?; + assert_move(&["abc|[ ]"], &["abc| "], false, move_caret_up)?; + assert_move(&["abc\n","|[def]"], &["abc\n","|def"], false, move_caret_up)?; + assert_move(&["abc\n","d|[ef]"], &["abc\n","d|ef"], false, move_caret_up)?; + assert_move(&["abc\n","de|[f]"], &["abc\n","de|f"], false, move_caret_up)?; + assert_move(&["[abc\n","]|def"], &["|abc\n","def"], false, move_caret_up)?; + assert_move(&["a[bc\n","d]|ef"], &["a|bc\n","def"], false, move_caret_up)?; + assert_move(&["ab|[c\n","de]f"], &["ab|c\n","def"], false, move_caret_up)?; + assert_move(&["abc[\n","def]|"], &["abc|\n","def"], false, move_caret_up)?; + assert_move(&["abc\n","|[def \n", "]ghi"], &["abc\n","|def \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","d[ef \n", "g]|hi"], &["abc\n","d|ef \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","de|[f \n", "gh]i"], &["abc\n","de|f \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","def[ \n", "ghi]|"], &["abc\n","def| \n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","def [\n", "ghi]|"], &["abc\n","def |\n", "ghi"], false, move_caret_up)?; + assert_move(&["abc\n","de[\n", "gh]|i"], &["abc\n","de|\n", "ghi"], false, move_caret_up)?; + assert_move(&["abc|[\n","de]"], &["abc|\n","de"], false, move_caret_up)?; + assert_move(&["ab[c\n","de]|"], &["ab|c\n","de"], false, move_caret_up)?; + assert_move(&["a|[bc\n","d]e"], &["a|bc\n","de"], false, move_caret_up)?; + assert_move(&["[abc\n","]|de"], &["|abc\n","de"], false, move_caret_up)?; + assert_move(&["ab[\n","cd]|ef\n", "ghijkl\n","mnopqrst"], &["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","cdef|[\n", "ghij]kl\n","mnopqrst"], &["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl[\n","mnopqr]|st"], &["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], false, move_caret_up)?; + assert_move(&[" [ab\n"," ]|cdef\n", "ghijkl\n","mnopqrst"], &[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","|[cdef\n", "]ghijkl\n","mnopqrst"], &["ab\n","|cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "[ghijkl\n","]|mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_up)?; + assert_move(&["abcdefgh[\n","ijklmn]|\n", "opqr\n","st"], &["abcdefgh|\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn[\n", "opqr]|\n","st"], &["abcdefgh\n","ijklmn|\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr[\n","st]|"], &["abcdefgh\n","ijklmn\n", "opqr|\n","st"], false, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","[st]|"], &["abcdefgh\n","ijklmn\n", "opqr\n","|st"], false, move_caret_up)?; + assert_move(&["abc de[f gh ]|"], &["abc de|f gh "], false, move_caret_up)?; + assert_move(&["ab|[c def gh ]"], &["ab|c def gh "], false, move_caret_up)?; + assert_move(&["a[bc def gh ]|"], &["a|bc def gh "], false, move_caret_up)?; + assert_move(&["[abc def gh ]|"], &["|abc def gh "], false, move_caret_up)?; + + Ok(()) + } + } \ No newline at end of file diff --git a/editor/src/tea/update.rs b/editor/src/tea/update.rs index baeaa7939e..9d01694d61 100644 --- a/editor/src/tea/update.rs +++ b/editor/src/tea/update.rs @@ -11,17 +11,23 @@ pub fn move_caret_left( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = if old_col_nr == 0 { - if old_line_nr == 0 { - (0, 0) - } else if let Some(curr_line) = lines.get(old_line_nr - 1) { - (old_line_nr - 1, curr_line.len() - 1) + let (line_nr, col_nr) = + if old_selection_opt.is_some() && !shift_pressed{ + match old_selection_opt { + Some(old_selection) => (old_selection.start_pos.line, old_selection.start_pos.column), + None => unreachable!(), + } + } else if old_col_nr == 0 { + if old_line_nr == 0 { + (0, 0) + } else if let Some(curr_line) = lines.get(old_line_nr - 1) { + (old_line_nr - 1, curr_line.len() - 1) + } else { + unreachable!() + } } else { - unreachable!() - } - } else { - (old_line_nr, old_col_nr - 1) - }; + (old_line_nr, old_col_nr - 1) + }; let new_caret_pos = Position { line: line_nr, @@ -67,25 +73,31 @@ pub fn move_caret_right( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = if let Some(curr_line) = lines.get(old_line_nr) { - if let Some(last_char) = curr_line.chars().last() { - if is_newline(&last_char) { - if old_col_nr + 1 > curr_line.len() - 1 { - (old_line_nr + 1, 0) - } else { + let (line_nr, col_nr) = + if old_selection_opt.is_some() && !shift_pressed{ + match old_selection_opt { + Some(old_selection) => (old_selection.end_pos.line, old_selection.end_pos.column), + None => unreachable!(), + } + } else if let Some(curr_line) = lines.get(old_line_nr) { + if let Some(last_char) = curr_line.chars().last() { + if is_newline(&last_char) { + if old_col_nr + 1 > curr_line.len() - 1 { + (old_line_nr + 1, 0) + } else { + (old_line_nr, old_col_nr + 1) + } + } else if old_col_nr < curr_line.len() { (old_line_nr, old_col_nr + 1) + } else { + (old_line_nr, old_col_nr) } - } else if old_col_nr < curr_line.len() { - (old_line_nr, old_col_nr + 1) } else { (old_line_nr, old_col_nr) } } else { - (old_line_nr, old_col_nr) - } - } else { - unreachable!() - }; + unreachable!() + }; let new_caret_pos = Position { line: line_nr, @@ -131,17 +143,23 @@ pub fn move_caret_up( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = if old_line_nr == 0 { - (old_line_nr, 0) - } else if let Some(prev_line) = lines.get(old_line_nr - 1) { - if prev_line.len() <= old_col_nr { - (old_line_nr - 1, prev_line.len() - 1) + let (line_nr, col_nr) = + if old_selection_opt.is_some() && !shift_pressed{ + match old_selection_opt { + Some(old_selection) => (old_selection.start_pos.line, old_selection.start_pos.column), + None => unreachable!(), + } + } else if old_line_nr == 0 { + (old_line_nr, 0) + } else if let Some(prev_line) = lines.get(old_line_nr - 1) { + if prev_line.len() <= old_col_nr { + (old_line_nr - 1, prev_line.len() - 1) + } else { + (old_line_nr - 1, old_col_nr) + } } else { - (old_line_nr - 1, old_col_nr) - } - } else { - unreachable!() - }; + unreachable!() + }; let new_caret_pos = Position { line: line_nr, @@ -178,7 +196,13 @@ pub fn move_caret_down( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = if old_line_nr + 1 >= lines.len() { + let (line_nr, col_nr) = + if old_selection_opt.is_some() && !shift_pressed{ + match old_selection_opt { + Some(old_selection) => (old_selection.end_pos.line, old_selection.end_pos.column), + None => unreachable!(), + } + } else if old_line_nr + 1 >= lines.len() { if let Some(curr_line) = lines.get(old_line_nr) { (old_line_nr, curr_line.len()) } else { From bed9166fcb30e00f6e6f0073db34869634c90c52 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 5 Jan 2021 17:56:28 +0100 Subject: [PATCH 5/7] selection extension test, selection extension fixes --- editor/src/selection.rs | 81 ++++++++++++++++++++++++++++++++++++++++ editor/src/tea/update.rs | 38 +++++++++++++++---- 2 files changed, 111 insertions(+), 8 deletions(-) diff --git a/editor/src/selection.rs b/editor/src/selection.rs index 72d8df2ead..4dfa0bd719 100644 --- a/editor/src/selection.rs +++ b/editor/src/selection.rs @@ -771,4 +771,85 @@ mod test_parse { Ok(()) } + #[test] + fn extend_selection_right() -> Result<(), String> { + assert_move(&["[a]|bc"], &["[ab]|c"], true, move_caret_right)?; + assert_move(&["a[b]|c"], &["a[bc]|"], true, move_caret_right)?; + assert_move(&["[ab]|c"], &["[abc]|"], true, move_caret_right)?; + assert_move(&["[ ]|abc"], &["[ a]|bc"], true, move_caret_right)?; + assert_move(&["[abc]|"], &["[abc]|"], true, move_caret_right)?; + assert_move(&["a[bc]|"], &["a[bc]|"], true, move_caret_right)?; + assert_move(&["ab[c]|"], &["ab[c]|"], true, move_caret_right)?; + assert_move(&["abc[\n","]|d"], &["abc[\n","d]|"], true, move_caret_right)?; + assert_move(&["ab[c]|\n",""], &["ab[c\n","]|"], true, move_caret_right)?; + assert_move(&["ab[c]|\n","d"], &["ab[c\n","]|d"], true, move_caret_right)?; + assert_move(&["abc\n","def\n", "ghi[\n","]|jkl"], &["abc\n","def\n", "ghi[\n", "j]|kl"], true, move_caret_right)?; + assert_move(&["ab[c\n","def\n", "ghi\n","]|jkl"], &["ab[c\n","def\n", "ghi\n", "j]|kl"], true, move_caret_right)?; + assert_move(&["ab[c\n","def\n", "]|ghi\n","jkl"], &["ab[c\n","def\n", "g]|hi\n", "jkl"], true, move_caret_right)?; + assert_move(&["[abc\n","def\n", "ghi\n","jk]|l"], &["[abc\n","def\n", "ghi\n", "jkl]|"], true, move_caret_right)?; + assert_move(&["[abc\n","def\n", "ghi\n", "jkl]|"], &["[abc\n","def\n", "ghi\n", "jkl]|"], true, move_caret_right)?; + + Ok(()) + } + + #[test] + fn extend_selection_left() -> Result<(), String> { + assert_move(&["ab|[c]"], &["a|[bc]"], true, move_caret_left)?; + assert_move(&["a|[bc]"], &["|[abc]"], true, move_caret_left)?; + assert_move(&["|[abc]"], &["|[abc]"], true, move_caret_left)?; + assert_move(&["|[ab]c"], &["|[ab]c"], true, move_caret_left)?; + assert_move(&["|[a]bc"], &["|[a]bc"], true, move_caret_left)?; + assert_move(&[" |[a]bc"], &["|[ a]bc"], true, move_caret_left)?; + assert_move(&["abc|[\n","]d"], &["ab|[c\n","]d"], true, move_caret_left)?; + assert_move(&["abc\n","|[d]"], &["abc|[\n","d]"], true, move_caret_left)?; + assert_move(&["ab|[c\n","]"], &["a|[bc\n","]"], true, move_caret_left)?; + assert_move(&["abc\n","def|[\n", "ghi\n","j]kl"], &["abc\n","de|[f\n", "ghi\n", "j]kl"], true, move_caret_left)?; + assert_move(&["a|[bc\n","def\n", "ghi\n","jkl]"], &["|[abc\n","def\n", "ghi\n", "jkl]"], true, move_caret_left)?; + assert_move(&["abc\n","def\n", "ghi\n", "|[jkl]"], &["abc\n","def\n", "ghi|[\n", "jkl]"], true, move_caret_left)?; + + Ok(()) + } + + #[test] + fn extend_selection_up() -> Result<(), String> { + assert_move(&["ab|[c]"], &["|[abc]"], true, move_caret_up)?; + assert_move(&["a|[bc]"], &["|[abc]"], true, move_caret_up)?; + assert_move(&["|[abc]"], &["|[abc]"], true, move_caret_up)?; + assert_move(&["|[ab]c"], &["|[ab]c"], true, move_caret_up)?; + assert_move(&["|[a]bc"], &["|[a]bc"], true, move_caret_up)?; + assert_move(&[" |[a]bc"], &["|[ a]bc"], true, move_caret_up)?; + assert_move(&["ab[c]|"], &["|[ab]c"], true, move_caret_up)?; + assert_move(&["[a]|"], &["|a"], true, move_caret_up)?; + assert_move(&["[a]|bc"], &["|abc"], true, move_caret_up)?; + assert_move(&["[a]|bc\n","d"], &["|abc\n","d"], true, move_caret_up)?; + assert_move(&["abc\n","de[f]|"], &["abc|[\n","de]f"], true, move_caret_up)?; + assert_move(&["abc\n","de|[f]"], &["ab|[c\n","def]"], true, move_caret_up)?; + assert_move(&["ab|[c\n","def]"], &["|[abc\n","def]"], true, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","[mnopqr]|st"], &["ab\n","cdef\n", "ghijkl|[\n","]mnopqrst"], true, move_caret_up)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","[mnopqrs]|t"], &["ab\n","cdef\n", "ghijkl|[\n","]mnopqrst"], true, move_caret_up)?; + assert_move(&["abcdefgh\n","ijklmn\n", "|[o]pqr\n","st"], &["abcdefgh\n","|[ijklmn\n", "o]pqr\n","st"], true, move_caret_up)?; + + Ok(()) + } + + #[test] + fn extend_selection_down() -> Result<(), String> { + assert_move(&["[ab]|c"], &["[abc]|"], true, move_caret_down)?; + assert_move(&["[a]|bc"], &["[abc]|"], true, move_caret_down)?; + assert_move(&["[abc]|"], &["[abc]|"], true, move_caret_down)?; + assert_move(&["|[ab]c"], &["ab[c]|"], true, move_caret_down)?; + assert_move(&["|[a]bc"], &["a[bc]|"], true, move_caret_down)?; + assert_move(&["[a]|bc\n","d"], &["[abc\n","d]|"], true, move_caret_down)?; + assert_move(&["[a]|bc\n","de"], &["[abc\n","d]|e"], true, move_caret_down)?; + assert_move(&["[abc\n","d]|e"], &["[abc\n","de]|"], true, move_caret_down)?; + assert_move(&["[a]|bc\n",""], &["[abc\n","]|"], true, move_caret_down)?; + assert_move(&["ab\n","cdef\n", "ghijkl\n","[mnopqr]|st"], &["ab\n","cdef\n", "ghijkl\n","[mnopqrst]|"], true, move_caret_down)?; + assert_move(&["a[b\n","cdef\n", "ghijkl\n","mnopqr]|st"], &["a[b\n","cdef\n", "ghijkl\n","mnopqrst]|"], true, move_caret_down)?; + assert_move(&["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], &["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], true, move_caret_down)?; + assert_move(&["abcd[efgh]|\n","ijklmn\n", "opqr\n","st"], &["abcd[efgh\n","ijklmn]|\n", "opqr\n","st"], true, move_caret_down)?; + assert_move(&["abcd[e]|fgh\n","ijklmn\n", "opqr\n","st"], &["abcd[efgh\n","ijklm]|n\n", "opqr\n","st"], true, move_caret_down)?; + + Ok(()) + } + } \ No newline at end of file diff --git a/editor/src/tea/update.rs b/editor/src/tea/update.rs index 9d01694d61..8808dc6994 100644 --- a/editor/src/tea/update.rs +++ b/editor/src/tea/update.rs @@ -168,10 +168,21 @@ pub fn move_caret_up( let new_selection_opt = if shift_pressed { if let Some(old_selection) = old_selection_opt { - Some(RawSelection { - start_pos: new_caret_pos, - end_pos: old_selection.end_pos, - }) + if old_selection.end_pos <= old_caret_pos { + if new_caret_pos == old_selection.start_pos { + None + } else { + Some(RawSelection { + start_pos: new_caret_pos, + end_pos: old_selection.start_pos, + }) + } + } else { + Some(RawSelection { + start_pos: new_caret_pos, + end_pos: old_selection.end_pos, + }) + } } else if !(old_line_nr == line_nr && old_col_nr == col_nr) { Some(RawSelection { start_pos: min(old_caret_pos, new_caret_pos), @@ -233,10 +244,21 @@ pub fn move_caret_down( let new_selection_opt = if shift_pressed { if let Some(old_selection) = old_selection_opt { - Some(RawSelection { - start_pos: old_selection.start_pos, - end_pos: new_caret_pos, - }) + if old_caret_pos <= old_selection.start_pos { + if new_caret_pos == old_selection.end_pos { + None + } else { + Some(RawSelection { + start_pos: old_selection.end_pos, + end_pos: new_caret_pos, + }) + } + } else { + Some(RawSelection { + start_pos: old_selection.start_pos, + end_pos: new_caret_pos, + }) + } } else if !(old_line_nr == line_nr && old_col_nr == col_nr) { Some(RawSelection { start_pos: min(old_caret_pos, new_caret_pos), From 4e99f7ca6ac7aec9d9f2d7c13dd938d727bcf2e1 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 5 Jan 2021 20:08:19 +0100 Subject: [PATCH 6/7] selection shrink tests, selection shrink fixes --- editor/src/selection.rs | 56 +++++++++++++++++++++++++++++++++++++ editor/src/tea/update.rs | 60 +++++++++++++++++++++++++++------------- 2 files changed, 97 insertions(+), 19 deletions(-) diff --git a/editor/src/selection.rs b/editor/src/selection.rs index 4dfa0bd719..1025e46a8f 100644 --- a/editor/src/selection.rs +++ b/editor/src/selection.rs @@ -852,4 +852,60 @@ mod test_parse { Ok(()) } + #[test] + fn shrink_selection_right() -> Result<(), String> { + assert_move(&["ab|[c]"], &["abc|"], true, move_caret_right)?; + assert_move(&["a|[bc]"], &["ab|[c]"], true, move_caret_right)?; + assert_move(&["|[abc]"], &["a|[bc]"], true, move_caret_right)?; + assert_move(&["|[abc\n","def\n", "ghi\n","jkl]"], &["a|[bc\n","def\n", "ghi\n", "jkl]"], true, move_caret_right)?; + assert_move(&["abc\n","d|[ef\n", "]ghi\n","jkl"], &["abc\n","de|[f\n", "]ghi\n", "jkl"], true, move_caret_right)?; + assert_move(&["abc\n","de|[f]\n", "ghi\n","jkl"], &["abc\n","def|\n", "ghi\n", "jkl"], true, move_caret_right)?; + + Ok(()) + } + + #[test] + fn shrink_selection_left() -> Result<(), String> { + assert_move(&["ab[c]|"], &["ab|c"], true, move_caret_left)?; + assert_move(&["a[bc]|"], &["a[b]|c"], true, move_caret_left)?; + assert_move(&["[abc]|"], &["[ab]|c"], true, move_caret_left)?; + assert_move(&["[abc\n","def\n", "ghi\n","jkl]|"], &["[abc\n","def\n", "ghi\n", "jk]|l"], true, move_caret_left)?; + assert_move(&["|[abc\n","def\n", "ghi\n","jkl]"], &["|[abc\n","def\n", "ghi\n", "jkl]"], true, move_caret_left)?; + assert_move(&["abc\n","def[\n", "]|ghi\n","jkl"], &["abc\n","def|\n", "ghi\n", "jkl"], true, move_caret_left)?; + assert_move(&["abc\n","d[ef\n", "gh]|i\n","jkl"], &["abc\n","d[ef\n", "g]|hi\n", "jkl"], true, move_caret_left)?; + + Ok(()) + } + + #[test] + fn shrink_selection_up() -> Result<(), String> { + assert_move(&["[abc]|"], &["|abc"], true, move_caret_up)?; + assert_move(&["[ab]|c"], &["|abc"], true, move_caret_up)?; + assert_move(&["[a]|bc"], &["|abc"], true, move_caret_up)?; + assert_move(&["|abc"], &["|abc"], true, move_caret_up)?; + assert_move(&["[abc\n","def]|"], &["[abc]|\n","def"], true, move_caret_up)?; + assert_move(&["[abc\n","de]|f"], &["[ab]|c\n","def"], true, move_caret_up)?; + assert_move(&["[abc\n","def\n", "ghi\n","jkl]|"], &["[abc\n","def\n", "ghi]|\n", "jkl"], true, move_caret_up)?; + assert_move(&["abc\n","def\n", "ghi[\n","jkl]|"], &["abc\n","def\n", "ghi|\n", "jkl"], true, move_caret_up)?; + assert_move(&["abc\n","d[ef\n", "ghi\n","jk]|l"], &["abc\n","d[ef\n", "gh]|i\n", "jkl"], true, move_caret_up)?; + assert_move(&["[abc\n","d]|ef\n", "ghi\n","jkl"], &["[a]|bc\n","def\n", "ghi\n", "jkl"], true, move_caret_up)?; + + Ok(()) + } + + #[test] + fn shrink_selection_down() -> Result<(), String> { + assert_move(&["|[abc]"], &["abc|"], true, move_caret_down)?; + assert_move(&["|[abc\n","def]"], &["abc\n","|[def]"], true, move_caret_down)?; + assert_move(&["a|[bc\n","def]"], &["abc\n","d|[ef]"], true, move_caret_down)?; + assert_move(&["|[abc\n","def\n", "ghi]"], &["abc\n","|[def\n", "ghi]"], true, move_caret_down)?; + assert_move(&["ab|[c\n","def\n", "ghi]"], &["abc\n","de|[f\n", "ghi]"], true, move_caret_down)?; + assert_move(&["abc\n","de|[f\n", "ghi]"], &["abc\n","def\n", "gh|[i]"], true, move_caret_down)?; + assert_move(&["abcdef|[\n","ghij\n", "kl]"], &["abcdef\n","ghij|[\n", "kl]"], true, move_caret_down)?; + assert_move(&["abcde|[f\n","ghij\n", "kl]"], &["abcdef\n","ghij|[\n", "kl]"], true, move_caret_down)?; + assert_move(&["ab|[cdef\n","ghij\n", "kl]"], &["abcdef\n","gh|[ij\n", "kl]"], true, move_caret_down)?; + + Ok(()) + } + } \ No newline at end of file diff --git a/editor/src/tea/update.rs b/editor/src/tea/update.rs index 8808dc6994..3a08600282 100644 --- a/editor/src/tea/update.rs +++ b/editor/src/tea/update.rs @@ -36,13 +36,24 @@ pub fn move_caret_left( let new_selection_opt = if shift_pressed { if let Some(old_selection) = old_selection_opt { - Some(RawSelection { - start_pos: Position { - line: line_nr, - column: col_nr, - }, - end_pos: old_selection.end_pos, - }) + if old_caret_pos >= old_selection.end_pos { + if new_caret_pos == old_selection.start_pos { + None + } else { + Some(RawSelection { + start_pos: old_selection.start_pos, + end_pos: new_caret_pos, + }) + } + } else { + Some(RawSelection { + start_pos: Position { + line: line_nr, + column: col_nr, + }, + end_pos: old_selection.end_pos, + }) + } } else if !(old_line_nr == line_nr && old_col_nr == col_nr) { Some(RawSelection { start_pos: Position { @@ -106,13 +117,24 @@ pub fn move_caret_right( let new_selection_opt = if shift_pressed { if let Some(old_selection) = old_selection_opt { - Some(RawSelection { - start_pos: old_selection.start_pos, - end_pos: Position { - line: line_nr, - column: col_nr, - }, - }) + if old_caret_pos <= old_selection.start_pos { + if new_caret_pos == old_selection.end_pos { + None + } else { + Some(RawSelection { + start_pos: new_caret_pos, + end_pos: old_selection.end_pos, + }) + } + } else { + Some(RawSelection { + start_pos: old_selection.start_pos, + end_pos: Position { + line: line_nr, + column: col_nr, + }, + }) + } } else if !(old_line_nr == line_nr && old_col_nr == col_nr) { Some(RawSelection { start_pos: Position { @@ -173,8 +195,8 @@ pub fn move_caret_up( None } else { Some(RawSelection { - start_pos: new_caret_pos, - end_pos: old_selection.start_pos, + start_pos: min(old_selection.start_pos, new_caret_pos), + end_pos: max(old_selection.start_pos, new_caret_pos), }) } } else { @@ -220,7 +242,7 @@ pub fn move_caret_down( unreachable!() } } else if let Some(next_line) = lines.get(old_line_nr + 1) { - if next_line.len() < old_col_nr { + if next_line.len() <= old_col_nr { if let Some(last_char) = next_line.chars().last() { if is_newline(&last_char) { (old_line_nr + 1, next_line.len() - 1) @@ -249,8 +271,8 @@ pub fn move_caret_down( None } else { Some(RawSelection { - start_pos: old_selection.end_pos, - end_pos: new_caret_pos, + start_pos: min(old_selection.end_pos, new_caret_pos), + end_pos: max(old_selection.end_pos, new_caret_pos), }) } } else { From e19969ac6957e88bd2264bdecb24a5f0c121eaca Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 6 Jan 2021 10:38:31 +0100 Subject: [PATCH 7/7] clippy, fmt, comments --- editor/src/selection.rs | 2039 +++++++++++++++++++++++++++++++------- editor/src/tea/update.rs | 102 +- editor/src/vec_result.rs | 1 - 3 files changed, 1704 insertions(+), 438 deletions(-) diff --git a/editor/src/selection.rs b/editor/src/selection.rs index 1025e46a8f..310846cbf4 100644 --- a/editor/src/selection.rs +++ b/editor/src/selection.rs @@ -2,7 +2,7 @@ use crate::error::{EdResult, InvalidSelection}; use crate::graphics::colors; use crate::graphics::primitives::rect::Rect; use crate::tea::model::RawSelection; -use crate::vec_result::{get_res}; +use crate::vec_result::get_res; use bumpalo::collections::Vec as BumpVec; use bumpalo::Bump; use snafu::ensure; @@ -153,51 +153,60 @@ pub fn create_selection_rects<'a>( #[cfg(test)] mod test_parse { - use crate::tea::update::{move_caret_left, move_caret_right, move_caret_down, move_caret_up}; - use crate::tea::model::{RawSelection, Position}; use crate::error::{EdResult, OutOfBounds}; - use crate::vec_result::{get_res}; - use snafu::OptionExt; - use std::slice::SliceIndex; - use std::collections::HashMap; + use crate::tea::model::{Position, RawSelection}; + use crate::tea::update::{move_caret_down, move_caret_left, move_caret_right, move_caret_up}; + use crate::vec_result::get_res; use core::cmp::Ordering; use pest::Parser; - + use snafu::OptionExt; + use std::collections::HashMap; + use std::slice::SliceIndex; #[derive(Parser)] #[grammar = "../tests/selection.pest"] pub struct LineParser; - fn convert_selection_to_dsl(raw_sel_opt: Option, caret_pos: Position, lines: &mut [String]) -> EdResult<&[String]> { + // show selection and caret position as symbols in lines for easy testing + fn convert_selection_to_dsl( + raw_sel_opt: Option, + caret_pos: Position, + lines: &mut [String], + ) -> EdResult<&[String]> { if let Some(raw_sel) = raw_sel_opt { - let mut to_insert = vec![(raw_sel.start_pos, '['), (raw_sel.end_pos, ']'), (caret_pos, '|')]; - let symbol_map: HashMap = [('[', 2), (']', 0), ('|', 1)].iter().cloned().collect(); + let mut to_insert = vec![ + (raw_sel.start_pos, '['), + (raw_sel.end_pos, ']'), + (caret_pos, '|'), + ]; + let symbol_map: HashMap = + [('[', 2), (']', 0), ('|', 1)].iter().cloned().collect(); - to_insert.sort_by( - |a, b| { - let pos_cmp = a.0.cmp(&b.0); - if pos_cmp == Ordering::Equal { - symbol_map.get(&a.1).cmp(&symbol_map.get(&b.1)) - } else { - pos_cmp - } + // sort for nice printing + to_insert.sort_by(|a, b| { + let pos_cmp = a.0.cmp(&b.0); + if pos_cmp == Ordering::Equal { + symbol_map.get(&a.1).cmp(&symbol_map.get(&b.1)) + } else { + pos_cmp } - ); + }); + // insert symbols into text lines for i in 0..to_insert.len() { let (pos, insert_char) = *get_res(i, &to_insert)?; insert_at_pos(lines, pos, insert_char)?; + // shift position of following symbols now that symbol is inserted for j in i..to_insert.len() { let (old_pos, _) = get_mut_res(j, &mut to_insert)?; - + if old_pos.line == pos.line { old_pos.column += 1; } } } - } else { insert_at_pos(lines, caret_pos, '|')?; } @@ -212,21 +221,26 @@ mod test_parse { Ok(()) } - fn get_mut_res(index: usize, vec: & mut [T]) -> EdResult<& mut >::Output> { + // It's much nicer to have get_mut return a Result with clear error than an Option + fn get_mut_res( + index: usize, + vec: &mut [T], + ) -> EdResult<&mut >::Output> { let vec_len = vec.len(); - - let elt_ref = vec.get_mut(index).context(OutOfBounds { - index, - vec_len, - })?; - + + let elt_ref = vec.get_mut(index).context(OutOfBounds { index, vec_len })?; + Ok(elt_ref) } - fn convert_dsl_to_selection(lines: &[String]) -> Result<(Option, Position), String> { + // Retrieve selection and position from formatted string + fn convert_dsl_to_selection( + lines: &[String], + ) -> Result<(Option, Position), String> { let lines_str: String = lines.join(""); - let parsed = LineParser::parse(Rule::linesWithSelect, &lines_str).expect("Selection test DSL parsing failed"); + let parsed = LineParser::parse(Rule::linesWithSelect, &lines_str) + .expect("Selection test DSL parsing failed"); let mut caret_opt: Option<(usize, usize)> = None; let mut sel_start_opt: Option<(usize, usize)> = None; @@ -235,38 +249,44 @@ mod test_parse { let mut col_nr = 0; for line in parsed { - for elt in line.into_inner() { match elt.as_rule() { Rule::optCaret => { if elt.as_span().as_str() == "|" { if caret_opt.is_some() { - return Err("Multiple carets found, there should be only one".to_owned()) + return Err( + "Multiple carets found, there should be only one".to_owned() + ); } else { caret_opt = Some((line_nr, col_nr)); } } - }, + } Rule::optSelStart => { if sel_start_opt.is_some() { if elt.as_span().as_str() == "[" { - return Err("Found start of selection more than once, there should be only one".to_owned()) + return Err("Found start of selection more than once, there should be only one".to_owned()); } - } else if elt.as_span().as_str() == "[" { + } else if elt.as_span().as_str() == "[" { sel_start_opt = Some((line_nr, col_nr)); } - }, + } Rule::optSelEnd => { if sel_end_opt.is_some() { if elt.as_span().as_str() == "]" { - return Err("Found end of selection more than once, there should be only one".to_owned()) - } + return Err("Found end of selection more than once, there should be only one".to_owned()); + } } else if elt.as_span().as_str() == "]" { - sel_end_opt = Some((line_nr, col_nr)); + sel_end_opt = Some((line_nr, col_nr)); } - }, + } Rule::text => { - let split_str = elt.as_span().as_str().split('\n').into_iter().collect::>(); + let split_str = elt + .as_span() + .as_str() + .split('\n') + .into_iter() + .collect::>(); if split_str.len() > 1 { line_nr += split_str.len() - 1; @@ -275,85 +295,77 @@ mod test_parse { if let Some(last_str) = split_str.last() { col_nr += last_str.len() } - } _ => {} } } } - + + // Make sure return makes sense if let Some((line, column)) = caret_opt { - let caret_pos = - Position { - line, - column - }; + let caret_pos = Position { line, column }; if sel_start_opt.is_none() && sel_end_opt.is_none() { - Ok (( - None, - caret_pos - )) + Ok((None, caret_pos)) } else if let Some((start_line, start_column)) = sel_start_opt { - if let Some((end_line, end_column)) = sel_end_opt { - Ok (( - Some ( - RawSelection { - start_pos : - Position { - line: start_line, - column: start_column - }, - end_pos : - Position { - line: end_line, - column: end_column - } - } - ), - caret_pos - )) - } else { - Err("Selection end ']' was not found, but selection start '[' was. Bad input string.".to_owned()) - } + if let Some((end_line, end_column)) = sel_end_opt { + Ok(( + Some(RawSelection { + start_pos: Position { + line: start_line, + column: start_column, + }, + end_pos: Position { + line: end_line, + column: end_column, + }, + }), + caret_pos, + )) + } else { + Err("Selection end ']' was not found, but selection start '[' was. Bad input string.".to_owned()) + } } else { Err("Selection start '[' was not found, but selection end ']' was. Bad input string.".to_owned()) } } else { Err("No caret was found in lines.".to_owned()) } - } + pub type MoveCaretFun = + fn(Position, Option, bool, &[String]) -> (Position, Option); + + // Convert nice string representations and compare results fn assert_move( pre_lines_str: &[&str], expected_post_lines_str: &[&str], shift_pressed: bool, - move_fun: - fn(Position, Option, bool, &[String]) -> (Position, Option) + move_fun: MoveCaretFun, ) -> Result<(), String> { let pre_lines: Vec = pre_lines_str.iter().map(|l| l.to_string()).collect(); - let expected_post_lines: Vec = expected_post_lines_str.iter().map(|l| l.to_string()).collect(); + let expected_post_lines: Vec = expected_post_lines_str + .iter() + .map(|l| l.to_string()) + .collect(); let (sel_opt, caret_pos) = convert_dsl_to_selection(&pre_lines)?; - let mut clean_lines = - pre_lines.into_iter() - .map(|line| { - line.replace(&['[', ']', '|'][..], "") - }) + let mut clean_lines = pre_lines + .into_iter() + .map(|line| line.replace(&['[', ']', '|'][..], "")) .collect::>(); - let (new_caret_pos, new_sel_opt) = move_fun(caret_pos, sel_opt, shift_pressed, &clean_lines); + let (new_caret_pos, new_sel_opt) = + move_fun(caret_pos, sel_opt, shift_pressed, &clean_lines); - let post_lines_res = - convert_selection_to_dsl(new_sel_opt, new_caret_pos, &mut clean_lines); + let post_lines_res = convert_selection_to_dsl(new_sel_opt, new_caret_pos, &mut clean_lines); match post_lines_res { Ok(post_lines) => { assert_eq!(expected_post_lines, post_lines); Ok(()) - }, - Err(e) => Err(format!("{:?}", e)) + } + Err(e) => Err(format!("{:?}", e)), } } @@ -367,16 +379,51 @@ mod test_parse { assert_move(&["abc|"], &["abc|"], false, move_caret_right)?; assert_move(&["| abc"], &[" |abc"], false, move_caret_right)?; assert_move(&["abc| "], &["abc |"], false, move_caret_right)?; - assert_move(&["abc|\n","d"], &["abc\n","|d"], false, move_caret_right)?; - assert_move(&["abc|\n",""], &["abc\n","|"], false, move_caret_right)?; - assert_move(&["abc\n","|def"], &["abc\n","d|ef"], false, move_caret_right)?; - assert_move(&["abc\n","def| "], &["abc\n","def |"], false, move_caret_right)?; - assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def \n", "|ghi"], false, move_caret_right)?; - assert_move(&["abc\n","def|\n",""], &["abc\n","def\n", "|"], false, move_caret_right)?; - assert_move(&["abc\n","def\n", "ghi|\n","jkl"], &["abc\n","def\n", "ghi\n", "|jkl"], false, move_caret_right)?; - assert_move(&["abc\n","def\n", "|ghi\n","jkl"], &["abc\n","def\n", "g|hi\n", "jkl"], false, move_caret_right)?; - assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "gh|i\n", "jkl"], false, move_caret_right)?; - + assert_move(&["abc|\n", "d"], &["abc\n", "|d"], false, move_caret_right)?; + assert_move(&["abc|\n", ""], &["abc\n", "|"], false, move_caret_right)?; + assert_move( + &["abc\n", "|def"], + &["abc\n", "d|ef"], + false, + move_caret_right, + )?; + assert_move( + &["abc\n", "def| "], + &["abc\n", "def |"], + false, + move_caret_right, + )?; + assert_move( + &["abc\n", "def |\n", "ghi"], + &["abc\n", "def \n", "|ghi"], + false, + move_caret_right, + )?; + assert_move( + &["abc\n", "def|\n", ""], + &["abc\n", "def\n", "|"], + false, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "ghi|\n", "jkl"], + &["abc\n", "def\n", "ghi\n", "|jkl"], + false, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "|ghi\n", "jkl"], + &["abc\n", "def\n", "g|hi\n", "jkl"], + false, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "g|hi\n", "jkl"], + &["abc\n", "def\n", "gh|i\n", "jkl"], + false, + move_caret_right, + )?; + Ok(()) } @@ -390,16 +437,51 @@ mod test_parse { assert_move(&["abc|"], &["ab|c"], false, move_caret_left)?; assert_move(&[" |abc"], &["| abc"], false, move_caret_left)?; assert_move(&["abc |"], &["abc| "], false, move_caret_left)?; - assert_move(&["abc\n","|d"], &["abc|\n","d"], false, move_caret_left)?; - assert_move(&["abc\n","|"], &["abc|\n",""], false, move_caret_left)?; - assert_move(&["abc\n","d|ef"], &["abc\n","|def"], false, move_caret_left)?; - assert_move(&["abc\n","def |"], &["abc\n","def| "], false, move_caret_left)?; - assert_move(&["abc\n","def \n", "|ghi"], &["abc\n","def |\n", "ghi"], false, move_caret_left)?; - assert_move(&["abc\n","def\n","|"], &["abc\n","def|\n", ""], false, move_caret_left)?; - assert_move(&["abc\n","def\n", "ghi\n","|jkl"], &["abc\n","def\n", "ghi|\n", "jkl"], false, move_caret_left)?; - assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "|ghi\n", "jkl"], false, move_caret_left)?; - assert_move(&["abc\n","def\n", "gh|i\n","jkl"], &["abc\n","def\n", "g|hi\n", "jkl"], false, move_caret_left)?; - + assert_move(&["abc\n", "|d"], &["abc|\n", "d"], false, move_caret_left)?; + assert_move(&["abc\n", "|"], &["abc|\n", ""], false, move_caret_left)?; + assert_move( + &["abc\n", "d|ef"], + &["abc\n", "|def"], + false, + move_caret_left, + )?; + assert_move( + &["abc\n", "def |"], + &["abc\n", "def| "], + false, + move_caret_left, + )?; + assert_move( + &["abc\n", "def \n", "|ghi"], + &["abc\n", "def |\n", "ghi"], + false, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "|"], + &["abc\n", "def|\n", ""], + false, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "ghi\n", "|jkl"], + &["abc\n", "def\n", "ghi|\n", "jkl"], + false, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "g|hi\n", "jkl"], + &["abc\n", "def\n", "|ghi\n", "jkl"], + false, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "gh|i\n", "jkl"], + &["abc\n", "def\n", "g|hi\n", "jkl"], + false, + move_caret_left, + )?; + Ok(()) } @@ -411,32 +493,122 @@ mod test_parse { assert_move(&["a|bc"], &["|abc"], false, move_caret_up)?; assert_move(&["ab|c"], &["|abc"], false, move_caret_up)?; assert_move(&["abc|"], &["|abc"], false, move_caret_up)?; - assert_move(&["|abc\n","def"], &["|abc\n","def"], false, move_caret_up)?; - assert_move(&["abc\n","|def"], &["|abc\n","def"], false, move_caret_up)?; - assert_move(&["abc\n","d|ef"], &["a|bc\n","def"], false, move_caret_up)?; - assert_move(&["abc\n","de|f"], &["ab|c\n","def"], false, move_caret_up)?; - assert_move(&["abc\n","def|"], &["abc|\n","def"], false, move_caret_up)?; - assert_move(&["abc\n","def \n", "|ghi"], &["abc\n","|def \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","def \n", "g|hi"], &["abc\n","d|ef \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","def \n", "gh|i"], &["abc\n","de|f \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","def \n", "ghi|"], &["abc\n","def| \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","de\n", "ghi|"], &["abc\n","de|\n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","de|"], &["ab|c\n","de"], false, move_caret_up)?; - assert_move(&["abc\n","d|e"], &["a|bc\n","de"], false, move_caret_up)?; - assert_move(&["abc\n","|de"], &["|abc\n","de"], false, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], &["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], &[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], &["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","cde|f\n", "ghijkl\n","mnopqrst"], &["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","st|"], &["abcdefgh\n","ijklmn\n", "op|qr\n","st"], false, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijkl|mn\n", "opqr\n","st"], false, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdef|gh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; - assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; - assert_move(&["abcdefg|h\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; - assert_move(&["a|bcdefgh\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; - assert_move(&["|abcdefgh\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; + assert_move(&["|abc\n", "def"], &["|abc\n", "def"], false, move_caret_up)?; + assert_move(&["abc\n", "|def"], &["|abc\n", "def"], false, move_caret_up)?; + assert_move(&["abc\n", "d|ef"], &["a|bc\n", "def"], false, move_caret_up)?; + assert_move(&["abc\n", "de|f"], &["ab|c\n", "def"], false, move_caret_up)?; + assert_move(&["abc\n", "def|"], &["abc|\n", "def"], false, move_caret_up)?; + assert_move( + &["abc\n", "def \n", "|ghi"], + &["abc\n", "|def \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "def \n", "g|hi"], + &["abc\n", "d|ef \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "def \n", "gh|i"], + &["abc\n", "de|f \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "def \n", "ghi|"], + &["abc\n", "def| \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "de\n", "ghi|"], + &["abc\n", "de|\n", "ghi"], + false, + move_caret_up, + )?; + assert_move(&["abc\n", "de|"], &["ab|c\n", "de"], false, move_caret_up)?; + assert_move(&["abc\n", "d|e"], &["a|bc\n", "de"], false, move_caret_up)?; + assert_move(&["abc\n", "|de"], &["|abc\n", "de"], false, move_caret_up)?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "mnopqrst|"], + &["ab\n", "cdef\n", "ghijkl|\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl|\n", "mnopqrst"], + &["ab\n", "cdef|\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "|mnopqrst"], + &["ab\n", "cdef\n", "|ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &[" ab\n", " |cdef\n", "ghijkl\n", "mnopqrst"], + &[" |ab\n", " cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "mnopqr|st"], + &["ab\n", "cdef\n", "ghijkl|\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "cde|f\n", "ghijkl\n", "mnopqrst"], + &["ab|\n", "cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr\n", "st|"], + &["abcdefgh\n", "ijklmn\n", "op|qr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr|\n", "st"], + &["abcdefgh\n", "ijkl|mn\n", "opqr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn|\n", "opqr\n", "st"], + &["abcdef|gh\n", "ijklmn\n", "opqr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh|\n", "ijklmn\n", "opqr\n", "st"], + &["|abcdefgh\n", "ijklmn\n", "opqr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefg|h\n", "ijklmn\n", "opqr\n", "st"], + &["|abcdefgh\n", "ijklmn\n", "opqr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["a|bcdefgh\n", "ijklmn\n", "opqr\n", "st"], + &["|abcdefgh\n", "ijklmn\n", "opqr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["|abcdefgh\n", "ijklmn\n", "opqr\n", "st"], + &["|abcdefgh\n", "ijklmn\n", "opqr\n", "st"], + false, + move_caret_up, + )?; assert_move(&["abc def gh |"], &["|abc def gh "], false, move_caret_up)?; assert_move(&["abc de|f gh "], &["|abc def gh "], false, move_caret_up)?; assert_move(&["ab|c def gh "], &["|abc def gh "], false, move_caret_up)?; @@ -454,34 +626,154 @@ mod test_parse { assert_move(&["ab|c"], &["abc|"], false, move_caret_down)?; assert_move(&["abc|"], &["abc|"], false, move_caret_down)?; assert_move(&["abc| "], &["abc |"], false, move_caret_down)?; - assert_move(&["abc\n","|def"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["abc\n","d|ef"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["abc\n","de|f"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["abc\n","def|"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["|abc\n","def"], &["abc\n","|def"], false, move_caret_down)?; - assert_move(&["a|bc\n","def"], &["abc\n","d|ef"], false, move_caret_down)?; - assert_move(&["ab|c\n","def"], &["abc\n","de|f"], false, move_caret_down)?; - assert_move(&["abc|\n","def"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["abc\n","|def \n", "ghi"], &["abc\n","def \n", "|ghi"], false, move_caret_down)?; - assert_move(&["abc\n","d|ef \n", "ghi"], &["abc\n","def \n", "g|hi"], false, move_caret_down)?; - assert_move(&["abc\n","de|f \n", "ghi"], &["abc\n","def \n", "gh|i"], false, move_caret_down)?; - assert_move(&["abc\n","def| \n", "ghi"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; - assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; - assert_move(&["abc\n","de|\n", "ghi"], &["abc\n","de\n", "gh|i"], false, move_caret_down)?; - assert_move(&["abc|\n","de"], &["abc\n","de|"], false, move_caret_down)?; - assert_move(&["ab|c\n","de"], &["abc\n","de|"], false, move_caret_down)?; - assert_move(&["a|bc\n","de"], &["abc\n","d|e"], false, move_caret_down)?; - assert_move(&["|abc\n","de"], &["abc\n","|de"], false, move_caret_down)?; - assert_move(&["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], &["ab\n","cd|ef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "ghij|kl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], false, move_caret_down)?; - assert_move(&[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], &[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","|cdef\n", "ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], false, move_caret_down)?; - assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["abcdefgh\n","ijklmn|\n", "opqr\n","st"], false, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdefgh\n","ijklmn\n", "opqr|\n","st"], false, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","|st"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; + assert_move( + &["abc\n", "|def"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "d|ef"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|f"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "def|"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["|abc\n", "def"], + &["abc\n", "|def"], + false, + move_caret_down, + )?; + assert_move( + &["a|bc\n", "def"], + &["abc\n", "d|ef"], + false, + move_caret_down, + )?; + assert_move( + &["ab|c\n", "def"], + &["abc\n", "de|f"], + false, + move_caret_down, + )?; + assert_move( + &["abc|\n", "def"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "|def \n", "ghi"], + &["abc\n", "def \n", "|ghi"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "d|ef \n", "ghi"], + &["abc\n", "def \n", "g|hi"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|f \n", "ghi"], + &["abc\n", "def \n", "gh|i"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "def| \n", "ghi"], + &["abc\n", "def \n", "ghi|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "def |\n", "ghi"], + &["abc\n", "def \n", "ghi|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|\n", "ghi"], + &["abc\n", "de\n", "gh|i"], + false, + move_caret_down, + )?; + assert_move(&["abc|\n", "de"], &["abc\n", "de|"], false, move_caret_down)?; + assert_move(&["ab|c\n", "de"], &["abc\n", "de|"], false, move_caret_down)?; + assert_move(&["a|bc\n", "de"], &["abc\n", "d|e"], false, move_caret_down)?; + assert_move(&["|abc\n", "de"], &["abc\n", "|de"], false, move_caret_down)?; + assert_move( + &["ab|\n", "cdef\n", "ghijkl\n", "mnopqrst"], + &["ab\n", "cd|ef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef|\n", "ghijkl\n", "mnopqrst"], + &["ab\n", "cdef\n", "ghij|kl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl|\n", "mnopqrst"], + &["ab\n", "cdef\n", "ghijkl\n", "mnopqr|st"], + false, + move_caret_down, + )?; + assert_move( + &[" |ab\n", " cdef\n", "ghijkl\n", "mnopqrst"], + &[" ab\n", " |cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "|cdef\n", "ghijkl\n", "mnopqrst"], + &["ab\n", "cdef\n", "|ghijkl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef\n", "|ghijkl\n", "mnopqrst"], + &["ab\n", "cdef\n", "ghijkl\n", "|mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh|\n", "ijklmn\n", "opqr\n", "st"], + &["abcdefgh\n", "ijklmn|\n", "opqr\n", "st"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn|\n", "opqr\n", "st"], + &["abcdefgh\n", "ijklmn\n", "opqr|\n", "st"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr|\n", "st"], + &["abcdefgh\n", "ijklmn\n", "opqr\n", "st|"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr\n", "|st"], + &["abcdefgh\n", "ijklmn\n", "opqr\n", "st|"], + false, + move_caret_down, + )?; assert_move(&["abc def gh |"], &["abc def gh |"], false, move_caret_down)?; assert_move(&["abc de|f gh "], &["abc def gh |"], false, move_caret_down)?; assert_move(&["ab|c def gh "], &["abc def gh |"], false, move_caret_down)?; @@ -501,16 +793,51 @@ mod test_parse { assert_move(&["abc|"], &["abc|"], true, move_caret_right)?; assert_move(&["| abc"], &["[ ]|abc"], true, move_caret_right)?; assert_move(&["abc| "], &["abc[ ]|"], true, move_caret_right)?; - assert_move(&["abc|\n","d"], &["abc[\n","]|d"], true, move_caret_right)?; - assert_move(&["abc|\n",""], &["abc[\n","]|"], true, move_caret_right)?; - assert_move(&["abc\n","|def"], &["abc\n","[d]|ef"], true, move_caret_right)?; - assert_move(&["abc\n","def| "], &["abc\n","def[ ]|"], true, move_caret_right)?; - assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def [\n", "]|ghi"], true, move_caret_right)?; - assert_move(&["abc\n","def|\n",""], &["abc\n","def[\n", "]|"], true, move_caret_right)?; - assert_move(&["abc\n","def\n", "ghi|\n","jkl"], &["abc\n","def\n", "ghi[\n", "]|jkl"], true, move_caret_right)?; - assert_move(&["abc\n","def\n", "|ghi\n","jkl"], &["abc\n","def\n", "[g]|hi\n", "jkl"], true, move_caret_right)?; - assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "g[h]|i\n", "jkl"], true, move_caret_right)?; - + assert_move(&["abc|\n", "d"], &["abc[\n", "]|d"], true, move_caret_right)?; + assert_move(&["abc|\n", ""], &["abc[\n", "]|"], true, move_caret_right)?; + assert_move( + &["abc\n", "|def"], + &["abc\n", "[d]|ef"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "def| "], + &["abc\n", "def[ ]|"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "def |\n", "ghi"], + &["abc\n", "def [\n", "]|ghi"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "def|\n", ""], + &["abc\n", "def[\n", "]|"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "ghi|\n", "jkl"], + &["abc\n", "def\n", "ghi[\n", "]|jkl"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "|ghi\n", "jkl"], + &["abc\n", "def\n", "[g]|hi\n", "jkl"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "g|hi\n", "jkl"], + &["abc\n", "def\n", "g[h]|i\n", "jkl"], + true, + move_caret_right, + )?; + Ok(()) } @@ -524,18 +851,58 @@ mod test_parse { assert_move(&["abc|"], &["ab|[c]"], true, move_caret_left)?; assert_move(&[" |abc"], &["|[ ]abc"], true, move_caret_left)?; assert_move(&["abc |"], &["abc|[ ]"], true, move_caret_left)?; - assert_move(&["abc|\n","d"], &["ab|[c]\n","d"], true, move_caret_left)?; - assert_move(&["abc\n","|d"], &["abc|[\n","]d"], true, move_caret_left)?; - assert_move(&["abc\n","|"], &["abc|[\n","]"], true, move_caret_left)?; - assert_move(&["abc\n"," |def"], &["abc\n","|[ ]def"], true, move_caret_left)?; - assert_move(&["abc\n","d|ef"], &["abc\n","|[d]ef"], true, move_caret_left)?; - assert_move(&["abc\n","de|f "], &["abc\n","d|[e]f "], true, move_caret_left)?; - assert_move(&["abc\n","def\n","|"], &["abc\n","def|[\n", "]"], true, move_caret_left)?; - assert_move(&["abc\n","def\n", "|ghi\n","jkl"], &["abc\n","def|[\n", "]ghi\n", "jkl"], true, move_caret_left)?; - assert_move(&["abc\n","def\n", "g|hi\n","jkl"], &["abc\n","def\n", "|[g]hi\n", "jkl"], true, move_caret_left)?; - assert_move(&["abc\n","def\n", "gh|i\n","jkl"], &["abc\n","def\n", "g|[h]i\n", "jkl"], true, move_caret_left)?; - assert_move(&["abc\n","def\n", "ghi|\n","jkl"], &["abc\n","def\n", "gh|[i]\n", "jkl"], true, move_caret_left)?; - + assert_move(&["abc|\n", "d"], &["ab|[c]\n", "d"], true, move_caret_left)?; + assert_move(&["abc\n", "|d"], &["abc|[\n", "]d"], true, move_caret_left)?; + assert_move(&["abc\n", "|"], &["abc|[\n", "]"], true, move_caret_left)?; + assert_move( + &["abc\n", " |def"], + &["abc\n", "|[ ]def"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "d|ef"], + &["abc\n", "|[d]ef"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "de|f "], + &["abc\n", "d|[e]f "], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "|"], + &["abc\n", "def|[\n", "]"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "|ghi\n", "jkl"], + &["abc\n", "def|[\n", "]ghi\n", "jkl"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "g|hi\n", "jkl"], + &["abc\n", "def\n", "|[g]hi\n", "jkl"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "gh|i\n", "jkl"], + &["abc\n", "def\n", "g|[h]i\n", "jkl"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "ghi|\n", "jkl"], + &["abc\n", "def\n", "gh|[i]\n", "jkl"], + true, + move_caret_left, + )?; + Ok(()) } @@ -548,39 +915,199 @@ mod test_parse { assert_move(&["ab|c"], &["ab[c]|"], true, move_caret_down)?; assert_move(&["abc|"], &["abc|"], true, move_caret_down)?; assert_move(&["abc| "], &["abc[ ]|"], true, move_caret_down)?; - assert_move(&["abc\n","|def"], &["abc\n","[def]|"], true, move_caret_down)?; - assert_move(&["abc\n","d|ef"], &["abc\n","d[ef]|"], true, move_caret_down)?; - assert_move(&["abc\n","de|f"], &["abc\n","de[f]|"], true, move_caret_down)?; - assert_move(&["abc\n","def|"], &["abc\n","def|"], true, move_caret_down)?; - assert_move(&["|abc\n","def"], &["[abc\n","]|def"], true, move_caret_down)?; - assert_move(&["a|bc\n","def"], &["a[bc\n","d]|ef"], true, move_caret_down)?; - assert_move(&["ab|c\n","def"], &["ab[c\n","de]|f"], true, move_caret_down)?; - assert_move(&["abc|\n","def"], &["abc[\n","def]|"], true, move_caret_down)?; - assert_move(&["abc\n","|def \n", "ghi"], &["abc\n","[def \n", "]|ghi"], true, move_caret_down)?; - assert_move(&["abc\n","d|ef \n", "ghi"], &["abc\n","d[ef \n", "g]|hi"], true, move_caret_down)?; - assert_move(&["abc\n","de|f \n", "ghi"], &["abc\n","de[f \n", "gh]|i"], true, move_caret_down)?; - assert_move(&["abc\n","def| \n", "ghi"], &["abc\n","def[ \n", "ghi]|"], true, move_caret_down)?; - assert_move(&["abc\n","def |\n", "ghi"], &["abc\n","def [\n", "ghi]|"], true, move_caret_down)?; - assert_move(&["abc\n","de|\n", "ghi"], &["abc\n","de[\n", "gh]|i"], true, move_caret_down)?; - assert_move(&["abc|\n","de"], &["abc[\n","de]|"], true, move_caret_down)?; - assert_move(&["ab|c\n","de"], &["ab[c\n","de]|"], true, move_caret_down)?; - assert_move(&["a|bc\n","de"], &["a[bc\n","d]|e"], true, move_caret_down)?; - assert_move(&["|abc\n","de"], &["[abc\n","]|de"], true, move_caret_down)?; - assert_move(&["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], &["ab[\n","cd]|ef\n", "ghijkl\n","mnopqrst"], true, move_caret_down)?; - assert_move(&["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], &["ab\n","cdef[\n", "ghij]|kl\n","mnopqrst"], true, move_caret_down)?; - assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef\n", "ghijkl[\n","mnopqr]|st"], true, move_caret_down)?; - assert_move(&[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], &[" [ab\n"," ]|cdef\n", "ghijkl\n","mnopqrst"], true, move_caret_down)?; - assert_move(&["ab\n","|cdef\n", "ghijkl\n","mnopqrst"], &["ab\n","[cdef\n", "]|ghijkl\n","mnopqrst"], true, move_caret_down)?; - assert_move(&["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "[ghijkl\n","]|mnopqrst"], true, move_caret_down)?; - assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["abcdefgh[\n","ijklmn]|\n", "opqr\n","st"], true, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdefgh\n","ijklmn[\n", "opqr]|\n","st"], true, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijklmn\n", "opqr[\n","st]|"], true, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","|st"], &["abcdefgh\n","ijklmn\n", "opqr\n","[st]|"], true, move_caret_down)?; + assert_move( + &["abc\n", "|def"], + &["abc\n", "[def]|"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "d|ef"], + &["abc\n", "d[ef]|"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|f"], + &["abc\n", "de[f]|"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "def|"], + &["abc\n", "def|"], + true, + move_caret_down, + )?; + assert_move( + &["|abc\n", "def"], + &["[abc\n", "]|def"], + true, + move_caret_down, + )?; + assert_move( + &["a|bc\n", "def"], + &["a[bc\n", "d]|ef"], + true, + move_caret_down, + )?; + assert_move( + &["ab|c\n", "def"], + &["ab[c\n", "de]|f"], + true, + move_caret_down, + )?; + assert_move( + &["abc|\n", "def"], + &["abc[\n", "def]|"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "|def \n", "ghi"], + &["abc\n", "[def \n", "]|ghi"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "d|ef \n", "ghi"], + &["abc\n", "d[ef \n", "g]|hi"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|f \n", "ghi"], + &["abc\n", "de[f \n", "gh]|i"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "def| \n", "ghi"], + &["abc\n", "def[ \n", "ghi]|"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "def |\n", "ghi"], + &["abc\n", "def [\n", "ghi]|"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|\n", "ghi"], + &["abc\n", "de[\n", "gh]|i"], + true, + move_caret_down, + )?; + assert_move( + &["abc|\n", "de"], + &["abc[\n", "de]|"], + true, + move_caret_down, + )?; + assert_move( + &["ab|c\n", "de"], + &["ab[c\n", "de]|"], + true, + move_caret_down, + )?; + assert_move( + &["a|bc\n", "de"], + &["a[bc\n", "d]|e"], + true, + move_caret_down, + )?; + assert_move( + &["|abc\n", "de"], + &["[abc\n", "]|de"], + true, + move_caret_down, + )?; + assert_move( + &["ab|\n", "cdef\n", "ghijkl\n", "mnopqrst"], + &["ab[\n", "cd]|ef\n", "ghijkl\n", "mnopqrst"], + true, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef|\n", "ghijkl\n", "mnopqrst"], + &["ab\n", "cdef[\n", "ghij]|kl\n", "mnopqrst"], + true, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl|\n", "mnopqrst"], + &["ab\n", "cdef\n", "ghijkl[\n", "mnopqr]|st"], + true, + move_caret_down, + )?; + assert_move( + &[" |ab\n", " cdef\n", "ghijkl\n", "mnopqrst"], + &[" [ab\n", " ]|cdef\n", "ghijkl\n", "mnopqrst"], + true, + move_caret_down, + )?; + assert_move( + &["ab\n", "|cdef\n", "ghijkl\n", "mnopqrst"], + &["ab\n", "[cdef\n", "]|ghijkl\n", "mnopqrst"], + true, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef\n", "|ghijkl\n", "mnopqrst"], + &["ab\n", "cdef\n", "[ghijkl\n", "]|mnopqrst"], + true, + move_caret_down, + )?; + assert_move( + &["abcdefgh|\n", "ijklmn\n", "opqr\n", "st"], + &["abcdefgh[\n", "ijklmn]|\n", "opqr\n", "st"], + true, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn|\n", "opqr\n", "st"], + &["abcdefgh\n", "ijklmn[\n", "opqr]|\n", "st"], + true, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr|\n", "st"], + &["abcdefgh\n", "ijklmn\n", "opqr[\n", "st]|"], + true, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr\n", "|st"], + &["abcdefgh\n", "ijklmn\n", "opqr\n", "[st]|"], + true, + move_caret_down, + )?; assert_move(&["abc def gh |"], &["abc def gh |"], true, move_caret_down)?; - assert_move(&["abc de|f gh "], &["abc de[f gh ]|"], true, move_caret_down)?; - assert_move(&["ab|c def gh "], &["ab[c def gh ]|"], true, move_caret_down)?; - assert_move(&["a|bc def gh "], &["a[bc def gh ]|"], true, move_caret_down)?; - assert_move(&["|abc def gh "], &["[abc def gh ]|"], true, move_caret_down)?; + assert_move( + &["abc de|f gh "], + &["abc de[f gh ]|"], + true, + move_caret_down, + )?; + assert_move( + &["ab|c def gh "], + &["ab[c def gh ]|"], + true, + move_caret_down, + )?; + assert_move( + &["a|bc def gh "], + &["a[bc def gh ]|"], + true, + move_caret_down, + )?; + assert_move( + &["|abc def gh "], + &["[abc def gh ]|"], + true, + move_caret_down, + )?; Ok(()) } @@ -593,32 +1120,142 @@ mod test_parse { assert_move(&["a|bc"], &["|[a]bc"], true, move_caret_up)?; assert_move(&["ab|c"], &["|[ab]c"], true, move_caret_up)?; assert_move(&["abc|"], &["|[abc]"], true, move_caret_up)?; - assert_move(&["|abc\n","def"], &["|abc\n","def"], true, move_caret_up)?; - assert_move(&["abc\n","|def"], &["|[abc\n","]def"], true, move_caret_up)?; - assert_move(&["abc\n","d|ef"], &["a|[bc\n","d]ef"], true, move_caret_up)?; - assert_move(&["abc\n","de|f"], &["ab|[c\n","de]f"], true, move_caret_up)?; - assert_move(&["abc\n","def|"], &["abc|[\n","def]"], true, move_caret_up)?; - assert_move(&["abc\n","def \n", "|ghi"], &["abc\n","|[def \n", "]ghi"], true, move_caret_up)?; - assert_move(&["abc\n","def \n", "g|hi"], &["abc\n","d|[ef \n", "g]hi"], true, move_caret_up)?; - assert_move(&["abc\n","def \n", "gh|i"], &["abc\n","de|[f \n", "gh]i"], true, move_caret_up)?; - assert_move(&["abc\n","def \n", "ghi|"], &["abc\n","def|[ \n", "ghi]"], true, move_caret_up)?; - assert_move(&["abc\n","de\n", "ghi|"], &["abc\n","de|[\n", "ghi]"], true, move_caret_up)?; - assert_move(&["abc\n","de|"], &["ab|[c\n","de]"], true, move_caret_up)?; - assert_move(&["abc\n","d|e"], &["a|[bc\n","d]e"], true, move_caret_up)?; - assert_move(&["abc\n","|de"], &["|[abc\n","]de"], true, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], &["ab\n","cdef\n", "ghijkl|[\n","mnopqrst]"], true, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], &["ab\n","cdef|[\n", "ghijkl]\n","mnopqrst"], true, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], &["ab\n","cdef\n", "|[ghijkl\n","]mnopqrst"], true, move_caret_up)?; - assert_move(&[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], &[" |[ab\n"," ]cdef\n", "ghijkl\n","mnopqrst"], true, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], &["ab\n","cdef\n", "ghijkl|[\n","mnopqr]st"], true, move_caret_up)?; - assert_move(&["ab\n","cde|f\n", "ghijkl\n","mnopqrst"], &["ab|[\n","cde]f\n", "ghijkl\n","mnopqrst"], true, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","st|"], &["abcdefgh\n","ijklmn\n", "op|[qr\n","st]"], true, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr|\n","st"], &["abcdefgh\n","ijkl|[mn\n", "opqr]\n","st"], true, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn|\n", "opqr\n","st"], &["abcdef|[gh\n","ijklmn]\n", "opqr\n","st"], true, move_caret_up)?; - assert_move(&["abcdefgh|\n","ijklmn\n", "opqr\n","st"], &["|[abcdefgh]\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; - assert_move(&["abcdefg|h\n","ijklmn\n", "opqr\n","st"], &["|[abcdefg]h\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; - assert_move(&["a|bcdefgh\n","ijklmn\n", "opqr\n","st"], &["|[a]bcdefgh\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; - assert_move(&["|abcdefgh\n","ijklmn\n", "opqr\n","st"], &["|abcdefgh\n","ijklmn\n", "opqr\n","st"], true, move_caret_up)?; + assert_move(&["|abc\n", "def"], &["|abc\n", "def"], true, move_caret_up)?; + assert_move( + &["abc\n", "|def"], + &["|[abc\n", "]def"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "d|ef"], + &["a|[bc\n", "d]ef"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "de|f"], + &["ab|[c\n", "de]f"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "def|"], + &["abc|[\n", "def]"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "def \n", "|ghi"], + &["abc\n", "|[def \n", "]ghi"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "def \n", "g|hi"], + &["abc\n", "d|[ef \n", "g]hi"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "def \n", "gh|i"], + &["abc\n", "de|[f \n", "gh]i"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "def \n", "ghi|"], + &["abc\n", "def|[ \n", "ghi]"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "de\n", "ghi|"], + &["abc\n", "de|[\n", "ghi]"], + true, + move_caret_up, + )?; + assert_move(&["abc\n", "de|"], &["ab|[c\n", "de]"], true, move_caret_up)?; + assert_move(&["abc\n", "d|e"], &["a|[bc\n", "d]e"], true, move_caret_up)?; + assert_move(&["abc\n", "|de"], &["|[abc\n", "]de"], true, move_caret_up)?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "mnopqrst|"], + &["ab\n", "cdef\n", "ghijkl|[\n", "mnopqrst]"], + true, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl|\n", "mnopqrst"], + &["ab\n", "cdef|[\n", "ghijkl]\n", "mnopqrst"], + true, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "|mnopqrst"], + &["ab\n", "cdef\n", "|[ghijkl\n", "]mnopqrst"], + true, + move_caret_up, + )?; + assert_move( + &[" ab\n", " |cdef\n", "ghijkl\n", "mnopqrst"], + &[" |[ab\n", " ]cdef\n", "ghijkl\n", "mnopqrst"], + true, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "mnopqr|st"], + &["ab\n", "cdef\n", "ghijkl|[\n", "mnopqr]st"], + true, + move_caret_up, + )?; + assert_move( + &["ab\n", "cde|f\n", "ghijkl\n", "mnopqrst"], + &["ab|[\n", "cde]f\n", "ghijkl\n", "mnopqrst"], + true, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr\n", "st|"], + &["abcdefgh\n", "ijklmn\n", "op|[qr\n", "st]"], + true, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr|\n", "st"], + &["abcdefgh\n", "ijkl|[mn\n", "opqr]\n", "st"], + true, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn|\n", "opqr\n", "st"], + &["abcdef|[gh\n", "ijklmn]\n", "opqr\n", "st"], + true, + move_caret_up, + )?; + assert_move( + &["abcdefgh|\n", "ijklmn\n", "opqr\n", "st"], + &["|[abcdefgh]\n", "ijklmn\n", "opqr\n", "st"], + true, + move_caret_up, + )?; + assert_move( + &["abcdefg|h\n", "ijklmn\n", "opqr\n", "st"], + &["|[abcdefg]h\n", "ijklmn\n", "opqr\n", "st"], + true, + move_caret_up, + )?; + assert_move( + &["a|bcdefgh\n", "ijklmn\n", "opqr\n", "st"], + &["|[a]bcdefgh\n", "ijklmn\n", "opqr\n", "st"], + true, + move_caret_up, + )?; + assert_move( + &["|abcdefgh\n", "ijklmn\n", "opqr\n", "st"], + &["|abcdefgh\n", "ijklmn\n", "opqr\n", "st"], + true, + move_caret_up, + )?; assert_move(&["abc def gh |"], &["|[abc def gh ]"], true, move_caret_up)?; assert_move(&["abc de|f gh "], &["|[abc de]f gh "], true, move_caret_up)?; assert_move(&["ab|c def gh "], &["|[ab]c def gh "], true, move_caret_up)?; @@ -636,23 +1273,93 @@ mod test_parse { assert_move(&["[ ]|abc"], &[" |abc"], false, move_caret_right)?; assert_move(&["|[ ]abc"], &[" |abc"], false, move_caret_right)?; assert_move(&["a|[b]c"], &["ab|c"], false, move_caret_right)?; - assert_move(&["abc[\n","]|d"], &["abc\n","|d"], false, move_caret_right)?; - assert_move(&["abc|[\n","]d"], &["abc\n","|d"], false, move_caret_right)?; - assert_move(&["abc|[\n","]"], &["abc\n","|"], false, move_caret_right)?; - assert_move(&["abc\n","[d]|ef"], &["abc\n","d|ef"], false, move_caret_right)?; - assert_move(&["abc\n","def\n", "ghi[\n","]|jkl"], &["abc\n","def\n", "ghi\n", "|jkl"], false, move_caret_right)?; + assert_move( + &["abc[\n", "]|d"], + &["abc\n", "|d"], + false, + move_caret_right, + )?; + assert_move( + &["abc|[\n", "]d"], + &["abc\n", "|d"], + false, + move_caret_right, + )?; + assert_move(&["abc|[\n", "]"], &["abc\n", "|"], false, move_caret_right)?; + assert_move( + &["abc\n", "[d]|ef"], + &["abc\n", "d|ef"], + false, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "ghi[\n", "]|jkl"], + &["abc\n", "def\n", "ghi\n", "|jkl"], + false, + move_caret_right, + )?; assert_move(&["[ab]|c"], &["ab|c"], false, move_caret_right)?; assert_move(&["[abc]|"], &["abc|"], false, move_caret_right)?; - assert_move(&["ab|[c\n","]def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; - assert_move(&["ab[c\n","]|def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; - assert_move(&["a|[bc\n","]def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; - assert_move(&["|[abc\n","]def\n","ghi"], &["abc\n","|def\n","ghi"], false, move_caret_right)?; - assert_move(&["a|[bc\n","d]ef\n","ghi"], &["abc\n","d|ef\n","ghi"], false, move_caret_right)?; - assert_move(&["|[abc\n","def]\n","ghi"], &["abc\n","def|\n","ghi"], false, move_caret_right)?; - assert_move(&["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], &["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], false, move_caret_right)?; - assert_move(&["|[ab\n","cdef\n", "ghijkl\n","mnopqrst]"], &["ab\n","cdef\n", "ghijkl\n","mnopqrst|"], false, move_caret_right)?; - assert_move(&["ab\n","c[def\n", "ghijkl\n","mno]|pqrst"], &["ab\n","cdef\n", "ghijkl\n","mno|pqrst"], false, move_caret_right)?; - assert_move(&["ab\n","c|[def\n", "ghijkl\n","mno]pqrst"], &["ab\n","cdef\n", "ghijkl\n","mno|pqrst"], false, move_caret_right)?; + assert_move( + &["ab|[c\n", "]def\n", "ghi"], + &["abc\n", "|def\n", "ghi"], + false, + move_caret_right, + )?; + assert_move( + &["ab[c\n", "]|def\n", "ghi"], + &["abc\n", "|def\n", "ghi"], + false, + move_caret_right, + )?; + assert_move( + &["a|[bc\n", "]def\n", "ghi"], + &["abc\n", "|def\n", "ghi"], + false, + move_caret_right, + )?; + assert_move( + &["|[abc\n", "]def\n", "ghi"], + &["abc\n", "|def\n", "ghi"], + false, + move_caret_right, + )?; + assert_move( + &["a|[bc\n", "d]ef\n", "ghi"], + &["abc\n", "d|ef\n", "ghi"], + false, + move_caret_right, + )?; + assert_move( + &["|[abc\n", "def]\n", "ghi"], + &["abc\n", "def|\n", "ghi"], + false, + move_caret_right, + )?; + assert_move( + &["[ab\n", "cdef\n", "ghijkl\n", "mnopqrst]|"], + &["ab\n", "cdef\n", "ghijkl\n", "mnopqrst|"], + false, + move_caret_right, + )?; + assert_move( + &["|[ab\n", "cdef\n", "ghijkl\n", "mnopqrst]"], + &["ab\n", "cdef\n", "ghijkl\n", "mnopqrst|"], + false, + move_caret_right, + )?; + assert_move( + &["ab\n", "c[def\n", "ghijkl\n", "mno]|pqrst"], + &["ab\n", "cdef\n", "ghijkl\n", "mno|pqrst"], + false, + move_caret_right, + )?; + assert_move( + &["ab\n", "c|[def\n", "ghijkl\n", "mno]pqrst"], + &["ab\n", "cdef\n", "ghijkl\n", "mno|pqrst"], + false, + move_caret_right, + )?; Ok(()) } @@ -663,26 +1370,86 @@ mod test_parse { assert_move(&["[a]|bc"], &["|abc"], false, move_caret_left)?; assert_move(&["a[b]|c"], &["a|bc"], false, move_caret_left)?; assert_move(&["ab[c]|"], &["ab|c"], false, move_caret_left)?; - assert_move(&["[ ]|abc"], &["| abc"], false, move_caret_left)?; + assert_move(&["[ ]|abc"], &["| abc"], false, move_caret_left)?; assert_move(&["|[ ]abc"], &["| abc"], false, move_caret_left)?; assert_move(&["a|[b]c"], &["a|bc"], false, move_caret_left)?; - assert_move(&["abc[\n","]|d"], &["abc|\n","d"], false, move_caret_left)?; - assert_move(&["abc|[\n","]d"], &["abc|\n","d"], false, move_caret_left)?; - assert_move(&["abc|[\n","]"], &["abc|\n",""], false, move_caret_left)?; - assert_move(&["abc\n","[d]|ef"], &["abc\n","|def"], false, move_caret_left)?; - assert_move(&["abc\n","def\n", "ghi[\n","]|jkl"], &["abc\n","def\n", "ghi|\n", "jkl"], false, move_caret_left)?; + assert_move(&["abc[\n", "]|d"], &["abc|\n", "d"], false, move_caret_left)?; + assert_move(&["abc|[\n", "]d"], &["abc|\n", "d"], false, move_caret_left)?; + assert_move(&["abc|[\n", "]"], &["abc|\n", ""], false, move_caret_left)?; + assert_move( + &["abc\n", "[d]|ef"], + &["abc\n", "|def"], + false, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "ghi[\n", "]|jkl"], + &["abc\n", "def\n", "ghi|\n", "jkl"], + false, + move_caret_left, + )?; assert_move(&["[ab]|c"], &["|abc"], false, move_caret_left)?; assert_move(&["[abc]|"], &["|abc"], false, move_caret_left)?; - assert_move(&["ab|[c\n","]def\n","ghi"], &["ab|c\n","def\n","ghi"], false, move_caret_left)?; - assert_move(&["ab[c\n","]|def\n","ghi"], &["ab|c\n","def\n","ghi"], false, move_caret_left)?; - assert_move(&["a|[bc\n","]def\n","ghi"], &["a|bc\n","def\n","ghi"], false, move_caret_left)?; - assert_move(&["|[abc\n","]def\n","ghi"], &["|abc\n","def\n","ghi"], false, move_caret_left)?; - assert_move(&["a|[bc\n","d]ef\n","ghi"], &["a|bc\n","def\n","ghi"], false, move_caret_left)?; - assert_move(&["|[abc\n","def]\n","ghi"], &["|abc\n","def\n","ghi"], false, move_caret_left)?; - assert_move(&["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], &["|ab\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; - assert_move(&["|[ab\n","cdef\n", "ghijkl\n","mnopqrst]"], &["|ab\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; - assert_move(&["ab\n","c[def\n", "ghijkl\n","mno]|pqrst"], &["ab\n","c|def\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; - assert_move(&["ab\n","c|[def\n", "ghijkl\n","mno]pqrst"], &["ab\n","c|def\n", "ghijkl\n","mnopqrst"], false, move_caret_left)?; + assert_move( + &["ab|[c\n", "]def\n", "ghi"], + &["ab|c\n", "def\n", "ghi"], + false, + move_caret_left, + )?; + assert_move( + &["ab[c\n", "]|def\n", "ghi"], + &["ab|c\n", "def\n", "ghi"], + false, + move_caret_left, + )?; + assert_move( + &["a|[bc\n", "]def\n", "ghi"], + &["a|bc\n", "def\n", "ghi"], + false, + move_caret_left, + )?; + assert_move( + &["|[abc\n", "]def\n", "ghi"], + &["|abc\n", "def\n", "ghi"], + false, + move_caret_left, + )?; + assert_move( + &["a|[bc\n", "d]ef\n", "ghi"], + &["a|bc\n", "def\n", "ghi"], + false, + move_caret_left, + )?; + assert_move( + &["|[abc\n", "def]\n", "ghi"], + &["|abc\n", "def\n", "ghi"], + false, + move_caret_left, + )?; + assert_move( + &["[ab\n", "cdef\n", "ghijkl\n", "mnopqrst]|"], + &["|ab\n", "cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_left, + )?; + assert_move( + &["|[ab\n", "cdef\n", "ghijkl\n", "mnopqrst]"], + &["|ab\n", "cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_left, + )?; + assert_move( + &["ab\n", "c[def\n", "ghijkl\n", "mno]|pqrst"], + &["ab\n", "c|def\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_left, + )?; + assert_move( + &["ab\n", "c|[def\n", "ghijkl\n", "mno]pqrst"], + &["ab\n", "c|def\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_left, + )?; Ok(()) } @@ -694,37 +1461,192 @@ mod test_parse { assert_move(&["a|[bc]"], &["abc|"], false, move_caret_down)?; assert_move(&["ab[c]|"], &["abc|"], false, move_caret_down)?; assert_move(&["abc|[ ]"], &["abc |"], false, move_caret_down)?; - assert_move(&["abc\n","|[def]"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["abc\n","d|[ef]"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["abc\n","de|[f]"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["[abc\n","]|def"], &["abc\n","|def"], false, move_caret_down)?; - assert_move(&["a[bc\n","d]|ef"], &["abc\n","d|ef"], false, move_caret_down)?; - assert_move(&["ab|[c\n","de]f"], &["abc\n","de|f"], false, move_caret_down)?; - assert_move(&["abc[\n","def]|"], &["abc\n","def|"], false, move_caret_down)?; - assert_move(&["abc\n","|[def \n", "]ghi"], &["abc\n","def \n", "|ghi"], false, move_caret_down)?; - assert_move(&["abc\n","d[ef \n", "g]|hi"], &["abc\n","def \n", "g|hi"], false, move_caret_down)?; - assert_move(&["abc\n","de[f \n", "gh]|i"], &["abc\n","def \n", "gh|i"], false, move_caret_down)?; - assert_move(&["abc\n","def[ \n", "ghi]|"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; - assert_move(&["abc\n","def [\n", "ghi]|"], &["abc\n","def \n", "ghi|"], false, move_caret_down)?; - assert_move(&["abc\n","de[\n", "gh]|i"], &["abc\n","de\n", "gh|i"], false, move_caret_down)?; - assert_move(&["abc|[\n","de]"], &["abc\n","de|"], false, move_caret_down)?; - assert_move(&["ab[c\n","de]|"], &["abc\n","de|"], false, move_caret_down)?; - assert_move(&["a|[bc\n","d]e"], &["abc\n","d|e"], false, move_caret_down)?; - assert_move(&["[abc\n","]|de"], &["abc\n","|de"], false, move_caret_down)?; - assert_move(&["ab[\n","cd]|ef\n", "ghijkl\n","mnopqrst"], &["ab\n","cd|ef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","cdef|[\n", "ghij]kl\n","mnopqrst"], &["ab\n","cdef\n", "ghij|kl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","cdef\n", "ghijkl[\n","mnopqr]|st"], &["ab\n","cdef\n", "ghijkl\n","mnopqr|st"], false, move_caret_down)?; - assert_move(&[" [ab\n"," ]|cdef\n", "ghijkl\n","mnopqrst"], &[" ab\n"," |cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","|[cdef\n", "]ghijkl\n","mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_down)?; - assert_move(&["ab\n","cdef\n", "[ghijkl\n","]|mnopqrst"], &["ab\n","cdef\n", "ghijkl\n","|mnopqrst"], false, move_caret_down)?; - assert_move(&["abcdefgh[\n","ijklmn]|\n", "opqr\n","st"], &["abcdefgh\n","ijklmn|\n", "opqr\n","st"], false, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn[\n", "opqr]|\n","st"], &["abcdefgh\n","ijklmn\n", "opqr|\n","st"], false, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr[\n","st]|"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","[st]|"], &["abcdefgh\n","ijklmn\n", "opqr\n","st|"], false, move_caret_down)?; - assert_move(&["abc de[f gh ]|"], &["abc def gh |"], false, move_caret_down)?; - assert_move(&["ab|[c def gh ]"], &["abc def gh |"], false, move_caret_down)?; - assert_move(&["a[bc def gh ]|"], &["abc def gh |"], false, move_caret_down)?; - assert_move(&["[abc def gh ]|"], &["abc def gh |"], false, move_caret_down)?; + assert_move( + &["abc\n", "|[def]"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "d|[ef]"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|[f]"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["[abc\n", "]|def"], + &["abc\n", "|def"], + false, + move_caret_down, + )?; + assert_move( + &["a[bc\n", "d]|ef"], + &["abc\n", "d|ef"], + false, + move_caret_down, + )?; + assert_move( + &["ab|[c\n", "de]f"], + &["abc\n", "de|f"], + false, + move_caret_down, + )?; + assert_move( + &["abc[\n", "def]|"], + &["abc\n", "def|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "|[def \n", "]ghi"], + &["abc\n", "def \n", "|ghi"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "d[ef \n", "g]|hi"], + &["abc\n", "def \n", "g|hi"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "de[f \n", "gh]|i"], + &["abc\n", "def \n", "gh|i"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "def[ \n", "ghi]|"], + &["abc\n", "def \n", "ghi|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "def [\n", "ghi]|"], + &["abc\n", "def \n", "ghi|"], + false, + move_caret_down, + )?; + assert_move( + &["abc\n", "de[\n", "gh]|i"], + &["abc\n", "de\n", "gh|i"], + false, + move_caret_down, + )?; + assert_move( + &["abc|[\n", "de]"], + &["abc\n", "de|"], + false, + move_caret_down, + )?; + assert_move( + &["ab[c\n", "de]|"], + &["abc\n", "de|"], + false, + move_caret_down, + )?; + assert_move( + &["a|[bc\n", "d]e"], + &["abc\n", "d|e"], + false, + move_caret_down, + )?; + assert_move( + &["[abc\n", "]|de"], + &["abc\n", "|de"], + false, + move_caret_down, + )?; + assert_move( + &["ab[\n", "cd]|ef\n", "ghijkl\n", "mnopqrst"], + &["ab\n", "cd|ef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef|[\n", "ghij]kl\n", "mnopqrst"], + &["ab\n", "cdef\n", "ghij|kl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl[\n", "mnopqr]|st"], + &["ab\n", "cdef\n", "ghijkl\n", "mnopqr|st"], + false, + move_caret_down, + )?; + assert_move( + &[" [ab\n", " ]|cdef\n", "ghijkl\n", "mnopqrst"], + &[" ab\n", " |cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "|[cdef\n", "]ghijkl\n", "mnopqrst"], + &["ab\n", "cdef\n", "|ghijkl\n", "mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["ab\n", "cdef\n", "[ghijkl\n", "]|mnopqrst"], + &["ab\n", "cdef\n", "ghijkl\n", "|mnopqrst"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh[\n", "ijklmn]|\n", "opqr\n", "st"], + &["abcdefgh\n", "ijklmn|\n", "opqr\n", "st"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn[\n", "opqr]|\n", "st"], + &["abcdefgh\n", "ijklmn\n", "opqr|\n", "st"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr[\n", "st]|"], + &["abcdefgh\n", "ijklmn\n", "opqr\n", "st|"], + false, + move_caret_down, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr\n", "[st]|"], + &["abcdefgh\n", "ijklmn\n", "opqr\n", "st|"], + false, + move_caret_down, + )?; + assert_move( + &["abc de[f gh ]|"], + &["abc def gh |"], + false, + move_caret_down, + )?; + assert_move( + &["ab|[c def gh ]"], + &["abc def gh |"], + false, + move_caret_down, + )?; + assert_move( + &["a[bc def gh ]|"], + &["abc def gh |"], + false, + move_caret_down, + )?; + assert_move( + &["[abc def gh ]|"], + &["abc def gh |"], + false, + move_caret_down, + )?; Ok(()) } @@ -736,33 +1658,148 @@ mod test_parse { assert_move(&["a|[bc]"], &["a|bc"], false, move_caret_up)?; assert_move(&["ab[c]|"], &["ab|c"], false, move_caret_up)?; assert_move(&["abc|[ ]"], &["abc| "], false, move_caret_up)?; - assert_move(&["abc\n","|[def]"], &["abc\n","|def"], false, move_caret_up)?; - assert_move(&["abc\n","d|[ef]"], &["abc\n","d|ef"], false, move_caret_up)?; - assert_move(&["abc\n","de|[f]"], &["abc\n","de|f"], false, move_caret_up)?; - assert_move(&["[abc\n","]|def"], &["|abc\n","def"], false, move_caret_up)?; - assert_move(&["a[bc\n","d]|ef"], &["a|bc\n","def"], false, move_caret_up)?; - assert_move(&["ab|[c\n","de]f"], &["ab|c\n","def"], false, move_caret_up)?; - assert_move(&["abc[\n","def]|"], &["abc|\n","def"], false, move_caret_up)?; - assert_move(&["abc\n","|[def \n", "]ghi"], &["abc\n","|def \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","d[ef \n", "g]|hi"], &["abc\n","d|ef \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","de|[f \n", "gh]i"], &["abc\n","de|f \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","def[ \n", "ghi]|"], &["abc\n","def| \n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","def [\n", "ghi]|"], &["abc\n","def |\n", "ghi"], false, move_caret_up)?; - assert_move(&["abc\n","de[\n", "gh]|i"], &["abc\n","de|\n", "ghi"], false, move_caret_up)?; - assert_move(&["abc|[\n","de]"], &["abc|\n","de"], false, move_caret_up)?; - assert_move(&["ab[c\n","de]|"], &["ab|c\n","de"], false, move_caret_up)?; - assert_move(&["a|[bc\n","d]e"], &["a|bc\n","de"], false, move_caret_up)?; - assert_move(&["[abc\n","]|de"], &["|abc\n","de"], false, move_caret_up)?; - assert_move(&["ab[\n","cd]|ef\n", "ghijkl\n","mnopqrst"], &["ab|\n","cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","cdef|[\n", "ghij]kl\n","mnopqrst"], &["ab\n","cdef|\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl[\n","mnopqr]|st"], &["ab\n","cdef\n", "ghijkl|\n","mnopqrst"], false, move_caret_up)?; - assert_move(&[" [ab\n"," ]|cdef\n", "ghijkl\n","mnopqrst"], &[" |ab\n"," cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","|[cdef\n", "]ghijkl\n","mnopqrst"], &["ab\n","|cdef\n", "ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "[ghijkl\n","]|mnopqrst"], &["ab\n","cdef\n", "|ghijkl\n","mnopqrst"], false, move_caret_up)?; - assert_move(&["abcdefgh[\n","ijklmn]|\n", "opqr\n","st"], &["abcdefgh|\n","ijklmn\n", "opqr\n","st"], false, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn[\n", "opqr]|\n","st"], &["abcdefgh\n","ijklmn|\n", "opqr\n","st"], false, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr[\n","st]|"], &["abcdefgh\n","ijklmn\n", "opqr|\n","st"], false, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn\n", "opqr\n","[st]|"], &["abcdefgh\n","ijklmn\n", "opqr\n","|st"], false, move_caret_up)?; + assert_move( + &["abc\n", "|[def]"], + &["abc\n", "|def"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "d|[ef]"], + &["abc\n", "d|ef"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "de|[f]"], + &["abc\n", "de|f"], + false, + move_caret_up, + )?; + assert_move( + &["[abc\n", "]|def"], + &["|abc\n", "def"], + false, + move_caret_up, + )?; + assert_move( + &["a[bc\n", "d]|ef"], + &["a|bc\n", "def"], + false, + move_caret_up, + )?; + assert_move( + &["ab|[c\n", "de]f"], + &["ab|c\n", "def"], + false, + move_caret_up, + )?; + assert_move( + &["abc[\n", "def]|"], + &["abc|\n", "def"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "|[def \n", "]ghi"], + &["abc\n", "|def \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "d[ef \n", "g]|hi"], + &["abc\n", "d|ef \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "de|[f \n", "gh]i"], + &["abc\n", "de|f \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "def[ \n", "ghi]|"], + &["abc\n", "def| \n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "def [\n", "ghi]|"], + &["abc\n", "def |\n", "ghi"], + false, + move_caret_up, + )?; + assert_move( + &["abc\n", "de[\n", "gh]|i"], + &["abc\n", "de|\n", "ghi"], + false, + move_caret_up, + )?; + assert_move(&["abc|[\n", "de]"], &["abc|\n", "de"], false, move_caret_up)?; + assert_move(&["ab[c\n", "de]|"], &["ab|c\n", "de"], false, move_caret_up)?; + assert_move(&["a|[bc\n", "d]e"], &["a|bc\n", "de"], false, move_caret_up)?; + assert_move(&["[abc\n", "]|de"], &["|abc\n", "de"], false, move_caret_up)?; + assert_move( + &["ab[\n", "cd]|ef\n", "ghijkl\n", "mnopqrst"], + &["ab|\n", "cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef|[\n", "ghij]kl\n", "mnopqrst"], + &["ab\n", "cdef|\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl[\n", "mnopqr]|st"], + &["ab\n", "cdef\n", "ghijkl|\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &[" [ab\n", " ]|cdef\n", "ghijkl\n", "mnopqrst"], + &[" |ab\n", " cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "|[cdef\n", "]ghijkl\n", "mnopqrst"], + &["ab\n", "|cdef\n", "ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "[ghijkl\n", "]|mnopqrst"], + &["ab\n", "cdef\n", "|ghijkl\n", "mnopqrst"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh[\n", "ijklmn]|\n", "opqr\n", "st"], + &["abcdefgh|\n", "ijklmn\n", "opqr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn[\n", "opqr]|\n", "st"], + &["abcdefgh\n", "ijklmn|\n", "opqr\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr[\n", "st]|"], + &["abcdefgh\n", "ijklmn\n", "opqr|\n", "st"], + false, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "opqr\n", "[st]|"], + &["abcdefgh\n", "ijklmn\n", "opqr\n", "|st"], + false, + move_caret_up, + )?; assert_move(&["abc de[f gh ]|"], &["abc de|f gh "], false, move_caret_up)?; assert_move(&["ab|[c def gh ]"], &["ab|c def gh "], false, move_caret_up)?; assert_move(&["a[bc def gh ]|"], &["a|bc def gh "], false, move_caret_up)?; @@ -780,14 +1817,49 @@ mod test_parse { assert_move(&["[abc]|"], &["[abc]|"], true, move_caret_right)?; assert_move(&["a[bc]|"], &["a[bc]|"], true, move_caret_right)?; assert_move(&["ab[c]|"], &["ab[c]|"], true, move_caret_right)?; - assert_move(&["abc[\n","]|d"], &["abc[\n","d]|"], true, move_caret_right)?; - assert_move(&["ab[c]|\n",""], &["ab[c\n","]|"], true, move_caret_right)?; - assert_move(&["ab[c]|\n","d"], &["ab[c\n","]|d"], true, move_caret_right)?; - assert_move(&["abc\n","def\n", "ghi[\n","]|jkl"], &["abc\n","def\n", "ghi[\n", "j]|kl"], true, move_caret_right)?; - assert_move(&["ab[c\n","def\n", "ghi\n","]|jkl"], &["ab[c\n","def\n", "ghi\n", "j]|kl"], true, move_caret_right)?; - assert_move(&["ab[c\n","def\n", "]|ghi\n","jkl"], &["ab[c\n","def\n", "g]|hi\n", "jkl"], true, move_caret_right)?; - assert_move(&["[abc\n","def\n", "ghi\n","jk]|l"], &["[abc\n","def\n", "ghi\n", "jkl]|"], true, move_caret_right)?; - assert_move(&["[abc\n","def\n", "ghi\n", "jkl]|"], &["[abc\n","def\n", "ghi\n", "jkl]|"], true, move_caret_right)?; + assert_move( + &["abc[\n", "]|d"], + &["abc[\n", "d]|"], + true, + move_caret_right, + )?; + assert_move(&["ab[c]|\n", ""], &["ab[c\n", "]|"], true, move_caret_right)?; + assert_move( + &["ab[c]|\n", "d"], + &["ab[c\n", "]|d"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "def\n", "ghi[\n", "]|jkl"], + &["abc\n", "def\n", "ghi[\n", "j]|kl"], + true, + move_caret_right, + )?; + assert_move( + &["ab[c\n", "def\n", "ghi\n", "]|jkl"], + &["ab[c\n", "def\n", "ghi\n", "j]|kl"], + true, + move_caret_right, + )?; + assert_move( + &["ab[c\n", "def\n", "]|ghi\n", "jkl"], + &["ab[c\n", "def\n", "g]|hi\n", "jkl"], + true, + move_caret_right, + )?; + assert_move( + &["[abc\n", "def\n", "ghi\n", "jk]|l"], + &["[abc\n", "def\n", "ghi\n", "jkl]|"], + true, + move_caret_right, + )?; + assert_move( + &["[abc\n", "def\n", "ghi\n", "jkl]|"], + &["[abc\n", "def\n", "ghi\n", "jkl]|"], + true, + move_caret_right, + )?; Ok(()) } @@ -800,12 +1872,37 @@ mod test_parse { assert_move(&["|[ab]c"], &["|[ab]c"], true, move_caret_left)?; assert_move(&["|[a]bc"], &["|[a]bc"], true, move_caret_left)?; assert_move(&[" |[a]bc"], &["|[ a]bc"], true, move_caret_left)?; - assert_move(&["abc|[\n","]d"], &["ab|[c\n","]d"], true, move_caret_left)?; - assert_move(&["abc\n","|[d]"], &["abc|[\n","d]"], true, move_caret_left)?; - assert_move(&["ab|[c\n","]"], &["a|[bc\n","]"], true, move_caret_left)?; - assert_move(&["abc\n","def|[\n", "ghi\n","j]kl"], &["abc\n","de|[f\n", "ghi\n", "j]kl"], true, move_caret_left)?; - assert_move(&["a|[bc\n","def\n", "ghi\n","jkl]"], &["|[abc\n","def\n", "ghi\n", "jkl]"], true, move_caret_left)?; - assert_move(&["abc\n","def\n", "ghi\n", "|[jkl]"], &["abc\n","def\n", "ghi|[\n", "jkl]"], true, move_caret_left)?; + assert_move( + &["abc|[\n", "]d"], + &["ab|[c\n", "]d"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "|[d]"], + &["abc|[\n", "d]"], + true, + move_caret_left, + )?; + assert_move(&["ab|[c\n", "]"], &["a|[bc\n", "]"], true, move_caret_left)?; + assert_move( + &["abc\n", "def|[\n", "ghi\n", "j]kl"], + &["abc\n", "de|[f\n", "ghi\n", "j]kl"], + true, + move_caret_left, + )?; + assert_move( + &["a|[bc\n", "def\n", "ghi\n", "jkl]"], + &["|[abc\n", "def\n", "ghi\n", "jkl]"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "def\n", "ghi\n", "|[jkl]"], + &["abc\n", "def\n", "ghi|[\n", "jkl]"], + true, + move_caret_left, + )?; Ok(()) } @@ -821,13 +1918,43 @@ mod test_parse { assert_move(&["ab[c]|"], &["|[ab]c"], true, move_caret_up)?; assert_move(&["[a]|"], &["|a"], true, move_caret_up)?; assert_move(&["[a]|bc"], &["|abc"], true, move_caret_up)?; - assert_move(&["[a]|bc\n","d"], &["|abc\n","d"], true, move_caret_up)?; - assert_move(&["abc\n","de[f]|"], &["abc|[\n","de]f"], true, move_caret_up)?; - assert_move(&["abc\n","de|[f]"], &["ab|[c\n","def]"], true, move_caret_up)?; - assert_move(&["ab|[c\n","def]"], &["|[abc\n","def]"], true, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","[mnopqr]|st"], &["ab\n","cdef\n", "ghijkl|[\n","]mnopqrst"], true, move_caret_up)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","[mnopqrs]|t"], &["ab\n","cdef\n", "ghijkl|[\n","]mnopqrst"], true, move_caret_up)?; - assert_move(&["abcdefgh\n","ijklmn\n", "|[o]pqr\n","st"], &["abcdefgh\n","|[ijklmn\n", "o]pqr\n","st"], true, move_caret_up)?; + assert_move(&["[a]|bc\n", "d"], &["|abc\n", "d"], true, move_caret_up)?; + assert_move( + &["abc\n", "de[f]|"], + &["abc|[\n", "de]f"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "de|[f]"], + &["ab|[c\n", "def]"], + true, + move_caret_up, + )?; + assert_move( + &["ab|[c\n", "def]"], + &["|[abc\n", "def]"], + true, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "[mnopqr]|st"], + &["ab\n", "cdef\n", "ghijkl|[\n", "]mnopqrst"], + true, + move_caret_up, + )?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "[mnopqrs]|t"], + &["ab\n", "cdef\n", "ghijkl|[\n", "]mnopqrst"], + true, + move_caret_up, + )?; + assert_move( + &["abcdefgh\n", "ijklmn\n", "|[o]pqr\n", "st"], + &["abcdefgh\n", "|[ijklmn\n", "o]pqr\n", "st"], + true, + move_caret_up, + )?; Ok(()) } @@ -839,15 +1966,55 @@ mod test_parse { assert_move(&["[abc]|"], &["[abc]|"], true, move_caret_down)?; assert_move(&["|[ab]c"], &["ab[c]|"], true, move_caret_down)?; assert_move(&["|[a]bc"], &["a[bc]|"], true, move_caret_down)?; - assert_move(&["[a]|bc\n","d"], &["[abc\n","d]|"], true, move_caret_down)?; - assert_move(&["[a]|bc\n","de"], &["[abc\n","d]|e"], true, move_caret_down)?; - assert_move(&["[abc\n","d]|e"], &["[abc\n","de]|"], true, move_caret_down)?; - assert_move(&["[a]|bc\n",""], &["[abc\n","]|"], true, move_caret_down)?; - assert_move(&["ab\n","cdef\n", "ghijkl\n","[mnopqr]|st"], &["ab\n","cdef\n", "ghijkl\n","[mnopqrst]|"], true, move_caret_down)?; - assert_move(&["a[b\n","cdef\n", "ghijkl\n","mnopqr]|st"], &["a[b\n","cdef\n", "ghijkl\n","mnopqrst]|"], true, move_caret_down)?; - assert_move(&["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], &["[ab\n","cdef\n", "ghijkl\n","mnopqrst]|"], true, move_caret_down)?; - assert_move(&["abcd[efgh]|\n","ijklmn\n", "opqr\n","st"], &["abcd[efgh\n","ijklmn]|\n", "opqr\n","st"], true, move_caret_down)?; - assert_move(&["abcd[e]|fgh\n","ijklmn\n", "opqr\n","st"], &["abcd[efgh\n","ijklm]|n\n", "opqr\n","st"], true, move_caret_down)?; + assert_move( + &["[a]|bc\n", "d"], + &["[abc\n", "d]|"], + true, + move_caret_down, + )?; + assert_move( + &["[a]|bc\n", "de"], + &["[abc\n", "d]|e"], + true, + move_caret_down, + )?; + assert_move( + &["[abc\n", "d]|e"], + &["[abc\n", "de]|"], + true, + move_caret_down, + )?; + assert_move(&["[a]|bc\n", ""], &["[abc\n", "]|"], true, move_caret_down)?; + assert_move( + &["ab\n", "cdef\n", "ghijkl\n", "[mnopqr]|st"], + &["ab\n", "cdef\n", "ghijkl\n", "[mnopqrst]|"], + true, + move_caret_down, + )?; + assert_move( + &["a[b\n", "cdef\n", "ghijkl\n", "mnopqr]|st"], + &["a[b\n", "cdef\n", "ghijkl\n", "mnopqrst]|"], + true, + move_caret_down, + )?; + assert_move( + &["[ab\n", "cdef\n", "ghijkl\n", "mnopqrst]|"], + &["[ab\n", "cdef\n", "ghijkl\n", "mnopqrst]|"], + true, + move_caret_down, + )?; + assert_move( + &["abcd[efgh]|\n", "ijklmn\n", "opqr\n", "st"], + &["abcd[efgh\n", "ijklmn]|\n", "opqr\n", "st"], + true, + move_caret_down, + )?; + assert_move( + &["abcd[e]|fgh\n", "ijklmn\n", "opqr\n", "st"], + &["abcd[efgh\n", "ijklm]|n\n", "opqr\n", "st"], + true, + move_caret_down, + )?; Ok(()) } @@ -857,9 +2024,24 @@ mod test_parse { assert_move(&["ab|[c]"], &["abc|"], true, move_caret_right)?; assert_move(&["a|[bc]"], &["ab|[c]"], true, move_caret_right)?; assert_move(&["|[abc]"], &["a|[bc]"], true, move_caret_right)?; - assert_move(&["|[abc\n","def\n", "ghi\n","jkl]"], &["a|[bc\n","def\n", "ghi\n", "jkl]"], true, move_caret_right)?; - assert_move(&["abc\n","d|[ef\n", "]ghi\n","jkl"], &["abc\n","de|[f\n", "]ghi\n", "jkl"], true, move_caret_right)?; - assert_move(&["abc\n","de|[f]\n", "ghi\n","jkl"], &["abc\n","def|\n", "ghi\n", "jkl"], true, move_caret_right)?; + assert_move( + &["|[abc\n", "def\n", "ghi\n", "jkl]"], + &["a|[bc\n", "def\n", "ghi\n", "jkl]"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "d|[ef\n", "]ghi\n", "jkl"], + &["abc\n", "de|[f\n", "]ghi\n", "jkl"], + true, + move_caret_right, + )?; + assert_move( + &["abc\n", "de|[f]\n", "ghi\n", "jkl"], + &["abc\n", "def|\n", "ghi\n", "jkl"], + true, + move_caret_right, + )?; Ok(()) } @@ -869,10 +2051,30 @@ mod test_parse { assert_move(&["ab[c]|"], &["ab|c"], true, move_caret_left)?; assert_move(&["a[bc]|"], &["a[b]|c"], true, move_caret_left)?; assert_move(&["[abc]|"], &["[ab]|c"], true, move_caret_left)?; - assert_move(&["[abc\n","def\n", "ghi\n","jkl]|"], &["[abc\n","def\n", "ghi\n", "jk]|l"], true, move_caret_left)?; - assert_move(&["|[abc\n","def\n", "ghi\n","jkl]"], &["|[abc\n","def\n", "ghi\n", "jkl]"], true, move_caret_left)?; - assert_move(&["abc\n","def[\n", "]|ghi\n","jkl"], &["abc\n","def|\n", "ghi\n", "jkl"], true, move_caret_left)?; - assert_move(&["abc\n","d[ef\n", "gh]|i\n","jkl"], &["abc\n","d[ef\n", "g]|hi\n", "jkl"], true, move_caret_left)?; + assert_move( + &["[abc\n", "def\n", "ghi\n", "jkl]|"], + &["[abc\n", "def\n", "ghi\n", "jk]|l"], + true, + move_caret_left, + )?; + assert_move( + &["|[abc\n", "def\n", "ghi\n", "jkl]"], + &["|[abc\n", "def\n", "ghi\n", "jkl]"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "def[\n", "]|ghi\n", "jkl"], + &["abc\n", "def|\n", "ghi\n", "jkl"], + true, + move_caret_left, + )?; + assert_move( + &["abc\n", "d[ef\n", "gh]|i\n", "jkl"], + &["abc\n", "d[ef\n", "g]|hi\n", "jkl"], + true, + move_caret_left, + )?; Ok(()) } @@ -883,12 +2085,42 @@ mod test_parse { assert_move(&["[ab]|c"], &["|abc"], true, move_caret_up)?; assert_move(&["[a]|bc"], &["|abc"], true, move_caret_up)?; assert_move(&["|abc"], &["|abc"], true, move_caret_up)?; - assert_move(&["[abc\n","def]|"], &["[abc]|\n","def"], true, move_caret_up)?; - assert_move(&["[abc\n","de]|f"], &["[ab]|c\n","def"], true, move_caret_up)?; - assert_move(&["[abc\n","def\n", "ghi\n","jkl]|"], &["[abc\n","def\n", "ghi]|\n", "jkl"], true, move_caret_up)?; - assert_move(&["abc\n","def\n", "ghi[\n","jkl]|"], &["abc\n","def\n", "ghi|\n", "jkl"], true, move_caret_up)?; - assert_move(&["abc\n","d[ef\n", "ghi\n","jk]|l"], &["abc\n","d[ef\n", "gh]|i\n", "jkl"], true, move_caret_up)?; - assert_move(&["[abc\n","d]|ef\n", "ghi\n","jkl"], &["[a]|bc\n","def\n", "ghi\n", "jkl"], true, move_caret_up)?; + assert_move( + &["[abc\n", "def]|"], + &["[abc]|\n", "def"], + true, + move_caret_up, + )?; + assert_move( + &["[abc\n", "de]|f"], + &["[ab]|c\n", "def"], + true, + move_caret_up, + )?; + assert_move( + &["[abc\n", "def\n", "ghi\n", "jkl]|"], + &["[abc\n", "def\n", "ghi]|\n", "jkl"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "def\n", "ghi[\n", "jkl]|"], + &["abc\n", "def\n", "ghi|\n", "jkl"], + true, + move_caret_up, + )?; + assert_move( + &["abc\n", "d[ef\n", "ghi\n", "jk]|l"], + &["abc\n", "d[ef\n", "gh]|i\n", "jkl"], + true, + move_caret_up, + )?; + assert_move( + &["[abc\n", "d]|ef\n", "ghi\n", "jkl"], + &["[a]|bc\n", "def\n", "ghi\n", "jkl"], + true, + move_caret_up, + )?; Ok(()) } @@ -896,16 +2128,55 @@ mod test_parse { #[test] fn shrink_selection_down() -> Result<(), String> { assert_move(&["|[abc]"], &["abc|"], true, move_caret_down)?; - assert_move(&["|[abc\n","def]"], &["abc\n","|[def]"], true, move_caret_down)?; - assert_move(&["a|[bc\n","def]"], &["abc\n","d|[ef]"], true, move_caret_down)?; - assert_move(&["|[abc\n","def\n", "ghi]"], &["abc\n","|[def\n", "ghi]"], true, move_caret_down)?; - assert_move(&["ab|[c\n","def\n", "ghi]"], &["abc\n","de|[f\n", "ghi]"], true, move_caret_down)?; - assert_move(&["abc\n","de|[f\n", "ghi]"], &["abc\n","def\n", "gh|[i]"], true, move_caret_down)?; - assert_move(&["abcdef|[\n","ghij\n", "kl]"], &["abcdef\n","ghij|[\n", "kl]"], true, move_caret_down)?; - assert_move(&["abcde|[f\n","ghij\n", "kl]"], &["abcdef\n","ghij|[\n", "kl]"], true, move_caret_down)?; - assert_move(&["ab|[cdef\n","ghij\n", "kl]"], &["abcdef\n","gh|[ij\n", "kl]"], true, move_caret_down)?; + assert_move( + &["|[abc\n", "def]"], + &["abc\n", "|[def]"], + true, + move_caret_down, + )?; + assert_move( + &["a|[bc\n", "def]"], + &["abc\n", "d|[ef]"], + true, + move_caret_down, + )?; + assert_move( + &["|[abc\n", "def\n", "ghi]"], + &["abc\n", "|[def\n", "ghi]"], + true, + move_caret_down, + )?; + assert_move( + &["ab|[c\n", "def\n", "ghi]"], + &["abc\n", "de|[f\n", "ghi]"], + true, + move_caret_down, + )?; + assert_move( + &["abc\n", "de|[f\n", "ghi]"], + &["abc\n", "def\n", "gh|[i]"], + true, + move_caret_down, + )?; + assert_move( + &["abcdef|[\n", "ghij\n", "kl]"], + &["abcdef\n", "ghij|[\n", "kl]"], + true, + move_caret_down, + )?; + assert_move( + &["abcde|[f\n", "ghij\n", "kl]"], + &["abcdef\n", "ghij|[\n", "kl]"], + true, + move_caret_down, + )?; + assert_move( + &["ab|[cdef\n", "ghij\n", "kl]"], + &["abcdef\n", "gh|[ij\n", "kl]"], + true, + move_caret_down, + )?; Ok(()) } - -} \ No newline at end of file +} diff --git a/editor/src/tea/update.rs b/editor/src/tea/update.rs index 3a08600282..3e08a3cb21 100644 --- a/editor/src/tea/update.rs +++ b/editor/src/tea/update.rs @@ -11,23 +11,22 @@ pub fn move_caret_left( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = - if old_selection_opt.is_some() && !shift_pressed{ - match old_selection_opt { - Some(old_selection) => (old_selection.start_pos.line, old_selection.start_pos.column), - None => unreachable!(), - } - } else if old_col_nr == 0 { - if old_line_nr == 0 { - (0, 0) - } else if let Some(curr_line) = lines.get(old_line_nr - 1) { - (old_line_nr - 1, curr_line.len() - 1) - } else { - unreachable!() - } + let (line_nr, col_nr) = if old_selection_opt.is_some() && !shift_pressed { + match old_selection_opt { + Some(old_selection) => (old_selection.start_pos.line, old_selection.start_pos.column), + None => unreachable!(), + } + } else if old_col_nr == 0 { + if old_line_nr == 0 { + (0, 0) + } else if let Some(curr_line) = lines.get(old_line_nr - 1) { + (old_line_nr - 1, curr_line.len() - 1) } else { - (old_line_nr, old_col_nr - 1) - }; + unreachable!() + } + } else { + (old_line_nr, old_col_nr - 1) + }; let new_caret_pos = Position { line: line_nr, @@ -84,31 +83,30 @@ pub fn move_caret_right( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = - if old_selection_opt.is_some() && !shift_pressed{ - match old_selection_opt { - Some(old_selection) => (old_selection.end_pos.line, old_selection.end_pos.column), - None => unreachable!(), - } - } else if let Some(curr_line) = lines.get(old_line_nr) { - if let Some(last_char) = curr_line.chars().last() { - if is_newline(&last_char) { - if old_col_nr + 1 > curr_line.len() - 1 { - (old_line_nr + 1, 0) - } else { - (old_line_nr, old_col_nr + 1) - } - } else if old_col_nr < curr_line.len() { - (old_line_nr, old_col_nr + 1) + let (line_nr, col_nr) = if old_selection_opt.is_some() && !shift_pressed { + match old_selection_opt { + Some(old_selection) => (old_selection.end_pos.line, old_selection.end_pos.column), + None => unreachable!(), + } + } else if let Some(curr_line) = lines.get(old_line_nr) { + if let Some(last_char) = curr_line.chars().last() { + if is_newline(&last_char) { + if old_col_nr + 1 > curr_line.len() - 1 { + (old_line_nr + 1, 0) } else { - (old_line_nr, old_col_nr) + (old_line_nr, old_col_nr + 1) } + } else if old_col_nr < curr_line.len() { + (old_line_nr, old_col_nr + 1) } else { (old_line_nr, old_col_nr) } } else { - unreachable!() - }; + (old_line_nr, old_col_nr) + } + } else { + unreachable!() + }; let new_caret_pos = Position { line: line_nr, @@ -165,23 +163,22 @@ pub fn move_caret_up( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = - if old_selection_opt.is_some() && !shift_pressed{ - match old_selection_opt { - Some(old_selection) => (old_selection.start_pos.line, old_selection.start_pos.column), - None => unreachable!(), - } - } else if old_line_nr == 0 { - (old_line_nr, 0) - } else if let Some(prev_line) = lines.get(old_line_nr - 1) { - if prev_line.len() <= old_col_nr { - (old_line_nr - 1, prev_line.len() - 1) - } else { - (old_line_nr - 1, old_col_nr) - } + let (line_nr, col_nr) = if old_selection_opt.is_some() && !shift_pressed { + match old_selection_opt { + Some(old_selection) => (old_selection.start_pos.line, old_selection.start_pos.column), + None => unreachable!(), + } + } else if old_line_nr == 0 { + (old_line_nr, 0) + } else if let Some(prev_line) = lines.get(old_line_nr - 1) { + if prev_line.len() <= old_col_nr { + (old_line_nr - 1, prev_line.len() - 1) } else { - unreachable!() - }; + (old_line_nr - 1, old_col_nr) + } + } else { + unreachable!() + }; let new_caret_pos = Position { line: line_nr, @@ -229,8 +226,7 @@ pub fn move_caret_down( let old_line_nr = old_caret_pos.line; let old_col_nr = old_caret_pos.column; - let (line_nr, col_nr) = - if old_selection_opt.is_some() && !shift_pressed{ + let (line_nr, col_nr) = if old_selection_opt.is_some() && !shift_pressed { match old_selection_opt { Some(old_selection) => (old_selection.end_pos.line, old_selection.end_pos.column), None => unreachable!(), diff --git a/editor/src/vec_result.rs b/editor/src/vec_result.rs index 0d8eb67c8a..202af28a96 100644 --- a/editor/src/vec_result.rs +++ b/editor/src/vec_result.rs @@ -13,4 +13,3 @@ pub fn get_res(index: usize, vec: &[T]) -> EdResult<&