e2a6e33 · helix · git.iko.soy

10 next_grapheme_boundary, nth_next_grapheme_boundary, nth_prev_grapheme_boundary,

11 prev_grapheme_boundary,

12 },

13− line_ending::{rope_is_line_ending, str_is_line_ending},

13+ line_ending::rope_is_line_ending,

14 pos_at_coords,

15 syntax::LanguageConfiguration,

16 textobject::TextObject,

188}

189

190pub fn move_next_para(slice: RopeSlice, range: Range, count: usize, behavior: Movement) -> Range {

191− let mut line = slice.char_to_line(range.head);

191+ let mut line = range.cursor_line(slice);

192+ let last_char =

193+ prev_grapheme_boundary(slice, slice.line_to_char(line + 1)) == range.cursor(slice);

194+ let curr_line_empty = rope_is_line_ending(slice.line(line));

195+ let next_line_empty = rope_is_line_ending(slice.line(line.saturating_sub(1)));

196+ let empty_to_line = curr_line_empty && !next_line_empty;

197+

198+ // iterate current line if first character after paragraph boundary

199+ if empty_to_line && last_char {

200+ line += 1;

201+ }

202+

192− let lines = slice.lines_at(line);

203+ let mut lines = slice.lines_at(line).map(rope_is_line_ending).peekable();

193− let mut lines = lines.map(|l| l.chunks().all(str_is_line_ending)).peekable();

194 for _ in 0..count {

204 for _ in 0..count {

195 while lines.next_if(|&e| !e).is_some() {

205 while lines.next_if(|&e| !e).is_some() {

196 line += 1;

206 line += 1;

199 line += 1;

209 line += 1;

200 }

210 }

201 }

211 }

212+ let head = slice.line_to_char(line);

202 let anchor = if behavior == Movement::Move {

213 let anchor = if behavior == Movement::Move {

214+ if empty_to_line && last_char {

215+ range.head

216+ } else {

203− range.cursor(slice)

217+ range.cursor(slice)

218+ }

204 } else {

219 } else {

205− range.anchor

220+ range.put_cursor(slice, head, true).anchor

206 };

221 };

207− Range::new(anchor, slice.line_to_char(line))

222+ Range::new(anchor, head)

208}

223}

209

224

210// ---- util ------------

225// ---- util ------------

1253 ),

1268 ),

1254 ];

1269 ];

1255

1270

1256− for (actual, expected) in tests {

1271+ for (before, expected) in tests {

1257− let (s, selection) = crate::test::print(actual);

1272+ let (s, selection) = crate::test::print(before);

1258 let text = Rope::from(s.as_str());

1273 let text = Rope::from(s.as_str());

1259 let selection =

1274 let selection =

1260 selection.transform(|r| move_prev_para(text.slice(..), r, 1, Movement::Move));

1275 selection.transform(|r| move_prev_para(text.slice(..), r, 1, Movement::Move));

1261 let actual = crate::test::plain(&s, selection);

1276 let actual = crate::test::plain(&s, selection);

1262− assert_eq!(actual, expected);

1277+ assert_eq!(actual, expected, "\nbefore: `{before:?}`");

1263 }

1278 }

1264 }

1279 }

1265

1280

1266− #[ignore]

1267 #[test]

1281 #[test]

1268− fn test_behaviour_when_moving_to_prev_paragraph_double() {}

1282+ fn test_behaviour_when_moving_to_prev_paragraph_double() {

1283+ let tests = [

1284+ ("on^e@\n\ntwo\n\nthree\n\n", "@one^\n\ntwo\n\nthree\n\n"),

1285+ ("one\n\ntwo\n\nth^r@ee\n\n", "one\n\n@two\n\nthr^ee\n\n"),

1286+ ];

1287+

1288+ for (before, expected) in tests {

1289+ let (s, selection) = crate::test::print(before);

1290+ let text = Rope::from(s.as_str());

1291+ let selection =

1292+ selection.transform(|r| move_prev_para(text.slice(..), r, 2, Movement::Move));

1293+ let actual = crate::test::plain(&s, selection);

1294+ assert_eq!(actual, expected, "\nbefore: `{before:?}`");

1295+ }

1296+ }

1297+

1298+ #[test]

1299+ fn test_behaviour_when_moving_to_prev_paragraph_extend() {

1300+ let tests = [

1301+ ("one\n\n@two\n\n^three\n\n", "@one\n\ntwo\n\n^three\n\n"),

1302+ ("@one\n\ntwo\n\n^three\n\n", "@one\n\ntwo\n\n^three\n\n"),

1303+ ];

1304+

1305+ for (before, expected) in tests {

1306+ let (s, selection) = crate::test::print(before);

1307+ let text = Rope::from(s.as_str());

1308+ let selection =

1309+ selection.transform(|r| move_prev_para(text.slice(..), r, 1, Movement::Extend));

1310+ let actual = crate::test::plain(&s, selection);

1311+ assert_eq!(actual, expected, "\nbefore: `{before:?}`");

1312+ }

1313+ }

1269

1314

1270 #[test]

1315 #[test]

1271 fn test_behaviour_when_moving_to_next_paragraph_single() {

1316 fn test_behaviour_when_moving_to_next_paragraph_single() {

1291 ),

1336 ),

1292 ];

1337 ];

1293

1338

1294− for (actual, expected) in tests {

1339+ for (before, expected) in tests {

1295− let (s, selection) = crate::test::print(actual);

1340+ let (s, selection) = crate::test::print(before);

1296 let text = Rope::from(s.as_str());

1341 let text = Rope::from(s.as_str());

1297 let selection =

1342 let selection =

1298 selection.transform(|r| move_next_para(text.slice(..), r, 1, Movement::Move));

1343 selection.transform(|r| move_next_para(text.slice(..), r, 1, Movement::Move));

1299 let actual = crate::test::plain(&s, selection);

1344 let actual = crate::test::plain(&s, selection);

1300− assert_eq!(actual, expected);

1345+ assert_eq!(actual, expected, "\nbefore: `{before:?}`");

1346+ }

1347+ }

1348+

1349+ #[test]

1350+ fn test_behaviour_when_moving_to_next_paragraph_double() {

1351+ let tests = [

1352+ ("one\n\ntwo\n\nth^r@ee\n\n", "one\n\ntwo\n\nth^ree\n\n@"),

1353+ ("on^e@\n\ntwo\n\nthree\n\n", "on^e\n\ntwo\n\n@three\n\n"),

1354+ ];

1355+

1356+ for (before, expected) in tests {

1357+ let (s, selection) = crate::test::print(before);

1358+ let text = Rope::from(s.as_str());

1359+ let selection =

1360+ selection.transform(|r| move_next_para(text.slice(..), r, 2, Movement::Move));

1361+ let actual = crate::test::plain(&s, selection);

1362+ assert_eq!(actual, expected, "\nbefore: `{before:?}`");

1363+ }

1364+ }

1365+

1366+ #[test]

1367+ fn test_behaviour_when_moving_to_next_paragraph_extend() {

1368+ let tests = [

1369+ ("one\n\n^two\n\n@three\n\n", "one\n\n^two\n\nthree\n\n@"),

1370+ ("one\n\n^two\n\nthree\n\n@", "one\n\n^two\n\nthree\n\n@"),

1371+ ];

1372+

1373+ for (before, expected) in tests {

1374+ let (s, selection) = crate::test::print(before);

1375+ let text = Rope::from(s.as_str());

1376+ let selection =

1377+ selection.transform(|r| move_next_para(text.slice(..), r, 1, Movement::Extend));

1378+ let actual = crate::test::plain(&s, selection);

1379+ assert_eq!(actual, expected, "\nbefore: `{before:?}`");

1301 }

1380 }

1302 }

1381 }

1303}

1382}