[WIP - DON'T MERGE] Multicursor wrap

.mocharc.json

@@ -0,0 +1 @@
+{ "require": ["ts-node/register", "src/util/lodashMixins.ts"] }

CHANGELOG.md

@@ -4,6 +4,10 @@ Changes to Calva.
 
 ## [Unreleased]
 
+- Add "Wrap with Set #{}" paredit command.
+- [Implement experimental support for multicursor wrap commands](https://github.com/BetterThanTomorrow/calva/issues/2448). Enable `calva.paredit.multicursor` in your settings to try it out. Addressing [#2445](https://github.com/BetterThanTomorrow/calva/issues/2445) 
+- [Support command binding args to toggle multicursor per command or toggle copy per kill command. Closes #2485](https://github.com/BetterThanTomorrow/calva/issues/2485)
+
 ## [2.0.439] - 2024-04-11
 
 - Fix: [Refresh Changed Namespaces do not output to the selected output destination](https://github.com/BetterThanTomorrow/calva/issues/2506)

docs/site/paredit.md

@@ -58,6 +58,34 @@ The Paredit commands are sorted into **Navigation**, **Selection**, and **Edit**
 
 To make the command descriptions a bit clearer, each entry is animated. When you try to figure out what is going on in the GIFs, focus on where the cursor is at the start of the animation loop.
 
+### Command Args
+
+Some Paredit commands accept arguments. You can utilize this in keybindings and from [Joyride](https://github.com/BetterThanTomorrow/joyride).
+
+#### **`copy` for all `kill*` commands**
+
+When specified, will control whether killed text will be copied to the clipboard.
+This is an alternative to, or supports binding-specific overrides for, `calva.paredit.killAlsoCutsToClipboard`.
+
+For example, here's 2 keybindings for `paredit.killRight` with different `copy` args, allowing you to choose when or if you want killed text copied at keypress-time, regardless of global `calva.paredit.killAlsoCutsToClipboard` setting:
+
+```json
+{
+  "key": "ctrl+k",
+  "command": "paredit.killRight",
+  "when": "... your when conditions ...",
+  "args": {"copy": false}
+},
+{
+  "key": "cmd+k ctrl+k",
+  "command": "paredit.killRight",
+  "when": "... your when conditions ...",
+  "args": {"copy": true}
+},
+```
+
+Or, you can even have both of them use the **same `key`**, but **separate `when` conditions** to taste, to allow context-conditional copying.
+
 ### Strings are not Lists, but Anyway...
 
 In Calva Paredit, strings are treated in much the same way as lists are. Here's an example showing **Slurp** and **Barf**, **Forward/Backward List**, and **Expand Selection**.
@@ -159,7 +187,31 @@ There are some context keys you can utilize to configure keyboard shortcuts with
 
 *The Nuclear Option*: You can choose to disable all default key bindings by configuring `calva.paredit.defaultKeyMap` to `none`. (Then you probably also want to register your own shortcuts for the commands you often use.)
 
-In some instances built-in command defaults are the same as Paredit's defaults, and Paredit's functionality in a particular case is less than what the default is. This is true of *Expand Selection* and *Shrink Selection* for Windows/Linux when multiple lines are selected. In this particular case adding `!editorHasMultipleSelections` to the `when` clause of the binding makes for a better workflow. The point is that when the bindings overlap and default functionality is desired peaceful integration can be achieved with the right `when` clause. This is left out of Paredit's defaults to respect user preference, and ease of maintenance.
+### When Clauses and VSCode Default Bindings
+
+There are instances where VSCode's built-in command binding defaults are the same as Paredit's, where Paredit's version has less functionality. For example, Calva's _Expand Selection_ and _Shrink Selection_ doesn't support multiple selections (though this may change in the future - see Multicursor section below). In this particular case, adding `!editorHasMultipleSelections` to the `when` clause of the binding makes up for this gap by letting the binding fall back to VSCode's native grow/shrink selection.
+
+For example, here's the JSON version of the keybindings settings demonstrating the above. Note this can also specified in the Keyboard Shortcuts UI:
+
+```json
+{
+  "key": "shift+alt+right",
+  "command": "paredit.sexpRangeExpansion",
+  "when": "calva:keybindingsEnabled && editorLangId == clojure && editorTextFocus && paredit:keyMap =~ /original|strict/ && !calva:cursorInComment"
+}
+```
+
+to
+
+```json
+{
+  "key": "shift+alt+right",
+  "command": "paredit.sexpRangeExpansion",
+  "when": "!editorHasMultipleSelections && calva:keybindingsEnabled && editorLangId == clojure && editorTextFocus && paredit:keyMap =~ /original|strict/ && !calva:cursorInComment"
+}
+```
+
+The point is that when the bindings overlap and default functionality is desired peaceful integration can be achieved with the right `when` clause. This is left out of Paredit's defaults to respect user preference, and ease of maintenance.
 
 Happy Editing! ❤️
 
@@ -170,3 +222,18 @@ There is an ongoing effort to support simultaneous multicursor editing with Pare
 - Movement
 - Selection (except for `Select Current Form` - coming soon!)
 - Rewrap
+
+### Toggling Multicursor per command
+
+The experimental multicursor-supported commands support an optional command arg - like `copy` for the `kill*` commands [mentioned above](#command-args) - to control whether multicursor is enabled for that command. This is an alternative to, or supports binding-specific overrides for, `calva.paredit.multicursor`.
+
+For example:
+
+```json
+{
+  "key": "ctrl+k",
+  "command": "paredit.sexpRangeExpansion",
+  "when": "... your when conditions ...",
+  "args": {"multicursor": false}
+}
+```

package.json

@@ -3,7 +3,7 @@
   "displayName": "Calva: Clojure & ClojureScript Interactive Programming",
   "description": "Integrated REPL, formatter, Paredit, and more. Powered by cider-nrepl and clojure-lsp.",
   "icon": "assets/calva.png",
-  "version": "2.0.439",
+  "version": "2.0.440",
   "publisher": "betterthantomorrow",
   "author": {
     "name": "Better Than Tomorrow",
@@ -2564,6 +2564,11 @@
         "key": "ctrl+alt+shift+q",
         "when": "calva:keybindingsEnabled && editorLangId == clojure && editorTextFocus && paredit:keyMap =~ /original|strict/"
       },
+      {
+        "command": "paredit.wrapAroundSet",
+        "key": "ctrl+alt+shift+h",
+        "when": "calva:keybindingsEnabled && editorLangId == clojure && editorTextFocus && paredit:keyMap =~ /original|strict/"
+      },
       {
         "command": "paredit.rewrapParens",
         "key": "ctrl+alt+r ctrl+alt+p",
@@ -3221,8 +3226,8 @@
     "integration-test": "node ./out/extension-test/integration/runTests.js",
     "e2e-test": "node ./src/extension-test/e2e-test/launch.js",
     "pree2e-test": "cd ./src/extension-test/e2e-test/ && npm i",
-    "unit-test": "npx mocha --require ts-node/register 'src/extension-test/unit/**/*-test.ts'",
-    "unit-test-watch": "npx mocha --watch --require ts-node/register --watch-extensions ts --watch-files src 'src/extension-test/unit/**/*-test.ts'",
+    "unit-test": "npx mocha --require ts-node/register,src/util/lodashMixins.ts 'src/extension-test/unit/**/*-test.ts'",
+    "unit-test-watch": "npx mocha --watch --require ts-node/register,src/util/lodashMixins.ts --watch-extensions ts --watch-files src 'src/extension-test/unit/**/*-test.ts'",
     "prettier-format": "npx prettier --write \"./**/*.{ts,js,json}\"",
     "prettier-check": "npx prettier --check \"./**/*.{ts,js,json}\"",
     "prettier-check-watch": "onchange \"./**/*.{ts,js,json}\" -- prettier --check {{changed}}",

src/cursor-doc/cursor-doc-utils.ts

@@ -0,0 +1,117 @@
+import { first, isNumber, last, ListIterator, range } from 'lodash';
+import { isModelEditSelection, isModelRange, ModelEditRange, ModelEditSelection } from './model';
+import _ = require('lodash');
+
+type RangeOrSelection = ModelEditRange | ModelEditSelection;
+export function mapRangeOrSelectionToOffset1(
+  side: 'start' | 'end' | 'anchor' | 'active' = 'start'
+) {
+  return function inner(
+    // support passing either range/sel or [range/sel, original list order]
+    t: RangeOrSelection | [rangeOrSel: RangeOrSelection, order: number]
+  ): number {
+    // const rangeOrSel = isModelEditSelection(t) || isModelRange(t) ? t : first(t);
+    const rangeOrSel = isModelEditSelection(t) ? t : isModelRange(t) ? t : t[0];
+
+    if (rangeOrSel instanceof ModelEditSelection) {
+      return rangeOrSel[side];
+    } else if (isModelRange(rangeOrSel)) {
+      // let fn: (...args: number[]) => number;
+      switch (side) {
+        case 'start':
+          // fn = Math.min;
+          return Math.min(...rangeOrSel);
+        // break;
+        case 'end':
+          // fn = Math.max;
+          return Math.max(...rangeOrSel);
+        // break;
+        case 'anchor':
+          // fn = (...x) => first(x);
+          return first(rangeOrSel);
+        // break;
+        case 'active':
+          // fn = (...x) => last(x);
+          return last(rangeOrSel);
+        // break;
+        default:
+          // break;
+          return range[0];
+      }
+
+      // return fn(...rangeOrSel);
+      // return fn(...rangeOrSel);
+    }
+  };
+}
+export function mapRangeOrSelectionToOffset(side: 'start' | 'end' | 'anchor' | 'active' = 'start') {
+  return function inner(
+    // support passing either range/sel or [range/sel, original list order]
+    t: RangeOrSelection | [rangeOrSel: RangeOrSelection, order: number]
+  ): number {
+    const rangeOrSel = isModelEditSelection(t) ? t : isModelRange(t) ? t : t[0];
+
+    if (rangeOrSel instanceof ModelEditSelection) {
+      return rangeOrSel[side];
+    } else if (isModelRange(rangeOrSel)) {
+      switch (side) {
+        case 'start':
+          return Math.min(...rangeOrSel);
+        case 'end':
+          return Math.max(...rangeOrSel);
+        case 'anchor':
+          return first(rangeOrSel);
+        case 'active':
+          return last(rangeOrSel);
+        default:
+          return range[0];
+      }
+    }
+  };
+}
+
+export function repositionSelectionByCumulativeOffsets(
+  /**
+   * Either a fixed offset to add for each cursor (eg 2 if wrapping by parens),
+   * or a 'getter' fn to get the value from each cursor.
+   */
+  offsetGetter: ListIterator<ModelEditSelection, number> | number
+) {
+  // if (true) {
+  return repositionSelectionWithGetterByCumulativeOffsets<ModelEditSelection>(
+    _.identity,
+    offsetGetter
+  );
+}
+
+export function repositionSelectionWithGetterByCumulativeOffsets<T>(
+  selectionGetter: ListIterator<T, ModelEditSelection>,
+  /**
+   * Either a fixed offset to add for each cursor (eg 2 if wrapping by parens),
+   * or a 'getter' fn to get the value from each cursor.
+   */
+  offsetGetter: ListIterator<ModelEditSelection, number> | number
+) {
+  return (
+    t: T,
+    index: number,
+    // array: ModelEditSelection[]
+    array: T[]
+  ): ModelEditSelection => {
+    const sel = selectionGetter(t, index, array);
+    const newSel = sel.clone();
+
+    const getItemOffset = isNumber(offsetGetter) ? () => offsetGetter : offsetGetter;
+
+    const offset = _(array)
+      .filter((x, i, a) => {
+        const s = selectionGetter(x, i, a);
+        return s.start < sel.start;
+      })
+      .map(getItemOffset)
+      .sum();
+
+    newSel.reposition(offset);
+    return newSel;
+  };
+}

src/cursor-doc/model.ts

@@ -50,6 +50,14 @@ export class ModelEdit<T extends ModelEditFunction> {
   constructor(public editFn: T, public args: Readonly<ModelEditArgs<T>>) {}
 }
 
+export function isModelRange(o: any): o is ModelEditRange {
+  return _.isArray(o) && o.length === 2 && isNumber(o[0]) && isNumber(o[1]);
+}
+
+export function isModelEditSelection(o: any): o is ModelEditSelection {
+  return o instanceof ModelEditSelection;
+}
+
 /**
  * An undirected range representing a cursor/selection in a document.
  * Is a tuple of [start, end] where each is an offset.