From 30091819a311b128baf3f3e182f2bc47de5433cd Mon Sep 17 00:00:00 2001 From: Kirill Kalikin Date: Sat, 14 Nov 2026 14:00:54 +0700 Subject: [PATCH] Implementation --- cmd/cleaner/main.go | 55 +++++++++++- internal/keywords/keywords.go | 164 ++++++++++++++++++++++++++++++++++ internal/renamer/renamer.go | 98 ++++++++++++++++++++ 3 files changed, 314 insertions(+), 3 deletions(-) create mode 100644 internal/keywords/keywords.go create mode 100644 internal/renamer/renamer.go diff --git a/cmd/cleaner/main.go b/cmd/cleaner/main.go index 03a0736..c479e4d 100644 --- a/cmd/cleaner/main.go +++ b/cmd/cleaner/main.go @@ -1,7 +1,56 @@ package main + import ( + "flag" "fmt" + "os" + "path/filepath" + + "nertz/cleaner/internal/keywords" + "nertz/cleaner/internal/renamer" ) -func main(){ - fmt.Println("111") -} \ No newline at end of file + +var ( + version = "dev" + commit = "none" + date = "unknown" +) + +func main() { + // Определяем папку, где лежит сам бинарный файл, чтобы хранить конфиги рядом с ним + exeDir := "." + if exePath, err := os.Executable(); err == nil { + exeDir = filepath.Dir(exePath) + } + + dirFlag := flag.String("dir", ".", "Путь к корневой папке для обработки") + wordsFileFlag := flag.String("words-file", filepath.Join(exeDir, "words.txt"), "Путь к файлу со списком ключевых слов") + trashFileFlag := flag.String("trash-file", filepath.Join(exeDir, "trash.txt"), "Путь к файлу со списком удаляемых файлов") + dryRunFlag := flag.Bool("dry-run", false, "Пробный запуск без изменения и удаления файлов") + ignoreCaseFlag := flag.Bool("i", true, "Игнорировать регистр при поиске") + versionFlag := flag.Bool("version", false, "Показать версию утилиты") + + flag.Parse() + + if *versionFlag { + fmt.Printf("cleaner %s (commit: %s, built at: %s)\n", version, commit, date) + return + } + + filter, err := keywords.LoadFromFiles(*wordsFileFlag, *trashFileFlag, *ignoreCaseFlag) + if err != nil { + fmt.Fprintf(os.Stderr, "Ошибка загрузки списков: %v\n", err) + os.Exit(1) + } + + cfg := renamer.Config{ + RootDir: *dirFlag, + Filter: filter, + DryRun: *dryRunFlag, + } + + if err := renamer.Run(cfg); err != nil { + fmt.Fprintf(os.Stderr, "Критическая ошибка: %v\n", err) + os.Exit(1) + } +} diff --git a/internal/keywords/keywords.go b/internal/keywords/keywords.go new file mode 100644 index 0000000..b3e329b --- /dev/null +++ b/internal/keywords/keywords.go @@ -0,0 +1,164 @@ +package keywords + +import ( + "bufio" + "fmt" + "os" + "path/filepath" + "strings" +) + +const defaultWordsTemplate = `# Список ключевых слов и тегов для удаления из имён файлов и папок (по одному на строку). +# Строки, начинающиеся с #, игнорируются. + +[SWBAND.CO] +` +// defaultWords — ключевые слова для вырезания из имён файлов и папок. +var defaultWords = []string{ + "[SWBAND.CO]", +} + +const defaultTrashTemplate = `# Точные имена мусорных файлов для полного удаления (по одному на строку). +# Строки, начинающиеся с #, игнорируются. + +.DS_Store +Thumbs.db +desktop.ini +readme.url +Прочти перед изучением!.docx +Введение начни правильно.docx +Не пропусти этот шаг!.docx +Твой первый шаг здесь.docx +Шаг №1 — Прочти!.docx +Обязательно к прочтению.docx +Важно! Перед стартом курса.docx +Ключ к успешному старту.docx +Главное перед изучением.docx +Инструкция перед началом.docx +` + +type Filter struct { + words []string + trash map[string]struct{} + ignoreCase bool +} + +// LoadFromFiles читает списки из текстовых файлов. +// Если файл не существует, создаёт его с шаблоном по умолчанию. +func LoadFromFiles(wordsPath, trashPath string, ignoreCase bool) (*Filter, error) { + if err := ensureFileExists(wordsPath, defaultWordsTemplate); err != nil { + return nil, fmt.Errorf("не удалось подготовить файл слов %s: %w", wordsPath, err) + } + if err := ensureFileExists(trashPath, defaultTrashTemplate); err != nil { + return nil, fmt.Errorf("не удалось подготовить файл мусора %s: %w", trashPath, err) + } + + wordsList, err := readLines(wordsPath) + if err != nil { + return nil, fmt.Errorf("ошибка чтения %s: %w", wordsPath, err) + } + + trashList, err := readLines(trashPath) + if err != nil { + return nil, fmt.Errorf("ошибка чтения %s: %w", trashPath, err) + } + + trashMap := make(map[string]struct{}, len(trashList)) + for _, tf := range trashList { + key := tf + if ignoreCase { + key = strings.ToLower(tf) + } + trashMap[key] = struct{}{} + } + + return &Filter{ + words: wordsList, + trash: trashMap, + ignoreCase: ignoreCase, + }, nil +} + +func ensureFileExists(path, template string) error { + if _, err := os.Stat(path); os.IsNotExist(err) { + return os.WriteFile(path, []byte(template), 0644) + } + return nil +} + +func readLines(path string) ([]string, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + + var lines []string + scanner := bufio.NewScanner(file) + for scanner.Scan() { + line := strings.TrimSpace(scanner.Text()) + // Пропускаем пустые строки и комментарии + if line == "" || strings.HasPrefix(line, "#") { + continue + } + lines = append(lines, line) + } + + return lines, scanner.Err() +} + +func (f *Filter) ShouldDelete(name string) bool { + target := name + if f.ignoreCase { + target = strings.ToLower(name) + } + _, exists := f.trash[target] + return exists +} + +// Clean очищает имя. Для папок (isDir = true) имя обрабатывается целиком без отделения расширения. +func (f *Filter) Clean(name string, isDir bool) string { + var base, ext string + + if isDir { + base = name + } else { + ext = filepath.Ext(name) + base = strings.TrimSuffix(name, ext) + } + + for _, kw := range f.words { + if f.ignoreCase { + base = replaceIgnoreCase(base, kw, "") + } else { + base = strings.ReplaceAll(base, kw, "") + } + } + + base = strings.TrimSpace(base) + base = strings.Join(strings.Fields(base), " ") + + if base == "" { + return "" + } + return base + ext +} + +func replaceIgnoreCase(s, old, replacement string) string { + lowerS := strings.ToLower(s) + lowerOld := strings.ToLower(old) + + var result strings.Builder + i := 0 + for { + idx := strings.Index(lowerS[i:], lowerOld) + if idx == -1 { + result.WriteString(s[i:]) + break + } + result.WriteString(s[i : i+idx]) + result.WriteString(replacement) + i += idx + len(old) + } + return result.String() +} \ No newline at end of file diff --git a/internal/renamer/renamer.go b/internal/renamer/renamer.go new file mode 100644 index 0000000..8baba11 --- /dev/null +++ b/internal/renamer/renamer.go @@ -0,0 +1,98 @@ +package renamer + +import ( + "fmt" + "io/fs" + "os" + "path/filepath" + "sort" + "strings" + + "nertz/cleaner/internal/keywords" +) + +// Config хранит параметры запуска утилиты. +type Config struct { + RootDir string + Filter *keywords.Filter + DryRun bool +} + +// Run выполняет рекурсивный обход, удаление мусорных файлов и переименование. +func Run(cfg Config) error { + var paths []string + + err := filepath.WalkDir(cfg.RootDir, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if path == cfg.RootDir { + return nil + } + // Пропускаем скрытые директории (например, .git) + if d.IsDir() && strings.HasPrefix(d.Name(), ".") { + return filepath.SkipDir + } + paths = append(paths, path) + return nil + }) + if err != nil { + return fmt.Errorf("ошибка при сканировании директории: %w", err) + } + + // Сортируем от самых глубоких путей к верхним (обход снизу вверх) + sort.Slice(paths, func(i, j int) bool { + return len(paths[i]) > len(paths[j]) + }) + + for _, oldPath := range paths { + info, err := os.Lstat(oldPath) + if err != nil { + fmt.Printf("[ОШИБКА] Не удалось получить информацию о %s: %v\n", oldPath, err) + continue + } + + dir := filepath.Dir(oldPath) + oldName := filepath.Base(oldPath) + + // 1. Проверяем, нужно ли удалить файл (папки не удаляем) + if !info.IsDir() && cfg.Filter.ShouldDelete(oldName) { + if cfg.DryRun { + fmt.Printf("[DRY-RUN УДАЛЕНИЕ] %s\n", oldPath) + continue + } + if err := os.Remove(oldPath); err != nil { + fmt.Printf("[ОШИБКА] Не удалось удалить %s: %v\n", oldPath, err) + continue + } + fmt.Printf("[УДАЛЕНО] %s\n", oldPath) + continue + } + + // 2. Очищаем имя файла или папки от ключевых слов + newName := cfg.Filter.Clean(oldName, info.IsDir()) + if newName == "" || newName == oldName { + continue + } + + newPath := filepath.Join(dir, newName) + + if _, err := os.Stat(newPath); err == nil { + fmt.Printf("[ПРОПУСК] %s -> %s (целевой объект уже существует)\n", oldPath, newName) + continue + } + + if cfg.DryRun { + fmt.Printf("[DRY-RUN] %s ---> %s\n", oldPath, newName) + continue + } + + if err := os.Rename(oldPath, newPath); err != nil { + fmt.Printf("[ОШИБКА] Не удалось переименовать %s: %v\n", oldPath, err) + continue + } + fmt.Printf("[OK] %s ---> %s\n", oldPath, newName) + } + + return nil +}