Documentation

Overview

    Package filter controls the filtering of files

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var DefaultOpt = Opt{
    	MinAge:  fs.DurationOff,
    	MaxAge:  fs.DurationOff,
    	MinSize: fs.SizeSuffix(-1),
    	MaxSize: fs.SizeSuffix(-1),
    }

      DefaultOpt is the default config for the filter

      Functions

      func ReplaceConfig

      func ReplaceConfig(ctx context.Context, f *Filter) context.Context

        ReplaceConfig replaces the filter config in the ctx with the one passed in and returns a new context with that added to it.

        Types

        type FilesMap

        type FilesMap map[string]struct{}

          FilesMap describes the map of files to transfer

          type Filter

          type Filter struct {
          	Opt         Opt
          	ModTimeFrom time.Time
          	ModTimeTo   time.Time
          	// contains filtered or unexported fields
          }

            Filter describes any filtering in operation

            func AddConfig

            func AddConfig(ctx context.Context) (context.Context, *Filter)

              AddConfig returns a mutable config structure based on a shallow copy of that found in ctx and returns a new context with that added to it.

              func GetConfig

              func GetConfig(ctx context.Context) *Filter

                GetConfig returns the global or context sensitive config

                func NewFilter

                func NewFilter(opt *Opt) (f *Filter, err error)

                  NewFilter parses the command line options and creates a Filter object. If opt is nil, then DefaultOpt will be used

                  func (*Filter) Add

                  func (f *Filter) Add(Include bool, glob string) error

                    Add adds a filter rule with include or exclude status indicated

                    func (*Filter) AddFile

                    func (f *Filter) AddFile(file string) error

                      AddFile adds a single file to the files from list

                      func (*Filter) AddRule

                      func (f *Filter) AddRule(rule string) error

                        AddRule adds a filter rule with include/exclude indicated by the prefix

                        These are

                        + glob
                        - glob
                        !
                        

                        '+' includes the glob, '-' excludes it and '!' resets the filter list

                        Line comments may be introduced with '#' or ';'

                        func (*Filter) Clear

                        func (f *Filter) Clear()

                          Clear clears all the filter rules

                          func (*Filter) DirContainsExcludeFile

                          func (f *Filter) DirContainsExcludeFile(ctx context.Context, fremote fs.Fs, remote string) (bool, error)

                            DirContainsExcludeFile checks if exclude file is present in a directory. If fs is nil, it works properly if ExcludeFile is an empty string (for testing).

                            func (*Filter) DumpFilters

                            func (f *Filter) DumpFilters() string

                              DumpFilters dumps the filters in textual form, 1 per line

                              func (*Filter) Files

                              func (f *Filter) Files() FilesMap

                                Files returns all the files from the `--files-from` list

                                It may be nil if the list is empty

                                func (*Filter) HaveFilesFrom

                                func (f *Filter) HaveFilesFrom() bool

                                  HaveFilesFrom returns true if --files-from has been supplied

                                  func (*Filter) InActive

                                  func (f *Filter) InActive() bool

                                    InActive returns false if any filters are active

                                    func (*Filter) Include

                                    func (f *Filter) Include(remote string, size int64, modTime time.Time) bool

                                      Include returns whether this object should be included into the sync or not

                                      func (*Filter) IncludeDirectory

                                      func (f *Filter) IncludeDirectory(ctx context.Context, fs fs.Fs) func(string) (bool, error)

                                        IncludeDirectory returns a function which checks whether this directory should be included in the sync or not.

                                        func (*Filter) IncludeObject

                                        func (f *Filter) IncludeObject(ctx context.Context, o fs.Object) bool

                                          IncludeObject returns whether this object should be included into the sync or not. This is a convenience function to avoid calling o.ModTime(), which is an expensive operation.

                                          func (*Filter) ListContainsExcludeFile

                                          func (f *Filter) ListContainsExcludeFile(entries fs.DirEntries) bool

                                            ListContainsExcludeFile checks if exclude file is present in the list.

                                            func (*Filter) MakeListR

                                            func (f *Filter) MakeListR(ctx context.Context, NewObject func(ctx context.Context, remote string) (fs.Object, error)) fs.ListRFn

                                              MakeListR makes function to return all the files set using --files-from

                                              func (*Filter) UsesDirectoryFilters

                                              func (f *Filter) UsesDirectoryFilters() bool

                                                UsesDirectoryFilters returns true if the filter uses directory filters and false if it doesn't.

                                                This is used in deciding whether to walk directories or use ListR

                                                type Opt

                                                type Opt struct {
                                                	DeleteExcluded bool
                                                	FilterRule     []string
                                                	FilterFrom     []string
                                                	ExcludeRule    []string
                                                	ExcludeFrom    []string
                                                	ExcludeFile    string
                                                	IncludeRule    []string
                                                	IncludeFrom    []string
                                                	FilesFrom      []string
                                                	FilesFromRaw   []string
                                                	MinAge         fs.Duration
                                                	MaxAge         fs.Duration
                                                	MinSize        fs.SizeSuffix
                                                	MaxSize        fs.SizeSuffix
                                                	IgnoreCase     bool
                                                }

                                                  Opt configures the filter

                                                  Source Files

                                                  Directories

                                                  Path Synopsis
                                                  Package filterflags implements command line flags to set up a filter
                                                  Package filterflags implements command line flags to set up a filter