64afd54 · helix · git.iko.soy

45

46impl DateIncrementor {

47 pub fn from_range(text: RopeSlice, range: Range) -> Option<DateIncrementor> {

48+ let range = if range.is_empty() {

49+ if range.anchor < text.len_bytes() {

50+ // Treat empty range as a cursor range.

51+ range.put_cursor(text, range.anchor + 1, true)

52+ } else {

53+ // The range is empty and at the end of the text.

54+ return None;

55+ }

56+ } else {

57+ range

58+ };

59+

48 let from = range.from().saturating_sub(DATE_LENGTH);

60 let from = range.from().saturating_sub(DATE_LENGTH);

49 let to = (range.from() + DATE_LENGTH).min(text.len_chars());

61 let to = (range.from() + DATE_LENGTH).min(text.len_chars());

62+

50 let (from_in_text, to_in_text) = (range.from() - from, range.to() - from);

63 let (from_in_text, to_in_text) = (range.from() - from, range.to() - from);

51 let text: Cow<str> = text.slice(from..to).into();

64 let text: Cow<str> = text.slice(from..to).into();

52

65

58 let offset = range.from() - from_in_text;

71 let offset = range.from() - from_in_text;

59 let range = Range::new(date.start() + offset, date.end() + offset);

72 let range = Range::new(date.start() + offset, date.end() + offset);

60

73

61− let year = captures.get(1)?;

74+ let (year, month, day) = (captures.get(1)?, captures.get(2)?, captures.get(3)?);

62− let month = captures.get(2)?;

63− let day = captures.get(3)?;

64−

65− let year_range = year.range();

66− let month_range = month.range();

67− let day_range = day.range();

75+ let (year_range, month_range, day_range) = (year.range(), month.range(), day.range());

68

76

69− let to_inclusive = if to_in_text > from_in_text {

70− to_in_text - 1

71− } else {

72− to_in_text

73− };

74− let field = if year_range.contains(&from_in_text) && year_range.contains(&to_inclusive)

77+ let field = if year_range.contains(&from_in_text)

78+ && year_range.contains(&(to_in_text - 1))

75 {

79 {

76 DateField::Year

80 DateField::Year

77− } else if month_range.contains(&from_in_text) && month_range.contains(&to_inclusive) {

81+ } else if month_range.contains(&from_in_text) && month_range.contains(&(to_in_text - 1))

82+ {

78 DateField::Month

83 DateField::Month

79− } else if day_range.contains(&from_in_text) && day_range.contains(&to_inclusive) {

84+ } else if day_range.contains(&from_in_text) && day_range.contains(&(to_in_text - 1)) {

80 DateField::Day

85 DateField::Day

81 } else {

86 } else {

82 return None;

87 return None;

83 };

88 };

84

89

85− let year: i16 = year.as_str().parse().ok()?;

86− let month: u8 = month.as_str().parse().ok()?;

87− let day: u8 = day.as_str().parse().ok()?;

88−

89− let date = Date::new(year, month, day).ok()?;

90+ let date = Date::new(

91+ year.as_str().parse::<i16>().ok()?,

92+ month.as_str().parse::<u8>().ok()?,

93+ day.as_str().parse::<u8>().ok()?,

94+ )

95+ .ok()?;

90

96

91 Some(DateIncrementor {

97 Some(DateIncrementor {

92 date,

98 date,

131 fn test_create_incrementor_for_year_with_dashes() {

137 fn test_create_incrementor_for_year_with_dashes() {

132 let rope = Rope::from_str("2021-11-15");

138 let rope = Rope::from_str("2021-11-15");

133

139

134− for head in 0..=3 {

140+ for cursor in 0..=3 {

135− let range = Range::point(head);

141+ let range = Range::new(cursor, cursor + 1);

136 assert_eq!(

142 assert_eq!(

137 DateIncrementor::from_range(rope.slice(..), range),

143 DateIncrementor::from_range(rope.slice(..), range),

138 Some(DateIncrementor {

144 Some(DateIncrementor {

149 fn test_create_incrementor_for_month_with_dashes() {

155 fn test_create_incrementor_for_month_with_dashes() {

150 let rope = Rope::from_str("2021-11-15");

156 let rope = Rope::from_str("2021-11-15");

151

157

152− for head in 5..=6 {

158+ for cursor in 5..=6 {

153− let range = Range::point(head);

159+ let range = Range::new(cursor, cursor + 1);

154 assert_eq!(

160 assert_eq!(

155 DateIncrementor::from_range(rope.slice(..), range),

161 DateIncrementor::from_range(rope.slice(..), range),

156 Some(DateIncrementor {

162 Some(DateIncrementor {

167 fn test_create_incrementor_for_day_with_dashes() {

173 fn test_create_incrementor_for_day_with_dashes() {

168 let rope = Rope::from_str("2021-11-15");

174 let rope = Rope::from_str("2021-11-15");

169

175

170− for head in 8..=9 {

176+ for cursor in 8..=9 {

171− let range = Range::point(head);

177+ let range = Range::new(cursor, cursor + 1);

172 assert_eq!(

178 assert_eq!(

173 DateIncrementor::from_range(rope.slice(..), range),

179 DateIncrementor::from_range(rope.slice(..), range),

174 Some(DateIncrementor {

180 Some(DateIncrementor {

185 fn test_try_create_incrementor_on_dashes() {

191 fn test_try_create_incrementor_on_dashes() {

186 let rope = Rope::from_str("2021-11-15");

192 let rope = Rope::from_str("2021-11-15");

187

193

188− for head in &[4, 7] {

194+ for &cursor in &[4, 7] {

189− let range = Range::point(*head);

195+ let range = Range::new(cursor, cursor + 1);

190 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None,);

196 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None,);

191 }

197 }

192 }

198 }

195 fn test_create_incrementor_for_year_with_slashes() {

201 fn test_create_incrementor_for_year_with_slashes() {

196 let rope = Rope::from_str("2021/11/15");

202 let rope = Rope::from_str("2021/11/15");

197

203

198− for head in 0..=3 {

204+ for cursor in 0..=3 {

199− let range = Range::point(head);

205+ let range = Range::new(cursor, cursor + 1);

200 assert_eq!(

206 assert_eq!(

201 DateIncrementor::from_range(rope.slice(..), range),

207 DateIncrementor::from_range(rope.slice(..), range),

202 Some(DateIncrementor {

208 Some(DateIncrementor {

213 fn test_create_incrementor_for_month_with_slashes() {

219 fn test_create_incrementor_for_month_with_slashes() {

214 let rope = Rope::from_str("2021/11/15");

220 let rope = Rope::from_str("2021/11/15");

215

221

216− for head in 5..=6 {

222+ for cursor in 5..=6 {

217− let range = Range::point(head);

223+ let range = Range::new(cursor, cursor + 1);

218 assert_eq!(

224 assert_eq!(

219 DateIncrementor::from_range(rope.slice(..), range),

225 DateIncrementor::from_range(rope.slice(..), range),

220 Some(DateIncrementor {

226 Some(DateIncrementor {

231 fn test_create_incrementor_for_day_with_slashes() {

237 fn test_create_incrementor_for_day_with_slashes() {

232 let rope = Rope::from_str("2021/11/15");

238 let rope = Rope::from_str("2021/11/15");

233

239

234− for head in 8..=9 {

240+ for cursor in 8..=9 {

235− let range = Range::point(head);

241+ let range = Range::new(cursor, cursor + 1);

236 assert_eq!(

242 assert_eq!(

237 DateIncrementor::from_range(rope.slice(..), range),

243 DateIncrementor::from_range(rope.slice(..), range),

238 Some(DateIncrementor {

244 Some(DateIncrementor {

249 fn test_try_create_incrementor_on_slashes() {

255 fn test_try_create_incrementor_on_slashes() {

250 let rope = Rope::from_str("2021/11/15");

256 let rope = Rope::from_str("2021/11/15");

251

257

252− for head in &[4, 7] {

258+ for &cursor in &[4, 7] {

253− let range = Range::point(*head);

259+ let range = Range::new(cursor, cursor + 1);

254 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None,);

260 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None,);

255 }

261 }

256 }

262 }

258 #[test]

264 #[test]

259 fn test_date_surrounded_by_spaces() {

265 fn test_date_surrounded_by_spaces() {

260 let rope = Rope::from_str(" 2021-11-15 ");

266 let rope = Rope::from_str(" 2021-11-15 ");

261− let range = Range::point(3);

267+ let range = Range::new(3, 4);

262 assert_eq!(

268 assert_eq!(

263 DateIncrementor::from_range(rope.slice(..), range),

269 DateIncrementor::from_range(rope.slice(..), range),

264 Some(DateIncrementor {

270 Some(DateIncrementor {

273 #[test]

279 #[test]

274 fn test_date_in_single_quotes() {

280 fn test_date_in_single_quotes() {

275 let rope = Rope::from_str("date = '2021-11-15'");

281 let rope = Rope::from_str("date = '2021-11-15'");

276− let range = Range::point(10);

282+ let range = Range::new(10, 11);

277 assert_eq!(

283 assert_eq!(

278 DateIncrementor::from_range(rope.slice(..), range),

284 DateIncrementor::from_range(rope.slice(..), range),

279 Some(DateIncrementor {

285 Some(DateIncrementor {

288 #[test]

294 #[test]

289 fn test_date_in_double_quotes() {

295 fn test_date_in_double_quotes() {

290 let rope = Rope::from_str("let date = \"2021-11-15\";");

296 let rope = Rope::from_str("let date = \"2021-11-15\";");

291− let range = Range::point(12);

297+ let range = Range::new(12, 13);

292 assert_eq!(

298 assert_eq!(

293 DateIncrementor::from_range(rope.slice(..), range),

299 DateIncrementor::from_range(rope.slice(..), range),

294 Some(DateIncrementor {

300 Some(DateIncrementor {

303 #[test]

309 #[test]

304 fn test_date_cursor_one_right_of_date() {

310 fn test_date_cursor_one_right_of_date() {

305 let rope = Rope::from_str("2021-11-15 ");

311 let rope = Rope::from_str("2021-11-15 ");

306− let range = Range::point(10);

312+ let range = Range::new(10, 11);

307 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None);

313 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None);

308 }

314 }

309

315

310 #[test]

316 #[test]

311 fn test_date_cursor_one_left_of_number() {

317 fn test_date_cursor_one_left_of_number() {

312 let rope = Rope::from_str(" 2021-11-15");

318 let rope = Rope::from_str(" 2021-11-15");

319+ let range = Range::new(0, 1);

320+ assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None);

321+ }

322+

323+ #[test]

324+ fn test_date_empty_range_at_beginning() {

325+ let rope = Rope::from_str("2021-11-15");

313 let range = Range::point(0);

326 let range = Range::point(0);

327+ assert_eq!(

328+ DateIncrementor::from_range(rope.slice(..), range),

329+ Some(DateIncrementor {

330+ date: Date::new(2021, 11, 15).unwrap(),

331+ range: Range::new(0, 10),

332+ field: DateField::Year,

333+ format: FORMATS[0],

334+ })

335+ );

336+ }

337+

338+ #[test]

339+ fn test_date_empty_range_at_in_middle() {

340+ let rope = Rope::from_str("2021-11-15");

341+ let range = Range::point(5);

342+ assert_eq!(

343+ DateIncrementor::from_range(rope.slice(..), range),

344+ Some(DateIncrementor {

345+ date: Date::new(2021, 11, 15).unwrap(),

346+ range: Range::new(0, 10),

347+ field: DateField::Month,

348+ format: FORMATS[0],

349+ })

350+ );

351+ }

352+

353+ #[test]

354+ fn test_date_empty_range_at_end() {

355+ let rope = Rope::from_str("2021-11-15");

356+ let range = Range::point(10);

314 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None);

357 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None);

315 }

358 }

316

359

337

380

338 for invalid in tests {

381 for invalid in tests {

339 let rope = Rope::from_str(invalid);

382 let rope = Rope::from_str(invalid);

340− let range = Range::point(0);

383+ let range = Range::new(0, 1);

341

384

342 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None);

385 assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None);

343 }

386 }

367

410

368 for (original, cursor, amount, expected) in tests {

411 for (original, cursor, amount, expected) in tests {

369 let rope = Rope::from_str(original);

412 let rope = Rope::from_str(original);

370− let range = Range::point(cursor);

413+ let range = Range::new(cursor, cursor + 1);

371 assert_eq!(

414 assert_eq!(

372 DateIncrementor::from_range(rope.slice(..), range)

415 DateIncrementor::from_range(rope.slice(..), range)

373 .unwrap()

416 .unwrap()