Skip to content

Commit a3981ea

Browse files
riotrahriotrah
committed
Post forward or up commands rebase fixes; multi cursor seems to work!
1 parent 6e2123d commit a3981ea

File tree

3 files changed

+153
-96
lines changed

3 files changed

+153
-96
lines changed

‎src/cursor-doc/paredit.ts

Lines changed: 127 additions & 70 deletions
Original file line numberDiff line numberDiff line change
@@ -91,12 +91,14 @@ export function selectRight(doc: EditableDocument) {
9191
}
9292

9393
export function selectForwardSexpOrUp(doc: EditableDocument) {
94-
const rangeFn =
95-
doc.selection.active >= doc.selection.anchor
96-
? forwardSexpOrUpRange
97-
: (doc: EditableDocument) => forwardSexpOrUpRange(doc, doc.selection.active, true);
98-
99-
selectRangeForward(doc, rangeFn(doc));
94+
const ranges = doc.selections.map((selection) => {
95+
const rangeFn =
96+
selection.active >= selection.anchor
97+
? (doc) => forwardSexpOrUpRange(doc, selection.end)
98+
: (doc: EditableDocument) => forwardSexpOrUpRange(doc, selection.active, true);
99+
return rangeFn(doc);
100+
});
101+
selectRangeForward(doc, ranges);
100102
}
101103

102104
export function selectBackwardSexp(doc: EditableDocument) {
@@ -147,11 +149,14 @@ export function selectBackwardUpSexp(doc: EditableDocument) {
147149
}
148150

149151
export function selectBackwardSexpOrUp(doc: EditableDocument) {
150-
const rangeFn =
151-
doc.selection.active <= doc.selection.anchor
152-
? (doc: EditableDocument) => backwardSexpOrUpRange(doc, doc.selection.active, false)
153-
: (doc: EditableDocument) => backwardSexpOrUpRange(doc, doc.selection.active, false);
154-
selectRangeBackward(doc, rangeFn(doc));
152+
const ranges = doc.selections.map((selection) => {
153+
const rangeFn =
154+
selection.active <= selection.anchor
155+
? (doc: EditableDocument) => backwardSexpOrUpRange(doc, selection.active, false)
156+
: (doc: EditableDocument) => backwardSexpOrUpRange(doc, selection.active, false);
157+
return rangeFn(doc);
158+
});
159+
selectRangeBackward(doc, ranges);
155160
}
156161

157162
export function selectCloseList(doc: EditableDocument) {
@@ -197,92 +202,120 @@ enum GoUpSexpOption {
197202
*/
198203
function _forwardSexpRange(
199204
doc: EditableDocument,
200-
offset = Math.max(doc.selection.anchor, doc.selection.active),
205+
offsets = doc.selections.map((s) => s.end),
201206
goUpSexp: GoUpSexpOption,
202207
goPastWhitespace = false
203-
): [number, number] {
204-
const cursor = doc.getTokenCursor(offset);
208+
): Array<[number, number]> {
209+
return offsets.map((offset) => {
210+
const cursor = doc.getTokenCursor(offset);
205211

206-
if (goUpSexp == GoUpSexpOption.Never || goUpSexp == GoUpSexpOption.WhenAtLimit) {
207-
// Normalize our position by scooting to the beginning of the closest sexp
208-
cursor.forwardWhitespace();
212+
if (goUpSexp == GoUpSexpOption.Never || goUpSexp == GoUpSexpOption.WhenAtLimit) {
213+
// Normalize our position by scooting to the beginning of the closest sexp
214+
cursor.forwardWhitespace();
209215

210-
if (cursor.forwardSexp(true, true)) {
211-
if (goPastWhitespace) {
212-
cursor.forwardWhitespace();
216+
if (cursor.forwardSexp(true, true)) {
217+
if (goPastWhitespace) {
218+
cursor.forwardWhitespace();
219+
}
220+
return [offset, cursor.offsetStart];
213221
}
214-
return [offset, cursor.offsetStart];
215222
}
216-
}
217223

218-
if (goUpSexp == GoUpSexpOption.Required || goUpSexp == GoUpSexpOption.WhenAtLimit) {
219-
cursor.forwardList();
220-
if (cursor.upList()) {
221-
if (goPastWhitespace) {
222-
cursor.forwardWhitespace();
224+
if (goUpSexp == GoUpSexpOption.Required || goUpSexp == GoUpSexpOption.WhenAtLimit) {
225+
cursor.forwardList();
226+
if (cursor.upList()) {
227+
if (goPastWhitespace) {
228+
cursor.forwardWhitespace();
229+
}
230+
return [offset, cursor.offsetStart];
223231
}
224-
return [offset, cursor.offsetStart];
225232
}
226-
}
227-
return [offset, offset];
233+
return [offset, offset];
234+
});
228235
}
229236

230237
/**
231238
* Return a modified selection range on doc. Moves the left limit around sexps, potentially moving up.
232239
*/
233240
function _backwardSexpRange(
234241
doc: EditableDocument,
235-
offset: number = Math.min(doc.selection.anchor, doc.selection.active),
242+
offsets: number[] = doc.selections.map((s) => s.start),
236243
goUpSexp: GoUpSexpOption,
237244
goPastWhitespace = false
238-
): [number, number] {
239-
const cursor = doc.getTokenCursor(offset);
240-
241-
if (goUpSexp == GoUpSexpOption.Never || goUpSexp == GoUpSexpOption.WhenAtLimit) {
242-
if (!cursor.isWhiteSpace() && cursor.offsetStart < offset) {
243-
// This is because cursor.backwardSexp() can't move backwards when "on" the first sexp inside a list
244-
// TODO: Try to fix this in LispTokenCursor instead.
245-
cursor.forwardSexp();
246-
}
247-
cursor.backwardWhitespace();
245+
): Array<[number, number]> {
246+
return offsets.map((offset) => {
247+
const cursor = doc.getTokenCursor(offset);
248+
249+
if (goUpSexp == GoUpSexpOption.Never || goUpSexp == GoUpSexpOption.WhenAtLimit) {
250+
if (!cursor.isWhiteSpace() && cursor.offsetStart < offset) {
251+
// This is because cursor.backwardSexp() can't move backwards when "on" the first sexp inside a list
252+
// TODO: Try to fix this in LispTokenCursor instead.
253+
cursor.forwardSexp();
254+
}
255+
cursor.backwardWhitespace();
248256

249-
if (cursor.backwardSexp(true, true)) {
250-
if (goPastWhitespace) {
251-
cursor.backwardWhitespace();
257+
if (cursor.backwardSexp(true, true)) {
258+
if (goPastWhitespace) {
259+
cursor.backwardWhitespace();
260+
}
261+
return [cursor.offsetStart, offset];
252262
}
253-
return [cursor.offsetStart, offset];
254263
}
255-
}
256264

257-
if (goUpSexp == GoUpSexpOption.Required || goUpSexp == GoUpSexpOption.WhenAtLimit) {
258-
cursor.backwardList();
259-
if (cursor.backwardUpList()) {
260-
cursor.forwardSexp(true, true);
261-
cursor.backwardSexp(true, true);
262-
if (goPastWhitespace) {
263-
cursor.backwardWhitespace();
265+
if (goUpSexp == GoUpSexpOption.Required || goUpSexp == GoUpSexpOption.WhenAtLimit) {
266+
cursor.backwardList();
267+
if (cursor.backwardUpList()) {
268+
cursor.forwardSexp(true, true);
269+
cursor.backwardSexp(true, true);
270+
if (goPastWhitespace) {
271+
cursor.backwardWhitespace();
272+
}
273+
return [cursor.offsetStart, offset];
264274
}
265-
return [cursor.offsetStart, offset];
266275
}
267-
}
268276

269-
return [offset, offset];
277+
return [offset, offset];
278+
});
270279
}
271280

272281
export function forwardSexpRange(
273282
doc: EditableDocument,
274-
offset = Math.max(doc.selection.anchor, doc.selection.active),
283+
offsets?: number[],
284+
goPastWhitespace?: boolean
285+
): Array<[number, number]>;
286+
export function forwardSexpRange(
287+
doc: EditableDocument,
288+
offset?: number,
289+
goPastWhitespace?: boolean
290+
): [number, number];
291+
export function forwardSexpRange(
292+
doc: EditableDocument,
293+
oneOrMoreOffsets: number[]|number = doc.selections.map((s) => s.end),
275294
goPastWhitespace = false
276-
): [number, number] {
277-
return _forwardSexpRange(doc, offset, GoUpSexpOption.Never, goPastWhitespace);
295+
): Array<[number, number]> | [number, number] {
296+
const offsets = Array.isArray(oneOrMoreOffsets) ? oneOrMoreOffsets : [oneOrMoreOffsets];
297+
const ranges = _forwardSexpRange(doc, offsets, GoUpSexpOption.Never, goPastWhitespace);
298+
return Array.isArray(oneOrMoreOffsets) ? ranges : ranges[0];
278299
}
279300

280301
export function backwardSexpRange(
281302
doc: EditableDocument,
282-
offset: number = Math.min(doc.selection.anchor, doc.selection.active),
303+
offsets?: number[],
304+
goPastWhitespace?: boolean
305+
): Array<[number, number]>;
306+
export function backwardSexpRange(
307+
doc: EditableDocument,
308+
offset?: number,
309+
goPastWhitespace?: boolean
310+
): [number, number];
311+
export function backwardSexpRange(
312+
doc: EditableDocument,
313+
oneOrMoreOffsets: number[] | number = doc.selections.map((s) => s.start),
283314
goPastWhitespace = false
284-
): [number, number] {
285-
return _backwardSexpRange(doc, offset, GoUpSexpOption.Never, goPastWhitespace);
315+
): Array<[number, number]> | [number, number] {
316+
const offsets = Array.isArray(oneOrMoreOffsets) ? oneOrMoreOffsets : [oneOrMoreOffsets];
317+
const ranges = _backwardSexpRange(doc, offsets, GoUpSexpOption.Never, goPastWhitespace);
318+
return Array.isArray(oneOrMoreOffsets) ? ranges : ranges[0];
286319
}
287320

288321
export function forwardListRange(
@@ -418,7 +451,7 @@ export function rangeToForwardUpList(
418451
offset: number = doc.selections[0].end,
419452
goPastWhitespace = false
420453
): [number, number] {
421-
return _forwardSexpRange(doc, offset, GoUpSexpOption.Required, goPastWhitespace);
454+
return _forwardSexpRange(doc, [offset], GoUpSexpOption.Required, goPastWhitespace)[0];
422455
}
423456

424457
export function rangeToBackwardUpList(
@@ -427,23 +460,47 @@ export function rangeToBackwardUpList(
427460
offset: number = doc.selections[0].start,
428461
goPastWhitespace = false
429462
): [number, number] {
430-
return _backwardSexpRange(doc, offset, GoUpSexpOption.Required, goPastWhitespace);
463+
return _backwardSexpRange(doc, [offset], GoUpSexpOption.Required, goPastWhitespace)[0];
431464
}
432465

433466
export function forwardSexpOrUpRange(
434467
doc: EditableDocument,
435-
offset = Math.max(doc.selection.anchor, doc.selection.active),
468+
offsets?: number[],
469+
goPastWhitespace?: boolean
470+
): Array<[number, number]>;
471+
export function forwardSexpOrUpRange(
472+
doc: EditableDocument,
473+
offset?: number,
474+
goPastWhitespace?: boolean
475+
): [number, number];
476+
export function forwardSexpOrUpRange(
477+
doc: EditableDocument,
478+
oneOrMoreOffsets: number[] | number = doc.selections.map((s) => s.end),
436479
goPastWhitespace = false
437-
): [number, number] {
438-
return _forwardSexpRange(doc, offset, GoUpSexpOption.WhenAtLimit, goPastWhitespace);
480+
): Array<[number, number]> | [number, number] {
481+
const offsets = isNumber(oneOrMoreOffsets) ? [oneOrMoreOffsets] : oneOrMoreOffsets;
482+
const ranges = _forwardSexpRange(doc, offsets, GoUpSexpOption.WhenAtLimit, goPastWhitespace);
483+
return isNumber(oneOrMoreOffsets) ? ranges[0] : ranges;
439484
}
440485

441486
export function backwardSexpOrUpRange(
442487
doc: EditableDocument,
443-
offset: number = Math.min(doc.selection.anchor, doc.selection.active),
488+
offsets?: number[],
489+
goPastWhitespace?: boolean
490+
): Array<[number, number]>;
491+
export function backwardSexpOrUpRange(
492+
doc: EditableDocument,
493+
offset?: number,
494+
goPastWhitespace?: boolean
495+
): [number, number];
496+
export function backwardSexpOrUpRange(
497+
doc: EditableDocument,
498+
oneOrMoreOffsets: number[] | number = doc.selections.map((s) => s.start),
444499
goPastWhitespace = false
445-
): [number, number] {
446-
return _backwardSexpRange(doc, offset, GoUpSexpOption.WhenAtLimit, goPastWhitespace);
500+
): Array<[number, number]> | [number, number] {
501+
const offsets = isNumber(oneOrMoreOffsets) ? [oneOrMoreOffsets] : oneOrMoreOffsets;
502+
const ranges = _backwardSexpRange(doc, offsets, GoUpSexpOption.WhenAtLimit, goPastWhitespace);
503+
return isNumber(oneOrMoreOffsets) ? ranges[0] : ranges;
447504
}
448505

449506
export function rangeToForwardDownList(

0 commit comments

Comments
 (0)