clcode.go

package main

import (
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"strings"
)

// 支持的编程语言文件扩展名和对应的注释样式
var langExtensions = map[string]struct {
	lineComment    string   // 单行注释前缀
	blockStart     string   // 块注释开始
	blockEnd       string   // 块注释结束
	fileExtensions []string // 文件扩展名
}{
	"golang": {
		lineComment:    "//",
		blockStart:     "/*",
		blockEnd:       "*/",
		fileExtensions: []string{".go"},
	},
	"java": {
		lineComment:    "//",
		blockStart:     "/*",
		blockEnd:       "*/",
		fileExtensions: []string{".java"},
	},
	"kotlin": {
		lineComment:    "//",
		blockStart:     "/*",
		blockEnd:       "*/",
		fileExtensions: []string{".kt", ".kts"},
	},
	"javascript": {
		lineComment:    "//",
		blockStart:     "/*",
		blockEnd:       "*/",
		fileExtensions: []string{".js", ".jsx", ".ts", ".tsx"},
	},
	"python": {
		lineComment:    "#",
		blockStart:     "\"\"\"",
		blockEnd:       "\"\"\"",
		fileExtensions: []string{".py"},
	},
	"rust": {
		lineComment:    "//",
		blockStart:     "/*",
		blockEnd:       "*/",
		fileExtensions: []string{".rs"},
	},
	"cpp": {
		lineComment:    "//",
		blockStart:     "/*",
		blockEnd:       "*/",
		fileExtensions: []string{".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hxx", ".h++", ".c"},
	},
	"csharp": {
		lineComment:    "//",
		blockStart:     "/*",
		blockEnd:       "*/",
		fileExtensions: []string{".cs"},
	},
}

// 要排除的目录名
var excludedDirs = []string{
	// Go
	"vendor", "node_modules", ".git",
	// Java/Kotlin
	"build", "target", "out", "bin", ".gradle", "gradle", ".mvn", ".idea",
	// JavaScript/TypeScript
	"node_modules", "dist", "build", ".next", "out",
	// Python
	"venv", "env", "__pycache__", ".pytest_cache", "dist", "build", "*.egg-info",
	// Rust
	"target", "cargo",
	// C++
	"build", "out", "bin", "lib", "obj", ".vs",
	// C#
	"bin", "obj", "packages", ".vs",
}

// 文件扩展名 -> 语言类型的映射
var extToLang map[string]string

// 检测文件扩展名是否属于受支持的编程语言
func isSupportedExtension(ext string) bool {
	_, exists := extToLang[ext]
	return exists
}

// 初始化扩展名映射
func initExtensionMap() {
	extToLang = make(map[string]string)
	for lang, info := range langExtensions {
		for _, ext := range info.fileExtensions {
			extToLang[ext] = lang
		}
	}
}

// 版权注释检测的正则表达式
var copyrightRegex = regexp.MustCompile(`(?i)copyright|©|\(c\)|all rights reserved|license|patent|trademark|proprietary`)
var info bool = false
// 检查目录是否被排除
func isExcludedDir(dirName string) bool {
	baseName := filepath.Base(dirName)
	for _, excluded := range excludedDirs {
		if baseName == excluded {
			return true
		}
	}
	return false
}

// 处理单个文件
func processFile(filePath string, dryRun bool) error {
	ext := filepath.Ext(filePath)
	lang, exists := extToLang[ext]
	if !exists {
		return nil // 不支持的文件类型
	}

	// 读取文件内容
	content, err := os.ReadFile(filePath)
	if err != nil {
		return err
	}

	langInfo := langExtensions[lang]
	contentStr := string(content)
	lines := strings.Split(contentStr, "\n")
	
	// 需要从头部删除的行
	linesToRemove := 0
	inCommentBlock := false
	foundCopyright := false

	// 检查文件开头的空行
	firstNonEmptyLine := 0
	for i, line := range lines {
		if strings.TrimSpace(line) != "" {
			firstNonEmptyLine = i
			break
		}
	}

	// 检查头部注释
	for i := firstNonEmptyLine; i < len(lines); i++ {
		line := strings.TrimSpace(lines[i])

		// 检查是否为源码指令或包声明，则停止检查
		if strings.HasPrefix(line, "package ") || 
		   strings.HasPrefix(line, "import ") || 
		   strings.HasPrefix(line, "using ") ||
		   strings.HasPrefix(line, "#include") ||
		   strings.HasPrefix(line, "#ifndef") ||
		   strings.HasPrefix(line, "namespace") ||
		   strings.HasPrefix(line, "public class") ||
		   strings.HasPrefix(line, "class ") ||
		   strings.HasPrefix(line, "def ") ||
		   strings.HasPrefix(line, "function ") ||
		   strings.HasPrefix(line, "const ") ||
		   strings.HasPrefix(line, "var ") ||
		   strings.HasPrefix(line, "let ") {
			
			// 找到实际代码行了，如果此前找到了版权信息，就停止搜索
			if foundCopyright {
				break
			} else {
				// 没有找到版权信息，保留原文件
				return nil
			}
		}
		// 块注释处理
		if !inCommentBlock && strings.HasPrefix(line, langInfo.blockStart) {
			inCommentBlock = true
			fmt.Println(line)
			// 检查这一行是否包含版权信息
			if copyrightRegex.MatchString(line) {
				foundCopyright = true
			}
		} else if inCommentBlock {
			if !foundCopyright && copyrightRegex.MatchString(line) {
				foundCopyright = true
			}
			if strings.Contains(line, langInfo.blockEnd) {
				inCommentBlock = false
				if foundCopyright {
					linesToRemove = i + 1
				}
				continue
			}
		}

		// 行注释处理
		if strings.HasPrefix(line, langInfo.lineComment) && !inCommentBlock {
			if copyrightRegex.MatchString(line) {
				foundCopyright = true
				linesToRemove = i + 1
			}
		} else if !inCommentBlock && line != "" && !strings.HasPrefix(line, langInfo.lineComment) {
			// 遇到非注释行，如果已找到版权信息，则停止检查
			if foundCopyright {
				break
			} else {
				// 没找到版权信息就遇到代码行，保留原文件
				return nil
			}
		}

		// 对于Python的文档字符串特殊处理
		if lang == "python" && strings.HasPrefix(line, "\"\"\"") {
			// 找到结束的文档字符串
			docStringEnd := false
			for j := i + 1; j < len(lines) && !docStringEnd; j++ {
				if strings.Contains(lines[j], "\"\"\"") {
					docStringEnd = true
					if copyrightRegex.MatchString(strings.Join(lines[i:j+1], " ")) {
						foundCopyright = true
						linesToRemove = j + 1
					}
					i = j
				}
			}
		}
	}

	// 没有找到版权信息
	if !foundCopyright || linesToRemove == 0 {
		return nil
	}
	if !dryRun {
		if info {
			fmt.Printf("Removing copyright from: %s\n", filePath)
		}
		newContent := strings.Join(lines[linesToRemove:], "\n")
		return os.WriteFile(filePath, []byte(newContent), 0644)
	} else {
		fmt.Printf("[Test Mod] Would remove copyright header from: %s\n", filePath)
	}

	return nil
}

func processDirectory(dirPath string, dryRun bool) error {
	fileCount := 0
	modifiedCount := 0
	
	err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			if isExcludedDir(path) {
				return filepath.SkipDir
			}
			return nil
		}
		
		ext := filepath.Ext(path)
		if isSupportedExtension(ext) {
			fileCount++
			// 处理文件前记录文件大小
			origSize := info.Size()
			
			err := processFile(path, dryRun)
			if err != nil {
				fmt.Printf("Error processing file %s: %v\n", path, err)
				return nil // 继续处理其他文件
			}
			
			// 如果不是试运行模式，检查文件大小是否变化
			if !dryRun {
				newInfo, err := os.Stat(path)
				if err == nil && newInfo.Size() != origSize {
					modifiedCount++
				}
			}
		}

		return nil
	})
	
	if !dryRun && info {
		fmt.Printf("\n处理完成! 共扫描 %d 个文件，修改了 %d 个文件\n", fileCount, modifiedCount)
	}
	
	return err
}

func main() {
	initExtensionMap()
	dirPath := flag.String("d", ".", "要处理的项目目录路径")
	dryRun := flag.Bool("t", false, "是否进行试运行（不实际修改文件）")
	excludeDirsStr := flag.String("e", "", "额外要排除的目录，以逗号分隔")
	help := flag.Bool("h", false, "显示帮助信息")
	verbose := flag.Bool("v", false, "显示详细信息")
	flag.Parse()
	if *verbose {
		info = true
	}
	if *help {
		fmt.Println("用法: clscode -d <目录> [-t] [-e <排除目录>] [-v] [-h]")
		fmt.Println("  -d <目录>       指定要处理的项目目录")
		fmt.Println("  -t              试运行模式，不实际修改文件")
		fmt.Println("  -e <排除目录>   额外要排除的目录，以逗号分隔")
		fmt.Println("  -v              显示详细处理信息")
		fmt.Println("  -h              显示此帮助信息")
		fmt.Println("\n支持以下语言：")
		languages := make([]string, 0, len(langExtensions))
		for lang := range langExtensions {
			languages = append(languages, lang)
		}
		fmt.Println(strings.Join(languages, ", "))
		os.Exit(0)
	}
	
	// 添加用户指定的排除目录
	if *excludeDirsStr != "" {
		userExcludedDirs := strings.Split(*excludeDirsStr, ",")
		for _, dir := range userExcludedDirs {
			excludedDirs = append(excludedDirs, strings.TrimSpace(dir))
		}
	}

	// 确保目录存在
	if _, err := os.Stat(*dirPath); os.IsNotExist(err) {
		fmt.Printf("目录不存在: %s\n", *dirPath)
		os.Exit(1)
	}

	fmt.Printf("开始处理目录: %s\n", *dirPath)
	if *dryRun {
		fmt.Println("运行模式: 试运行 (不会实际修改文件)")
	}

	// 处理目录
	err := processDirectory(*dirPath, *dryRun)
	if err != nil {
		fmt.Printf("处理过程中出错: %v\n", err)
		os.Exit(1)
	}
}