Expand extractRule and add unit tests

Co-authored-by: Copilot <copilot@github.com>

Author: XanderVertegaal

frontend/src/app/annotate/annotation-parse-results/parse-tree-table/parse-tree-table.component.spec.ts

@@ -1,6 +1,6 @@
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 
-import { ParseTreeTableComponent } from './parse-tree-table.component';
+import { ParseTreeTableComponent, extractRule } from './parse-tree-table.component';
 import { TreeWithType } from '../annotation-parse-results.component';
 
 const mockTree: TreeWithType = {
@@ -35,3 +35,46 @@ describe('ParseTreeTableComponent', () => {
         expect(component).toBeTruthy();
     });
 });
+
+describe('extractRule', () => {
+    describe('standard format', () => {
+        it('should extract rule and content from standard format', () => {
+            const result = extractRule('fa[s:ng-np]');
+            expect(result).toEqual({ rule: 'fa', content: 's:ng-np' });
+        });
+
+        it('should extract rule with complex content', () => {
+            const result = extractRule('fa[(s:dcl\\np)/np]');
+            expect(result).toEqual({ rule: 'fa', content: '(s:dcl\\np)/np' });
+        });
+    });
+
+    describe('trivial @ rule', () => {
+        it('should return empty rule for @ symbol', () => {
+            const result = extractRule('@[np:nb]');
+            expect(result).toEqual({ rule: '', content: 'np:nb' });
+        });
+    });
+
+    describe('handle extra brackets', () => {
+        it('should strip extra opening brackets from content', () => {
+            const result = extractRule('fa[s:[ng-np]');
+            expect(result).toEqual({ rule: 'fa', content: 's:ng-np' });
+        });
+
+        it('should strip extra closing brackets from content', () => {
+            const result = extractRule('fa[s:ng]-np]');
+            expect(result).toEqual({ rule: 'fa', content: 's:ng-np' });
+        });
+
+        it('should strip multiple extra brackets from content', () => {
+            const result = extractRule('fa[s:[ng]-[np]]');
+            expect(result).toEqual({ rule: 'fa', content: 's:ng-np' });
+        });
+
+        it('should strip all internal brackets', () => {
+            const result = extractRule('ba[[[s:dcl]]]');
+            expect(result).toEqual({ rule: 'ba', content: 's:dcl' });
+        });
+    });
+});

frontend/src/app/annotate/annotation-parse-results/parse-tree-table/parse-tree-table.component.ts

@@ -72,33 +72,33 @@ function buildUnaryNode(node: UnaryNode): TreeNodeDisplay {
 /**
  * Parses a node string to extract the rule and the content.
  *
- * A node string is usually of the form "A(B)", where a is the rule applied
+ * A node string is usually of the form "A[B]", where a is the rule applied
  * and B is the resulting category. The rule is anything everything before
- * the first parenthesis. Everything within it is the content. For example,
- * in "fa(s:ng-np)", "fa" is the rule and "s:ng-np" is the content.
+ * the first bracket. Everything within it is the content. For example,
+ * in "fa[s:ng-np]", "fa" is the rule and "s:ng-np" is the content.
  *
- * Due to a bug in the CCG parser, sometimes the node string can have
- * multiple layers of parentheses, e.g. fa(((s:ng-np)-(s:ng-np))).
- * function only strips off the first.
+ * If there are more brackets, we ignore them.
+ *
+ * The rule symbolised by '@' is trivial and all too common, so it is ignored.
  *
  */
-function extractRule(nodeString: string): { rule: string, content: string; } {
-    const firstParen = nodeString.indexOf('(');
-    const lastParen = nodeString.lastIndexOf(')');
+export function extractRule(nodeString: string): { rule: string, content: string; } {
+    const firstBracket = nodeString.indexOf('[');
+    const lastBracket = nodeString.lastIndexOf(']');
 
     // Return a fallback value if the string is not what we expect.
-    if (firstParen === -1 || lastParen === -1 || lastParen < firstParen) {
+    if (firstBracket === -1 || lastBracket === -1 || lastBracket < firstBracket) {
         return {
             rule: "",
             content: nodeString
         };
     }
 
-    const rule = nodeString.slice(0, firstParen);
-    // Strip off any remaining parentheses due to the CCG parser bug.
-    const content = nodeString.slice(firstParen + 1, lastParen).replaceAll('(', '').replaceAll(')', '');
+    const rule = nodeString.slice(0, firstBracket);
+    // Strip off any remaining brackets.
+    const content = nodeString.slice(firstBracket + 1, lastBracket).replaceAll('[', '').replaceAll(']', '');
 
-    return { rule, content };
+    return { rule: rule === '@' ? "" : rule, content };
 }
 
 @Component({