205 lines
4.7 KiB
Go
205 lines
4.7 KiB
Go
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()
|
||
}
|