cleaner/internal/keywords/keywords.go

213 lines
5.2 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package keywords
import (
"bufio"
_ "embed"
"fmt"
"os"
"path/filepath"
"strings"
)
//go:embed templates/words.txt
var defaultWordsTemplate string
//go:embed templates/trash.txt
var defaultTrashTemplate string
//go:embed templates/replacements.txt
var defaultReplacementTemplate string
type ReplacementRule struct {
Old string
New string
}
type Filter struct {
words []string
trash map[string]struct{}
replacements []ReplacementRule
ignoreCase bool
}
// LoadFromFiles читает списки из текстовых файлов.
// Если файл не существует, создаёт его с шаблоном по умолчанию.
func LoadFromFiles(wordsPath, trashPath, replacementsPath 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)
}
if err := ensureFileExists(replacementsPath, defaultReplacementTemplate); err != nil {
return nil, fmt.Errorf("не удалось подготовить файл замен %s: %w", replacementsPath, 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)
}
replacementRules, err := readReplacementRules(replacementsPath)
if err != nil {
return nil, fmt.Errorf("ошибка чтения %s: %w", replacementsPath, 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,
replacements: replacementRules,
ignoreCase: ignoreCase,
}, nil
}
func ensureFileExists(path, template string) error {
if _, err := os.Stat(path); err == nil {
return nil
} else if !os.IsNotExist(err) {
return err
}
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
return err
}
return os.WriteFile(path, []byte(template), 0o644)
}
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 readReplacementRules(path string) ([]ReplacementRule, error) {
file, err := os.Open(path)
if err != nil {
return nil, err
}
defer file.Close()
var rules []ReplacementRule
scanner := bufio.NewScanner(file)
for scanner.Scan() {
line := strings.TrimSpace(scanner.Text())
if line == "" || strings.HasPrefix(line, "#") {
continue
}
parts := strings.SplitN(line, "->", 2)
if len(parts) != 2 {
return nil, fmt.Errorf("неверное правило замены %q: ожидается формат 'old -> new'", line)
}
old := strings.TrimSpace(parts[0])
newValue := strings.TrimSpace(parts[1])
if old == "" || newValue == "" {
return nil, fmt.Errorf("неверное правило замены %q: пустое значение", line)
}
rules = append(rules, ReplacementRule{Old: old, New: newValue})
}
return rules, 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) applyReplacements(name string) string {
result := name
for _, rule := range f.replacements {
if f.ignoreCase {
result = replaceIgnoreCase(result, rule.Old, rule.New)
} else {
result = strings.ReplaceAll(result, rule.Old, rule.New)
}
}
return result
}
func (f *Filter) Clean(name string, isDir bool) string {
name = f.applyReplacements(name)
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()
}