fix code block parsing: exclude all code-blocks which dont start with… (#276)

* fix code block parsing: exclude all code-blocks which dont start with method

* audit fix

* format

Author: generall

package-lock.json

@@ -24,18 +24,19 @@ describe('QdrantClientExtended', () => {
       });
       await client.downloadSnapshot(collectionName, snapshotName);
 
-      // check that fetch was called with correct arguments
-      expect(fetchSpy).toHaveBeenCalledWith(
-        new Request(`${url}/collections/${collectionName}/snapshots/${snapshotName}`, {
-          method: 'GET',
-          headers: {
-            'Content-Disposition': `attachment; filename="${snapshotName}"`,
-            'Content-Type': 'application/gzip',
-            'api-key': apiKey,
-          },
-        }),
-        { signal: controller.signal }
-      );
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+
+      // Extract the actual arguments
+      const [actualRequest, actualOptions] = fetchSpy.mock.calls[0];
+
+      // Check the URL and method
+      expect(actualRequest.url).toBe(`${url}/collections/${collectionName}/snapshots/${snapshotName}`);
+      expect(actualRequest.method).toBe('GET');
+
+      // Check the headers
+      expect(actualRequest.headers.get('Content-Disposition')).toBe(`attachment; filename="${snapshotName}"`);
+      expect(actualRequest.headers.get('Content-Type')).toBe('application/gzip');
+      expect(actualRequest.headers.get('api-key')).toBe(apiKey);
     });
   });
 

src/common/client.test.js

@@ -119,6 +119,11 @@ const CodeEditorWindow = ({ onChange, code, onChangeResult, setRequestCount }) =
           onChangeResult('code', bigIntJSON.stringify(result));
           setRequestCount((prev) => prev - 1);
         });
+      } else {
+        // Remove the decoration
+        decorations = editor.deltaDecorations([decorations[0]], []);
+        // Remove the command
+        editor.addCommand(monaco.KeyMod.CtrlCmd + monaco.KeyCode.Enter, () => {});
       }
     });
   }

src/components/CodeEditorWindow/index.jsx

@@ -47,7 +47,6 @@ GET collections/startups
 }
 
 PUT collections/demo1
-
 {
     "vectors":
     {
@@ -61,7 +60,7 @@ PUT collections/demo1
 describe('parser', () => {
   it('Should extract query blocks from code', () => {
     const requests = getCodeBlocks(testCode);
-    expect(requests.length).toEqual(10);
+    expect(requests.length).toEqual(8);
     expect(requests[1].blockStartLine).toEqual(3);
     expect(requests[1].blockEndLine).toEqual(10);
     expect(requests[2].blockStartLine).toEqual(requests[2].blockEndLine);
@@ -164,25 +163,6 @@ describe('parser', () => {
     //     }
     // }
     block = selectBlock(blocks, 38);
-    requests = codeParse(block.blockText);
-    expect(requests.method).toEqual(null);
-    expect(requests.endpoint).toEqual(null);
-    expect(requests.error).toEqual('Add Headline or remove the line gap between json and headline (if any)');
-
-    // 47
-    // PUT collections/demo1
-    //   //47 this line should be ignored
-    // {
-    //     "vectors":
-    //     {
-    //         "size": 1,
-    //         "distance": "Cosine"
-    //     }
-    // }
-    block = selectBlock(blocks, 47);
-    requests = codeParse(block.blockText);
-    expect(requests.method).toEqual(null);
-    expect(requests.endpoint).toEqual(null);
-    expect(requests.error).toEqual('Add Headline or remove the line gap between json and headline (if any)');
+    expect(block).toEqual(null);
   });
 });

src/components/CodeEditorWindow/parser.test.js

@@ -137,53 +137,150 @@ export function selectBlock(blocks, location) {
   return null;
 }
 
-export function getCodeBlocks(codeText) {
-  const codeArray = codeText.split(/\r?\n/);
-  const blocksArray = [];
-  let block = { blockText: '', blockStartLine: null, blockEndLine: null };
-  let backetcount = 0;
-  let codeStarLine = 0;
-  let codeEndline = 0;
-  for (let i = 0; i < codeArray.length; ++i) {
-    // dealing for request which have JSON Body
-    if (codeArray[i].includes('{')) {
-      if (backetcount === 0) {
-        codeStarLine = i;
-        block.blockText = codeArray[i - 1] + ' \n ';
+/*
+A function which parses text into blocks of code.
+
+Each block is an HTTP request, which starts with a method (GET, POST, etc) and optionally has a JSON body.
+
+Example of code block:
+
+```
+POST collections/collection_name/points/scroll
+{
+  "limit": 10,
+  "filter": {
+    "must":{
+      "key": "city",
+      "match": {
+        "value": "Berlin"
       }
-      backetcount = backetcount + codeArray[i].match(/{/gi).length;
     }
-    if (codeArray[i].includes('}')) {
-      backetcount = backetcount - codeArray[i].match(/}/gi).length;
-      if (backetcount === 0) {
-        codeEndline = i + 1;
-      }
+  }
+}
+```
+
+Function should find all such blocks in the text and return them as an array of objects.
+Example of return value:
+
+```
+[
+  {
+    blockText: '<here full text of the block>',
+    blockStartLine: 7,
+    blockEndLine: 16
+  }
+]
+```
+
+All other lines should be ignored.
+
+Example of input text:
+
+```
+// List all collections
+GET collections
+
+// Get collection info
+GET collections/collection_name
+
+// List points in a collection, using filter
+POST collections/collection_name/points/scroll
+{
+  "limit": 10
+}
+
+unrelated text
+```
+
+Example of return value:
+
+```
+[
+  {
+    blockText: 'GET collections',
+    blockStartLine: 1,
+    blockEndLine: 1
+  },
+  {
+    blockText: 'GET collections/collection_name',
+    blockStartLine: 3,
+    blockEndLine: 3
+  },
+  {
+    blockText: 'POST collections/collection_name/points/scroll\n{\n  "limit": 10\n}',
+    blockStartLine: 7,
+    blockEndLine: 10
+  }
+]
+
+*/
+export function getCodeBlocks(text) {
+  // Define HTTP methods
+  const HTTP_METHODS = new Set(Method);
+
+  const lines = text.split(/\r?\n/);
+  const blocks = [];
+  const totalLines = lines.length;
+  let i = 0;
+
+  while (i < totalLines) {
+    const line = lines[i].trim();
+    if (line === '') {
+      i++;
+      continue; // Ignore empty lines
     }
-    if (codeStarLine) {
-      block.blockStartLine = codeStarLine;
-      block.blockText = block.blockText + codeArray[i] + '\n';
-      if (codeEndline) {
-        block.blockEndLine = codeEndline;
-        blocksArray.push(block);
-        codeEndline = 0;
-        codeStarLine = 0;
-        block = { blockText: '', blockStartLine: null, blockEndLine: null };
+
+    // Split the line by whitespace to get the first word
+    const firstWord = line.split(/\s+/)[0].toUpperCase();
+
+    if (HTTP_METHODS.has(firstWord)) {
+      const blockStartLine = i + 1; // 1-based indexing
+      let blockText = lines[i];
+      let blockEndLine = blockStartLine;
+
+      // Check if next line exists and starts with '{'
+      let j = i + 1;
+      if (j < totalLines && lines[j].trim().startsWith('{')) {
+        // Start of JSON body
+        const jsonLines = [];
+        let braceCount = 0;
+        while (j < totalLines) {
+          const currentLine = lines[j];
+          jsonLines.push(currentLine);
+          // Count braces to find the matching closing brace
+          for (const char of currentLine) {
+            if (char === '{') braceCount++;
+            else if (char === '}') braceCount--;
+          }
+          if (braceCount === 0) {
+            break; // Found the closing brace
+          }
+          j++;
+        }
+
+        if (braceCount !== 0) {
+          // JSON body is not closed
+          i++;
+          continue;
+        }
+        blockText += '\n' + jsonLines.join('\n');
+        blockEndLine = j + 1;
+        i = j + 1;
+      } else {
+        // No JSON body
+        i++;
       }
-    }
 
-    // dealing for request which don't have JSON Body
-    if (
-      codeArray[i].replace(/\s/g, '').length &&
-      backetcount === 0 &&
-      !codeArray[i].includes('}') &&
-      !codeArray[i + 1]?.includes('{')
-    ) {
-      block.blockText = codeArray[i];
-      block.blockStartLine = i + 1;
-      block.blockEndLine = i + 1;
-      blocksArray.push(block);
-      block = { blockText: '', blockStartLine: null, blockEndLine: null };
+      blocks.push({
+        blockText: blockText,
+        blockStartLine: blockStartLine,
+        blockEndLine: blockEndLine,
+      });
+    } else {
+      // Not a code block start
+      i++;
     }
   }
-  return blocksArray;
+
+  return blocks;
 }

src/components/EditorCommon/config/Rules.js

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { getCodeBlocks } from '../config/Rules';
+
+describe('get-code-blocks', () => {
+  it('should return 4 code blocks', () => {
+    const codeText = `
+// List all collections
+GET collections
+
+// Get collection info
+GET collections/collection_name
+
+// List points in a collection, using filter
+POST collections/collection_name/points/scroll
+{
+  "limit": 10,
+  "filter": {
+    "must": [
+      {
+        "key": "city",
+        "match": {
+          "any": [
+            "San Francisco",
+            "New York",
+            "Berlin"
+          ]
+        }
+      }
+    ]
+  }
+}
+
+lalal something unrelated
+
+GET collections/collection_name/points/{point_id}
+`;
+    let blocks = getCodeBlocks(codeText);
+
+    expect(blocks.length).toBe(4);
+  });
+
+  it('should return 1 code block with correct start and end lines', () => {
+    const codeText = `
+// List all collections
+GET collections
+
+// Get collection info
+THIS IS NOT A CODE BLOCK
+{
+    lalalal
+}
+
+`;
+
+    let blocks = getCodeBlocks(codeText);
+
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].blockStartLine).toBe(3);
+    expect(blocks[0].blockEndLine).toBe(3);
+  });
+
+  it('incomplete block should be ignored', () => {
+    const codeText = `
+// List all collections
+GET collections
+
+// Scrolling through points
+POST collections/collection_name/points/scroll
+{
+  "limit": 10
+
+This is not a complete block
+
+// Get point info
+GET collections/collection_name/points/{point_id}
+
+`;
+    let blocks = getCodeBlocks(codeText);
+
+    expect(blocks.length).toBe(2);
+
+    expect(blocks[0].blockStartLine).toBe(3);
+    expect(blocks[0].blockEndLine).toBe(3);
+    // The incomplete block should be ignored
+    // Go straight to the next block
+    expect(blocks[1].blockStartLine).toBe(13);
+    expect(blocks[1].blockEndLine).toBe(13);
+  });
+});