c-next 0.2.12 → 0.2.13

package/src/transpiler/data/__tests__/CppEntryPointScanner.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import CppEntryPointScanner from "../CppEntryPointScanner";
+import IFileSystem from "../../types/IFileSystem";
+
+describe("CppEntryPointScanner", () => {
+  let mockFs: IFileSystem;
+  let files: Map<string, string>;
+
+  beforeEach(() => {
+    files = new Map();
+    mockFs = {
+      readFile: (path: string) => {
+        const content = files.get(path);
+        if (!content) throw new Error(`File not found: ${path}`);
+        return content;
+      },
+      exists: (path: string) => files.has(path),
+      isDirectory: () => false,
+      isFile: (path: string) => files.has(path),
+      writeFile: () => {},
+      mkdir: () => {},
+      readdir: () => [],
+      stat: () => ({ mtimeMs: Date.now() }),
+    };
+  });
+
+  describe("scan", () => {
+    it("should find .cnx source from header with marker", () => {
+      files.set("/project/main.cpp", '#include "led.h"\nint main() {}');
+      files.set(
+        "/project/led.h",
+        `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */
+void led_on(void);`,
+      );
+      files.set("/project/led.cnx", "scope LED { public void on() {} }");
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      expect(result.cnextSources).toHaveLength(1);
+      expect(result.cnextSources[0]).toBe("/project/led.cnx");
+    });
+
+    it("should return empty when no C-Next markers found", () => {
+      files.set("/project/main.cpp", '#include "utils.h"\nint main() {}');
+      files.set("/project/utils.h", "void utils_init(void);");
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      expect(result.cnextSources).toHaveLength(0);
+      expect(result.noCNextFound).toBe(true);
+    });
+
+    it("should follow transitive includes through .cnx sources", () => {
+      files.set("/project/main.cpp", '#include "middleware.h"');
+      files.set(
+        "/project/middleware.h",
+        `/**
+ * Generated by C-Next Transpiler from: middleware.cnx
+ */`,
+      );
+      files.set("/project/middleware.cnx", '#include "led.h"');
+      files.set(
+        "/project/led.h",
+        `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */`,
+      );
+      files.set("/project/led.cnx", "scope LED {}");
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      expect(result.cnextSources).toContain("/project/middleware.cnx");
+      expect(result.cnextSources).toContain("/project/led.cnx");
+    });
+
+    it("should report error when marker points to missing .cnx", () => {
+      files.set("/project/main.cpp", '#include "led.h"');
+      files.set(
+        "/project/led.h",
+        `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */`,
+      );
+      // led.cnx does NOT exist
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]).toContain("led.cnx");
+      expect(result.errors[0]).toContain("led.h");
+    });
+
+    it("should handle cycle detection", () => {
+      files.set("/project/main.cpp", '#include "a.h"');
+      files.set(
+        "/project/a.h",
+        `/**
+ * Generated by C-Next Transpiler from: a.cnx
+ */`,
+      );
+      files.set("/project/a.cnx", '#include "b.h"');
+      files.set(
+        "/project/b.h",
+        `/**
+ * Generated by C-Next Transpiler from: b.cnx
+ */`,
+      );
+      files.set("/project/b.cnx", '#include "a.h"'); // cycle back to a.h
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      // Should not infinite loop
+      expect(result.cnextSources).toContain("/project/a.cnx");
+      expect(result.cnextSources).toContain("/project/b.cnx");
+    });
+
+    it("should handle multiple includes in one file", () => {
+      files.set(
+        "/project/main.cpp",
+        `#include "led.h"
+#include "motor.h"
+int main() {}`,
+      );
+      files.set(
+        "/project/led.h",
+        `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */`,
+      );
+      files.set("/project/led.cnx", "scope LED {}");
+      files.set(
+        "/project/motor.h",
+        `/**
+ * Generated by C-Next Transpiler from: motor.cnx
+ */`,
+      );
+      files.set("/project/motor.cnx", "scope Motor {}");
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      expect(result.cnextSources).toHaveLength(2);
+      expect(result.cnextSources).toContain("/project/led.cnx");
+      expect(result.cnextSources).toContain("/project/motor.cnx");
+    });
+
+    it("should skip system includes", () => {
+      files.set(
+        "/project/main.cpp",
+        `#include <stdio.h>
+#include "led.h"
+int main() {}`,
+      );
+      files.set(
+        "/project/led.h",
+        `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */`,
+      );
+      files.set("/project/led.cnx", "scope LED {}");
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      // Should only find led.cnx, not fail on stdio.h
+      expect(result.cnextSources).toHaveLength(1);
+      expect(result.cnextSources[0]).toBe("/project/led.cnx");
+    });
+
+    it("should scan non-C-Next headers for nested includes", () => {
+      files.set("/project/main.cpp", '#include "wrapper.h"');
+      files.set("/project/wrapper.h", '#include "led.h"\nvoid wrapper_init();');
+      files.set(
+        "/project/led.h",
+        `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */`,
+      );
+      files.set("/project/led.cnx", "scope LED {}");
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      expect(result.cnextSources).toHaveLength(1);
+      expect(result.cnextSources[0]).toBe("/project/led.cnx");
+    });
+
+    it("should handle old-style C-Next markers without source path", () => {
+      files.set("/project/main.cpp", '#include "led.h"');
+      files.set(
+        "/project/led.h",
+        `/**
+ * Generated by C-Next Transpiler
+ */
+void led_on(void);`,
+      );
+
+      const scanner = new CppEntryPointScanner(["/project"], mockFs);
+      const result = scanner.scan("/project/main.cpp");
+
+      // Old marker without source path - should be treated as C-Next generated
+      // but without a source path, we can't add it to cnextSources
+      expect(result.cnextSources).toHaveLength(0);
+      // Should not follow includes from old-style C-Next headers (they're leaf nodes)
+    });
+
+    it("should find .cnx source via search paths when --header-out is used", () => {
+      // Simulate --header-out: headers in include/, sources in src/
+      files.set("/project/main.cpp", '#include "led.h"');
+      files.set(
+        "/project/include/led.h",
+        `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */
+void led_on(void);`,
+      );
+      // Source is in src/, not include/
+      files.set("/project/src/led.cnx", "scope LED { public void on() {} }");
+
+      // Scanner search paths include src/
+      const scanner = new CppEntryPointScanner(
+        ["/project/include", "/project/src"],
+        mockFs,
+      );
+      const result = scanner.scan("/project/main.cpp");
+
+      expect(result.cnextSources).toHaveLength(1);
+      expect(result.cnextSources[0]).toBe("/project/src/led.cnx");
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+});

package/src/transpiler/data/__tests__/FileDiscovery.test.ts

@@ -2,7 +2,6 @@
  * Unit tests for FileDiscovery
  *
  * Tests file discovery functionality:
- * - discover: Scan directories for source files
  * - discoverFile: Discover single file
  * - discoverFiles: Discover multiple files
  * - filterByType, getCNextFiles, getHeaderFiles: Filter utilities
@@ -37,11 +36,6 @@ describe("FileDiscovery", () => {
     // Create source files
     writeFileSync(join(srcDir, "impl.c"), "int main() {}");
     writeFileSync(join(srcDir, "impl.cpp"), "int main() {}");
-
-    // Create nested structure
-    mkdirSync(join(srcDir, "modules"), { recursive: true });
-    writeFileSync(join(srcDir, "modules", "display.cnx"), "scope Display {}");
-    writeFileSync(join(srcDir, "modules", "io.cnx"), "scope IO {}");
   });
 
   afterEach(() => {
@@ -51,140 +45,6 @@ describe("FileDiscovery", () => {
     vi.restoreAllMocks();
   });
 
-  // ==========================================================================
-  // discover
-  // ==========================================================================
-
-  describe("discover", () => {
-    it("discovers all files in directory recursively by default", () => {
-      const files = FileDiscovery.discover([srcDir]);
-
-      // Should find main.cnx, utils.cnx, legacy.cnext, impl.c, impl.cpp,
-      // modules/display.cnx, modules/io.cnx
-      expect(files.length).toBeGreaterThanOrEqual(5);
-      expect(files.some((f) => f.path.endsWith("main.cnx"))).toBe(true);
-      expect(files.some((f) => f.path.endsWith("display.cnx"))).toBe(true);
-    });
-
-    it("discovers files non-recursively when recursive=false", () => {
-      const files = FileDiscovery.discover([srcDir], { recursive: false });
-
-      // Should find files in srcDir but not in modules/
-      expect(files.some((f) => f.path.endsWith("main.cnx"))).toBe(true);
-      expect(files.some((f) => f.path.endsWith("display.cnx"))).toBe(false);
-    });
-
-    it("filters by extensions when specified", () => {
-      const files = FileDiscovery.discover([srcDir], { extensions: [".cnx"] });
-
-      // Should only find .cnx files
-      expect(files.every((f) => f.extension === ".cnx")).toBe(true);
-      expect(files.some((f) => f.path.endsWith("impl.c"))).toBe(false);
-    });
-
-    it("discovers files from multiple directories", () => {
-      const files = FileDiscovery.discover([srcDir, includeDir]);
-
-      expect(files.some((f) => f.path.endsWith("main.cnx"))).toBe(true);
-      expect(files.some((f) => f.path.endsWith("types.h"))).toBe(true);
-    });
-
-    it("removes duplicates from overlapping directories (Issue #331)", () => {
-      // srcDir is already under testDir
-      const files = FileDiscovery.discover([testDir, srcDir]);
-
-      // Count files with same path
-      const paths = files.map((f) => f.path);
-      const uniquePaths = new Set(paths);
-
-      expect(paths.length).toBe(uniquePaths.size);
-    });
-
-    it("classifies C-Next files correctly", () => {
-      const files = FileDiscovery.discover([srcDir], { extensions: [".cnx"] });
-
-      const cnxFile = files.find((f) => f.path.endsWith("main.cnx"));
-      expect(cnxFile).toBeDefined();
-      expect(cnxFile!.type).toBe(EFileType.CNext);
-      expect(cnxFile!.extension).toBe(".cnx");
-    });
-
-    it("classifies .cnext files as C-Next", () => {
-      const files = FileDiscovery.discover([srcDir], {
-        extensions: [".cnext"],
-      });
-
-      const cnextFile = files.find((f) => f.path.endsWith("legacy.cnext"));
-      expect(cnextFile).toBeDefined();
-      expect(cnextFile!.type).toBe(EFileType.CNext);
-    });
-
-    it("classifies header files correctly", () => {
-      const files = FileDiscovery.discover([includeDir]);
-
-      const hFile = files.find((f) => f.path.endsWith("types.h"));
-      expect(hFile).toBeDefined();
-      expect(hFile!.type).toBe(EFileType.CHeader);
-
-      const hppFile = files.find((f) => f.path.endsWith("utils.hpp"));
-      expect(hppFile).toBeDefined();
-      expect(hppFile!.type).toBe(EFileType.CppHeader);
-    });
-
-    it("classifies source files correctly", () => {
-      const files = FileDiscovery.discover([srcDir]);
-
-      const cFile = files.find((f) => f.path.endsWith("impl.c"));
-      expect(cFile).toBeDefined();
-      expect(cFile!.type).toBe(EFileType.CSource);
-
-      const cppFile = files.find((f) => f.path.endsWith("impl.cpp"));
-      expect(cppFile).toBeDefined();
-      expect(cppFile!.type).toBe(EFileType.CppSource);
-    });
-
-    it("warns when directory not found", () => {
-      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-
-      const files = FileDiscovery.discover([join(testDir, "nonexistent")]);
-
-      expect(files).toHaveLength(0);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Directory not found"),
-      );
-    });
-
-    it("uses default ignore patterns", () => {
-      // Create node_modules directory (should be ignored)
-      mkdirSync(join(srcDir, "node_modules"), { recursive: true });
-      writeFileSync(join(srcDir, "node_modules", "dep.cnx"), "// dep");
-
-      const files = FileDiscovery.discover([srcDir]);
-
-      expect(files.some((f) => f.path.includes("node_modules"))).toBe(false);
-    });
-
-    it("uses custom exclude patterns when provided", () => {
-      // Create a test directory that would normally be included
-      mkdirSync(join(srcDir, "excluded"), { recursive: true });
-      writeFileSync(join(srcDir, "excluded", "skip.cnx"), "// skip");
-
-      const files = FileDiscovery.discover([srcDir], {
-        excludePatterns: [/excluded/],
-      });
-
-      expect(files.some((f) => f.path.includes("excluded"))).toBe(false);
-    });
-
-    it("returns absolute paths", () => {
-      const files = FileDiscovery.discover([srcDir]);
-
-      for (const file of files) {
-        expect(file.path.startsWith("/")).toBe(true);
-      }
-    });
-  });
-
   // ==========================================================================
   // discoverFile
   // ==========================================================================
@@ -282,7 +142,14 @@ describe("FileDiscovery", () => {
 
   describe("filterByType", () => {
     it("filters files by C-Next type", () => {
-      const allFiles = FileDiscovery.discover([testDir]);
+      const allFiles = FileDiscovery.discoverFiles([
+        join(srcDir, "main.cnx"),
+        join(srcDir, "utils.cnx"),
+        join(srcDir, "legacy.cnext"),
+        join(srcDir, "impl.c"),
+        join(srcDir, "impl.cpp"),
+        join(includeDir, "types.h"),
+      ]);
       const cnxFiles = FileDiscovery.filterByType(allFiles, EFileType.CNext);
 
       expect(cnxFiles.every((f) => f.type === EFileType.CNext)).toBe(true);
@@ -290,16 +157,21 @@ describe("FileDiscovery", () => {
     });
 
     it("filters files by C header type", () => {
-      const allFiles = FileDiscovery.discover([testDir]);
+      const allFiles = FileDiscovery.discoverFiles([
+        join(srcDir, "main.cnx"),
+        join(includeDir, "types.h"),
+        join(includeDir, "utils.hpp"),
+      ]);
       const hFiles = FileDiscovery.filterByType(allFiles, EFileType.CHeader);
 
       expect(hFiles.every((f) => f.type === EFileType.CHeader)).toBe(true);
     });
 
     it("returns empty array when no matches", () => {
-      const cnxFiles = FileDiscovery.discover([srcDir], {
-        extensions: [".cnx"],
-      });
+      const cnxFiles = FileDiscovery.discoverFiles([
+        join(srcDir, "main.cnx"),
+        join(srcDir, "utils.cnx"),
+      ]);
       const hFiles = FileDiscovery.filterByType(cnxFiles, EFileType.CHeader);
 
       expect(hFiles).toHaveLength(0);
@@ -312,7 +184,13 @@ describe("FileDiscovery", () => {
 
   describe("getCNextFiles", () => {
     it("returns only C-Next files", () => {
-      const allFiles = FileDiscovery.discover([testDir]);
+      const allFiles = FileDiscovery.discoverFiles([
+        join(srcDir, "main.cnx"),
+        join(srcDir, "utils.cnx"),
+        join(srcDir, "legacy.cnext"),
+        join(srcDir, "impl.c"),
+        join(includeDir, "types.h"),
+      ]);
       const cnxFiles = FileDiscovery.getCNextFiles(allFiles);
 
       expect(cnxFiles.every((f) => f.type === EFileType.CNext)).toBe(true);
@@ -320,7 +198,11 @@ describe("FileDiscovery", () => {
     });
 
     it("includes both .cnx and .cnext files", () => {
-      const allFiles = FileDiscovery.discover([srcDir]);
+      const allFiles = FileDiscovery.discoverFiles([
+        join(srcDir, "main.cnx"),
+        join(srcDir, "utils.cnx"),
+        join(srcDir, "legacy.cnext"),
+      ]);
       const cnxFiles = FileDiscovery.getCNextFiles(allFiles);
 
       // Should include both main.cnx and legacy.cnext
@@ -335,7 +217,12 @@ describe("FileDiscovery", () => {
 
   describe("getHeaderFiles", () => {
     it("returns C and C++ header files", () => {
-      const allFiles = FileDiscovery.discover([includeDir]);
+      const allFiles = FileDiscovery.discoverFiles([
+        join(includeDir, "types.h"),
+        join(includeDir, "utils.hpp"),
+        join(includeDir, "config.hxx"),
+        join(srcDir, "impl.c"),
+      ]);
       const headerFiles = FileDiscovery.getHeaderFiles(allFiles);
 
       expect(headerFiles.length).toBeGreaterThan(0);
@@ -347,7 +234,11 @@ describe("FileDiscovery", () => {
     });
 
     it("includes .h, .hpp, and .hxx files", () => {
-      const allFiles = FileDiscovery.discover([includeDir]);
+      const allFiles = FileDiscovery.discoverFiles([
+        join(includeDir, "types.h"),
+        join(includeDir, "utils.hpp"),
+        join(includeDir, "config.hxx"),
+      ]);
       const headerFiles = FileDiscovery.getHeaderFiles(allFiles);
 
       expect(headerFiles.some((f) => f.extension === ".h")).toBe(true);
@@ -356,52 +247,15 @@ describe("FileDiscovery", () => {
     });
 
     it("excludes source files", () => {
-      const allFiles = FileDiscovery.discover([srcDir]);
+      const allFiles = FileDiscovery.discoverFiles([
+        join(srcDir, "impl.c"),
+        join(srcDir, "impl.cpp"),
+        join(includeDir, "types.h"),
+      ]);
       const headerFiles = FileDiscovery.getHeaderFiles(allFiles);
 
       expect(headerFiles.some((f) => f.extension === ".c")).toBe(false);
       expect(headerFiles.some((f) => f.extension === ".cpp")).toBe(false);
     });
   });
-
-  // ==========================================================================
-  // Edge cases
-  // ==========================================================================
-
-  describe("edge cases", () => {
-    it("handles empty directory", () => {
-      const emptyDir = join(testDir, "empty");
-      mkdirSync(emptyDir, { recursive: true });
-
-      const files = FileDiscovery.discover([emptyDir]);
-
-      expect(files).toHaveLength(0);
-    });
-
-    it("handles unknown file extensions", () => {
-      writeFileSync(join(srcDir, "readme.txt"), "text file");
-
-      const files = FileDiscovery.discover([srcDir], {
-        extensions: [".txt"],
-      });
-
-      // File should be discovered but with Unknown type
-      expect(files).toHaveLength(1);
-      expect(files[0].type).toBe(EFileType.Unknown);
-    });
-
-    it("handles mixed case extensions", () => {
-      // Note: fast-glob behavior varies by filesystem
-      // On case-sensitive filesystems, .CNX won't match .cnx pattern
-      writeFileSync(join(srcDir, "test-upper.cnx"), "// test file");
-
-      const files = FileDiscovery.discover([srcDir]);
-
-      // Extension should be lowercased
-      const testFile = files.find((f) => f.path.endsWith("test-upper.cnx"));
-      expect(testFile).toBeDefined();
-      expect(testFile!.extension).toBe(".cnx");
-      expect(testFile!.type).toBe(EFileType.CNext);
-    });
-  });
 });