Feature/quick scan (#5)

Author: Hermesiss

.github/workflows/build-and-release.yml

@@ -2,11 +2,11 @@ name: Build and Release
 
 on:
   push:
-    branches: ["main", "develop"]
+    branches: ["main", "develop", "feature/*"]
 
 jobs:
   build-windows:
-    if: github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.merged == true)
+    if: github.event_name == 'push' || (github.ref_name == 'develop' || github.ref_name == 'main' || startsWith(github.ref_name, 'feature/'))
     runs-on: windows-latest
 
     outputs:
@@ -67,7 +67,7 @@ jobs:
             dist/DevNullifier-win-unpacked.zip
 
   build-linux:
-    if: github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.merged == true)
+    if: github.event_name == 'push' || (github.ref_name == 'develop' || github.ref_name == 'main' || startsWith(github.ref_name, 'feature/'))
     runs-on: ubuntu-latest
 
     steps:
@@ -109,7 +109,7 @@ jobs:
             dist/DevNullifier-linux-unpacked.zip
 
   build-macos:
-    if: github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.merged == true)
+    if: github.event_name == 'push' || (github.ref_name == 'develop' || github.ref_name == 'main' || startsWith(github.ref_name, 'feature/'))
     runs-on: macos-latest
 
     steps:
@@ -148,7 +148,7 @@ jobs:
             dist/DevNullifier-mac-unpacked.zip
 
   create-release:
-    if: github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.merged == true)
+    if: github.event_name == 'push' && (github.ref_name == 'develop' || github.ref_name == 'main')
     runs-on: ubuntu-latest
     needs: [build-windows, build-linux, build-macos]
 

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to DevNullifier will be documented in this file.
 
+## [1.2.3] - Quick scan
+
+### Added
+
+- **Quick Scan**: scan only folders found during full scan
+
 ## [1.2.2] - Dark Mode
 
 ### Added

package.json

@@ -1,6 +1,6 @@
 {
   "name": "devnullifier",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "DevNullifier: Clean application data, dev caches (node_modules, .cache, Library, Binary, Intermediate, etc) with Electron, Vue 3, and Vuetify 3.",
   "main": "dist-main/main/main.js",
   "scripts": {

src/main/__tests__/appDataScanWorker.test.ts

@@ -1,7 +1,8 @@
 import { promises as fs } from "fs";
 import { vi, describe, it, expect, beforeEach } from "vitest";
 import { getDirSize } from "../fileUtils";
-import { FolderScanner, type IMessagePort, type WorkerResponse } from "../appDataScanWorker";
+import { FolderScanner, initializeWorker, type IMessagePort, type WorkerResponse } from "../appDataScanWorker";
+import path from "path";
 
 // Mock modules
 vi.mock("fs", () => ({
@@ -32,6 +33,11 @@ describe("FolderScanner", () => {
     mockMessagePort = {
       postMessage: (msg: WorkerResponse) => {
         messages.push(msg);
+      },
+      on: (event: "message", listener: (message: WorkerResponse) => void) => {
+        if (event === "message") {
+          listener(messages[messages.length - 1]);
+        }
       }
     };
 
@@ -58,19 +64,26 @@ describe("FolderScanner", () => {
         ] as any);
 
       const results = await scanner.scanPaths(paths, 2, keywords);
+      scanner.sendFolders(true); // Force send any remaining folders
 
       expect(results).toHaveLength(2);
       expect(messages).toContainEqual({ type: "current-path", path: paths[0] });
       expect(messages).toContainEqual({ type: "current-path", path: paths[1] });
-      expect(messages).toContainEqual({ 
-        type: "folder-found", 
-        folder: expect.objectContaining({ name: "cache-dir" })
-      });
-      expect(messages).toContainEqual({ 
-        type: "folder-found", 
-        folder: expect.objectContaining({ name: "temp-dir" })
-      });
-      expect(messages).toContainEqual({ type: "progress", count: 1 });
+      
+      // Find all folder-found messages
+      const folderFoundMessages = messages.filter(m => m.type === "folder-found");
+      expect(folderFoundMessages).toHaveLength(1); // We expect one final batched message
+      
+      // Verify the folders in the message - order doesn't matter since they're batched
+      const foundFolders = folderFoundMessages[0].folders;
+      expect(foundFolders).toHaveLength(2);
+      expect(foundFolders).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ name: "cache-dir", size: 1234 }),
+          expect.objectContaining({ name: "temp-dir", size: 1234 })
+        ])
+      );
+
       expect(messages).toContainEqual({ type: "progress", count: 2 });
       expect(messages).toContainEqual({ type: "done", results });
     });
@@ -140,9 +153,89 @@ describe("FolderScanner", () => {
       ] as any);
 
       const results = await scanner.scanPaths(["/test"], 1, ["cache"]);
+      scanner.sendFolders(true); // Force send any remaining folders
 
       expect(results).toHaveLength(3);
-      expect(messages.filter(m => m.type === "folder-found")).toHaveLength(3);
+      // Since folders are now batched, we expect one message with all 3 folders
+      const folderFoundMessages = messages.filter(m => m.type === "folder-found");
+      expect(folderFoundMessages).toHaveLength(1);
+      
+      // Verify all folders are in the final batched message
+      const foundFolders = folderFoundMessages[0].folders;
+      expect(foundFolders).toHaveLength(3);
+      expect(foundFolders).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ name: "CACHE", size: 1234 }),
+          expect.objectContaining({ name: "Cache", size: 1234 }),
+          expect.objectContaining({ name: "cache", size: 1234 })
+        ])
+      );
+    });
+
+    it("should handle error when path normalization fails", async () => {
+      // Mock path.normalize to throw
+      const originalNormalize = path.normalize;
+      path.normalize = vi.fn().mockImplementation(() => {
+        throw new Error("Invalid path");
+      });
+      
+      try {
+        const results = await scanner.scanPaths(["/test/path"], 1, ["cache"]);
+        
+        expect(messages).toEqual([
+          {
+            type: "error",
+            error: "Invalid path"
+          }
+        ]);
+        
+        expect(results).toEqual([]);
+      } finally {
+        // Restore original normalize function
+        path.normalize = originalNormalize;
+      }
+    });
+
+    it("initialize worker without parentPort throws error", () => {
+      expect(() => initializeWorker()).toThrowError("Worker thread parent port not available");
+    });
+
+    it("initialize worker with injected port", () => {
+      let functions: any[] = [];
+      const port = {
+        postMessage: (message: WorkerResponse) => {
+          messages.push(message);
+        },
+        on: (event: string, listener: (message: WorkerResponse) => void) => {
+          functions.push(listener);
+        }
+      } as unknown as IMessagePort;
+      initializeWorker(port);
+      expect(functions).toHaveLength(1);
+      expect(functions[0]).toBeDefined();
+
+      // call function message.paths, message.maxDepth, message.keywords
+      functions[0]({
+        type: "message",
+        data: {
+          paths: ["/test"],
+          maxDepth: 1,
+          keywords: ["cache"]
+        }
+      });
+
+      expect(messages).toContainEqual({
+        "error": "paths is not iterable",
+        "type": "error"
+      });
+
+      functions[0]({
+        type: "stop",
+      });
+
+      expect(messages).toContainEqual({
+        "type": "stop"
+      });
     });
   });
 });

src/main/__tests__/developerScanWorker.test.ts

@@ -293,6 +293,56 @@ describe("developerScanWorker", () => {
       expect(Array.isArray(result)).toBe(true);
     });
 
+    it("should continue scanning subdirectories when project has no caches", async () => {
+      // Mock initial directory read
+      vi
+        .mocked(fs.readdir)
+        .mockResolvedValueOnce(
+          [
+            mockDirEntry("package.json", false),
+            mockDirEntry("subproject", true)
+          ] as any
+        ) // Root dir
+        .mockResolvedValueOnce([mockDirEntry("package.json", false)] as any); // Subproject dir
+
+      // Mock calculateCacheSizes to return no caches for root project but some for subproject
+      const mockCalculateCacheSizes = vi.spyOn(worker, "calculateCacheSizes");
+      mockCalculateCacheSizes
+        .mockResolvedValueOnce({ caches: [], totalSize: 0 }) // Root project
+        .mockResolvedValueOnce({
+          caches: [
+            {
+              pattern: "node_modules",
+              category: "TestProject",
+              matches: [],
+              totalSize: 1000,
+              selectedSize: 0,
+              expanded: false
+            }
+          ],
+          totalSize: 1000
+        }); // Subproject
+
+      // Mock fs.stat
+      vi.mocked(fs.stat).mockResolvedValue(
+        {
+          isDirectory: () => true,
+          mtime: new Date(),
+          size: 1000
+        } as any
+      );
+
+      const result = await worker.scanDeveloperProjects(
+        ["/test/path"],
+        [mockCategory]
+      );
+
+      // Should find one project (the subproject)
+      expect(result).toHaveLength(1);
+      expect(result[0].path).toContain("/test/path");
+      expect(result[0].totalCacheSize).toBe(2000);
+    });
+
     it("should handle scan errors gracefully", async () => {
       // Mock fs.readdir to throw error
       vi.mocked(fs.readdir).mockRejectedValue(new Error("Test error"));

src/main/__tests__/dirSize.test.ts

@@ -1,4 +1,4 @@
-import { promises as fs } from "fs";
+import { promises as fs, existsSync } from "fs";
 import path from "path";
 import os from "os";
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
@@ -10,6 +10,9 @@ describe("getDirectorySize", () => {
   beforeEach(async () => {
     // Create a temporary directory
     tempDir = path.join(os.tmpdir(), `test-${Date.now()}`);
+    if (existsSync(tempDir)) {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
     await fs.mkdir(tempDir);
   });
 
@@ -36,7 +39,7 @@ describe("getDirectorySize", () => {
   it("should calculate size of directory with nested directories", async () => {
     // Create nested directory structure
     const subDir = path.join(tempDir, "subdir");
-    await fs.mkdir(subDir);
+    await fs.mkdir(subDir, { recursive: true }); // Ensure subdirectory exists
 
     // Create files in both root and nested directory
     const rootContent = "a".repeat(100);