Use the new package to do the match

Use the new package to do the match

Signed-off-by: Wenkai Yin <yinw@vmware.com>

src/Gopkg.lock

@@ -81,6 +81,14 @@
   pruneopts = "UT"
   revision = "e87155e8f0c05bf323d0b13470e1b97af0cb5652"
 
+[[projects]]
+  digest = "1:2aaf2cc045d0219bba79655e4df795b973168c310574669cb75786684f7287d3"
+  name = "github.com/bmatcuk/doublestar"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "85a78806aa1b4707d1dbace9be592cf1ece91ab3"
+  version = "v1.1.1"
+
 [[projects]]
   digest = "1:76ca0dfcbf951d1868c7449453981dba9e1f79034706d1500a5a785000f5f222"
   name = "github.com/casbin/casbin"
@@ -651,11 +659,10 @@
   revision = "f534d624797b270e5e46104dc7e2c2d61edbb85d"
 
 [[projects]]
-  digest = "1:b2a0bdcfc59bed6a64d3ade946f9bf807f8fcd105892d940a008b0b2816babe5"
+  digest = "1:131682c26796b64f0abb77ac3d85525712706fde0b085aaa7b6d10b4398167cc"
   name = "k8s.io/client-go"
   packages = [
     "kubernetes/scheme",
-    "kubernetes/typed/authentication/v1beta1",
     "pkg/apis/clientauthentication",
     "pkg/apis/clientauthentication/v1alpha1",
     "pkg/apis/clientauthentication/v1beta1",
@@ -714,6 +721,7 @@
     "github.com/astaxie/beego/session/redis",
     "github.com/astaxie/beego/validation",
     "github.com/beego/i18n",
+    "github.com/bmatcuk/doublestar",
     "github.com/casbin/casbin",
     "github.com/casbin/casbin/model",
     "github.com/casbin/casbin/persist",
@@ -729,7 +737,6 @@
     "github.com/docker/distribution/reference",
     "github.com/docker/distribution/registry/auth/token",
     "github.com/docker/distribution/registry/client/auth/challenge",
-    "github.com/docker/distribution/uuid",
     "github.com/docker/libtrust",
     "github.com/docker/notary",
     "github.com/docker/notary/client",
@@ -760,7 +767,9 @@
     "gopkg.in/yaml.v2",
     "k8s.io/api/authentication/v1beta1",
     "k8s.io/apimachinery/pkg/apis/meta/v1",
-    "k8s.io/client-go/kubernetes/typed/authentication/v1beta1",
+    "k8s.io/apimachinery/pkg/runtime/schema",
+    "k8s.io/apimachinery/pkg/runtime/serializer",
+    "k8s.io/client-go/kubernetes/scheme",
     "k8s.io/client-go/rest",
     "k8s.io/helm/cmd/helm/search",
     "k8s.io/helm/pkg/chartutil",

src/Gopkg.toml

@@ -123,3 +123,7 @@ ignored = ["github.com/goharbor/harbor/tests*"]
 [[constraint]]
   name = "k8s.io/api"
   version = "kubernetes-1.13.4"
+
+[[constraint]]
+  name = "github.com/bmatcuk/doublestar"
+  version = "1.1.1"

src/replication/util/util.go

@@ -16,15 +16,15 @@ package util
 
 import (
 	"net/http"
-	"path/filepath"
 	"strings"
 
+	"github.com/bmatcuk/doublestar"
 	"github.com/goharbor/harbor/src/common/utils/registry"
 )
 
 // Match returns whether the str matches the pattern
 func Match(pattern, str string) (bool, error) {
-	return filepath.Match(pattern, str)
+	return doublestar.Match(pattern, str)
 }
 
 // GetHTTPTransport can be used to share the common HTTP transport

src/replication/util/util_test.go

@@ -33,13 +33,28 @@ func TestMatch(t *testing.T) {
 			match:   true,
 		},
 		{
-			pattern: "1.*",
+			pattern: "*",
-			str:     "1.0",
+			str:     "library",
 			match:   true,
 		},
 		{
-			pattern: "1.*",
+			pattern: "*",
-			str:     "1.01",
+			str:     "library/hello-world",
+			match:   false,
+		},
+		{
+			pattern: "**",
+			str:     "library/hello-world",
+			match:   true,
+		},
+		{
+			pattern: "{library,harbor}/**",
+			str:     "library/hello-world",
+			match:   true,
+		},
+		{
+			pattern: "{library,harbor}/**",
+			str:     "harbor/hello-world",
 			match:   true,
 		},
 		{
@@ -52,22 +67,6 @@ func TestMatch(t *testing.T) {
 			str:     "1.01",
 			match:   false,
 		},
-
-		{
-			pattern: "library/*",
-			str:     "library/hello-world",
-			match:   true,
-		},
-		{
-			pattern: "lib*",
-			str:     "library/hello-world",
-			match:   false,
-		},
-		{
-			pattern: "lib*/*",
-			str:     "library/hello-world",
-			match:   true,
-		},
 	}
 	for _, c := range cases {
 		match, err := Match(c.pattern, c.str)

src/vendor/github.com/bmatcuk/doublestar/.gitignore

@@ -0,0 +1,29 @@
+# vi
+*~
+*.swp
+*.swo
+
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof

src/vendor/github.com/bmatcuk/doublestar/.travis.yml

@@ -0,0 +1,17 @@
+language: go
+
+go:
+  - 1.3
+  - 1.4
+  - 1.5
+  - 1.6
+
+before_install:
+  - go get -t -v ./...
+
+script:
+  - go test -race -coverprofile=coverage.txt -covermode=atomic
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
+

src/vendor/github.com/bmatcuk/doublestar/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Bob Matcuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

src/vendor/github.com/bmatcuk/doublestar/README.md

@@ -0,0 +1,109 @@
+![Release](https://img.shields.io/github/release/bmatcuk/doublestar.svg?branch=master)
+[![Build Status](https://travis-ci.org/bmatcuk/doublestar.svg?branch=master)](https://travis-ci.org/bmatcuk/doublestar)
+[![codecov.io](https://img.shields.io/codecov/c/github/bmatcuk/doublestar.svg?branch=master)](https://codecov.io/github/bmatcuk/doublestar?branch=master)
+
+# doublestar
+
+**doublestar** is a [golang](http://golang.org/) implementation of path pattern
+matching and globbing with support for "doublestar" (aka globstar: `**`)
+patterns.
+
+doublestar patterns match files and directories recursively. For example, if
+you had the following directory structure:
+
+```
+grandparent
+`-- parent
+    |-- child1
+    `-- child2
+```
+
+You could find the children with patterns such as: `**/child*`,
+`grandparent/**/child?`, `**/parent/*`, or even just `**` by itself (which will
+return all files and directories recursively).
+
+Bash's globstar is doublestar's inspiration and, as such, works similarly.
+Note that the doublestar must appear as a path component by itself. A pattern
+such as `/path**` is invalid and will be treated the same as `/path*`, but
+`/path*/**` should achieve the desired result. Additionally, `/path/**` will
+match all directories and files under the path directory, but `/path/**/` will
+only match directories.
+
+## Installation
+
+**doublestar** can be installed via `go get`:
+
+```bash
+go get github.com/bmatcuk/doublestar
+```
+
+To use it in your code, you must import it:
+
+```go
+import "github.com/bmatcuk/doublestar"
+```
+
+## Functions
+
+### Match
+```go
+func Match(pattern, name string) (bool, error)
+```
+
+Match returns true if `name` matches the file name `pattern`
+([see below](#patterns)). `name` and `pattern` are split on forward slash (`/`)
+characters and may be relative or absolute.
+
+Note: `Match()` is meant to be a drop-in replacement for `path.Match()`. As
+such, it always uses `/` as the path separator. If you are writing code that
+will run on systems where `/` is not the path separator (such as Windows), you
+want to use `PathMatch()` (below) instead.
+
+
+### PathMatch
+```go
+func PathMatch(pattern, name string) (bool, error)
+```
+
+PathMatch returns true  if `name` matches the file name `pattern`
+([see below](#patterns)). The difference between Match and PathMatch is that
+PathMatch will automatically use your system's path separator to split `name`
+and `pattern`.
+
+`PathMatch()` is meant to be a drop-in replacement for `filepath.Match()`.
+
+### Glob
+```go
+func Glob(pattern string) ([]string, error)
+```
+
+Glob finds all files and directories in the filesystem that match `pattern`
+([see below](#patterns)). `pattern` may be relative (to the current working
+directory), or absolute.
+
+`Glob()` is meant to be a drop-in replacement for `filepath.Glob()`.
+
+## Patterns
+
+**doublestar** supports the following special terms in the patterns:
+
+Special Terms | Meaning
+------------- | -------
+`*`           | matches any sequence of non-path-separators
+`**`          | matches any sequence of characters, including path separators
+`?`           | matches any single non-path-separator character
+`[class]`     | matches any single non-path-separator character against a class of characters ([see below](#character-classes))
+`{alt1,...}`  | matches a sequence of characters if one of the comma-separated alternatives matches
+
+Any character with a special meaning can be escaped with a backslash (`\`).
+
+### Character Classes
+
+Character classes support the following:
+
+Class      | Meaning
+---------- | -------
+`[abc]`    | matches any single character within the set
+`[a-z]`    | matches any single character in the range
+`[^class]` | matches any single character which does *not* match the class
+

src/vendor/github.com/bmatcuk/doublestar/doublestar.go

@@ -0,0 +1,455 @@
+package doublestar
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"unicode/utf8"
+)
+
+var ErrBadPattern = path.ErrBadPattern
+
+// Split a path on the given separator, respecting escaping.
+func splitPathOnSeparator(path string, separator rune) []string {
+	// if the separator is '\\', then we can just split...
+	if separator == '\\' {
+		return strings.Split(path, string(separator))
+	}
+
+	// otherwise, we need to be careful of situations where the separator was escaped
+	cnt := strings.Count(path, string(separator))
+	if cnt == 0 {
+		return []string{path}
+	}
+	ret := make([]string, cnt+1)
+	pathlen := len(path)
+	separatorLen := utf8.RuneLen(separator)
+	idx := 0
+	for start := 0; start < pathlen; {
+		end := indexRuneWithEscaping(path[start:], separator)
+		if end == -1 {
+			end = pathlen
+		} else {
+			end += start
+		}
+		ret[idx] = path[start:end]
+		start = end + separatorLen
+		idx++
+	}
+	return ret[:idx]
+}
+
+// Find the first index of a rune in a string,
+// ignoring any times the rune is escaped using "\".
+func indexRuneWithEscaping(s string, r rune) int {
+	end := strings.IndexRune(s, r)
+	if end == -1 {
+		return -1
+	}
+	if end > 0 && s[end-1] == '\\' {
+		start := end + utf8.RuneLen(r)
+		end = indexRuneWithEscaping(s[start:], r)
+		if end != -1 {
+			end += start
+		}
+	}
+	return end
+}
+
+// Match returns true if name matches the shell file name pattern.
+// The pattern syntax is:
+//
+//  pattern:
+//    { term }
+//  term:
+//    '*'         matches any sequence of non-path-separators
+//              '**'        matches any sequence of characters, including
+//                          path separators.
+//    '?'         matches any single non-path-separator character
+//    '[' [ '^' ] { character-range } ']'
+//          character class (must be non-empty)
+//    '{' { term } [ ',' { term } ... ] '}'
+//    c           matches character c (c != '*', '?', '\\', '[')
+//    '\\' c      matches character c
+//
+//  character-range:
+//    c           matches character c (c != '\\', '-', ']')
+//    '\\' c      matches character c
+//    lo '-' hi   matches character c for lo <= c <= hi
+//
+// Match requires pattern to match all of name, not just a substring.
+// The path-separator defaults to the '/' character. The only possible
+// returned error is ErrBadPattern, when pattern is malformed.
+//
+// Note: this is meant as a drop-in replacement for path.Match() which
+// always uses '/' as the path separator. If you want to support systems
+// which use a different path separator (such as Windows), what you want
+// is the PathMatch() function below.
+//
+func Match(pattern, name string) (bool, error) {
+	return matchWithSeparator(pattern, name, '/')
+}
+
+// PathMatch is like Match except that it uses your system's path separator.
+// For most systems, this will be '/'. However, for Windows, it would be '\\'.
+// Note that for systems where the path separator is '\\', escaping is
+// disabled.
+//
+// Note: this is meant as a drop-in replacement for filepath.Match().
+//
+func PathMatch(pattern, name string) (bool, error) {
+	return matchWithSeparator(pattern, name, os.PathSeparator)
+}
+
+// Match returns true if name matches the shell file name pattern.
+// The pattern syntax is:
+//
+//  pattern:
+//    { term }
+//  term:
+//    '*'         matches any sequence of non-path-separators
+//              '**'        matches any sequence of characters, including
+//                          path separators.
+//    '?'         matches any single non-path-separator character
+//    '[' [ '^' ] { character-range } ']'
+//          character class (must be non-empty)
+//    '{' { term } [ ',' { term } ... ] '}'
+//    c           matches character c (c != '*', '?', '\\', '[')
+//    '\\' c      matches character c
+//
+//  character-range:
+//    c           matches character c (c != '\\', '-', ']')
+//    '\\' c      matches character c, unless separator is '\\'
+//    lo '-' hi   matches character c for lo <= c <= hi
+//
+// Match requires pattern to match all of name, not just a substring.
+// The only possible returned error is ErrBadPattern, when pattern
+// is malformed.
+//
+func matchWithSeparator(pattern, name string, separator rune) (bool, error) {
+	patternComponents := splitPathOnSeparator(pattern, separator)
+	nameComponents := splitPathOnSeparator(name, separator)
+	return doMatching(patternComponents, nameComponents)
+}
+
+func doMatching(patternComponents, nameComponents []string) (matched bool, err error) {
+	// check for some base-cases
+	patternLen, nameLen := len(patternComponents), len(nameComponents)
+	if patternLen == 0 && nameLen == 0 {
+		return true, nil
+	}
+	if patternLen == 0 || nameLen == 0 {
+		return false, nil
+	}
+
+	patIdx, nameIdx := 0, 0
+	for patIdx < patternLen && nameIdx < nameLen {
+		if patternComponents[patIdx] == "**" {
+			// if our last pattern component is a doublestar, we're done -
+			// doublestar will match any remaining name components, if any.
+			if patIdx++; patIdx >= patternLen {
+				return true, nil
+			}
+
+			// otherwise, try matching remaining components
+			for ; nameIdx < nameLen; nameIdx++ {
+				if m, _ := doMatching(patternComponents[patIdx:], nameComponents[nameIdx:]); m {
+					return true, nil
+				}
+			}
+			return false, nil
+		} else {
+			// try matching components
+			matched, err = matchComponent(patternComponents[patIdx], nameComponents[nameIdx])
+			if !matched || err != nil {
+				return
+			}
+		}
+		patIdx++
+		nameIdx++
+	}
+	return patIdx >= patternLen && nameIdx >= nameLen, nil
+}
+
+// Glob returns the names of all files matching pattern or nil
+// if there is no matching file. The syntax of pattern is the same
+// as in Match. The pattern may describe hierarchical names such as
+// /usr/*/bin/ed (assuming the Separator is '/').
+//
+// Glob ignores file system errors such as I/O errors reading directories.
+// The only possible returned error is ErrBadPattern, when pattern
+// is malformed.
+//
+// Your system path separator is automatically used. This means on
+// systems where the separator is '\\' (Windows), escaping will be
+// disabled.
+//
+// Note: this is meant as a drop-in replacement for filepath.Glob().
+//
+func Glob(pattern string) (matches []string, err error) {
+	patternComponents := splitPathOnSeparator(filepath.ToSlash(pattern), '/')
+	if len(patternComponents) == 0 {
+		return nil, nil
+	}
+
+	// On Windows systems, this will return the drive name ('C:'), on others,
+	// it will return an empty string.
+	volumeName := filepath.VolumeName(pattern)
+
+	// If the first pattern component is equal to the volume name, then the
+	// pattern is an absolute path.
+	if patternComponents[0] == volumeName {
+		return doGlob(fmt.Sprintf("%s%s", volumeName, string(os.PathSeparator)), patternComponents[1:], matches)
+	}
+
+	// otherwise, it's a relative pattern
+	return doGlob(".", patternComponents, matches)
+}
+
+// Perform a glob
+func doGlob(basedir string, components, matches []string) (m []string, e error) {
+	m = matches
+	e = nil
+
+	// figure out how many components we don't need to glob because they're
+	// just names without patterns - we'll use os.Lstat below to check if that
+	// path actually exists
+	patLen := len(components)
+	patIdx := 0
+	for ; patIdx < patLen; patIdx++ {
+		if strings.IndexAny(components[patIdx], "*?[{\\") >= 0 {
+			break
+		}
+	}
+	if patIdx > 0 {
+		basedir = filepath.Join(basedir, filepath.Join(components[0:patIdx]...))
+	}
+
+	// Lstat will return an error if the file/directory doesn't exist
+	fi, err := os.Lstat(basedir)
+	if err != nil {
+		return
+	}
+
+	// if there are no more components, we've found a match
+	if patIdx >= patLen {
+		m = append(m, basedir)
+		return
+	}
+
+	// otherwise, we need to check each item in the directory...
+	// first, if basedir is a symlink, follow it...
+	if (fi.Mode() & os.ModeSymlink) != 0 {
+		fi, err = os.Stat(basedir)
+		if err != nil {
+			return
+		}
+	}
+
+	// confirm it's a directory...
+	if !fi.IsDir() {
+		return
+	}
+
+	// read directory
+	dir, err := os.Open(basedir)
+	if err != nil {
+		return
+	}
+	defer dir.Close()
+
+	files, _ := dir.Readdir(-1)
+	lastComponent := (patIdx + 1) >= patLen
+	if components[patIdx] == "**" {
+		// if the current component is a doublestar, we'll try depth-first
+		for _, file := range files {
+			// if symlink, we may want to follow
+			if (file.Mode() & os.ModeSymlink) != 0 {
+				file, err = os.Stat(filepath.Join(basedir, file.Name()))
+				if err != nil {
+					continue
+				}
+			}
+
+			if file.IsDir() {
+				// recurse into directories
+				if lastComponent {
+					m = append(m, filepath.Join(basedir, file.Name()))
+				}
+				m, e = doGlob(filepath.Join(basedir, file.Name()), components[patIdx:], m)
+			} else if lastComponent {
+				// if the pattern's last component is a doublestar, we match filenames, too
+				m = append(m, filepath.Join(basedir, file.Name()))
+			}
+		}
+		if lastComponent {
+			return // we're done
+		}
+		patIdx++
+		lastComponent = (patIdx + 1) >= patLen
+	}
+
+	// check items in current directory and recurse
+	var match bool
+	for _, file := range files {
+		match, e = matchComponent(components[patIdx], file.Name())
+		if e != nil {
+			return
+		}
+		if match {
+			if lastComponent {
+				m = append(m, filepath.Join(basedir, file.Name()))
+			} else {
+				m, e = doGlob(filepath.Join(basedir, file.Name()), components[patIdx+1:], m)
+			}
+		}
+	}
+	return
+}
+
+// Attempt to match a single pattern component with a path component
+func matchComponent(pattern, name string) (bool, error) {
+	// check some base cases
+	patternLen, nameLen := len(pattern), len(name)
+	if patternLen == 0 && nameLen == 0 {
+		return true, nil
+	}
+	if patternLen == 0 {
+		return false, nil
+	}
+	if nameLen == 0 && pattern != "*" {
+		return false, nil
+	}
+
+	// check for matches one rune at a time
+	patIdx, nameIdx := 0, 0
+	for patIdx < patternLen && nameIdx < nameLen {
+		patRune, patAdj := utf8.DecodeRuneInString(pattern[patIdx:])
+		nameRune, nameAdj := utf8.DecodeRuneInString(name[nameIdx:])
+		if patRune == '\\' {
+			// handle escaped runes
+			patIdx += patAdj
+			patRune, patAdj = utf8.DecodeRuneInString(pattern[patIdx:])
+			if patRune == utf8.RuneError {
+				return false, ErrBadPattern
+			} else if patRune == nameRune {
+				patIdx += patAdj
+				nameIdx += nameAdj
+			} else {
+				return false, nil
+			}
+		} else if patRune == '*' {
+			// handle stars
+			if patIdx += patAdj; patIdx >= patternLen {
+				// a star at the end of a pattern will always
+				// match the rest of the path
+				return true, nil
+			}
+
+			// check if we can make any matches
+			for ; nameIdx < nameLen; nameIdx += nameAdj {
+				if m, _ := matchComponent(pattern[patIdx:], name[nameIdx:]); m {
+					return true, nil
+				}
+			}
+			return false, nil
+		} else if patRune == '[' {
+			// handle character sets
+			patIdx += patAdj
+			endClass := indexRuneWithEscaping(pattern[patIdx:], ']')
+			if endClass == -1 {
+				return false, ErrBadPattern
+			}
+			endClass += patIdx
+			classRunes := []rune(pattern[patIdx:endClass])
+			classRunesLen := len(classRunes)
+			if classRunesLen > 0 {
+				classIdx := 0
+				matchClass := false
+				if classRunes[0] == '^' {
+					classIdx++
+				}
+				for classIdx < classRunesLen {
+					low := classRunes[classIdx]
+					if low == '-' {
+						return false, ErrBadPattern
+					}
+					classIdx++
+					if low == '\\' {
+						if classIdx < classRunesLen {
+							low = classRunes[classIdx]
+							classIdx++
+						} else {
+							return false, ErrBadPattern
+						}
+					}
+					high := low
+					if classIdx < classRunesLen && classRunes[classIdx] == '-' {
+						// we have a range of runes
+						if classIdx++; classIdx >= classRunesLen {
+							return false, ErrBadPattern
+						}
+						high = classRunes[classIdx]
+						if high == '-' {
+							return false, ErrBadPattern
+						}
+						classIdx++
+						if high == '\\' {
+							if classIdx < classRunesLen {
+								high = classRunes[classIdx]
+								classIdx++
+							} else {
+								return false, ErrBadPattern
+							}
+						}
+					}
+					if low <= nameRune && nameRune <= high {
+						matchClass = true
+					}
+				}
+				if matchClass == (classRunes[0] == '^') {
+					return false, nil
+				}
+			} else {
+				return false, ErrBadPattern
+			}
+			patIdx = endClass + 1
+			nameIdx += nameAdj
+		} else if patRune == '{' {
+			// handle alternatives such as {alt1,alt2,...}
+			patIdx += patAdj
+			endOptions := indexRuneWithEscaping(pattern[patIdx:], '}')
+			if endOptions == -1 {
+				return false, ErrBadPattern
+			}
+			endOptions += patIdx
+			options := splitPathOnSeparator(pattern[patIdx:endOptions], ',')
+			patIdx = endOptions + 1
+			for _, o := range options {
+				m, e := matchComponent(o+pattern[patIdx:], name[nameIdx:])
+				if e != nil {
+					return false, e
+				}
+				if m {
+					return true, nil
+				}
+			}
+			return false, nil
+		} else if patRune == '?' || patRune == nameRune {
+			// handle single-rune wildcard
+			patIdx += patAdj
+			nameIdx += nameAdj
+		} else {
+			return false, nil
+		}
+	}
+	if patIdx >= patternLen && nameIdx >= nameLen {
+		return true, nil
+	}
+	if nameIdx >= nameLen && pattern[patIdx:] == "*" || pattern[patIdx:] == "**" {
+		return true, nil
+	}
+	return false, nil
+}

src/vendor/github.com/bmatcuk/doublestar/go.mod

@@ -0,0 +1 @@
+module github.com/bmatcuk/doublestar

src/vendor/github.com/bmatcuk/doublestar/test/b/symlink-dir

@@ -0,0 +1 @@
+../axbxcxdxe/

src/vendor/github.com/bmatcuk/doublestar/test/broken-symlink

@@ -0,0 +1 @@
+/tmp/nonexistant-file-20160902155705

src/vendor/github.com/bmatcuk/doublestar/test/working-symlink

@@ -0,0 +1 @@
+a/b

src/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/authentication_client.go

@@ -1,90 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1beta1
-
-import (
-	v1beta1 "k8s.io/api/authentication/v1beta1"
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-type AuthenticationV1beta1Interface interface {
-	RESTClient() rest.Interface
-	TokenReviewsGetter
-}
-
-// AuthenticationV1beta1Client is used to interact with features provided by the authentication.k8s.io group.
-type AuthenticationV1beta1Client struct {
-	restClient rest.Interface
-}
-
-func (c *AuthenticationV1beta1Client) TokenReviews() TokenReviewInterface {
-	return newTokenReviews(c)
-}
-
-// NewForConfig creates a new AuthenticationV1beta1Client for the given config.
-func NewForConfig(c *rest.Config) (*AuthenticationV1beta1Client, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &AuthenticationV1beta1Client{client}, nil
-}
-
-// NewForConfigOrDie creates a new AuthenticationV1beta1Client for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *AuthenticationV1beta1Client {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new AuthenticationV1beta1Client for the given RESTClient.
-func New(c rest.Interface) *AuthenticationV1beta1Client {
-	return &AuthenticationV1beta1Client{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	gv := v1beta1.SchemeGroupVersion
-	config.GroupVersion = &gv
-	config.APIPath = "/apis"
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
-
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-
-	return nil
-}
-
-// RESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *AuthenticationV1beta1Client) RESTClient() rest.Interface {
-	if c == nil {
-		return nil
-	}
-	return c.restClient
-}

src/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/doc.go

@@ -1,20 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-// This package has the automatically generated typed clients.
-package v1beta1

src/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/generated_expansion.go

@@ -1,19 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1beta1

src/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/tokenreview.go

@@ -1,46 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1beta1
-
-import (
-	rest "k8s.io/client-go/rest"
-)
-
-// TokenReviewsGetter has a method to return a TokenReviewInterface.
-// A group's client should implement this interface.
-type TokenReviewsGetter interface {
-	TokenReviews() TokenReviewInterface
-}
-
-// TokenReviewInterface has methods to work with TokenReview resources.
-type TokenReviewInterface interface {
-	TokenReviewExpansion
-}
-
-// tokenReviews implements TokenReviewInterface
-type tokenReviews struct {
-	client rest.Interface
-}
-
-// newTokenReviews returns a TokenReviews
-func newTokenReviews(c *AuthenticationV1beta1Client) *tokenReviews {
-	return &tokenReviews{
-		client: c.RESTClient(),
-	}
-}

src/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/tokenreview_expansion.go

@@ -1,35 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1beta1
-
-import (
-	authenticationapi "k8s.io/api/authentication/v1beta1"
-)
-
-type TokenReviewExpansion interface {
-	Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error)
-}
-
-func (c *tokenReviews) Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
-	result = &authenticationapi.TokenReview{}
-	err = c.client.Post().
-		Resource("tokenreviews").
-		Body(tokenReview).
-		Do().
-		Into(result)
-	return
-}