autosnippet 1.1.13 → 1.1.15

package/bin/findPath.js

@@ -4,189 +4,445 @@ 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;
+/**
+ * 检测是否为工程根目录
+ * 通过查找常见的工程根目录标记来判断
+ */
+function isProjectRoot(dirPath, entries) {
+	if (!entries) {
+		return false;
+	}
+	
+	// 工程根目录标记（按优先级）
+	const rootMarkers = [
+		'.git',              // Git 仓库根目录
+		PACKAGE_SWIFT,       // SPM 项目根目录
+		'.xcodeproj',        // Xcode 项目根目录
+		'.xcworkspace',      // Xcode 工作空间根目录
+		'Podfile',           // CocoaPods 项目根目录
+		'.swiftpm',          // Swift Package Manager 元数据目录
+	];
+	
+	for (const entry of entries) {
+		const name = entry.name;
+		
+		// 检查文件标记
+		if (entry.isFile() && rootMarkers.includes(name)) {
+			return true;
 		}
+		
+		// 检查目录标记（.git 可能是目录）
+		if (entry.isDirectory() && rootMarkers.includes(name)) {
+			return true;
+		}
+	}
+	
+	return false;
+}
 
-		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 configDir = null;
+	let currentPath = path.resolve(filePath);
+	const maxLevels = 20; // 安全限制：最多向上查找 20 层
+	let levelsChecked = 0;
+	
+	while (currentPath && levelsChecked < maxLevels) {
+		try {
+			const entries = await getDirectoryEntries(currentPath);
+			
+			// 查找 AutoSnippet.boxspec.json
+			if (entries) {
+				for (const entry of entries) {
+					if (entry.isFile() && entry.name === HOLDER_NAME) {
+						if (!configPath) {
+							// 第一次找到配置文件
+							configPath = path.join(currentPath, entry.name);
+							configDir = currentPath;
+						}
+					}
+				}
 			}
-        });
-
-		if (isEnd) {
-			return;
+			
+			// 如果已经找到配置文件，检查是否到达工程根目录
+			if (configPath) {
+				// 如果在配置文件所在目录或以上发现了工程根目录标记，停止查找
+				if (isProjectRoot(currentPath, entries)) {
+					return configPath;
+				}
+				
+				// 如果已经向上查找了，但没有找到工程根目录标记，继续查找
+				if (path.resolve(currentPath) !== configDir) {
+					// 当前目录不是配置文件所在目录，继续向上查找
+				}
+			}
+			
+			// 继续向上查找
+			const parentPath = path.dirname(currentPath);
+			if (parentPath === currentPath) {
+				// 已到达根目录
+				break;
+			}
+			currentPath = parentPath;
+			levelsChecked++;
+			
+		} catch (err) {
+			// 错误处理：权限错误继续查找
+			if (err.code === 'ENOENT' || err.code === 'EACCES') {
+				const parentPath = path.dirname(currentPath);
+				if (parentPath === currentPath) {
+					break;
+				}
+				currentPath = parentPath;
+				levelsChecked++;
+				continue;
+			}
+			// 其他错误，抛出
+			throw err;
 		}
+	}
+	
+	// 如果找到配置文件，返回它（即使没有找到明确的工程根目录）
+	return configPath || null;
+}
 
-		if (!isEnd && filePath !== '/' && filePath !== '/Users') {
-			findPCHPath(path.join(filePath, '/..'), callback);
-		} else {
-			callback(false, null);
+/**
+ * 同步版本：检测是否为工程根目录
+ */
+function isProjectRootSync(dirPath, files) {
+	if (!files || files.length === 0) {
+		return false;
+	}
+	
+	// 工程根目录标记（按优先级）
+	const rootMarkers = [
+		'.git',              // Git 仓库根目录
+		PACKAGE_SWIFT,       // SPM 项目根目录
+		'.xcodeproj',        // Xcode 项目根目录
+		'.xcworkspace',      // Xcode 工作空间根目录
+		'Podfile',           // CocoaPods 项目根目录
+	];
+	
+	// 检查文件名
+	for (const filename of files) {
+		if (rootMarkers.includes(filename)) {
+			// 检查是否为文件或目录
+			try {
+				const filePath = path.join(dirPath, filename);
+				const stats = fs.lstatSync(filePath);
+				if (stats.isFile() || stats.isDirectory()) {
+					return true;
+				}
+			} catch (err) {
+				// 忽略错误，继续检查
+			}
 		}
-    });
+	}
+	
+	return false;
 }
 
-// 向上查找模块.spec文件
-function findBPSpacPath(filePath, callback) {
-	fs.readdir(filePath, function (err, files) {
-		if (err) {
-			console.log(err);
+// 向上查找AutoSnippet配置文件（保留回调版本，兼容现有代码）
+function findASSpecPath(filePath, callback, configPath, configDir) {
+	// 初始化参数
+	if (configPath === undefined) configPath = null;
+	if (configDir === undefined) configDir = null;
+	
+	const maxLevels = 20; // 安全限制：最多向上查找 20 层
+	let levelsChecked = 0;
+	
+	function search(currentPath, foundConfigPath, foundConfigDir, level) {
+		if (level >= maxLevels) {
+			if (foundConfigPath) {
+				callback(foundConfigPath);
+			} else {
+				console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
+			}
 			return;
 		}
+		
+		fs.readdir(currentPath, function (err, files) {
+			if (err) {
+				// 错误处理：权限错误继续查找
+				if (err.code === 'ENOENT' || err.code === 'EACCES') {
+					const parentPath = path.join(currentPath, '/..');
+					const parentResolvedPath = path.resolve(parentPath);
+					
+					// 如果已经到达根目录，停止查找
+					if (parentResolvedPath === path.resolve(currentPath)) {
+						if (foundConfigPath) {
+							callback(foundConfigPath);
+						} else {
+							console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
+						}
+						return;
+					}
+					
+					search(parentPath, foundConfigPath, foundConfigDir, level + 1);
+				} else {
+					console.log(err);
+				}
+				return;
+			}
 
-		let isError = false;
-		let isEnd = false;
-		let readme = null;
-		let specName = null;
+			let isFound = false;
+			let currentConfigPath = foundConfigPath;
+			let currentConfigDir = foundConfigDir;
+			
+			// 查找 AutoSnippet.boxspec.json
+			files.forEach(function (filename) {
+				if (filename === HOLDER_NAME) {
+					isFound = true;
+					if (!currentConfigPath) {
+						// 第一次找到配置文件，记录路径（不立即调用回调）
+						currentConfigPath = path.join(currentPath, filename);
+						currentConfigDir = path.resolve(currentPath);
+					}
+				}
+			});
 
-        files.forEach(function (filename) {
-			if (filename === HOLDER_NAME) {
-				isError = true;
-			}
-			if (filename.toLowerCase() === README_NAME) {
-                readme = filename;
+			// 如果已经找到配置文件，检查是否到达工程根目录
+			if (currentConfigPath) {
+				// 如果在配置文件所在目录或以上发现了工程根目录标记，停止查找并调用回调
+				if (isProjectRootSync(currentPath, files)) {
+					callback(currentConfigPath);
+					return;
+				}
 			}
-			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;
-                }
+			// 继续向上查找
+			const parentPath = path.join(currentPath, '/..');
+			const parentResolvedPath = path.resolve(parentPath);
+			
+			// 如果已经到达根目录，停止查找
+			if (parentResolvedPath === path.resolve(currentPath)) {
+				// 如果找到了配置文件，即使没找到工程根目录标记，也调用回调
+				if (currentConfigPath) {
+					callback(currentConfigPath);
+				} else {
+					console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
+				}
+				return;
 			}
-        });
-
-		if (isEnd && specName) {
-			callback(filePath, specName, readme);
-			return;
-		}
 
-		if (isError) {
-			console.log('先找到了 AutoSnippet.boxspec.json 文件，请检查路径。');
-			return;
-		}
+			search(parentPath, currentConfigPath, currentConfigDir, level + 1);
+		});
+	}
+	
+	search(filePath, configPath, configDir, 0);
+}
 
-		if (!isEnd && filePath !== '/' && filePath !== '/Users' && filePath !== '/LocalModule') {
-			findBPSpacPath(path.join(filePath, '/..'), callback);
-		} else {
-			console.log('未找到 .boxspec 文件，请检查路径。');
+// 向上查找 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;
 }
 
-// 向下查找模块默认头文件
-async function findSubHeaderPath(filePath, headerName) {
-	let resultPath = 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/init.js

@@ -47,10 +47,14 @@ async function initSpec() {
                             return false;
                         }
                     }
-                    idsArray.push(item['{identifier}']);
-					// 头文件相对路径需要补齐
+					idsArray.push(item['{identifier}']);
+					// ✅ 头文件相对路径需要补齐（将子配置的相对路径转换为相对于主配置的路径）
 					if (item['{specHeadPath}']) {
-						item['{specHeadPath}'] = thePath + item['{specHeadPath}'];
+						// 解码原始路径，拼接子配置路径，再编码
+						const decodedPath = decodeURI(item['{specHeadPath}']);
+						const combinedPath = thePath ? path.join(thePath, decodedPath) : decodedPath;
+						// 规范化路径（处理 .. 和 .）
+						item['{specHeadPath}'] = encodeURI(path.normalize(combinedPath));
 					}
                     return true;
                 });