Merge pull request #2742 from pbwolf/healer-module

Healer module

Author: PEZ

CHANGELOG.md

@@ -5,6 +5,7 @@ Changes to Calva.
 ## [Unreleased]
 
 - Bump deps.clj.jar to v1.12.0.1517
+- Add unit tests for the reformatter's "healer" of incomplete forms
 
 ## [2.0.486] - 2025-02-16
 

src/calva-fmt/src/format.ts

@@ -9,6 +9,7 @@ import { isUndefined, cloneDeep } from 'lodash';
 import { LispTokenCursor } from '../../cursor-doc/token-cursor';
 import { formatIndex } from './format-index';
 import * as state from '../../state';
+import * as healer from './healer';
 
 const FormatDepthDefaults = {
   deftype: 2,
@@ -59,27 +60,9 @@ export function formatRangeEdits(
   if (!cursor.withinString() && !cursor.withinComment()) {
     const eol = _convertEolNumToStringNotation(document.eol);
     const originalText = document.getText(originalRange);
-    const leadingWs = originalText.match(/^\s*/)[0];
-    const trailingWs = originalText.match(/\s*$/)[0];
-    const missingTexts = cursorDocUtils.getMissingBrackets(originalText);
-    const healedText = `${missingTexts.prepend}${originalText.trim()}${missingTexts.append}`;
-    const formattedHealedText = formatCode(healedText, document.eol);
-    const leadingEolPos = leadingWs.lastIndexOf(eol);
-    const startIndent =
-      leadingEolPos === -1
-        ? originalRange.start.character
-        : leadingWs.length - leadingEolPos - eol.length;
-    const formattedText = formattedHealedText
-      .substring(
-        missingTexts.prepend.length,
-        missingTexts.prepend.length + formattedHealedText.length - missingTexts.append.length
-      )
-      .split(eol)
-      .map((line: string, i: number) => (i === 0 ? line : `${' '.repeat(startIndent)}${line}`))
-      .join(eol);
-    const newText = `${formattedText.startsWith(leadingWs) ? '' : leadingWs}${formattedText}${
-      formattedText.endsWith(trailingWs) ? '' : trailingWs
-    }`;
+    const healing = healer.bandage(originalText, originalRange.start.character, eol);
+    const formattedHealedText = formatCode(healing.healedText, document.eol);
+    const newText = healer.unbandage(healing, formattedHealedText);
     return [vscode.TextEdit.replace(originalRange, newText)];
   }
 }

src/calva-fmt/src/healer.ts

@@ -0,0 +1,69 @@
+/**
+ * @module
+ * Facilitator of code formatting by
+ * converting original text to 'healed' formattable text,
+ * and converting formatted 'healed' text to
+ * an 'unhealed' formatted string fit for use as a substitute for the original
+ */
+
+import * as cursorDocUtils from '../../cursor-doc/utilities';
+
+/**
+ * 'Healed' text suitable for code-formatting
+ * and details with which a formatted version of it
+ * can be translated back to unhealed replacment text
+ */
+type BandageContext = {
+  healedText: string;
+  details: {
+    originalIndent: number;
+    originalText: string;
+    eol: string;
+    missingTexts: cursorDocUtils.MissingTexts;
+  };
+};
+
+/**
+ * Formattable text (fixed up to compensate for apparently missing list openers or closers)
+ * and context with which to unbandage a formatted version of the same and recover the exact text
+ * to substitute back into the document.
+ * @param originalText Text to be reformatted
+ * @param originalIndent Character offset where the first line of originalText begins
+ * @param eol Newline characters that should be used in the code
+ * @returns healedText - patched-up forms to be given to a code formatter, and other context the unbandage function needs
+ */
+export function bandage(originalText: string, originalIndent: number, eol: string): BandageContext {
+  const missingTexts = cursorDocUtils.getMissingBrackets(originalText);
+  const healedText = `${missingTexts.prepend}${originalText.trim()}${missingTexts.append}`;
+  return {
+    healedText,
+    details: { eol, originalText, originalIndent, missingTexts },
+  };
+}
+
+/**
+ * Formatted substitute text derived from formattedHealedText by removing bandages and reimposing an indentation.
+ * @param context Context from bandage
+ * @param formattedHealedText Formatted version of the healedText
+ * @returns
+ */
+export function unbandage(context: BandageContext, formattedHealedText: string) {
+  const d = context.details;
+  const leadingWs = d.originalText.match(/^\s*/)[0];
+  const trailingWs = d.originalText.match(/\s*$/)[0];
+  const leadingEolPos = leadingWs.lastIndexOf(d.eol);
+  const startIndent =
+    leadingEolPos === -1 ? d.originalIndent : leadingWs.length - leadingEolPos - d.eol.length;
+  const formattedText = formattedHealedText
+    .substring(
+      d.missingTexts.prepend.length,
+      d.missingTexts.prepend.length + formattedHealedText.length - d.missingTexts.append.length
+    )
+    .split(d.eol)
+    .map((line: string, i: number) => (i === 0 ? line : `${' '.repeat(startIndent)}${line}`))
+    .join(d.eol);
+  const newText = `${formattedText.startsWith(leadingWs) ? '' : leadingWs}${formattedText}${
+    formattedText.endsWith(trailingWs) ? '' : trailingWs
+  }`;
+  return newText;
+}

src/extension-test/unit/calva-fmt/healer-test.ts

@@ -0,0 +1,36 @@
+import * as expect from 'expect';
+import * as healer from '../../../calva-fmt/src/healer';
+import * as model from '../../../cursor-doc/model';
+
+model.initScanner(20000);
+
+describe('calva-fmt', () => {
+  it('Heals unopened list', () => {
+    const originalDoc = '(def a[:x :y :z ])';
+    //                         \----------/
+    const originalFrag = originalDoc.substring(6);
+    const healing = healer.bandage(originalFrag, 6, '\n');
+    expect(healing.healedText).toEqual('([:x :y :z ])');
+    const formattedHealed = '([:x :y :z])';
+    const replacement = healer.unbandage(healing, formattedHealed);
+    expect(replacement).toEqual('[:x :y :z])');
+  });
+  it('Heals unclosed vector', () => {
+    const originalDoc = '(def a[:x :y :z ]) ';
+    //                         \--------/
+    const originalFrag = originalDoc.substring(6, 16);
+    const healing = healer.bandage(originalFrag, 6, '\n');
+    expect(healing.healedText).toEqual('[:x :y :z]');
+    const formattedHealed = '[:x :y :z]';
+    const replacement = healer.unbandage(healing, formattedHealed);
+    expect(replacement).toEqual('[:x :y :z ');
+  });
+  it('Indents subsequent lines relative to first-line indent', () => {
+    const originalFrag = '(def a\n42)';
+    const healing = healer.bandage(originalFrag, 4, '\n');
+    expect(healing.healedText).toEqual('(def a\n42)');
+    const formattedHealed = '(def a\n  42)';
+    const replacement = healer.unbandage(healing, formattedHealed);
+    expect(replacement).toEqual('(def a\n      42)');
+  });
+});