cleaner/internal/keywords/keywords.go

205 lines
4.7 KiB
Go
Raw Permalink 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/trash.txt
var defaultTrashTemplate string
//go:embed templates/replacements.txt
var defaultReplacementTemplate string
type ReplacementRule struct {
Old string
New string
}
type Filter struct {
trash map[string]struct{}
replacements []ReplacementRule
ignoreCase bool
}
// LoadFromFiles читает списки из текстовых файлов.
// Если файл не существует, создаёт его с шаблоном по умолчанию.
func LoadFromFiles(trashPath, replacementsPath string, ignoreCase bool) (*Filter, error) {
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)
}
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{
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
}
if !strings.Contains(line, "->") {
rules = append(rules, ReplacementRule{Old: line, New: ""})
continue
}
parts := strings.SplitN(line, "->", 2)
old := strings.TrimSpace(parts[0])
newValue := strings.TrimSpace(parts[1])
if old == "" {
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
}
func (f *Filter) applyReplacements(name string) string {
result := name
for _, rule := range f.replacements {
if rule.New == "" {
if f.ignoreCase {
result = replaceIgnoreCase(result, rule.Old, "")
} else {
result = strings.ReplaceAll(result, rule.Old, "")
}
continue
}
if f.ignoreCase {
result = replaceIgnoreCase(result, rule.Old, rule.New)
} else {
result = strings.ReplaceAll(result, rule.Old, rule.New)
}
}
return result
}
// Clean очищает имя. Для папок (isDir = true) имя обрабатывается целиком без отделения расширения.
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)
}
base = strings.TrimSpace(base)
base = strings.Join(strings.Fields(base), " ")
if base == "" {
return ""
}
return base + ext
}
func replaceIgnoreCase(s, old, replacement string) string {
if old == "" {
return s
}
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()
}