2014-11-16 21:13:20 +01:00
|
|
|
// Copyright (C) 2014 The Syncthing Authors.
|
2014-09-29 21:43:32 +02:00
|
|
|
//
|
2015-03-07 21:36:35 +01:00
|
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
2017-02-09 07:52:18 +01:00
|
|
|
// You can obtain one at https://mozilla.org/MPL/2.0/.
|
2014-09-04 22:29:53 +02:00
|
|
|
|
|
|
|
package ignore
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
2014-12-23 10:05:08 +01:00
|
|
|
"bytes"
|
|
|
|
"crypto/md5"
|
2014-09-04 22:29:53 +02:00
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"path/filepath"
|
2016-04-02 21:03:24 +02:00
|
|
|
"runtime"
|
2014-09-04 22:29:53 +02:00
|
|
|
"strings"
|
2014-12-23 10:05:08 +01:00
|
|
|
"time"
|
2014-09-04 22:29:53 +02:00
|
|
|
|
2016-04-02 21:03:24 +02:00
|
|
|
"github.com/gobwas/glob"
|
2017-08-19 16:36:56 +02:00
|
|
|
"github.com/syncthing/syncthing/lib/fs"
|
2017-04-01 11:58:06 +02:00
|
|
|
"github.com/syncthing/syncthing/lib/osutil"
|
2015-08-06 11:29:25 +02:00
|
|
|
"github.com/syncthing/syncthing/lib/sync"
|
2014-09-04 22:29:53 +02:00
|
|
|
)
|
|
|
|
|
2016-05-01 17:58:23 +02:00
|
|
|
const (
|
2016-05-04 09:15:56 +02:00
|
|
|
resultNotMatched Result = 0
|
|
|
|
resultInclude Result = 1 << iota
|
|
|
|
resultDeletable = 1 << iota
|
|
|
|
resultFoldCase = 1 << iota
|
2016-05-01 17:58:23 +02:00
|
|
|
)
|
|
|
|
|
2014-09-04 22:29:53 +02:00
|
|
|
type Pattern struct {
|
2016-05-01 17:58:23 +02:00
|
|
|
pattern string
|
|
|
|
match glob.Glob
|
|
|
|
result Result
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
|
2014-12-23 10:05:08 +01:00
|
|
|
func (p Pattern) String() string {
|
2016-04-02 21:03:24 +02:00
|
|
|
ret := p.pattern
|
2016-05-01 17:58:23 +02:00
|
|
|
if p.result&resultInclude != resultInclude {
|
2016-04-02 21:03:24 +02:00
|
|
|
ret = "!" + ret
|
2014-12-23 10:05:08 +01:00
|
|
|
}
|
2016-05-01 17:58:23 +02:00
|
|
|
if p.result&resultFoldCase == resultFoldCase {
|
2016-04-02 21:03:24 +02:00
|
|
|
ret = "(?i)" + ret
|
|
|
|
}
|
2016-05-01 17:58:23 +02:00
|
|
|
if p.result&resultDeletable == resultDeletable {
|
2016-04-07 11:34:07 +02:00
|
|
|
ret = "(?d)" + ret
|
|
|
|
}
|
2016-04-02 21:03:24 +02:00
|
|
|
return ret
|
2014-12-23 10:05:08 +01:00
|
|
|
}
|
|
|
|
|
2016-05-01 17:58:23 +02:00
|
|
|
type Result uint8
|
2016-04-07 11:34:07 +02:00
|
|
|
|
|
|
|
func (r Result) IsIgnored() bool {
|
2016-05-01 17:58:23 +02:00
|
|
|
return r&resultInclude == resultInclude
|
2016-04-07 11:34:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (r Result) IsDeletable() bool {
|
2016-05-01 17:58:23 +02:00
|
|
|
return r.IsIgnored() && r&resultDeletable == resultDeletable
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r Result) IsCaseFolded() bool {
|
|
|
|
return r&resultFoldCase == resultFoldCase
|
2016-04-07 11:34:07 +02:00
|
|
|
}
|
|
|
|
|
2017-06-11 12:27:12 +02:00
|
|
|
// The ChangeDetector is responsible for determining if files have changed
|
|
|
|
// on disk. It gets told to Remember() files (name and modtime) and will
|
|
|
|
// then get asked if a file has been Seen() (i.e., Remember() has been
|
|
|
|
// called on it) and if any of the files have Changed(). To forget all
|
|
|
|
// files, call Reset().
|
|
|
|
type ChangeDetector interface {
|
2017-08-22 08:45:00 +02:00
|
|
|
Remember(fs fs.Filesystem, name string, modtime time.Time)
|
|
|
|
Seen(fs fs.Filesystem, name string) bool
|
2017-06-11 12:27:12 +02:00
|
|
|
Changed() bool
|
|
|
|
Reset()
|
|
|
|
}
|
|
|
|
|
2014-10-12 23:35:15 +02:00
|
|
|
type Matcher struct {
|
2017-08-19 16:36:56 +02:00
|
|
|
fs fs.Filesystem
|
2017-07-06 13:44:11 +02:00
|
|
|
lines []string // exact lines read from .stignore
|
|
|
|
patterns []Pattern // patterns including those from included files
|
2017-06-11 12:27:12 +02:00
|
|
|
withCache bool
|
|
|
|
matches *cache
|
|
|
|
curHash string
|
|
|
|
stop chan struct{}
|
|
|
|
changeDetector ChangeDetector
|
|
|
|
mut sync.Mutex
|
|
|
|
}
|
|
|
|
|
|
|
|
// An Option can be passed to New()
|
|
|
|
type Option func(*Matcher)
|
|
|
|
|
|
|
|
// WithCache enables or disables lookup caching. The default is disabled.
|
|
|
|
func WithCache(v bool) Option {
|
|
|
|
return func(m *Matcher) {
|
|
|
|
m.withCache = v
|
|
|
|
}
|
2014-12-23 10:05:08 +01:00
|
|
|
}
|
|
|
|
|
2017-06-11 12:27:12 +02:00
|
|
|
// WithChangeDetector sets a custom ChangeDetector. The default is to simply
|
|
|
|
// use the on disk modtime for comparison.
|
|
|
|
func WithChangeDetector(cd ChangeDetector) Option {
|
|
|
|
return func(m *Matcher) {
|
|
|
|
m.changeDetector = cd
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-19 16:36:56 +02:00
|
|
|
func New(fs fs.Filesystem, opts ...Option) *Matcher {
|
2014-12-23 10:05:08 +01:00
|
|
|
m := &Matcher{
|
2017-08-19 16:36:56 +02:00
|
|
|
fs: fs,
|
2017-06-11 12:27:12 +02:00
|
|
|
stop: make(chan struct{}),
|
|
|
|
mut: sync.NewMutex(),
|
2014-12-23 10:05:08 +01:00
|
|
|
}
|
2017-06-11 12:27:12 +02:00
|
|
|
for _, opt := range opts {
|
|
|
|
opt(m)
|
|
|
|
}
|
|
|
|
if m.changeDetector == nil {
|
2017-08-22 08:45:00 +02:00
|
|
|
m.changeDetector = newModtimeChecker()
|
2017-06-11 12:27:12 +02:00
|
|
|
}
|
|
|
|
if m.withCache {
|
2014-12-23 10:05:08 +01:00
|
|
|
go m.clean(2 * time.Hour)
|
|
|
|
}
|
|
|
|
return m
|
2014-10-12 23:35:15 +02:00
|
|
|
}
|
2014-09-04 22:29:53 +02:00
|
|
|
|
2014-12-23 10:05:08 +01:00
|
|
|
func (m *Matcher) Load(file string) error {
|
2016-11-22 22:30:45 +01:00
|
|
|
m.mut.Lock()
|
|
|
|
defer m.mut.Unlock()
|
|
|
|
|
2017-08-22 08:45:00 +02:00
|
|
|
if m.changeDetector.Seen(m.fs, file) && !m.changeDetector.Changed() {
|
2016-11-22 22:30:45 +01:00
|
|
|
return nil
|
|
|
|
}
|
2014-12-23 10:05:08 +01:00
|
|
|
|
2017-09-04 14:46:19 +02:00
|
|
|
fd, info, err := loadIgnoreFile(m.fs, file, m.changeDetector)
|
2014-12-23 10:05:08 +01:00
|
|
|
if err != nil {
|
2016-11-22 22:30:45 +01:00
|
|
|
m.parseLocked(&bytes.Buffer{}, file)
|
2014-12-23 10:05:08 +01:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer fd.Close()
|
|
|
|
|
2017-06-11 12:27:12 +02:00
|
|
|
m.changeDetector.Reset()
|
2017-08-22 08:45:00 +02:00
|
|
|
m.changeDetector.Remember(m.fs, file, info.ModTime())
|
2016-11-22 22:30:45 +01:00
|
|
|
|
|
|
|
return m.parseLocked(fd, file)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
|
2014-12-23 10:05:08 +01:00
|
|
|
func (m *Matcher) Parse(r io.Reader, file string) error {
|
|
|
|
m.mut.Lock()
|
|
|
|
defer m.mut.Unlock()
|
2016-11-22 22:30:45 +01:00
|
|
|
return m.parseLocked(r, file)
|
|
|
|
}
|
2014-12-23 10:05:08 +01:00
|
|
|
|
2016-11-22 22:30:45 +01:00
|
|
|
func (m *Matcher) parseLocked(r io.Reader, file string) error {
|
2017-09-04 14:46:19 +02:00
|
|
|
lines, patterns, err := parseIgnoreFile(m.fs, r, file, m.changeDetector, make(map[string]struct{}))
|
2014-12-23 10:05:08 +01:00
|
|
|
// Error is saved and returned at the end. We process the patterns
|
|
|
|
// (possibly blank) anyway.
|
|
|
|
|
2018-01-20 08:52:57 +01:00
|
|
|
m.lines = lines
|
|
|
|
|
2014-12-23 10:05:08 +01:00
|
|
|
newHash := hashPatterns(patterns)
|
|
|
|
if newHash == m.curHash {
|
|
|
|
// We've already loaded exactly these patterns.
|
|
|
|
return err
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
2014-12-23 10:05:08 +01:00
|
|
|
|
|
|
|
m.curHash = newHash
|
|
|
|
m.patterns = patterns
|
|
|
|
if m.withCache {
|
|
|
|
m.matches = newCache(patterns)
|
|
|
|
}
|
|
|
|
|
|
|
|
return err
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
|
2016-04-07 11:34:07 +02:00
|
|
|
func (m *Matcher) Match(file string) (result Result) {
|
2017-09-06 08:39:18 +02:00
|
|
|
if file == "." {
|
2016-05-04 09:15:56 +02:00
|
|
|
return resultNotMatched
|
2015-04-27 21:49:10 +02:00
|
|
|
}
|
|
|
|
|
2014-12-23 10:05:08 +01:00
|
|
|
m.mut.Lock()
|
|
|
|
defer m.mut.Unlock()
|
|
|
|
|
2014-10-12 23:35:15 +02:00
|
|
|
if len(m.patterns) == 0 {
|
2016-05-04 09:15:56 +02:00
|
|
|
return resultNotMatched
|
2014-10-12 23:35:15 +02:00
|
|
|
}
|
|
|
|
|
2014-12-02 23:13:03 +01:00
|
|
|
if m.matches != nil {
|
|
|
|
// Check the cache for a known result.
|
|
|
|
res, ok := m.matches.get(file)
|
2014-10-12 23:35:15 +02:00
|
|
|
if ok {
|
2014-12-02 23:13:03 +01:00
|
|
|
return res
|
2014-10-12 23:35:15 +02:00
|
|
|
}
|
2014-12-02 23:13:03 +01:00
|
|
|
|
|
|
|
// Update the cache with the result at return time
|
|
|
|
defer func() {
|
|
|
|
m.matches.set(file, result)
|
|
|
|
}()
|
2014-10-12 23:35:15 +02:00
|
|
|
}
|
|
|
|
|
2014-12-02 23:13:03 +01:00
|
|
|
// Check all the patterns for a match.
|
2016-04-02 21:03:24 +02:00
|
|
|
file = filepath.ToSlash(file)
|
|
|
|
var lowercaseFile string
|
2014-10-12 23:35:15 +02:00
|
|
|
for _, pattern := range m.patterns {
|
2016-05-01 17:58:23 +02:00
|
|
|
if pattern.result.IsCaseFolded() {
|
2016-04-02 21:03:24 +02:00
|
|
|
if lowercaseFile == "" {
|
|
|
|
lowercaseFile = strings.ToLower(file)
|
|
|
|
}
|
|
|
|
if pattern.match.Match(lowercaseFile) {
|
2016-05-01 17:58:23 +02:00
|
|
|
return pattern.result
|
2016-04-02 21:03:24 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if pattern.match.Match(file) {
|
2016-05-01 17:58:23 +02:00
|
|
|
return pattern.result
|
2016-04-02 21:03:24 +02:00
|
|
|
}
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
}
|
2014-12-02 23:13:03 +01:00
|
|
|
|
2016-05-04 09:15:56 +02:00
|
|
|
// Default to not matching.
|
|
|
|
return resultNotMatched
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
|
2017-04-01 11:58:06 +02:00
|
|
|
// Lines return a list of the unprocessed lines in .stignore at last load
|
|
|
|
func (m *Matcher) Lines() []string {
|
|
|
|
m.mut.Lock()
|
|
|
|
defer m.mut.Unlock()
|
|
|
|
return m.lines
|
|
|
|
}
|
|
|
|
|
2016-04-02 21:03:24 +02:00
|
|
|
// Patterns return a list of the loaded patterns, as they've been parsed
|
2014-11-08 22:12:18 +01:00
|
|
|
func (m *Matcher) Patterns() []string {
|
2014-12-23 10:05:08 +01:00
|
|
|
m.mut.Lock()
|
|
|
|
defer m.mut.Unlock()
|
|
|
|
|
2014-11-08 22:12:18 +01:00
|
|
|
patterns := make([]string, len(m.patterns))
|
|
|
|
for i, pat := range m.patterns {
|
2014-12-23 10:05:08 +01:00
|
|
|
patterns[i] = pat.String()
|
2014-11-08 22:12:18 +01:00
|
|
|
}
|
|
|
|
return patterns
|
|
|
|
}
|
|
|
|
|
2014-12-23 10:05:08 +01:00
|
|
|
func (m *Matcher) Hash() string {
|
|
|
|
m.mut.Lock()
|
|
|
|
defer m.mut.Unlock()
|
|
|
|
return m.curHash
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *Matcher) Stop() {
|
|
|
|
close(m.stop)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *Matcher) clean(d time.Duration) {
|
|
|
|
t := time.NewTimer(d / 2)
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-m.stop:
|
|
|
|
return
|
|
|
|
case <-t.C:
|
|
|
|
m.mut.Lock()
|
|
|
|
if m.matches != nil {
|
|
|
|
m.matches.clean(d)
|
|
|
|
}
|
|
|
|
t.Reset(d / 2)
|
|
|
|
m.mut.Unlock()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-17 08:33:48 +01:00
|
|
|
// ShouldIgnore returns true when a file is temporary, internal or ignored
|
|
|
|
func (m *Matcher) ShouldIgnore(filename string) bool {
|
|
|
|
switch {
|
2017-09-02 07:52:38 +02:00
|
|
|
case fs.IsTemporary(filename):
|
2017-01-17 08:33:48 +01:00
|
|
|
return true
|
|
|
|
|
2017-09-02 07:52:38 +02:00
|
|
|
case fs.IsInternal(filename):
|
2017-01-17 08:33:48 +01:00
|
|
|
return true
|
|
|
|
|
|
|
|
case m.Match(filename).IsIgnored():
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2014-12-23 10:05:08 +01:00
|
|
|
func hashPatterns(patterns []Pattern) string {
|
|
|
|
h := md5.New()
|
|
|
|
for _, pat := range patterns {
|
|
|
|
h.Write([]byte(pat.String()))
|
|
|
|
h.Write([]byte("\n"))
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%x", h.Sum(nil))
|
|
|
|
}
|
|
|
|
|
2017-09-04 14:46:19 +02:00
|
|
|
func loadIgnoreFile(fs fs.Filesystem, file string, cd ChangeDetector) (fs.File, fs.FileInfo, error) {
|
|
|
|
fd, err := fs.Open(file)
|
|
|
|
if err != nil {
|
|
|
|
return fd, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
info, err := fd.Stat()
|
|
|
|
if err != nil {
|
|
|
|
fd.Close()
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
|
2017-09-04 14:46:19 +02:00
|
|
|
return fd, info, err
|
|
|
|
}
|
|
|
|
|
2018-01-17 17:56:53 +01:00
|
|
|
func loadParseIncludeFile(filesystem fs.Filesystem, file string, cd ChangeDetector, linesSeen map[string]struct{}) ([]Pattern, error) {
|
2017-08-22 08:45:00 +02:00
|
|
|
// Allow escaping the folders filesystem.
|
|
|
|
// TODO: Deprecate, somehow?
|
|
|
|
if filesystem.Type() == fs.FilesystemTypeBasic {
|
|
|
|
uri := filesystem.URI()
|
|
|
|
joined := filepath.Join(uri, file)
|
|
|
|
if !strings.HasPrefix(joined, uri) {
|
|
|
|
filesystem = fs.NewFilesystem(filesystem.Type(), filepath.Dir(joined))
|
|
|
|
file = filepath.Base(joined)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-04 14:46:19 +02:00
|
|
|
if cd.Seen(filesystem, file) {
|
2018-01-17 17:56:53 +01:00
|
|
|
return nil, fmt.Errorf("multiple include of ignore file %q", file)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
|
2017-09-04 14:46:19 +02:00
|
|
|
fd, info, err := loadIgnoreFile(filesystem, file, cd)
|
2016-11-22 22:30:45 +01:00
|
|
|
if err != nil {
|
2018-01-17 17:56:53 +01:00
|
|
|
return nil, err
|
2016-11-22 22:30:45 +01:00
|
|
|
}
|
2017-09-04 14:46:19 +02:00
|
|
|
defer fd.Close()
|
2016-11-22 22:30:45 +01:00
|
|
|
|
2017-08-22 08:45:00 +02:00
|
|
|
cd.Remember(filesystem, file, info.ModTime())
|
2017-06-11 12:27:12 +02:00
|
|
|
|
2018-01-17 17:56:53 +01:00
|
|
|
_, patterns, err := parseIgnoreFile(filesystem, fd, file, cd, linesSeen)
|
|
|
|
return patterns, err
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
|
2017-09-04 14:46:19 +02:00
|
|
|
func parseIgnoreFile(fs fs.Filesystem, fd io.Reader, currentFile string, cd ChangeDetector, linesSeen map[string]struct{}) ([]string, []Pattern, error) {
|
2017-04-01 11:58:06 +02:00
|
|
|
var lines []string
|
2014-12-23 10:05:08 +01:00
|
|
|
var patterns []Pattern
|
2014-09-04 22:29:53 +02:00
|
|
|
|
2016-05-01 17:58:23 +02:00
|
|
|
defaultResult := resultInclude
|
|
|
|
if runtime.GOOS == "darwin" || runtime.GOOS == "windows" {
|
|
|
|
defaultResult |= resultFoldCase
|
|
|
|
}
|
|
|
|
|
2014-09-04 22:29:53 +02:00
|
|
|
addPattern := func(line string) error {
|
2016-04-02 21:03:24 +02:00
|
|
|
pattern := Pattern{
|
2016-05-24 01:32:08 +02:00
|
|
|
result: defaultResult,
|
2016-04-02 21:03:24 +02:00
|
|
|
}
|
|
|
|
|
2016-04-07 11:34:07 +02:00
|
|
|
// Allow prefixes to be specified in any order, but only once.
|
|
|
|
var seenPrefix [3]bool
|
|
|
|
|
|
|
|
for {
|
|
|
|
if strings.HasPrefix(line, "!") && !seenPrefix[0] {
|
|
|
|
seenPrefix[0] = true
|
|
|
|
line = line[1:]
|
2016-05-01 17:58:23 +02:00
|
|
|
pattern.result ^= resultInclude
|
2016-04-07 11:34:07 +02:00
|
|
|
} else if strings.HasPrefix(line, "(?i)") && !seenPrefix[1] {
|
|
|
|
seenPrefix[1] = true
|
2016-05-01 17:58:23 +02:00
|
|
|
pattern.result |= resultFoldCase
|
2016-04-07 11:34:07 +02:00
|
|
|
line = line[4:]
|
|
|
|
} else if strings.HasPrefix(line, "(?d)") && !seenPrefix[2] {
|
|
|
|
seenPrefix[2] = true
|
2016-05-01 17:58:23 +02:00
|
|
|
pattern.result |= resultDeletable
|
2016-04-07 11:34:07 +02:00
|
|
|
line = line[4:]
|
|
|
|
} else {
|
|
|
|
break
|
|
|
|
}
|
2016-04-05 08:35:51 +02:00
|
|
|
}
|
|
|
|
|
2016-05-01 17:58:23 +02:00
|
|
|
if pattern.result.IsCaseFolded() {
|
2016-04-05 08:35:51 +02:00
|
|
|
line = strings.ToLower(line)
|
2015-09-02 20:54:18 +02:00
|
|
|
}
|
|
|
|
|
2016-05-24 01:32:08 +02:00
|
|
|
pattern.pattern = line
|
|
|
|
|
2016-04-02 21:03:24 +02:00
|
|
|
var err error
|
2014-09-04 22:29:53 +02:00
|
|
|
if strings.HasPrefix(line, "/") {
|
|
|
|
// Pattern is rooted in the current dir only
|
2016-10-21 09:33:40 +02:00
|
|
|
pattern.match, err = glob.Compile(line[1:], '/')
|
2014-09-04 22:29:53 +02:00
|
|
|
if err != nil {
|
2016-05-06 17:45:11 +02:00
|
|
|
return fmt.Errorf("invalid pattern %q in ignore file (%v)", line, err)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
2016-04-02 21:03:24 +02:00
|
|
|
patterns = append(patterns, pattern)
|
2014-09-04 22:29:53 +02:00
|
|
|
} else if strings.HasPrefix(line, "**/") {
|
|
|
|
// Add the pattern as is, and without **/ so it matches in current dir
|
2016-10-21 09:33:40 +02:00
|
|
|
pattern.match, err = glob.Compile(line, '/')
|
2014-09-04 22:29:53 +02:00
|
|
|
if err != nil {
|
2016-05-06 17:45:11 +02:00
|
|
|
return fmt.Errorf("invalid pattern %q in ignore file (%v)", line, err)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
2016-04-02 21:03:24 +02:00
|
|
|
patterns = append(patterns, pattern)
|
2014-09-04 22:29:53 +02:00
|
|
|
|
2016-04-04 14:22:25 +02:00
|
|
|
line = line[3:]
|
|
|
|
pattern.pattern = line
|
2016-10-21 09:33:40 +02:00
|
|
|
pattern.match, err = glob.Compile(line, '/')
|
2014-09-04 22:29:53 +02:00
|
|
|
if err != nil {
|
2016-05-06 17:45:11 +02:00
|
|
|
return fmt.Errorf("invalid pattern %q in ignore file (%v)", line, err)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
2016-04-02 21:03:24 +02:00
|
|
|
patterns = append(patterns, pattern)
|
2014-09-04 22:29:53 +02:00
|
|
|
} else {
|
|
|
|
// Path name or pattern, add it so it matches files both in
|
|
|
|
// current directory and subdirs.
|
2016-10-21 09:33:40 +02:00
|
|
|
pattern.match, err = glob.Compile(line, '/')
|
2014-09-04 22:29:53 +02:00
|
|
|
if err != nil {
|
2016-05-06 17:45:11 +02:00
|
|
|
return fmt.Errorf("invalid pattern %q in ignore file (%v)", line, err)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
2016-04-02 21:03:24 +02:00
|
|
|
patterns = append(patterns, pattern)
|
2014-09-04 22:29:53 +02:00
|
|
|
|
2016-04-04 14:22:25 +02:00
|
|
|
line := "**/" + line
|
|
|
|
pattern.pattern = line
|
2016-10-21 09:33:40 +02:00
|
|
|
pattern.match, err = glob.Compile(line, '/')
|
2014-09-04 22:29:53 +02:00
|
|
|
if err != nil {
|
2016-05-06 17:45:11 +02:00
|
|
|
return fmt.Errorf("invalid pattern %q in ignore file (%v)", line, err)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
2016-04-02 21:03:24 +02:00
|
|
|
patterns = append(patterns, pattern)
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
scanner := bufio.NewScanner(fd)
|
|
|
|
var err error
|
|
|
|
for scanner.Scan() {
|
|
|
|
line := strings.TrimSpace(scanner.Text())
|
2017-04-01 11:58:06 +02:00
|
|
|
lines = append(lines, line)
|
2017-09-04 14:46:19 +02:00
|
|
|
if _, ok := linesSeen[line]; ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
linesSeen[line] = struct{}{}
|
2014-09-04 22:29:53 +02:00
|
|
|
switch {
|
|
|
|
case line == "":
|
|
|
|
continue
|
2014-09-16 23:22:21 +02:00
|
|
|
case strings.HasPrefix(line, "//"):
|
|
|
|
continue
|
2016-04-02 21:03:24 +02:00
|
|
|
}
|
|
|
|
|
2016-05-12 09:11:16 +02:00
|
|
|
line = filepath.ToSlash(line)
|
2016-04-02 21:03:24 +02:00
|
|
|
switch {
|
2018-01-17 17:56:53 +01:00
|
|
|
case strings.HasPrefix(line, "#include"):
|
|
|
|
includeRel := strings.TrimSpace(line[len("#include "):])
|
|
|
|
includeFile := filepath.Join(filepath.Dir(currentFile), includeRel)
|
|
|
|
var includePatterns []Pattern
|
|
|
|
if includePatterns, err = loadParseIncludeFile(fs, includeFile, cd, linesSeen); err == nil {
|
|
|
|
patterns = append(patterns, includePatterns...)
|
|
|
|
}
|
2014-09-04 22:29:53 +02:00
|
|
|
case strings.HasSuffix(line, "/**"):
|
|
|
|
err = addPattern(line)
|
|
|
|
case strings.HasSuffix(line, "/"):
|
2016-10-04 01:12:55 +02:00
|
|
|
err = addPattern(line + "**")
|
2014-09-04 22:29:53 +02:00
|
|
|
default:
|
|
|
|
err = addPattern(line)
|
|
|
|
if err == nil {
|
|
|
|
err = addPattern(line + "/**")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if err != nil {
|
2017-04-01 11:58:06 +02:00
|
|
|
return nil, nil, err
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-01 11:58:06 +02:00
|
|
|
return lines, patterns, nil
|
2014-09-04 22:29:53 +02:00
|
|
|
}
|
2016-12-01 15:00:11 +01:00
|
|
|
|
2017-04-01 11:58:06 +02:00
|
|
|
// WriteIgnores is a convenience function to avoid code duplication
|
2017-08-19 16:36:56 +02:00
|
|
|
func WriteIgnores(filesystem fs.Filesystem, path string, content []string) error {
|
|
|
|
fd, err := osutil.CreateAtomicFilesystem(filesystem, path)
|
2017-04-01 11:58:06 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, line := range content {
|
|
|
|
fmt.Fprintln(fd, line)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := fd.Close(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-08-19 16:36:56 +02:00
|
|
|
filesystem.Hide(path)
|
2017-04-01 11:58:06 +02:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2017-06-11 12:27:12 +02:00
|
|
|
|
2017-08-22 08:45:00 +02:00
|
|
|
type modtimeCheckerKey struct {
|
|
|
|
fs fs.Filesystem
|
|
|
|
name string
|
|
|
|
}
|
|
|
|
|
2017-06-11 12:27:12 +02:00
|
|
|
// modtimeChecker is the default implementation of ChangeDetector
|
|
|
|
type modtimeChecker struct {
|
2017-08-22 08:45:00 +02:00
|
|
|
modtimes map[modtimeCheckerKey]time.Time
|
2017-06-11 12:27:12 +02:00
|
|
|
}
|
|
|
|
|
2017-08-22 08:45:00 +02:00
|
|
|
func newModtimeChecker() *modtimeChecker {
|
2017-06-11 12:27:12 +02:00
|
|
|
return &modtimeChecker{
|
2017-08-22 08:45:00 +02:00
|
|
|
modtimes: map[modtimeCheckerKey]time.Time{},
|
2017-06-11 12:27:12 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-22 08:45:00 +02:00
|
|
|
func (c *modtimeChecker) Remember(fs fs.Filesystem, name string, modtime time.Time) {
|
|
|
|
c.modtimes[modtimeCheckerKey{fs, name}] = modtime
|
2017-06-11 12:27:12 +02:00
|
|
|
}
|
|
|
|
|
2017-08-22 08:45:00 +02:00
|
|
|
func (c *modtimeChecker) Seen(fs fs.Filesystem, name string) bool {
|
|
|
|
_, ok := c.modtimes[modtimeCheckerKey{fs, name}]
|
2017-06-11 12:27:12 +02:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *modtimeChecker) Reset() {
|
2017-08-22 08:45:00 +02:00
|
|
|
c.modtimes = map[modtimeCheckerKey]time.Time{}
|
2017-06-11 12:27:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *modtimeChecker) Changed() bool {
|
2017-08-22 08:45:00 +02:00
|
|
|
for key, modtime := range c.modtimes {
|
|
|
|
info, err := key.fs.Stat(key.name)
|
2017-06-11 12:27:12 +02:00
|
|
|
if err != nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if !info.ModTime().Equal(modtime) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|