autosnippet 1.2.4 → 1.2.6

package/bin/injection.js

@@ -136,41 +136,99 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
 	// ✅ 优先检查：如果头文件路径和当前文件在同一个目录下，直接使用文件名
 	const headRelativePathFromInfo = headerInfo.headRelativePath;
 	let isSameDirectory = false;
+	let headFullPath = null;
+	let headDir = null;
 	
 	if (headRelativePathFromInfo) {
 		// 从头文件相对路径构造完整路径
-		const headFullPath = path.join(currentPackageInfo.path, headRelativePathFromInfo);
-		const headDir = path.dirname(headFullPath);
+		// headRelativePathFromInfo 是相对于模块根目录的路径（如 Code/BDGlobalVideoPlayerManager.h）
 		
-		// 检查是否在同一个目录
-		if (updateFileDir === headDir) {
-			isSameDirectory = true;
-			// 如果同目录，直接使用文件名
-			header.relativePathToCurrentFile = header.headerName;
+		// 方法：从当前文件路径向上查找，直到找到包含 headRelativePathFromInfo 的路径
+		const headName = path.basename(headRelativePathFromInfo);  // BDGlobalVideoPlayerManager.h
+		
+		// 方案1：尝试在当前文件所在目录直接查找
+		const headInCurrentDir = path.join(updateFileDir, headName);
+		if (fs.existsSync(headInCurrentDir)) {
+			headFullPath = headInCurrentDir;
+			headDir = updateFileDir;
+		} else {
+			// 方案2：从当前文件路径向上查找，尝试找到头文件
+			let searchDir = updateFileDir;
+			for (let i = 0; i < 5 && searchDir !== path.dirname(searchDir); i++) {
+				const possiblePath = path.join(searchDir, headRelativePathFromInfo);
+				if (fs.existsSync(possiblePath)) {
+					headFullPath = possiblePath;
+					headDir = path.dirname(possiblePath);
+					break;
+				}
+				searchDir = path.dirname(searchDir);
+			}
+			
+			// 方案3：尝试使用模块路径拼接
+			if (!headFullPath) {
+				const possiblePaths = [
+					path.join(currentPackageInfo.path, headRelativePathFromInfo),  // 当前模块根目录
+				];
+				
+				// 如果当前文件在 Code/ 目录下，尝试向上查找模块根目录
+				if (updateFileDir.endsWith('Code')) {
+					const possibleModuleRoot = path.dirname(updateFileDir);
+					possiblePaths.push(path.join(possibleModuleRoot, headRelativePathFromInfo));
+				}
+				
+				for (const possiblePath of possiblePaths) {
+					if (fs.existsSync(possiblePath)) {
+						headFullPath = possiblePath;
+						headDir = path.dirname(possiblePath);
+						break;
+					}
+				}
+			}
+		}
+		
+		if (headDir) {
+			console.log(`🔍 目录比较: 当前目录=${updateFileDir}, 头文件目录=${headDir}, headRelativePath=${headRelativePathFromInfo}`);
+			
+			// 检查是否在同一个目录（使用规范化路径比较）
+			const normalizedUpdateDir = path.normalize(updateFileDir);
+			const normalizedHeadDir = path.normalize(headDir);
+			
+			if (normalizedUpdateDir === normalizedHeadDir) {
+				isSameDirectory = true;
+				// 如果同目录，直接使用文件名
+				header.relativePathToCurrentFile = header.headerName;
+				console.log(`✅ 识别为同目录，使用文件名: ${header.headerName}`);
+			}
+		}
+		
+		// ✅ 如果能找到头文件完整路径且不同目录，计算相对路径（即使模块名不同）
+		if (headFullPath && fs.existsSync(headFullPath) && !isSameDirectory) {
+			// 计算从当前文件到头文件的相对路径
+			const relativePathToHeader = path.relative(updateFileDir, headDir);
+			
+			// 如果相对路径为空或为当前目录，使用文件名
+			if (!relativePathToHeader || relativePathToHeader === '.') {
+				header.relativePathToCurrentFile = header.headerName;
+			} else {
+				// 拼接相对路径和文件名
+				header.relativePathToCurrentFile = path.join(relativePathToHeader, header.headerName).replace(/\\/g, '/');
+			}
+			
+			console.log(`✅ 计算相对路径: ${updateFileDir} -> ${headDir} = ${header.relativePathToCurrentFile}`);
 		}
 	}
 	
 	// ✅ 判断是否为同一模块
 	const isSameModule = currentModuleName === headerInfo.moduleName;
 	
-	// 如果同目录，视为同一模块，使用相对路径
-	const shouldUseRelativePath = isSameDirectory || isSameModule;
+	// ✅ 决定是否使用相对路径
+	// 1. 同目录 -> 使用文件名
+	// 2. 同一模块 -> 使用相对路径
+	// 3. 能找到完整路径 -> 使用相对路径
+	// 4. 其他 -> 使用 <> 格式
+	const shouldUseRelativePath = isSameDirectory || isSameModule || (headFullPath && fs.existsSync(headFullPath));
 	
-	console.log(`🔍 模块识别: 当前模块=${currentModuleName}, 头文件模块=${headerInfo.moduleName}, 同一模块=${isSameModule}, 同目录=${isSameDirectory}`);
-
-	// ✅ 如果是同一模块且不同目录，计算相对于当前文件的相对路径
-	if (isSameModule && headRelativePathFromInfo && !isSameDirectory) {
-		// 当前文件相对于模块根目录的路径
-		const currentFileRelativeToModuleRoot = path.relative(currentPackageInfo.path, updateFile);
-		// 头文件相对于模块根目录的路径
-		const headRelativeToModuleRoot = headRelativePathFromInfo;
-		
-		// 计算从当前文件到头文件的相对路径
-		const currentFileDir = path.dirname(currentFileRelativeToModuleRoot);
-		const relativePathToHeader = path.relative(currentFileDir, headRelativeToModuleRoot).replace(/\\/g, '/');
-		
-		header.relativePathToCurrentFile = relativePathToHeader;
-	}
+	console.log(`🔍 模块识别: 当前模块=${currentModuleName}, 头文件模块=${headerInfo.moduleName}, 同一模块=${isSameModule}, 同目录=${isSameDirectory}, 找到头文件路径=${headFullPath ? '是' : '否'}`);
 
 	// 如果同目录或同一模块，使用相对路径；否则使用 <> 格式
 	handleModuleHeader(specFile, updateFile, header, importArray, !shouldUseRelativePath);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "autosnippet",
-    "version": "1.2.4",
+    "version": "1.2.6",
     "description": "A iOS module management tool.",
     "main": "index.js",
     "scripts": {