force document reparse on paste due to possible structural hierarchy changes, remove profile logging code

ryanncode · ryanncode · commit f8983026e984 · 2025-07-01T19:12:09.000-04:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,12 +8,14 @@ All notable changes to the "pointblank" extension will be documented in this fil
 - When typing or pasting from the start of a list item line, the bullet point style now matches the next or previous list item line at the same level of indent for consistency.
 ### Changed
 - Replaced the document parser with a high-performance "Dirty Range" incremental parser, eliminating typing lag in large documents.
+- Paste operations are now handled as a single, atomic transaction. This prevents potential race conditions with the incremental parser and ensures that the document state remains consistent, improving performance and reliability, especially for large pastes.
 ### Fixed
+- Fixed an issue where automatic bullet insertion would interfere with VS Code's auto-completion for brackets, parentheses, and quotes.
 - Pasting a bullet at the beginning of a line no longer erases the line; pasted content is merged or inserted intelligently.
 - Numbered list items will remove their default bullet point.
 - Paste handling is now more robust: bullets are correctly added when pasting at the start of indented lines, and never in the middle of a line.
 ### Testing
-- Added a comprehensive unit test for paste scenarios.
+- Added comprehensive unit tests for document parsing and paste scenarios.
 - All parsing and paste logic is now tested using Jest unit tests.
 
 ## [0.6.3] - 2025-06-27
diff --git a/src/commands/commandManager.ts b/src/commands/commandManager.ts
@@ -243,7 +243,7 @@ export class CommandManager {
             vscode.commands.executeCommand('outdentLines');
         });
 
-        const pasteWithBulletsInstance = new PasteWithBullets();
+        const pasteWithBulletsInstance = new PasteWithBullets(this.extensionState);
         const pasteWithBulletsCommand = vscode.commands.registerTextEditorCommand('pointblank.pasteWithBullets', async () => {
             if (!config.getAutoBullets()) {
                 await vscode.commands.executeCommand('editor.action.clipboardPasteAction');
diff --git a/src/commands/pasteWithBullets.ts b/src/commands/pasteWithBullets.ts
@@ -1,6 +1,7 @@
-
 import * as vscode from 'vscode';
 import { processClipboardLinesPure, processSingleLinePaste, processTypedNodePaste } from '../utils/pasteUtils';
+import { ExtensionState } from '../state/extensionState';
+
 function detectBulletFromLine(line: string): string | null {
     // Match a bullet at the start: bullet char + space (including '+')
     const match = line.match(/^\s*([\u2022\-\*\•\+])\s/);
@@ -25,43 +26,90 @@ function getBulletStyle(document: vscode.TextDocument, lineNumber: number): stri
 }
 
 export class PasteWithBullets {
+    private extensionState: ExtensionState;
+
+    constructor(extensionState: ExtensionState) {
+        this.extensionState = extensionState;
+    }
+
     public async pasteWithBulletsCommand(): Promise<void> {
         const editor = vscode.window.activeTextEditor;
         if (!editor) { return; }
 
-        const clipboardText = await vscode.env.clipboard.readText();
-        const clipboardLines = clipboardText.split(/\r?\n/);
-        if (clipboardLines.length === 0) {
+        const documentModel = this.extensionState.getDocumentModel(editor.document.uri.toString());
+        if (!documentModel) {
+            // Fallback to default paste if model not found
             await vscode.commands.executeCommand('default:paste');
             return;
         }
 
-        const { selection, document } = editor;
-        const currentLine = document.lineAt(selection.start.line);
+        await documentModel.performBulkUpdate(async () => {
+            const clipboardText = await vscode.env.clipboard.readText();
+            const clipboardLines = clipboardText.split(/\r?\n/);
+            if (clipboardLines.length === 0) {
+                await vscode.commands.executeCommand('default:paste');
+                return;
+            }
 
+            const { selection, document } = editor;
+            const currentLine = document.lineAt(selection.start.line);
 
-        // Typed node paste
-        if (clipboardLines.length > 0 && /^\(\w+\)/.test(clipboardLines[0].trim())) {
-            const adjustedClipboardLines = processTypedNodePaste({ clipboardLines });
-            const textToInsert = adjustedClipboardLines.join('\n');
-            let startLine = selection.start.line;
-            await editor.edit(editBuilder => {
-                editBuilder.replace(selection, textToInsert);
-            });
-            // Place cursor at end of last pasted line
-            const lastLineIdx = adjustedClipboardLines.length - 1;
-            const lastLineText = adjustedClipboardLines[lastLineIdx] || '';
-            const newPosition = new vscode.Position(startLine + lastLineIdx, lastLineText.length);
-            editor.selection = new vscode.Selection(newPosition, newPosition);
-            return;
-        }
+            // Typed node paste
+            if (clipboardLines.length > 0 && /^\(\w+\)/.test(clipboardLines[0].trim())) {
+                const adjustedClipboardLines = processTypedNodePaste({ clipboardLines });
+                const textToInsert = adjustedClipboardLines.join('\n');
+                let startLine = selection.start.line;
+                await editor.edit(editBuilder => {
+                    editBuilder.replace(selection, textToInsert);
+                });
+                // Cursor placement is tricky in bulk update; this might need adjustment
+                const lastLineIdx = adjustedClipboardLines.length - 1;
+                const lastLineText = adjustedClipboardLines[lastLineIdx] || '';
+                const newPosition = new vscode.Position(startLine + lastLineIdx, lastLineText.length);
+                editor.selection = new vscode.Selection(newPosition, newPosition);
+                return;
+            }
+
+            // Multi-line paste
+            if (clipboardLines.length > 1) {
+                let partBeforeCursor: string;
+                let partAfterCursor: string;
+                let startLine = selection.start.line;
+                if (selection.start.character === currentLine.firstNonWhitespaceCharacterIndex) {
+                    partBeforeCursor = '';
+                    partAfterCursor = currentLine.text.substring(selection.start.character);
+                } else {
+                    partBeforeCursor = currentLine.text.substring(0, selection.start.character);
+                    partAfterCursor = currentLine.text.substring(selection.start.character);
+                }
+                const bullet = getBulletStyle(document, currentLine.lineNumber);
+                const newLines = processClipboardLinesPure({
+                    clipboardLines,
+                    partBeforeCursor,
+                    partAfterCursor,
+                    currentLineText: currentLine.text,
+                    currentLineIndent: currentLine.firstNonWhitespaceCharacterIndex,
+                    bulletTypeForLine: () => ({ bulletType: 'none' }),
+                    getBullet: () => bullet,
+                    document,
+                    lineNumber: currentLine.lineNumber
+                });
+                await editor.edit(editBuilder => {
+                    editBuilder.replace(currentLine.range, newLines.join('\n'));
+                });
+                const lastIdx = newLines.length - 1;
+                const lastLineText = newLines[lastIdx];
+                const afterTextLen = partAfterCursor.length;
+                const newChar = Math.max(0, lastLineText.length - afterTextLen);
+                const newPosition = new vscode.Position(startLine + lastIdx, newChar);
+                editor.selection = new vscode.Selection(newPosition, newPosition);
+                return;
+            }
 
-        // Multi-line paste
-        if (clipboardLines.length > 1) {
+            // Single-line paste
             let partBeforeCursor: string;
             let partAfterCursor: string;
             let startLine = selection.start.line;
-            // If cursor is at first non-whitespace character, treat as start of line for bullet logic
             if (selection.start.character === currentLine.firstNonWhitespaceCharacterIndex) {
                 partBeforeCursor = '';
                 partAfterCursor = currentLine.text.substring(selection.start.character);
@@ -71,7 +119,7 @@ export class PasteWithBullets {
             }
             const bullet = getBulletStyle(document, currentLine.lineNumber);
             const newLines = processClipboardLinesPure({
-                clipboardLines,
+                clipboardLines: [clipboardLines[0]],
                 partBeforeCursor,
                 partAfterCursor,
                 currentLineText: currentLine.text,
@@ -82,48 +130,12 @@ export class PasteWithBullets {
                 lineNumber: currentLine.lineNumber
             });
             await editor.edit(editBuilder => {
-                editBuilder.replace(currentLine.range, newLines.join('\n'));
+                editBuilder.replace(currentLine.range, newLines[0]);
             });
-            // Place cursor just before the original partAfterCursor on the last pasted line
-            const lastIdx = newLines.length - 1;
-            const lastLineText = newLines[lastIdx];
             const afterTextLen = partAfterCursor.length;
-            const newChar = Math.max(0, lastLineText.length - afterTextLen);
-            const newPosition = new vscode.Position(startLine + lastIdx, newChar);
+            const newChar = Math.max(0, newLines[0].length - afterTextLen);
+            const newPosition = new vscode.Position(startLine, newChar);
             editor.selection = new vscode.Selection(newPosition, newPosition);
-            return;
-        }
-
-        // Single-line paste: use the same bullet detection and context as multi-line paste
-        let partBeforeCursor: string;
-        let partAfterCursor: string;
-        let startLine = selection.start.line;
-        if (selection.start.character === currentLine.firstNonWhitespaceCharacterIndex) {
-            partBeforeCursor = '';
-            partAfterCursor = currentLine.text.substring(selection.start.character);
-        } else {
-            partBeforeCursor = currentLine.text.substring(0, selection.start.character);
-            partAfterCursor = currentLine.text.substring(selection.start.character);
-        }
-        const bullet = getBulletStyle(document, currentLine.lineNumber);
-        const newLines = processClipboardLinesPure({
-            clipboardLines: [clipboardLines[0]],
-            partBeforeCursor,
-            partAfterCursor,
-            currentLineText: currentLine.text,
-            currentLineIndent: currentLine.firstNonWhitespaceCharacterIndex,
-            bulletTypeForLine: () => ({ bulletType: 'none' }),
-            getBullet: () => bullet,
-            document,
-            lineNumber: currentLine.lineNumber
-        });
-        await editor.edit(editBuilder => {
-            editBuilder.replace(currentLine.range, newLines[0]);
         });
-        // Place cursor just before the original partAfterCursor on the pasted line
-        const afterTextLen = partAfterCursor.length;
-        const newChar = Math.max(0, newLines[0].length - afterTextLen);
-        const newPosition = new vscode.Position(startLine, newChar);
-        editor.selection = new vscode.Selection(newPosition, newPosition);
     }
 }
diff --git a/src/decorations/decorationCalculator.ts b/src/decorations/decorationCalculator.ts
@@ -1,6 +1,5 @@
 import * as vscode from 'vscode';
 import { BlockNode } from '../document/blockNode';
-import { withTiming } from '../utils/debugUtils';
 
 /**
  * A stateless calculator responsible for determining which decorations to apply based on the properties of `BlockNode`s.
@@ -16,34 +15,32 @@ export class DecorationCalculator {
      *                       and values are arrays of `DecorationOptions` to be applied.
      */
     public static calculateDecorations(nodes: BlockNode[], decorationsMap: Map<string, vscode.DecorationOptions[]>): void {
-        withTiming(() => {
-            for (const node of nodes) {
-                // Skip decoration for code blocks, markdown headers, or empty lines.
-                if (node.isCodeBlockDelimiter || node.isExcluded || node.line.isEmptyOrWhitespace) {
-                    continue;
-                }
+        for (const node of nodes) {
+            // Skip decoration for code blocks, markdown headers, or empty lines.
+            if (node.isCodeBlockDelimiter || node.isExcluded || node.line.isEmptyOrWhitespace) {
+                continue;
+            }
 
-                // Handle typed nodes like `(Book)`.
-                if (node.isTypedNode && node.typedNodeRange) {
-                    decorationsMap.get('typedNodeDecorationType')!.push({ range: node.typedNodeRange });
-                    continue; // Typed nodes don't have other decorations.
-                }
+            // Handle typed nodes like `(Book)`.
+            if (node.isTypedNode && node.typedNodeRange) {
+                decorationsMap.get('typedNodeDecorationType')!.push({ range: node.typedNodeRange });
+                continue; // Typed nodes don't have other decorations.
+            }
 
-                // Handle key-value pairs like `Author:: John Doe`.
-                if (node.isKeyValue && node.keyValue) {
-                    decorationsMap.get('keyValueDecorationType')!.push({ range: node.keyValue.keyRange });
-                    continue; // Key-value pairs don't have other decorations.
-                }
+            // Handle key-value pairs like `Author:: John Doe`.
+            if (node.isKeyValue && node.keyValue) {
+                decorationsMap.get('keyValueDecorationType')!.push({ range: node.keyValue.keyRange });
+                continue; // Key-value pairs don't have other decorations.
+            }
 
-                // Handle various bullet point types.
-                if (node.bulletRange) {
-                    const decorationType = DecorationCalculator.getDecorationTypeForBullet(node.bulletType); // Corrected 'this' to 'DecorationCalculator'
-                    if (decorationType) {
-                        decorationsMap.get(decorationType)!.push({ range: node.bulletRange });
-                    }
+            // Handle various bullet point types.
+            if (node.bulletRange) {
+                const decorationType = DecorationCalculator.getDecorationTypeForBullet(node.bulletType); // Corrected 'this' to 'DecorationCalculator'
+                if (decorationType) {
+                    decorationsMap.get(decorationType)!.push({ range: node.bulletRange });
                 }
             }
-        }, `Decoration calculation for ${nodes.length} nodes`);
+        }
     }
 
     /**
diff --git a/src/decorations/decorationManager.ts b/src/decorations/decorationManager.ts
@@ -5,7 +5,6 @@ import { DecorationCalculator } from './decorationCalculator';
 import { debounce } from '../utils/debounce';
 import { Configuration } from '../config/configuration';
 import { ExtensionState } from '../state/extensionState';
-import { withTiming } from '../utils/debugUtils';
 
 /**
  * Manages the application of text editor decorations. It orchestrates decoration updates
@@ -15,7 +14,7 @@ import { withTiming } from '../utils/debugUtils';
 export class DecorationManager implements vscode.Disposable {
     private _decorationTypes: Map<string, vscode.TextEditorDecorationType> = new Map();
     private _disposables: vscode.Disposable[] = [];
-private _debouncedUpdate: (editor: vscode.TextEditor, tree: DocumentTree) => void;
+    private _debouncedUpdate: (editor: vscode.TextEditor, tree: DocumentTree) => void;
     private _extensionState: ExtensionState;
 
     constructor(extensionState: ExtensionState) {
@@ -93,17 +92,15 @@ private _debouncedUpdate: (editor: vscode.TextEditor, tree: DocumentTree) => voi
      * @param tree The current `DocumentTree`.
      */
     private applyDecorations(editor: vscode.TextEditor, tree: DocumentTree): void {
-        withTiming(() => {
-            const decorationsToApply = new Map<string, vscode.DecorationOptions[]>();
-            this._decorationTypes.forEach((_, key) => decorationsToApply.set(key, []));
+        const decorationsToApply = new Map<string, vscode.DecorationOptions[]>();
+        this._decorationTypes.forEach((_, key) => decorationsToApply.set(key, []));
 
         const nodesToDecorate = this.getNodesInViewport(editor, tree);
         DecorationCalculator.calculateDecorations(nodesToDecorate, decorationsToApply);
 
-            this._decorationTypes.forEach((decorationType, typeName) => {
-                editor.setDecorations(decorationType, decorationsToApply.get(typeName) || []);
-            });
-        }, `Decoration rendering for ${editor.document.uri.fsPath}`);
+        this._decorationTypes.forEach((decorationType, typeName) => {
+            editor.setDecorations(decorationType, decorationsToApply.get(typeName) || []);
+        });
     }
 
     /**
diff --git a/src/document/documentParser.ts b/src/document/documentParser.ts
