photoprism/pkg/fs/ignore.go

166 lines
3.8 KiB
Go
Raw Normal View History

package fs
import (
"errors"
"fmt"
"path/filepath"
"strings"
)
type IgnoreLogFunc func(fileName string)
// IgnoreItem represents a file name pattern to be ignored.
type IgnoreItem struct {
Dir string
Pattern string
}
// NewIgnoreItem returns a pointer to a new IgnoreItem instance.
func NewIgnoreItem(dir, pattern string, caseSensitive bool) IgnoreItem {
if caseSensitive {
return IgnoreItem{Dir: dir + PathSeparator, Pattern: pattern}
} else {
return IgnoreItem{Dir: strings.ToLower(dir) + PathSeparator, Pattern: strings.ToLower(pattern)}
}
}
// Ignore returns true if the file name "base" in the directory "dir" should be ignored.
func (i IgnoreItem) Ignore(dir, base string) bool {
if !strings.HasPrefix(dir+PathSeparator, i.Dir) {
// different directory prefix: don't look any further
return false
} else if i.Pattern == base {
// file name is the same as pattern (no wildcard)
return true
}
if strings.ContainsRune(i.Pattern, filepath.Separator) {
base = filepath.Join(RelName(dir, i.Dir), base)
}
if ignore, err := filepath.Match(i.Pattern, base); ignore && err == nil {
return true
}
return false
}
// IgnoreList represents a list of name patterns to be ignored.
type IgnoreList struct {
Log IgnoreLogFunc
items []IgnoreItem
hiddenFiles []string
ignoredFiles []string
configFiles map[string][]string
configFile string
ignoreHidden bool
caseSensitive bool
}
// NewIgnoreList returns a pointer to a new IgnoreList instance.
func NewIgnoreList(configFile string, ignoreHidden bool, caseSensitive bool) *IgnoreList {
return &IgnoreList{
configFile: configFile,
ignoreHidden: ignoreHidden,
caseSensitive: caseSensitive,
configFiles: make(map[string][]string),
}
}
// Hidden returns hidden files that were ignored.
func (l *IgnoreList) Hidden() []string {
return l.hiddenFiles
}
// Ignored returns files that were ignored in addition to hidden files.
func (l *IgnoreList) Ignored() []string {
return l.ignoredFiles
}
// AppendItems adds items to the list of ignored items.
func (l *IgnoreList) AppendItems(dir string, patterns []string) error {
if dir == "" {
return errors.New("empty directory name")
}
for _, pattern := range patterns {
if pattern != "" && !strings.HasPrefix(pattern, "#") {
l.items = append(l.items, NewIgnoreItem(dir, pattern, l.caseSensitive))
}
}
return nil
}
// ConfigFile adds items in fileName to the list of ignored items.
func (l *IgnoreList) ConfigFile(fileName string) error {
items, err := ReadLines(fileName)
if err != nil {
return err
}
l.configFiles[fileName] = items
return l.AppendItems(filepath.Dir(fileName), items)
}
// Dir adds the ignore file in dirName to the list of ignored items.
func (l *IgnoreList) Dir(dir string) error {
if dir == "" {
return errors.New("empty directory name")
}
if l.configFile == "" {
return errors.New("empty ignore file name")
}
fileName := filepath.Join(dir, l.configFile)
if _, ok := l.configFiles[fileName]; ok {
return nil
}
if !FileExists(fileName) {
return fmt.Errorf("found no %s file", l.configFile)
}
return l.ConfigFile(fileName)
}
// Ignore returns true if the file name should be ignored.
func (l *IgnoreList) Ignore(fileName string) bool {
dir := filepath.Dir(fileName)
base := filepath.Base(fileName)
if l.caseSensitive == false {
dir = strings.ToLower(dir)
base = strings.ToLower(base)
}
if l.configFile != "" && base == l.configFile {
_ = l.ConfigFile(fileName)
return true
}
for _, item := range l.items {
if item.Ignore(dir, base) {
l.ignoredFiles = append(l.ignoredFiles, fileName)
if l.Log != nil {
l.Log(fileName)
}
return true
}
}
if l.ignoreHidden && FileNameHidden(fileName) {
l.hiddenFiles = append(l.hiddenFiles, fileName)
return true
}
return false
}