8b91ecd · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

Rename _para to _paragraph

8b91ecdIvan Tham5 years ago

helix-core/src/movement.rs+20−10

compare with master

unifiedsplit

@@ -150,7 +150,12 @@ fn word_move(slice: RopeSlice, range: Range, count: usize, target: WordMotionTar

150 })

151}

152

153−pub fn move_prev_para(slice: RopeSlice, range: Range, count: usize, behavior: Movement) -> Range {

153+pub fn move_prev_paragraph(

154+ slice: RopeSlice,

155+ range: Range,

156+ count: usize,

157+ behavior: Movement,

158+) -> Range {

154 let mut line = range.cursor_line(slice);

159 let mut line = range.cursor_line(slice);

155 let first_char = slice.line_to_char(line) == range.cursor(slice);

160 let first_char = slice.line_to_char(line) == range.cursor(slice);

156 let prev_line_empty = rope_is_line_ending(slice.line(line.saturating_sub(1)));

161 let prev_line_empty = rope_is_line_ending(slice.line(line.saturating_sub(1)));

@@ -187,7 +192,12 @@ pub fn move_prev_para(slice: RopeSlice, range: Range, count: usize, behavior: Mo

187 Range::new(anchor, head)

192 Range::new(anchor, head)

188}

193}

189

194

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

195+pub fn move_next_paragraph(

196+ slice: RopeSlice,

197+ range: Range,

198+ count: usize,

199+ behavior: Movement,

200+) -> Range {

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

201 let mut line = range.cursor_line(slice);

192 let last_char =

202 let last_char =

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

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

@@ -1280,7 +1290,7 @@ mod test {

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

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

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

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

1282 let selection =

1292 let selection =

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

1293+ selection.transform(|r| move_prev_paragraph(text.slice(..), r, 1, Movement::Move));

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

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

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

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

1286 }

1296 }

@@ -1303,7 +1313,7 @@ mod test {

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

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

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

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

1305 let selection =

1315 let selection =

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

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

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

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

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

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

1309 }

1319 }

@@ -1325,8 +1335,8 @@ mod test {

1325 for (before, expected) in tests {

1335 for (before, expected) in tests {

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

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

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

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

1328− let selection =

1338+ let selection = selection

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

1339+ .transform(|r| move_prev_paragraph(text.slice(..), r, 1, Movement::Extend));

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

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

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

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

1332 }

1342 }

@@ -1360,7 +1370,7 @@ mod test {

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

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

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

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

1362 let selection =

1372 let selection =

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

1373+ selection.transform(|r| move_next_paragraph(text.slice(..), r, 1, Movement::Move));

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

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

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

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

1366 }

1376 }

@@ -1383,7 +1393,7 @@ mod test {

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

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

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

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

1385 let selection =

1395 let selection =

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

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

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

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

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

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

1389 }

1399 }

@@ -1405,8 +1415,8 @@ mod test {

1405 for (before, expected) in tests {

1415 for (before, expected) in tests {

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

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

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

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

1408− let selection =

1418+ let selection = selection

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

1419+ .transform(|r| move_next_paragraph(text.slice(..), r, 1, Movement::Extend));

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

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

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

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

1412 }

1422 }

helix-core/src/textobject.rs+7−7

@@ -112,7 +112,7 @@ pub fn textobject_word(

112 }

113}

114

115−pub fn textobject_para(

115+pub fn textobject_paragraph(

116 slice: RopeSlice,

117 range: Range,

118 textobject: TextObject,

@@ -378,8 +378,8 @@ mod test {

378 for (before, expected) in tests {

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

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

381− let selection =

381+ let selection = selection

382− selection.transform(|r| textobject_para(text.slice(..), r, TextObject::Inside, 1));

382+ .transform(|r| textobject_paragraph(text.slice(..), r, TextObject::Inside, 1));

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

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

385 }

@@ -401,8 +401,8 @@ mod test {

401 for (before, expected) in tests {

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

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

404− let selection =

404+ let selection = selection

405− selection.transform(|r| textobject_para(text.slice(..), r, TextObject::Inside, 2));

405+ .transform(|r| textobject_paragraph(text.slice(..), r, TextObject::Inside, 2));

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

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

408 }

@@ -432,8 +432,8 @@ mod test {

432 for (before, expected) in tests {

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

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

435− let selection =

435+ let selection = selection

436− selection.transform(|r| textobject_para(text.slice(..), r, TextObject::Around, 1));

436+ .transform(|r| textobject_paragraph(text.slice(..), r, TextObject::Around, 1));

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

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

439 }

helix-term/src/commands.rs+7−7

@@ -209,8 +209,8 @@ impl MappableCommand {

209 move_next_long_word_start, "Move to beginning of next long word",

210 move_prev_long_word_start, "Move to beginning of previous long word",

211 move_next_long_word_end, "Move to end of next long word",

212− move_prev_para, "Move to previous paragraph",

212+ move_prev_paragraph, "Move to previous paragraph",

213− move_next_para, "Move to next paragraph",

213+ move_next_paragraph, "Move to next paragraph",

214 extend_next_word_start, "Extend to beginning of next word",

215 extend_prev_word_start, "Extend to beginning of previous word",

216 extend_next_long_word_start, "Extend to beginning of next long word",

@@ -924,12 +924,12 @@ where

924 doc.set_selection(view.id, selection);

925}

926

927−fn move_prev_para(cx: &mut Context) {

927+fn move_prev_paragraph(cx: &mut Context) {

928− move_para_impl(cx, movement::move_prev_para)

928+ move_para_impl(cx, movement::move_prev_paragraph)

929}

930

931−fn move_next_para(cx: &mut Context) {

931+fn move_next_paragraph(cx: &mut Context) {

932− move_para_impl(cx, movement::move_next_para)

932+ move_para_impl(cx, movement::move_next_paragraph)

933}

934

935fn goto_file_start(cx: &mut Context) {

@@ -3991,7 +3991,7 @@ fn select_textobject(cx: &mut Context, objtype: textobject::TextObject) {

3991 'f' => textobject_treesitter("function", range),

3992 'a' => textobject_treesitter("parameter", range),

3993 'o' => textobject_treesitter("comment", range),

3994− 'p' => textobject::textobject_para(text, range, objtype, count),

3994+ 'p' => textobject::textobject_paragraph(text, range, objtype, count),

3995 'm' => {

3996 let ch = text.char(range.cursor(text));

3997 if !ch.is_ascii_alphanumeric() {

helix-term/src/keymap/default.rs+2−2

@@ -104,7 +104,7 @@ pub fn default() -> HashMap<Mode, Keymap> {

104 "c" => goto_prev_class,

105 "a" => goto_prev_parameter,

106 "o" => goto_prev_comment,

107− "p" => move_prev_para,

107+ "p" => move_prev_paragraph,

108 "space" => add_newline_above,

109 },

110 "]" => { "Right bracket"

@@ -114,7 +114,7 @@ pub fn default() -> HashMap<Mode, Keymap> {

114 "c" => goto_next_class,

115 "a" => goto_next_parameter,

116 "o" => goto_next_comment,

117− "p" => move_next_para,

117+ "p" => move_next_paragraph,

118 "space" => add_newline_below,

119 },

120