Add bullet parsing functionality and corresponding tests

alpha912 · alpha912 · commit 51b402a1df7b · 2025-06-27T23:46:51.000+02:00
## Summary
- Introduced a new function `parseBullets` to handle bullet points with proper brace matching and escape sequences.
- Added a function `removeBulletsBlock` to cleanly remove bullet blocks from slide content.
- Created a new example file `braces_in_bullets.osf` demonstrating various bullet formats, including nested braces and escaped characters.
- Expanded test suite to cover new bullet parsing scenarios, including handling of empty bullet blocks and unclosed bullet blocks.

## Testing
- `pnpm test` to ensure all new and existing tests pass successfully.
diff --git a/examples/braces_in_bullets.osf b/examples/braces_in_bullets.osf
@@ -0,0 +1,27 @@
+@meta {
+  title: "Braces in Bullet Strings Example";
+  author: "OSF Parser";
+  version: "0.5.0";
+}
+
+@slide {
+  title: "Code Examples";
+  layout: TitleAndBullets;
+  bullets {
+    "JavaScript function: function() { return true; }";
+    "Object literal: { key: \"value\", nested: { inner: 42 } }";
+    "Array with objects: [{ id: 1, name: \"John\" }, { id: 2, name: \"Jane\" }]";
+    "Complex nested: { outer: { middle: { inner: \"deep value\" } } }";
+    "Mixed quotes and braces: { \"key\": \"value with { braces }\" }";
+  }
+}
+
+@slide {
+  title: "Escaped Characters";
+  layout: TitleAndBullets;
+  bullets {
+    "Quote inside: \"Hello World\"";
+    "Mixed syntax: { \"property\": \"value\" }";
+    "Escaped backslash: \\\"literal backslash quote\\\"";
+  }
+} 
diff --git a/parser/src/parser.ts b/parser/src/parser.ts
@@ -71,7 +71,19 @@ function parseString(str: string, i: number): { value: string; index: number } {
   let j = i + 1;
   let out = '';
   while (j < str.length && str[j] !== '"') {
-    out += str[j++];
+          if (str[j] === '\\' && j + 1 < str.length) {
+        // Handle escape sequences
+        const nextChar = str[j + 1];
+        if (nextChar === '"' || nextChar === '\\') {
+          out += nextChar;
+        } else {
+          out += str[j]! + nextChar!;
+        }
+        j += 2;
+    } else {
+      out += str[j];
+      j++;
+    }
   }
   return { value: out, index: j + 1 };
 }
@@ -138,6 +150,133 @@ function parseKV(content: string): Record<string, any> {
   return parseKVInternal(cleaned, 0).obj;
 }
 
+function parseBullets(content: string): string[] {
+  // Find the bullets block with proper brace matching
+  const bulletMatch = /bullets\s*\{/.exec(content);
+  if (!bulletMatch) return [];
+
+  let i = bulletMatch.index + bulletMatch[0].length;
+  let depth = 1;
+  let bulletContent = '';
+
+  // Find the matching closing brace, respecting quoted strings
+  while (i < content.length && depth > 0) {
+    const ch = content[i];
+    if (ch === '"') {
+      // Add the opening quote
+      bulletContent += ch;
+      i++;
+      // Process the string content, preserving escape sequences
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === '\\' && i + 1 < content.length) {
+          // Keep escape sequences as-is for now
+          bulletContent += content[i]! + content[i + 1]!;
+          i += 2;
+        } else {
+          bulletContent += content[i];
+          i++;
+        }
+      }
+      if (i < content.length) {
+        bulletContent += content[i]; // closing quote
+        i++;
+      }
+    } else if (ch === '{') {
+      depth++;
+      bulletContent += ch;
+      i++;
+    } else if (ch === '}') {
+      depth--;
+      if (depth > 0) {
+        bulletContent += ch;
+      }
+      i++;
+    } else {
+      bulletContent += ch;
+      i++;
+    }
+  }
+
+  if (depth > 0) {
+    throw new Error('Unclosed bullets block');
+  }
+
+  // Parse individual bullet items more carefully
+  const bullets: string[] = [];
+  let j = 0;
+  
+  while (j < bulletContent.length) {
+    j = skipWS(bulletContent, j);
+    if (j >= bulletContent.length) break;
+
+    if (bulletContent[j] === '"') {
+      // Parse quoted string using the existing parseString function
+      const result = parseString(bulletContent, j);
+      bullets.push(result.value);
+      j = result.index;
+      
+      // Skip whitespace and optional semicolon
+      j = skipWS(bulletContent, j);
+      if (j < bulletContent.length && bulletContent[j] === ';') {
+        j++;
+      }
+    } else {
+      // Handle unquoted content (skip to next semicolon or end)
+      const start = j;
+      while (j < bulletContent.length && bulletContent[j] !== ';') {
+        j++;
+      }
+      const item = bulletContent.slice(start, j).trim();
+      if (item) {
+        bullets.push(item);
+      }
+      if (j < bulletContent.length && bulletContent[j] === ';') {
+        j++;
+      }
+    }
+  }
+
+  return bullets;
+}
+
+function removeBulletsBlock(content: string): string {
+  const bulletMatch = /bullets\s*\{/.exec(content);
+  if (!bulletMatch) return content;
+
+  let i = bulletMatch.index + bulletMatch[0].length;
+  let depth = 1;
+
+  // Find the matching closing brace, respecting quoted strings
+  while (i < content.length && depth > 0) {
+    const ch = content[i];
+    if (ch === '"') {
+      // Skip over quoted string
+      i++;
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === '\\' && i + 1 < content.length) {
+          i += 2;
+        } else {
+          i++;
+        }
+      }
+      if (i < content.length) {
+        i++; // closing quote
+      }
+    } else if (ch === '{') {
+      depth++;
+      i++;
+    } else if (ch === '}') {
+      depth--;
+      i++;
+    } else {
+      i++;
+    }
+  }
+
+  // Remove the entire bullets block
+  return content.slice(0, bulletMatch.index) + content.slice(i);
+}
+
 export function parse(input: string): OSFDocument {
   const blocksRaw = findBlocks(input);
   const blocks: OSFBlock[] = blocksRaw.map(b => {
@@ -151,18 +290,13 @@ export function parse(input: string): OSFDocument {
       }
       case 'slide': {
         const slide: SlideBlock = { type: 'slide' };
-        const bulletMatch = /bullets\s*\{([\s\S]*?)\}/.exec(b.content);
-        if (bulletMatch) {
-          const bulletContent = bulletMatch[1];
-          if (bulletContent) {
-            const items = bulletContent
-              .split(/;\s*/)
-              .map(s => s.trim())
-              .filter(Boolean);
-            slide.bullets = items.map(it => it.replace(/^"|"$/g, ''));
-          }
-        }
-        const rest = b.content.replace(/bullets\s*\{[\s\S]*?\}/, '');
+        
+        // Use the new bullet parser
+        const bullets = parseBullets(b.content);
+        slide.bullets = bullets;
+        
+        // Remove bullets block from content before parsing other properties
+        const rest = removeBulletsBlock(b.content);
         Object.assign(slide, parseKV(rest));
         return slide;
       }
@@ -260,8 +394,8 @@ export function serialize(doc: OSFDocument): string {
             }
           });
 
-          // Add bullets if they exist
-          if (bullets && bullets.length > 0) {
+          // Add bullets if they exist (including empty arrays for consistency)
+          if (bullets !== undefined) {
             parts.push('  bullets {');
             bullets.forEach(bullet => {
               parts.push(`    "${bullet}";`);
diff --git a/parser/tests/parser.test.ts b/parser/tests/parser.test.ts
@@ -60,6 +60,141 @@ describe('OSF Parser', () => {
       expect(slideBlock.bullets).toEqual(['First bullet', 'Second bullet', 'Third bullet']);
     });
 
+    it('should parse slide bullets with braces inside strings', () => {
+      const input = `@slide {
+        title: "Test Slide";
+        bullets {
+          "Function call: func() { return true; }";
+          "Object literal: { key: value }";
+          "Array with objects: [{ id: 1 }, { id: 2 }]";
+          "Nested braces: { outer: { inner: \\"value\\" } }";
+        }
+      }`;
+
+      const result = parse(input);
+
+      expect(result.blocks).toHaveLength(1);
+      expect(result.blocks[0]?.type).toBe('slide');
+
+      const slideBlock = result.blocks[0] as SlideBlock;
+      expect(slideBlock.title).toBe('Test Slide');
+      expect(slideBlock.bullets).toEqual([
+        'Function call: func() { return true; }',
+        'Object literal: { key: value }',
+        'Array with objects: [{ id: 1 }, { id: 2 }]',
+        'Nested braces: { outer: { inner: "value" } }'
+      ]);
+    });
+
+    it('should parse slide bullets with escaped quotes', () => {
+      const input = `@slide {
+        title: "Test Slide";
+        bullets {
+          "Quote inside: \\"Hello World\\"";
+          "Mixed: { \\"key\\": \\"value\\" }";
+          "Escaped backslash: \\\\\\"test\\\\\\"";
+        }
+      }`;
+
+      const result = parse(input);
+
+      expect(result.blocks).toHaveLength(1);
+      const slideBlock = result.blocks[0] as SlideBlock;
+      expect(slideBlock.bullets).toEqual([
+        'Quote inside: "Hello World"',
+        'Mixed: { "key": "value" }',
+        'Escaped backslash: \\"test\\"'
+      ]);
+    });
+
+    it('should handle empty bullets block', () => {
+      const input = `@slide {
+        title: "Test Slide";
+        bullets {
+        }
+      }`;
+
+      const result = parse(input);
+
+      expect(result.blocks).toHaveLength(1);
+      const slideBlock = result.blocks[0] as SlideBlock;
+      expect(slideBlock.bullets).toEqual([]);
+    });
+
+    it('should handle bullets with only whitespace', () => {
+      const input = `@slide {
+        title: "Test Slide";
+        bullets {
+          
+          
+        }
+      }`;
+
+      const result = parse(input);
+
+      expect(result.blocks).toHaveLength(1);
+      const slideBlock = result.blocks[0] as SlideBlock;
+      expect(slideBlock.bullets).toEqual([]);
+    });
+
+    it('should handle bullets with trailing semicolons', () => {
+      const input = `@slide {
+        title: "Test Slide";
+        bullets {
+          "First bullet";
+          "Second bullet";
+          "Third bullet";
+        }
+      }`;
+
+      const result = parse(input);
+
+      expect(result.blocks).toHaveLength(1);
+      const slideBlock = result.blocks[0] as SlideBlock;
+      expect(slideBlock.bullets).toEqual(['First bullet', 'Second bullet', 'Third bullet']);
+    });
+
+    it('should handle bullets without trailing semicolons', () => {
+      const input = `@slide {
+        title: "Test Slide";
+        bullets {
+          "First bullet"
+          "Second bullet"
+          "Third bullet"
+        }
+      }`;
+
+      const result = parse(input);
+
+      expect(result.blocks).toHaveLength(1);
+      const slideBlock = result.blocks[0] as SlideBlock;
+      expect(slideBlock.bullets).toEqual(['First bullet', 'Second bullet', 'Third bullet']);
+    });
+
+    it('should throw error for unclosed bullets block', () => {
+      const input = `@slide {
+        title: "Test Slide";
+        bullets {
+          "First bullet";
+          "Second bullet";
+        }
+      }`;
+
+      // This should work fine
+      const result = parse(input);
+      expect(result.blocks).toHaveLength(1);
+      
+      // Test a truly unclosed bullets block
+      const badInput = `@slide {
+        title: "Test Slide";
+        bullets {
+          "First bullet";
+          "Second bullet"
+      }`;
+
+      expect(() => parse(badInput)).toThrow('Missing closing } for block slide');
+    });
+
     it('should parse a sheet block with data and formulas', () => {
       const input = `@sheet {
         name: "TestSheet";
@@ -147,6 +282,7 @@ describe('OSF Parser', () => {
       const docBlock = result.blocks[0] as DocBlock;
       expect(docBlock.content).toBe('');
     });
+
   });
 
   describe('serialize', () => {
