feat(files): skip excluded paths during copy operations

Author: bajrangCoder

src/lib/openFolder.js

@@ -10,6 +10,7 @@ import confirm from "dialogs/confirm";
 import prompt from "dialogs/prompt";
 import select from "dialogs/select";
 import escapeStringRegexp from "escape-string-regexp";
+import copyEntry from "utils/copyEntry";
 import helpers from "utils/helpers";
 import Path from "utils/Path";
 import Uri from "utils/Uri";
@@ -776,7 +777,19 @@ function execOperation(type, action, url, $target, name) {
 					newUrl = await fs.moveTo(url);
 				}
 			} else {
-				newUrl = await fs.copyTo(url);
+				if (appSettings.value.useFileOperationExclusions) {
+					const result = await copyEntry(clipBoard.url, url, {
+						excludePatterns: appSettings.value.excludeFolders,
+					});
+					newUrl = result.url;
+					if (!newUrl) {
+						toast(strings.skipped);
+						clearClipboard();
+						return;
+					}
+				} else {
+					newUrl = await fs.copyTo(url);
+				}
 			}
 			stopLoading();
 

src/lib/settings.js

@@ -192,6 +192,7 @@ class Settings {
 				16, 19, 17, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 			],
 			excludeFolders: this.#excludeFolders,
+			useFileOperationExclusions: true,
 			defaultFileEncoding: "UTF-8",
 			inlineAutoCompletion: true,
 			colorPreview: true,

src/pages/fileBrowser/fileBrowser.js

@@ -26,6 +26,7 @@ import mimeTypes from "mime-types";
 import mustache from "mustache";
 import filesSettings from "settings/filesSettings";
 import URLParse from "url-parse";
+import copyEntry from "utils/copyEntry";
 import helpers from "utils/helpers";
 import Url from "utils/Url";
 import _addMenu from "./add-menu.hbs";
@@ -726,6 +727,7 @@ function FileBrowserInclude(mode, info, doesOpenLast = true) {
 			);
 
 			let copiedCount = 0;
+			let skippedCount = 0;
 
 			try {
 				for (const url of copiedItems) {
@@ -772,48 +774,32 @@ function FileBrowserInclude(mode, info, doesOpenLast = true) {
 						await fsOperation(possibleConflictUrl).delete();
 					}
 
-					await copyEntry(url, targetDirUrl, name, stat);
-					copiedCount++;
+					const result = await copyEntry(url, targetDirUrl, {
+						name,
+						stat,
+						excludePatterns: appSettings.value.useFileOperationExclusions
+							? appSettings.value.excludeFolders
+							: [],
+					});
+					if (result.url) copiedCount++;
+					skippedCount += result.skipped;
 				}
 			} catch (err) {
 				helpers.error(err);
 			} finally {
 				if (copiedCount) {
 					toast(strings.success);
 					reload();
+				} else if (skippedCount) {
+					toast(strings.skipped);
 				}
+				if (copiedCount || skippedCount) copiedItems = [];
 				loadingDialog.destroy();
 				isPasting = false;
 				updatePasteToggler();
 			}
 		}
 
-		async function copyEntry(sourceUrl, targetDirUrl, name, sourceStat) {
-			const fs = fsOperation(sourceUrl);
-			const stat = sourceStat || (await fs.stat());
-			const entryName = name || stat.name || Url.basename(sourceUrl);
-
-			if (stat.isDirectory) {
-				const newDirUrl =
-					await fsOperation(targetDirUrl).createDirectory(entryName);
-				const entries = await fs.lsDir();
-
-				for (const entry of entries) {
-					await copyEntry(
-						entry.url,
-						newDirUrl,
-						entry.name || Url.basename(entry.url),
-						entry,
-					);
-				}
-
-				return newDirUrl;
-			}
-
-			const content = await fs.readFile();
-			return fsOperation(targetDirUrl).createFile(entryName, content);
-		}
-
 		function isInsideDirectory(sourceUrl, targetUrl) {
 			let source = Url.parse(sourceUrl).url;
 			let target = Url.parse(targetUrl).url;

src/settings/appSettings.js

@@ -264,6 +264,17 @@ export default function otherSettings() {
 			info: strings["settings-info-app-exclude-folders"],
 			category: categories.filesSessions,
 		},
+		{
+			key: "useFileOperationExclusions",
+			text:
+				strings["apply exclusions when copying"] ||
+				"Apply exclusions when copying",
+			checkbox: values.useFileOperationExclusions,
+			info:
+				strings["settings-info-app-use-file-operation-exclusions"] ||
+				"Skip files and folders matching the exclusion patterns during copy and paste operations.",
+			category: categories.filesSessions,
+		},
 		{
 			key: "defaultFileEncoding",
 			text: strings["default file encoding"],

src/utils/copyEntry.js

@@ -0,0 +1,50 @@
+import fsOperation from "fileSystem";
+import { isExcludedFileOperationPath } from "./fileOperationExclusions";
+import Url from "./Url";
+
+/**
+ * Recursively copy a file or directory while omitting excluded entries.
+ *
+ * @param {string} sourceUrl
+ * @param {string} targetDirUrl
+ * @param {object} [options]
+ * @param {string} [options.name]
+ * @param {object} [options.stat]
+ * @param {string[]} [options.excludePatterns]
+ * @returns {Promise<{url: string|null, copied: number, skipped: number}>}
+ */
+export default async function copyEntry(
+	sourceUrl,
+	targetDirUrl,
+	{ name, stat: sourceStat, excludePatterns = [] } = {},
+) {
+	if (isExcludedFileOperationPath(sourceUrl, excludePatterns)) {
+		return { url: null, copied: 0, skipped: 1 };
+	}
+
+	const sourceFs = fsOperation(sourceUrl);
+	const stat = sourceStat || (await sourceFs.stat());
+	const entryName = name || stat.name || Url.basename(sourceUrl);
+
+	if (!stat.isDirectory) {
+		const content = await sourceFs.readFile();
+		const url = await fsOperation(targetDirUrl).createFile(entryName, content);
+		return { url, copied: 1, skipped: 0 };
+	}
+
+	const url = await fsOperation(targetDirUrl).createDirectory(entryName);
+	const result = { url, copied: 1, skipped: 0 };
+	const entries = await sourceFs.lsDir();
+
+	for (const entry of entries) {
+		const child = await copyEntry(entry.url, url, {
+			name: entry.name || Url.basename(entry.url),
+			stat: entry,
+			excludePatterns,
+		});
+		result.copied += child.copied;
+		result.skipped += child.skipped;
+	}
+
+	return result;
+}

src/utils/fileOperationExclusions.js

@@ -0,0 +1,41 @@
+import picomatch from "picomatch/posix";
+import Url from "utils/Url";
+
+/**
+ * Test whether a file-system URL matches one of the configured exclusion globs.
+ * Both the URL path and a directory-style version are checked so recursive
+ * glob patterns also match the excluded directory itself.
+ *
+ * @param {string} url
+ * @param {string[]} patterns
+ * @returns {boolean}
+ */
+export function isExcludedFileOperationPath(url, patterns = []) {
+	if (!url || !Array.isArray(patterns) || !patterns.length) return false;
+
+	const parsedUrl = Url.parse(url).url;
+	const pathname = Url.pathname(parsedUrl) || parsedUrl;
+	const normalizedPath = pathname.replace(/\\/g, "/").replace(/\/+$/, "");
+	const relativePath = normalizedPath.replace(/^\/+/, "");
+	const candidates = [
+		normalizedPath,
+		`${normalizedPath}/`,
+		relativePath,
+		`${relativePath}/`,
+	];
+
+	return patterns.some((pattern) => {
+		if (typeof pattern !== "string" || !pattern.trim()) return false;
+
+		try {
+			return candidates.some((candidate) =>
+				picomatch.isMatch(candidate, pattern.trim(), {
+					matchBase: !pattern.includes("/") && !pattern.includes("\\"),
+				}),
+			);
+		} catch (error) {
+			console.warn(`Invalid file exclusion pattern: ${pattern}`, error);
+			return false;
+		}
+	});
+}

tests/unit/copyEntry.test.js

@@ -0,0 +1,121 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const fileSystem = vi.hoisted(() => {
+	const entries = new Map([
+		[
+			"/source",
+			{
+				name: "source",
+				isDirectory: true,
+				children: ["/source/src", "/source/node_modules"],
+			},
+		],
+		[
+			"/source/src",
+			{
+				name: "src",
+				isDirectory: true,
+				children: ["/source/src/index.js"],
+			},
+		],
+		[
+			"/source/src/index.js",
+			{
+				name: "index.js",
+				isDirectory: false,
+				content: "console.log('copied');",
+			},
+		],
+		[
+			"/source/node_modules",
+			{
+				name: "node_modules",
+				isDirectory: true,
+				children: ["/source/node_modules/package.json"],
+			},
+		],
+		[
+			"/source/node_modules/package.json",
+			{
+				name: "package.json",
+				isDirectory: false,
+				content: "{}",
+			},
+		],
+	]);
+
+	return {
+		entries,
+		created: [],
+	};
+});
+
+vi.mock("fileSystem", () => ({
+	default(url) {
+		const entry = fileSystem.entries.get(url);
+
+		return {
+			async stat() {
+				return { ...entry, url };
+			},
+			async lsDir() {
+				return entry.children.map((childUrl) => ({
+					...fileSystem.entries.get(childUrl),
+					url: childUrl,
+				}));
+			},
+			async readFile() {
+				return entry.content;
+			},
+			async createDirectory(name) {
+				const createdUrl = `${url}/${name}`;
+				fileSystem.created.push({ type: "directory", url: createdUrl });
+				return createdUrl;
+			},
+			async createFile(name, content) {
+				const createdUrl = `${url}/${name}`;
+				fileSystem.created.push({ type: "file", url: createdUrl, content });
+				return createdUrl;
+			},
+		};
+	},
+}));
+
+import copyEntry from "utils/copyEntry";
+
+describe("copyEntry", () => {
+	beforeEach(() => {
+		fileSystem.created.length = 0;
+	});
+
+	it("prunes excluded directory subtrees", async () => {
+		const result = await copyEntry("/source", "/target", {
+			excludePatterns: ["**/node_modules/**"],
+		});
+
+		expect(result).toEqual({
+			url: "/target/source",
+			copied: 3,
+			skipped: 1,
+		});
+		expect(fileSystem.created).toEqual([
+			{ type: "directory", url: "/target/source" },
+			{ type: "directory", url: "/target/source/src" },
+			{
+				type: "file",
+				url: "/target/source/src/index.js",
+				content: "console.log('copied');",
+			},
+		]);
+	});
+
+	it("copies excluded paths when no patterns are enabled", async () => {
+		const result = await copyEntry("/source/node_modules", "/target");
+
+		expect(result.skipped).toBe(0);
+		expect(fileSystem.created.map(({ url }) => url)).toEqual([
+			"/target/node_modules",
+			"/target/node_modules/package.json",
+		]);
+	});
+});