autosnippet 1.1.13 → 1.1.14

package/bin/findPath.js

@@ -4,189 +4,351 @@ const fs = require('fs');
 const path = require('path');
 // 全局常量
 const HOLDER_NAME = 'AutoSnippet.boxspec.json';
-const BOX_SPEC_NAME = '.boxspec';
-const POD_SPEC_NAME = '.podspec';
+const PACKAGE_SWIFT = 'Package.swift';
 const README_NAME = 'readme.md';
-const PCH_NAME = '.pch';
 
-// 向上查找AutoSnippet配置文件
-function findASSpecPath(filePath, callback) {
-	fs.readdir(filePath, function (err, files) {
-		if (err) {
-			console.log(err);
-			return;
-		}
-
-		let isEnd = false;
-        files.forEach(function (filename) {
+// 目录缓存（优化：减少重复读取）
+const directoryCache = new Map();
+const CACHE_TTL = 60000; // 缓存 60 秒
 
-			if (filename === HOLDER_NAME) {
-				isEnd = true;
-				callback(path.join(filePath, filename));
+/**
+ * 获取目录内容（带缓存）
+ */
+async function getDirectoryEntries(dirPath) {
+	const cacheKey = path.resolve(dirPath);
+	const cached = directoryCache.get(cacheKey);
+	
+	if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+		return cached.entries;
+	}
+	
+	try {
+		const entries = await fs.promises.readdir(dirPath, {
+			withFileTypes: true  // 返回 Dirent 对象，减少 stat 调用
+		});
+		
+		// 清理过期缓存（保持缓存大小合理）
+		if (directoryCache.size > 1000) {
+			const now = Date.now();
+			for (const [key, value] of directoryCache.entries()) {
+				if (now - value.timestamp >= CACHE_TTL) {
+					directoryCache.delete(key);
+				}
 			}
-        });
-
-		if (isEnd) {
-			return;
 		}
-
-		if (!isEnd && filePath !== '/' && filePath !== '/Users') {
-			findASSpecPath(path.join(filePath, '/..'), callback);
-		} else {
-			console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
+		
+		directoryCache.set(cacheKey, {
+			entries,
+			timestamp: Date.now()
+		});
+		
+		return entries;
+	} catch (err) {
+		if (err.code === 'ENOENT' || err.code === 'EACCES') {
+			return null;  // 路径不存在或权限不足
 		}
-    });
+		throw err;
+	}
 }
 
-// 向上查找.pch文件
-function findPCHPath(filePath, callback) {
-	fs.readdir(filePath, function (err, files) {
-		if (err) {
-			console.log(err);
-			return;
-		}
-
-		let isEnd = false;
-        files.forEach(function (filename) {
-
-			if (filename.endsWith(PCH_NAME)) {
-				isEnd = true;
-				callback(true, path.join(filePath, filename));
+// 向上查找AutoSnippet配置文件（优化：找到配置文件后，最多再向上查找两层停止）
+async function findASSpecPathAsync(filePath) {
+	let configPath = null;
+	let levelsUp = 0;
+	let currentPath = path.resolve(filePath);
+	
+	while (currentPath) {
+		try {
+			const entries = await getDirectoryEntries(currentPath);
+			if (!entries) {
+				// 目录不存在，继续向上
+				const parentPath = path.dirname(currentPath);
+				if (parentPath === currentPath) {
+					break;  // 已到达根目录
+				}
+				currentPath = parentPath;
+				continue;
 			}
-        });
-
-		if (isEnd) {
-			return;
-		}
-
-		if (!isEnd && filePath !== '/' && filePath !== '/Users') {
-			findPCHPath(path.join(filePath, '/..'), callback);
-		} else {
-			callback(false, null);
+			
+			// 查找 AutoSnippet.boxspec.json
+			for (const entry of entries) {
+				if (entry.isFile() && entry.name === HOLDER_NAME) {
+					if (!configPath) {
+						// 第一次找到配置文件
+						configPath = path.join(currentPath, entry.name);
+					}
+					// 找到后，标记为已找到，继续向上最多两层
+				}
+			}
+			
+			// 如果已经找到配置文件，检查是否已经向上查找了两层
+			if (configPath) {
+				if (path.resolve(currentPath) !== path.dirname(configPath)) {
+					// 当前目录不是配置文件所在目录，说明已经向上查找了
+					levelsUp++;
+				}
+				
+				// 如果已经向上查找了两层，停止查找
+				if (levelsUp >= 2) {
+					return configPath;
+				}
+			}
+			
+			// 继续向上查找
+			const parentPath = path.dirname(currentPath);
+			if (parentPath === currentPath) {
+				// 已到达根目录
+				break;
+			}
+			currentPath = parentPath;
+			
+		} catch (err) {
+			// 错误处理：权限错误继续查找
+			if (err.code === 'ENOENT' || err.code === 'EACCES') {
+				const parentPath = path.dirname(currentPath);
+				if (parentPath === currentPath) {
+					break;
+				}
+				currentPath = parentPath;
+				continue;
+			}
+			// 其他错误，抛出
+			throw err;
 		}
-    });
+	}
+	
+	return configPath || null;
 }
 
-// 向上查找模块.spec文件
-function findBPSpacPath(filePath, callback) {
+// 向上查找AutoSnippet配置文件（保留回调版本，兼容现有代码）
+function findASSpecPath(filePath, callback, configPath, levelsUp) {
+	// 初始化参数
+	if (configPath === undefined) configPath = null;
+	if (levelsUp === undefined) levelsUp = 0;
+	
 	fs.readdir(filePath, function (err, files) {
 		if (err) {
 			console.log(err);
 			return;
 		}
 
-		let isError = false;
-		let isEnd = false;
-		let readme = null;
-		let specName = null;
-
+		let isFound = false;
+		let foundConfigPath = configPath;
         files.forEach(function (filename) {
 			if (filename === HOLDER_NAME) {
-				isError = true;
-			}
-			if (filename.toLowerCase() === README_NAME) {
-                readme = filename;
-			}
-			if (filename.endsWith(BOX_SPEC_NAME) || filename.endsWith(POD_SPEC_NAME)) {
-                const dotIndex = filename.lastIndexOf('.');
-				const ext = filename.substr(dotIndex);
-
-                if (ext === BOX_SPEC_NAME || ext === POD_SPEC_NAME) {
-                    specName = filename;
-					isEnd = true;
-                }
+				isFound = true;
+				if (!foundConfigPath) {
+					// 第一次找到配置文件，记录路径并调用回调
+					foundConfigPath = path.resolve(filePath);
+					callback(path.join(filePath, filename));
+				}
 			}
         });
 
-		if (isEnd && specName) {
-			callback(filePath, specName, readme);
-			return;
+		// 如果已经找到配置文件，检查是否已经向上查找了两层
+		if (foundConfigPath) {
+			if (!isFound) {
+				// 当前目录不是配置文件所在目录，说明已经向上查找了
+				levelsUp++;
+			}
+			
+			// 如果已经向上查找了两层，停止查找
+			if (levelsUp >= 2) {
+				return;
+			}
 		}
 
-		if (isError) {
-			console.log('先找到了 AutoSnippet.boxspec.json 文件，请检查路径。');
-			return;
-		}
+		// 如果还没找到配置文件，继续向上查找
+		if (!foundConfigPath) {
+			// 继续向上查找
+			const parentPath = path.join(filePath, '/..');
+			const parentResolvedPath = path.resolve(parentPath);
+			
+			// 如果已经到达根目录，停止查找
+			if (parentResolvedPath === path.resolve(filePath)) {
+				console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
+				return;
+			}
 
-		if (!isEnd && filePath !== '/' && filePath !== '/Users' && filePath !== '/LocalModule') {
-			findBPSpacPath(path.join(filePath, '/..'), callback);
+			findASSpecPath(parentPath, callback, foundConfigPath, 0);
 		} else {
-			console.log('未找到 .boxspec 文件，请检查路径。');
+			// 已经找到配置文件，继续向上查找（最多两层）
+			const parentPath = path.join(filePath, '/..');
+			const parentResolvedPath = path.resolve(parentPath);
+			
+			// 如果已经到达根目录，停止查找
+			if (parentResolvedPath === path.resolve(filePath)) {
+				return;
+			}
+
+			findASSpecPath(parentPath, callback, foundConfigPath, levelsUp);
 		}
     });
 }
 
-// 向下查找模块默认头文件
-async function findSubHeaderPath(filePath, headerName) {
-	let resultPath = null;
+// 向上查找 Package.swift 文件（SPM 模块规范文件）
+async function findPackageSwiftPath(filePath) {
+	let currentPath = path.resolve(filePath);
+	
+	while (currentPath) {
+		try {
+			const entries = await getDirectoryEntries(currentPath);
+			if (!entries) {
+				const parentPath = path.dirname(currentPath);
+				if (parentPath === currentPath) {
+					break;
+				}
+				currentPath = parentPath;
+				continue;
+			}
+			
+			// 查找 Package.swift 文件
+			for (const entry of entries) {
+				if (entry.isFile() && entry.name === PACKAGE_SWIFT) {
+					return path.join(currentPath, entry.name);
+				}
+			}
+			
+			// 继续向上查找
+			const parentPath = path.dirname(currentPath);
+			if (parentPath === currentPath) {
+				break;
+			}
+			currentPath = parentPath;
+			
+		} catch (err) {
+			if (err.code === 'ENOENT' || err.code === 'EACCES') {
+				const parentPath = path.dirname(currentPath);
+				if (parentPath === currentPath) {
+					break;
+				}
+				currentPath = parentPath;
+				continue;
+			}
+			throw err;
+		}
+	}
+	
+	return null;
+}
 
+/**
+ * 解析 Package.swift 文件，提取模块信息
+ */
+async function parsePackageSwift(packagePath) {
 	try {
-		const files = fs.readdirSync(filePath);
-
-		for (let i = 0; i < files.length; i++) {
-			const filename = files[i];
-			const filedir = path.join(filePath, filename);
+		const content = await fs.promises.readFile(packagePath, 'utf8');
+		
+		// 简单解析 Package.swift（实际可以使用 Swift AST 解析器）
+		const packageNameMatch = content.match(/name:\s*"([^"]+)"/);
+		const targetsMatch = content.match(/\.target\s*\([^)]+name:\s*"([^"]+)"/g);
+		
+		const packageName = packageNameMatch ? packageNameMatch[1] : null;
+		const targets = [];
+		
+		if (targetsMatch) {
+			targetsMatch.forEach(match => {
+				const targetMatch = match.match(/name:\s*"([^"]+)"/);
+				if (targetMatch) {
+					targets.push(targetMatch[1]);
+				}
+			});
+		}
+		
+		return {
+			name: packageName,
+			targets: targets,
+			path: path.dirname(packagePath)
+		};
+	} catch (err) {
+		console.error('Error parsing Package.swift:', err);
+		return null;
+	}
+}
 
-			if (filename === (headerName + '.h')) {
-				resultPath = filedir;
-				break;
-			} else {
+// 向下查找模块头文件（优化：适配 SPM 结构，优先查找 include/ModuleName/ 目录）
+async function findSubHeaderPath(filePath, headerName, moduleName) {
+	// ✅ 优先查找 include/ModuleName/ 目录（SPM 结构）
+	if (moduleName) {
+		const includePath = path.join(filePath, 'include', moduleName);
+		try {
+			const stats = await fs.promises.stat(includePath);
+			if (stats.isDirectory()) {
+				const headerPath = path.join(includePath, `${headerName}.h`);
 				try {
-					// 读取路径是否为文件
-					const stats = fs.lstatSync(filedir);
-					const isDirectory = stats.isDirectory();
-					if (isDirectory) {
-						const result = await findSubHeaderPath(filedir, headerName);
-						if (result) {
-							resultPath = result;
-						}
-					}
-				} catch (err) {
-					console.error(err);
+					await fs.promises.access(headerPath);
+					return headerPath;
+				} catch {
+					// 头文件不存在，继续查找
+				}
+			}
+		} catch {
+			// include 目录不存在，继续查找
+		}
+	}
+	
+	// ✅ 降级：在整个模块目录中查找（深度限制）
+	try {
+		const entries = await getDirectoryEntries(filePath);
+		if (!entries) {
+			return null;
+		}
+		
+		for (const entry of entries) {
+			if (entry.isFile() && entry.name === `${headerName}.h`) {
+				return path.join(filePath, entry.name);
+			} else if (entry.isDirectory()) {
+				// 跳过 node_modules、.git 等目录
+				if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+					continue;
+				}
+				
+				const result = await findSubHeaderPath(path.join(filePath, entry.name), headerName, null);
+				if (result) {
+					return result;
 				}
 			}
 		}
 	} catch (err) {
-		console.log(err);
+		console.error(err);
 	}
-	return resultPath;
+	
+	return null;
 }
 
-// 向下查找AutoSnippet配置文件
+// 向下查找AutoSnippet配置文件（优化：异步 I/O）
 async function findSubASSpecPath(filePath) {
 	let resultArray = [];
 
 	try {
-		const files = fs.readdirSync(filePath);
-
-		for (let i = 0; i < files.length; i++) {
-			const filename = files[i];
-			const filedir = path.join(filePath, filename);
+		const entries = await getDirectoryEntries(filePath);
+		if (!entries) {
+			return resultArray;
+		}
 
-			if (filename === HOLDER_NAME) {
-				resultArray.push(filedir);
-			} else {
-				try {
-					// 读取路径是否为文件
-					const stats = fs.lstatSync(filedir);
-					const isDirectory = stats.isDirectory();
-					if (isDirectory) {
-						const array = await findSubASSpecPath(filedir);
-						resultArray = resultArray.concat(array);
-					}
-				} catch (err) {
-					console.error(err);
+		for (const entry of entries) {
+			if (entry.isFile() && entry.name === HOLDER_NAME) {
+				resultArray.push(path.join(filePath, entry.name));
+			} else if (entry.isDirectory()) {
+				// 跳过 node_modules、.git 等目录
+				if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+					continue;
 				}
+				
+				const array = await findSubASSpecPath(path.join(filePath, entry.name));
+				resultArray = resultArray.concat(array);
 			}
 		}
 	} catch (err) {
 		console.log(err);
 	}
+	
 	return resultArray;
 }
 
 exports.findASSpecPath = findASSpecPath;
-exports.findBPSpacPath = findBPSpacPath;
-exports.findPCHPath = findPCHPath;
+exports.findASSpecPathAsync = findASSpecPathAsync;
+exports.findPackageSwiftPath = findPackageSwiftPath;
+exports.parsePackageSwift = parsePackageSwift;
 exports.findSubHeaderPath = findSubHeaderPath;
-exports.findSubASSpecPath = findSubASSpecPath;
+exports.findSubASSpecPath = findSubASSpecPath;

package/bin/injection.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 const fs = require('fs');
+const fsPromises = require('fs').promises;
 const path = require('path');
 const readline = require('readline');
 const findPath = require('./findPath.js');
@@ -86,65 +87,23 @@ function handleModuleHeader(specFile, updateFile, header, importArray, isOuter)
     const headName = isOuter ? header.name : header.headerStrName;
 	const moduleName = isOuter ? header.specName : header.moduleStrName;
 
-	let isNeedFindPCH = true;
-
+	// 检查是否已经引入头文件
 	for (let i = 0; i < importArray.length; i++) {
 		const importHeader = importArray[i].split(importMark)[1].trim();
 
 		if (importHeader === headName) {
 			// 已经引入头文件
 			handelAddHeaderStatus(specFile, updateFile, header, true, false);
-			isNeedFindPCH = false;
-			break;
+			return;
 		} else if (importHeader === moduleName) {
 			// 已经引入spec头文件
 			handelAddHeaderStatus(specFile, updateFile, header, false, true);
-			isNeedFindPCH = false;
-			break;
+			return;
 		}
 	}
 
-	if (isNeedFindPCH) {
-		// 检查被修改文件的.pch文件是否引入了spec头文件
-		const slashIndex = updateFile.lastIndexOf('/');
-		const thePath = updateFile.substring(0, slashIndex + 1);
-
-		findPath.findPCHPath(thePath, function (success, pchName) {
-			if (success) {
-				try {
-					// 读取.pch文件
-					const data = fs.readFileSync(pchName, 'utf8');
-					const lineArray = data.split('\n');
-
-					let isAddedHeader = false;
-					let isAddedSpecHeader = false;
-
-					lineArray.forEach(element => {
-						const lineVal = element.trim();
-
-						if (importReg.test(lineVal)) {
-							const importHeader = lineVal.split(importMark)[1].trim();
-
-							if (importHeader === header.name
-								|| importHeader === header.headerStrName) {
-								isAddedHeader = true;
-							} else if (importHeader === header.specName
-								|| importHeader === header.moduleStrName) {
-								isAddedSpecHeader = true;
-							}
-						}
-					});
-
-					handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAddedSpecHeader);
-				} catch (err) {
-					console.error(err);
-				}
-			} else {
-				// 没有找到pch文件
-				addHeaderToFile(updateFile, header);
-			}
-		});
-	}
+	// 没有找到已引入的头文件，直接添加
+	addHeaderToFile(updateFile, header);
 }
 
 function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAddedSpecHeader) {
@@ -204,47 +163,57 @@ function isAddedToSpecHeader(specFile, header, callback) {
 
 function removeMarkFromFile(updateFile, header, string) {
 	readStream(updateFile, null, importMark);
-	checkDependency(updateFile, header.moduleName, string);
+	checkDependency(updateFile, header.moduleName, string).catch(err => {
+		console.error('Error checking dependency:', err);
+	});
 }
 
 function addHeaderToFile(updateFile, header) {
 	readStream(updateFile, importMark + ' ' + header.name, importMark);
-	checkDependency(updateFile, header.moduleName, '自动注入头文件完成。');
+	checkDependency(updateFile, header.moduleName, '自动注入头文件完成。').catch(err => {
+		console.error('Error checking dependency:', err);
+	});
 }
 
-function checkDependency(updateFile, moduleName, string) {
+async function checkDependency(updateFile, moduleName, string) {
 	const slashIndex = updateFile.lastIndexOf('/');
 	const thePath = updateFile.substring(0, slashIndex + 1);
 
-	findPath.findBPSpacPath(thePath, function (findFilePath, specName, readme) {
-		const specPath = path.join(findFilePath, specName);
-
-		try {
-			// 读取当前工作空间的.spec文件
-			const data = fs.readFileSync(specPath, 'utf8');
-			const lineArray = data.split('\n');
-
-			let isHaveDependency = false;
-
-			lineArray.forEach(element => {
-				const lineVal = element.trim();
+	try {
+		// ✅ 使用 SPM 的 Package.swift 查找（替代 .boxspec）
+		const packagePath = await findPath.findPackageSwiftPath(thePath);
+		if (!packagePath) {
+			displayNotification(string);
+			return;
+		}
 
-				if (!lineVal.startsWith('#')
-					&& lineVal.includes('dependency')
-					&& lineVal.includes(moduleName)) {
-					isHaveDependency = true;
-				}
-			});
+		// 解析 Package.swift 获取模块信息
+		const packageInfo = await findPath.parsePackageSwift(packagePath);
+		if (!packageInfo) {
+			displayNotification(string);
+			return;
+		}
 
-			if (isHaveDependency) {
-				displayNotification(string);
-			} else {
-				displayNotification(string + '\nspec文件未发现依赖项，请检查模块是否引入。');
-			}
-		} catch (err) {
-			console.error(err);
+		// 检查依赖关系（在 Package.swift 的 dependencies 中查找）
+		const packageContent = await fs.promises.readFile(packagePath, 'utf8');
+		
+		// 检查是否在 dependencies 中
+		const dependencyPattern = new RegExp(`\\.package\\([^)]*"([^"]*${moduleName}[^"]*)"`, 'g');
+		const targetDependencyPattern = new RegExp(`\\.product\\([^)]*name:\\s*"([^"]*${moduleName}[^"]*)"`, 'g');
+		
+		const hasDependency = dependencyPattern.test(packageContent) || 
+		                      targetDependencyPattern.test(packageContent) ||
+		                      packageInfo.targets.includes(moduleName);
+
+		if (hasDependency) {
+			displayNotification(string);
+		} else {
+			displayNotification(string + '\nPackage.swift 未发现依赖项，请检查模块是否引入。');
 		}
-	});
+	} catch (err) {
+		console.error(err);
+		displayNotification(string);
+	}
 }
 
 function readStream(filePath, headerName, currImportMark) {