Handle escaped quotes; Fix Vector return type color

.github/workflows/test.yml

@@ -0,0 +1,31 @@
+name: Tests
+
+on:
+  pull_request:
+    branches: [ main]
+  push:
+    branches: [ main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Run Jest
+      run: npx jest

README.md

@@ -21,3 +21,8 @@ npm install
 npm run dev
 ```
 
+### Run the tests
+
+```bash
+npx jest
+```

jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleFileExtensions: ['ts', 'js'],
+  testMatch: ['**/*.test.ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.test.ts'
+  ],
+  clearMocks: true,
+  setupFiles: ['<rootDir>/src/jest.setup.ts'],
+};

package.json

@@ -26,9 +26,12 @@
         "Pascal Aregger <pascal.aregger97@gmail.com>"
     ],
     "devDependencies": {
+        "@types/jest": "^30.0.0",
         "ifdef-loader": "^2.3.2",
+        "jest": "^30.2.0",
+        "ts-jest": "^29.4.4",
         "ts-loader": "^9.4.1",
-        "typescript": "^4.9.3",
+        "typescript": "^4.9.5",
         "webpack": "^5.75.0",
         "webpack-cli": "^5.0.0",
         "webpack-dev-server": "^4.11.1",

src/controls/label.ts

@@ -18,6 +18,7 @@ export class Label extends UserControl {
         this.text = text;
         this.font = (font || Constants.NODE_FONT);
         this.color = (color || Constants.NODE_TEXT_COLOR);
+        this.textAlign = 'left';
 
         this.padding = { top: 0, right: 0, bottom: 0, left: 0 }
     }

src/controls/tests/label.test.ts

@@ -0,0 +1,14 @@
+/// <reference types="jest" />
+
+import { Label } from '../label';
+
+describe('Label', () => {
+    test('constructor sets default values', () => {
+        const label = new Label('Test Text');
+
+        expect(label.text).toBe('Test Text');
+        expect(label.textAlign).toBeDefined();
+        expect(label.font).toBeDefined();
+        expect(label.color).toBeDefined();
+    });
+});

src/controls/utils/tests/color-utils.test.ts

@@ -0,0 +1,33 @@
+/// <reference types="jest" />
+
+import { ColorUtils } from '../color-utils';
+import { PinProperty } from '../../../data/pin/pin-property';
+import { PinCategory } from '../../../data/pin/pin-category';
+
+describe('ColorUtils', () => {
+    test('getPinColor handles null subCategoryObject', () => {
+        const pin = new PinProperty('TestNode');
+        pin.category = PinCategory.object;
+        pin.subCategoryObject = undefined;
+
+        const color = ColorUtils.getPinColor(pin);
+
+        expect(color).toBeDefined();
+        expect(typeof color).toBe('string');
+    });
+
+    test('getPinColor returns correct color for real category', () => {
+        const realPin = new PinProperty('RealPin');
+        realPin.category = PinCategory.real;
+        const realColor = ColorUtils.getPinColor(realPin);
+
+        const floatPin = new PinProperty('FloatPin');
+        floatPin.category = PinCategory.float;
+        const floatColor = ColorUtils.getPinColor(floatPin);
+
+        expect(realColor).toBeDefined();
+        expect(typeof realColor).toBe('string');
+        expect(realColor).toBe(floatColor);
+    });
+});
+

src/jest.setup.ts

@@ -0,0 +1,4 @@
+/// <reference types="jest" />
+
+// Mock browser APIs that aren't available in Node.js
+global.Path2D = jest.fn().mockImplementation((path) => ({ path }));

src/parser/node-friendly-names.ts

@@ -10,5 +10,6 @@ export const NodeFriendlyNames: { [name: string]: string; } = {
     'K2_GetTimerElapsedTimeHandle': 'Get Timer Elapsed Time by Handle',
     'K2_InvalidateTimerHandle': 'Invalidate',
     'K2_IsTimerActiveHandle': 'Is Timer Active by Handle',
-    'K2_DestroyActor': 'Destroy Actor'
+    'K2_DestroyActor': 'Destroy Actor',
+    'K2_GetActorLocation': 'Get Actor Location',
 }

src/parser/node-parsers/tests/call-function-node-parser.test.ts

@@ -0,0 +1,32 @@
+/// <reference types="jest" />
+
+import { CallFunctionNodeParser } from '../call-function-node.parser';
+import { ParsingNodeData } from '../../parsing-node-data';
+import { CallFunctionNode } from '../../../data/nodes/call-function.node';
+import { Vector2 } from '../../../math/vector2';
+
+describe('CallFunctionNodeParser', () => {
+    test('bDefaultsToPureFunc=True sets isPureFunc to true', () => {
+        const parser = new CallFunctionNodeParser();
+
+        const node: CallFunctionNode = {
+            pos: new Vector2(0, 0),
+            title: 'Test',
+            subTitles: [],
+            customProperties: [],
+            isPureFunc: false,
+            isConstFunc: false,
+            functionReference: null
+        } as CallFunctionNode;
+
+        const parsingData = new ParsingNodeData([
+            'Begin Object',
+            'bDefaultsToPureFunc=True',
+            'End Object'
+        ]);
+
+        parsingData.node = node;
+        parser.parse(parsingData);
+        expect(node.isPureFunc).toBe(true);
+    });
+});

src/parser/node-parsers/tests/generic-node-parser.test.ts

@@ -0,0 +1,52 @@
+/// <reference types="jest" />
+
+import { GenericNodeParser } from '../generic-node.parser';
+import { NodeParserRegistry } from "../../node-parser-registry";
+import { ParsingNodeData } from '../../parsing-node-data';
+import { PinDirection } from '../../../data/pin/pin-direction';
+import { TestableNodeControl } from '../../../tests/testable-node-control';
+
+
+// Mock UnrealNodeClass to reduce expensive constructor loop
+jest.mock('../../../data/classes/unreal-node-class', () => ({
+  UnrealNodeClass: {
+    CUSTOM_EVENT: '/Script/BlueprintGraph.K2Node_CustomEvent'
+  }
+}));
+
+describe('GenericNodeParser', () => {
+    let parser: GenericNodeParser;
+
+    beforeEach(() => {
+        let nodeParserRegistry = new NodeParserRegistry();
+        parser = new GenericNodeParser(nodeParserRegistry);
+    });
+
+    test('Can parse CustomProperties UserDefinedPin', () => {
+        const lines = [
+            'Begin Object Class=/Script/BlueprintGraph.K2Node_CustomEvent Name="K2Node_CustomEvent_4"',
+            '   NodeGuid=7E57DA7A000000000000000000000000',
+            'CustomProperties UserDefinedPin (PinName="Context",PinType=(PinCategory="object"),DesiredPinDirection=EGPD_Output)',
+            'End Object'
+        ];
+
+        const parsingData = new ParsingNodeData(lines);
+        const nodeControl = parser.parse(parsingData);
+        const result = new TestableNodeControl(nodeControl);
+
+        expect(result).toBeDefined();
+        expect(result.node).toBeDefined();
+        expect(result.node.customProperties).toBeDefined();
+
+        const userDefinedPin = result.node.customProperties.find((prop: any) => 
+            prop.constructor.name === 'PinProperty' && prop.name === 'Context'
+        ) as any;
+
+        expect(userDefinedPin).toBeDefined();
+        expect(userDefinedPin.name).toBe('Context');
+        expect(userDefinedPin.category).toBe('object');
+        expect(userDefinedPin.direction).toBe(PinDirection.EGPD_Output);
+    });
+
+});
+

src/parser/pin-property.parser.ts

@@ -97,13 +97,14 @@ export class PinPropertyParser implements CustomPropertyParser {
 
         // ([a-zA-Z0-9_.]+)                     Capture key (similar to \w, but also allows dots)
         // \s*=\s*                              Equal sign between optional white spaces
-        // (("[^"]*")|(\([^\)]*\))|([^,]*))     Captures a value implemented in one of 4 types
+        // (("[^"]*")|(\([^\)]*\))|([^,]*))     Captures a value implemented in one of several types
         //      ("[^"]*")                         Type 1: capture quoted values            e.g.: PinName="self"
         //      (\([^\)]*\))                      Type 2: capture values set in brackets   e.g.: LinkedTo=(K2Node_CallFunction_0 6A3D6AD94697B8938F5061A6BA9D5FF2,)
         //      (\w*\(\w*(?:[^\(]*\([^\)]*\))*\)) Type 3: capture multilevel loctext       e.g.: PinFriendlyName=LOCGEN_FORMAT_NAMED(NSLOCTEXT("KismetSchema", "SplitPinFriendlyNameFormat", "{PinDisplayName} {ProtoPinDisplayName}"), "PinDisplayName", NSLOCTEXT("", "E767B2BA4B1D5DFDD5E21E953300AB1E", "Settings"), "ProtoPinDisplayName", NSLOCTEXT("", "182F932842DA4BEA8624D89F6CD70FDA", "Attenuation Settings"))
         //      (\w*\([^\)]*\))                   Type 4: capture method values            e.g.: PinFriendlyName=NSLOCTEXT("K2Node", "Target", "Target")
         //      ([^,]*)                           Type 5: capture pure values              e.g.: PinType.bIsConst=False
-        const matches = propertyData.matchAll(/([a-zA-Z0-9_.]+)\s*=\s*(("[^"]*")|(\([^)]*\))|(\w*\(\w*(?:[^(]*\([^)]*(?:"[^"]*")\))*\))|(\w*\([^)]*\([^)]*\)[^)]*\))|(\w*\([^)]*\))|([^,]*))/g);
+        //      ("(?:[^"\\]|\\.)*\([^)]*\)")      Type 6: capture struct values with escaped quotes e.g.: DefaultValue="(ExecutionFunction=\"\",CallbackTarget=None)"
+        const matches = propertyData.matchAll(/([a-zA-Z0-9_.]+)\s*=\s*(("(?:[^"\\]|\\.)*\([^)]*\)")|("[^"]*")|(\([^)]*\))|(\w*\(\w*(?:[^(]*\([^)]*(?:"[^"]*")\))*\))|(\w*\([^)]*\([^)]*\)[^)]*\))|(\w*\([^)]*\))|([^,]*))/g);
 
         for (const [fullMatch, key, value] of matches) {
             if(!fullMatch || !key) { console.warn(`Skipped property attribute because invalid key: '${fullMatch}'`); continue; }
@@ -141,14 +142,26 @@ export class PinPropertyParser implements CustomPropertyParser {
 
 
     private static parseSubCategoryObject(value: string): PinSubCategoryObject {
-        let className = value;
-        let type = value.substring(0, value.indexOf("'"));
-        let matches = value.matchAll(/'"(.*)"'/g);
-        if (matches) {
-            let match = matches.next();
+        // Remove only the outer double quotes, preserve inner single quotes
+        if (value.startsWith('"') && value.endsWith('"')) {
+            value = value.substring(1, value.length - 1);
+        }
 
-            if (match && match.value) {
-                className = match.value[1];
+        let className = value;
+        let type = '';
+
+        // Check if there's a wrapper format like:
+        // /Script/CoreUObject.ScriptStruct'/Script/CoreUObject.Vector'
+        // Split by single quote to extract the parts
+        const quoteIndex = value.indexOf("'");
+        if (quoteIndex !== -1) {
+            // Extract the type (everything before the first single quote)
+            type = value.substring(0, quoteIndex);
+            // Extract the inner class path (between the single quotes)
+            const remainingPart = value.substring(quoteIndex + 1);
+            const endQuoteIndex = remainingPart.lastIndexOf("'");
+            if (endQuoteIndex !== -1) {
+                className = remainingPart.substring(0, endQuoteIndex);
             }
         }
 
@@ -158,6 +171,14 @@ export class PinPropertyParser implements CustomPropertyParser {
     private static parsePinFriendlyName(value: string): string {
         let name:string = "";
 
+        if (value.startsWith("INVTEXT")) {
+            let prefixLength = 'INVTEXT('.length;
+            value = value.substr(prefixLength, value.length - prefixLength - 1);
+
+            name = value.replace(/"/g, '');
+            return name;
+        }
+
         if (value.startsWith("NSLOCTEXT")) {
             let prefixLength = 'NSLOCTEXT('.length - 1;
             value = value.substr(prefixLength, value.length - prefixLength - 1);