fd684ef · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

Revert display-width-based vertical cursor movement.

fd684efNathan Vegdahl5 years ago

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

compare with master

unifiedsplit

@@ -521,16 +521,14 @@ mod test {

521 V,

522 }

523 let moves_and_expected_coordinates = IntoIter::new([

524− // Places cursor at the fourth kana (each of which are double-wide,

524+ // Places cursor at the fourth kana.

525− // so the visual column is 8).

526− ((Axis::H, Direction::Forward, 4), (0, 8)),

525+ ((Axis::H, Direction::Forward, 4), (0, 4)),

527− // Descent places cursor at the 8th character.

526+ // Descent places cursor at the 4th character.

528− ((Axis::V, Direction::Forward, 1usize), (1, 8)),

527+ ((Axis::V, Direction::Forward, 1usize), (1, 4)),

529− // Moving back a single-width character.

528+ // Moving back 1 character.

530− ((Axis::H, Direction::Backward, 1usize), (1, 7)),

529+ ((Axis::H, Direction::Backward, 1usize), (1, 3)),

531− // Jumping back up into the middle of a double-width character shifts

530+ // Jumping back up 1 line.

532− // the column to the start of that character.

533− ((Axis::V, Direction::Backward, 1usize), (0, 6)),

531+ ((Axis::V, Direction::Backward, 1usize), (0, 3)),

534 ]);

532 ]);

535

533

536 for ((axis, direction, amount), coordinates) in moves_and_expected_coordinates {

534 for ((axis, direction, amount), coordinates) in moves_and_expected_coordinates {

helix-core/src/position.rs+49−40

@@ -1,8 +1,6 @@

1−use std::borrow::Cow;

2−

3use crate::{

1use crate::{

4 chars::char_is_line_ending,

2 chars::char_is_line_ending,

5− graphemes::{ensure_grapheme_boundary_prev, grapheme_width, RopeGraphemes},

3+ graphemes::{ensure_grapheme_boundary_prev, RopeGraphemes},

6 line_ending::line_end_char_index,

4 line_ending::line_end_char_index,

7 RopeSlice,

5 RopeSlice,

8};

6};

@@ -66,12 +64,7 @@ pub fn coords_at_pos(text: RopeSlice, pos: usize) -> Position {

67 let line_start = text.line_to_char(line);

65 let line_start = text.line_to_char(line);

68 let pos = ensure_grapheme_boundary_prev(text, pos);

66 let pos = ensure_grapheme_boundary_prev(text, pos);

69− let col = RopeGraphemes::new(text.slice(line_start..pos))

67+ let col = RopeGraphemes::new(text.slice(line_start..pos)).count();

70− .map(|g| {

71− let g: Cow<str> = g.into();

72− grapheme_width(&g)

73− })

74− .sum();

76 Position::new(line, col)

69 Position::new(line, col)

77}

70}

@@ -83,6 +76,9 @@ pub fn coords_at_pos(text: RopeSlice, pos: usize) -> Position {

83/// `false` corresponds to properly round-tripping with `coords_at_pos()`,

76/// `false` corresponds to properly round-tripping with `coords_at_pos()`,

84/// whereas `true` will ensure that block cursors don't jump off the

77/// whereas `true` will ensure that block cursors don't jump off the

85/// end of the line.

78/// end of the line.

79+///

80+/// TODO: this should be changed to work in terms of visual row/column, not

81+/// graphemes.

86pub fn pos_at_coords(text: RopeSlice, coords: Position, is_1_width: bool) -> usize {

82pub fn pos_at_coords(text: RopeSlice, coords: Position, is_1_width: bool) -> usize {

87 let Position { row, col } = coords;

83 let Position { row, col } = coords;

88 let line_start = text.line_to_char(row);

84 let line_start = text.line_to_char(row);

@@ -92,17 +88,11 @@ pub fn pos_at_coords(text: RopeSlice, coords: Position, is_1_width: bool) -> usi

92 text.line_to_char((row + 1).min(text.len_lines()))

88 text.line_to_char((row + 1).min(text.len_lines()))

93 };

89 };

95− let mut prev_col = 0;

96 let mut col_char_offset = 0;

91 let mut col_char_offset = 0;

97− for g in RopeGraphemes::new(text.slice(line_start..line_end)) {

92+ for (i, g) in RopeGraphemes::new(text.slice(line_start..line_end)).enumerate() {

98− let g: Cow<str> = g.into();

99− let next_col = prev_col + grapheme_width(&g);

100−

101− if next_col > col {

93+ if i == col {

102 break;

94 break;

103 }

95 }

104−

105− prev_col = next_col;

106 col_char_offset += g.chars().count();

96 col_char_offset += g.chars().count();

107 }

97 }

108

@@ -131,17 +121,18 @@ mod test {

131 assert_eq!(coords_at_pos(slice, 10), (1, 4).into()); // position on d

121 assert_eq!(coords_at_pos(slice, 10), (1, 4).into()); // position on d

132

122

133 // Test with wide characters.

123 // Test with wide characters.

124+ // TODO: account for character width.

134 let text = Rope::from("今日はいい\n");

125 let text = Rope::from("今日はいい\n");

135 let slice = text.slice(..);

126 let slice = text.slice(..);

136 assert_eq!(coords_at_pos(slice, 0), (0, 0).into());

127 assert_eq!(coords_at_pos(slice, 0), (0, 0).into());

137− assert_eq!(coords_at_pos(slice, 1), (0, 2).into());

128+ assert_eq!(coords_at_pos(slice, 1), (0, 1).into());

138− assert_eq!(coords_at_pos(slice, 2), (0, 4).into());

129+ assert_eq!(coords_at_pos(slice, 2), (0, 2).into());

139− assert_eq!(coords_at_pos(slice, 3), (0, 6).into());

130+ assert_eq!(coords_at_pos(slice, 3), (0, 3).into());

140− assert_eq!(coords_at_pos(slice, 4), (0, 8).into());

131+ assert_eq!(coords_at_pos(slice, 4), (0, 4).into());

141− assert_eq!(coords_at_pos(slice, 5), (0, 10).into());

132+ assert_eq!(coords_at_pos(slice, 5), (0, 5).into());

142 assert_eq!(coords_at_pos(slice, 6), (1, 0).into());

133 assert_eq!(coords_at_pos(slice, 6), (1, 0).into());

143

134

144− // test with grapheme clusters

135+ // Test with grapheme clusters.

145 let text = Rope::from("a̐éö̲\r\n");

136 let text = Rope::from("a̐éö̲\r\n");

146 let slice = text.slice(..);

137 let slice = text.slice(..);

147 assert_eq!(coords_at_pos(slice, 0), (0, 0).into());

138 assert_eq!(coords_at_pos(slice, 0), (0, 0).into());

@@ -150,13 +141,23 @@ mod test {

150 assert_eq!(coords_at_pos(slice, 7), (0, 3).into());

141 assert_eq!(coords_at_pos(slice, 7), (0, 3).into());

151 assert_eq!(coords_at_pos(slice, 9), (1, 0).into());

142 assert_eq!(coords_at_pos(slice, 9), (1, 0).into());

152

143

144+ // Test with wide-character grapheme clusters.

145+ // TODO: account for character width.

153 let text = Rope::from("किमपि\n");

146 let text = Rope::from("किमपि\n");

154 let slice = text.slice(..);

147 let slice = text.slice(..);

155 assert_eq!(coords_at_pos(slice, 0), (0, 0).into());

148 assert_eq!(coords_at_pos(slice, 0), (0, 0).into());

156− assert_eq!(coords_at_pos(slice, 2), (0, 2).into());

149+ assert_eq!(coords_at_pos(slice, 2), (0, 1).into());

157− assert_eq!(coords_at_pos(slice, 3), (0, 3).into());

150+ assert_eq!(coords_at_pos(slice, 3), (0, 2).into());

158− assert_eq!(coords_at_pos(slice, 5), (0, 5).into());

151+ assert_eq!(coords_at_pos(slice, 5), (0, 3).into());

159 assert_eq!(coords_at_pos(slice, 6), (1, 0).into());

152 assert_eq!(coords_at_pos(slice, 6), (1, 0).into());

153+

154+ // Test with tabs.

155+ // Todo: account for tab stops.

156+ let text = Rope::from("\tHello\n");

157+ let slice = text.slice(..);

158+ assert_eq!(coords_at_pos(slice, 0), (0, 0).into());

159+ assert_eq!(coords_at_pos(slice, 1), (0, 1).into());

160+ assert_eq!(coords_at_pos(slice, 2), (0, 2).into());

160 }

161 }

161

162

162 #[test]

163 #[test]

@@ -172,21 +173,20 @@ mod test {

172 assert_eq!(pos_at_coords(slice, (1, 4).into(), false), 10); // position on d

173 assert_eq!(pos_at_coords(slice, (1, 4).into(), false), 10); // position on d

173

174

174 // Test with wide characters.

175 // Test with wide characters.

176+ // TODO: account for character width.

175 let text = Rope::from("今日はいい\n");

177 let text = Rope::from("今日はいい\n");

176 let slice = text.slice(..);

178 let slice = text.slice(..);

177 assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);

179 assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);

178− assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 0);

180+ assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 1);

179− assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 1);

181+ assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 2);

180− assert_eq!(pos_at_coords(slice, (0, 3).into(), false), 1);

182+ assert_eq!(pos_at_coords(slice, (0, 3).into(), false), 3);

181− assert_eq!(pos_at_coords(slice, (0, 4).into(), false), 2);

183+ assert_eq!(pos_at_coords(slice, (0, 4).into(), false), 4);

182− assert_eq!(pos_at_coords(slice, (0, 6).into(), false), 3);

183− assert_eq!(pos_at_coords(slice, (0, 8).into(), false), 4);

184− assert_eq!(pos_at_coords(slice, (0, 10).into(), false), 5);

184+ assert_eq!(pos_at_coords(slice, (0, 5).into(), false), 5);

185− assert_eq!(pos_at_coords(slice, (0, 11).into(), false), 6);

185+ assert_eq!(pos_at_coords(slice, (0, 6).into(), false), 6);

186− assert_eq!(pos_at_coords(slice, (0, 11).into(), true), 5);

186+ assert_eq!(pos_at_coords(slice, (0, 6).into(), true), 5);

187 assert_eq!(pos_at_coords(slice, (1, 0).into(), false), 6);

188

189− // test with grapheme clusters

189+ // Test with grapheme clusters.

190 let text = Rope::from("a̐éö̲\r\n");

191 let slice = text.slice(..);

192 assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);

@@ -197,15 +197,24 @@ mod test {

197 assert_eq!(pos_at_coords(slice, (0, 4).into(), true), 7);

198 assert_eq!(pos_at_coords(slice, (1, 0).into(), false), 9);

199

200+ // Test with wide-character grapheme clusters.

201+ // TODO: account for character width.

200 let text = Rope::from("किमपि");

202 let text = Rope::from("किमपि");

201 // 2 - 1 - 2 codepoints

203 // 2 - 1 - 2 codepoints

202 // TODO: delete handling as per https://news.ycombinator.com/item?id=20058454

204 // TODO: delete handling as per https://news.ycombinator.com/item?id=20058454

203 let slice = text.slice(..);

205 let slice = text.slice(..);

204 assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);

206 assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);

205− assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 0);

207+ assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 2);

208+ assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 3);

209+ assert_eq!(pos_at_coords(slice, (0, 3).into(), false), 5);

210+ assert_eq!(pos_at_coords(slice, (0, 3).into(), true), 5);

211+

212+ // Test with tabs.

213+ // Todo: account for tab stops.

214+ let text = Rope::from("\tHello\n");

215+ let slice = text.slice(..);

216+ assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);

217+ assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 1);

206 assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 2);

218 assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 2);

207− assert_eq!(pos_at_coords(slice, (0, 3).into(), false), 3);

208− assert_eq!(pos_at_coords(slice, (0, 4).into(), false), 3);

209− assert_eq!(pos_at_coords(slice, (0, 5).into(), false), 5); // eol

210 }

219 }

211}

220}