From eb06a8dc1c51a98b0ea4ec202ebdf8e59cee1227 Mon Sep 17 00:00:00 2001 From: Thomas Boerger Date: Thu, 18 Oct 2018 16:55:41 +0200 Subject: [PATCH] Upgrade envsubst to latest version Update the github.com/drone/envsubst to the latest version to include fixes to the substr function. --- vendor/github.com/drone/envsubst/funcs.go | 13 +- vendor/github.com/drone/envsubst/match.go | 20 -- .../github.com/drone/envsubst/parse/parse.go | 13 +- .../github.com/drone/envsubst/path/match.go | 207 ++++++++++++++++++ vendor/vendor.json | 18 +- 5 files changed, 234 insertions(+), 37 deletions(-) delete mode 100644 vendor/github.com/drone/envsubst/match.go create mode 100644 vendor/github.com/drone/envsubst/path/match.go diff --git a/vendor/github.com/drone/envsubst/funcs.go b/vendor/github.com/drone/envsubst/funcs.go index 8df1c9876..94a3be1f2 100644 --- a/vendor/github.com/drone/envsubst/funcs.go +++ b/vendor/github.com/drone/envsubst/funcs.go @@ -1,11 +1,12 @@ package envsubst import ( - "path" "strconv" "strings" "unicode" "unicode/utf8" + + "github.com/drone/envsubst/path" ) // defines a parameter substitution function. @@ -89,8 +90,8 @@ func toSubstr(s string, args ...string) string { if pos+length >= len(s) { // if the position exceeds the length of the - // string an empty string is returned - return "" + // string just return the rest of it like bash + return s[pos:] } return s[pos : pos+length] @@ -183,7 +184,7 @@ func trimLongestSuffix(s string, args ...string) string { func trimShortest(s, arg string) string { var shortestMatch string - for i :=0 ; i < len(s); i++ { + for i := 0; i < len(s); i++ { match, err := path.Match(arg, s[0:len(s)-i]) if err != nil { @@ -191,7 +192,7 @@ func trimShortest(s, arg string) string { } if match { - shortestMatch = s[0:len(s)-i] + shortestMatch = s[0 : len(s)-i] } } @@ -203,7 +204,7 @@ func trimShortest(s, arg string) string { } func trimLongest(s, arg string) string { - for i :=0 ; i < len(s); i++ { + for i := 0; i < len(s); i++ { match, err := path.Match(arg, s[0:len(s)-i]) if err != nil { diff --git a/vendor/github.com/drone/envsubst/match.go b/vendor/github.com/drone/envsubst/match.go deleted file mode 100644 index e2f94b580..000000000 --- a/vendor/github.com/drone/envsubst/match.go +++ /dev/null @@ -1,20 +0,0 @@ -package envsubst - -func matches() { - -} - -// alnum -// alpha -// ascii -// blank -// cntrl -// digit -// graph -// lower -// print -// punct -// space -// upper -// word -// xdigit diff --git a/vendor/github.com/drone/envsubst/parse/parse.go b/vendor/github.com/drone/envsubst/parse/parse.go index ef826289d..683b44d54 100644 --- a/vendor/github.com/drone/envsubst/parse/parse.go +++ b/vendor/github.com/drone/envsubst/parse/parse.go @@ -174,10 +174,6 @@ func (t *Tree) parseSubstrFunc(name string) (Node, error) { default: return nil, ErrBadSubstitution } - // err := t.consumeDelimiter(acceptColon, scanIdent|scanRbrack) - // if err != nil { - // return nil, err - // } // scan arg[2] { @@ -258,8 +254,15 @@ func (t *Tree) parseReplaceFunc(name string) (Node, error) { return nil, ErrBadSubstitution } + // check for blank string + switch t.scanner.peek() { + case '}': + return node, t.consumeRbrack() + } + + // scan arg[2] { - param, err := t.parseParam(acceptNotClosing, scanIdent) + param, err := t.parseParam(acceptNotClosing, scanIdent|scanEscape) if err != nil { return nil, err } diff --git a/vendor/github.com/drone/envsubst/path/match.go b/vendor/github.com/drone/envsubst/path/match.go new file mode 100644 index 000000000..9306b0c9d --- /dev/null +++ b/vendor/github.com/drone/envsubst/path/match.go @@ -0,0 +1,207 @@ +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package path + +import ( + "errors" + "unicode/utf8" +) + +// ErrBadPattern indicates a globbing pattern was malformed. +var ErrBadPattern = errors.New("syntax error in pattern") + +// Match reports whether name matches the shell file name pattern. +// The pattern syntax is: +// +// pattern: +// { term } +// term: +// '*' matches any sequence of non-/ characters +// '?' matches any single non-/ character +// '[' [ '^' ] { character-range } ']' +// character class (must be non-empty) +// 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 only possible returned error is ErrBadPattern, when pattern +// is malformed. +// +func Match(pattern, name string) (matched bool, err error) { +Pattern: + for len(pattern) > 0 { + var star bool + var chunk string + star, chunk, pattern = scanChunk(pattern) + if star && chunk == "" { + // Trailing * matches rest of string unless it has a /. + // return !strings.Contains(name, "/"), nil + + // Return rest of string + return true, nil + } + // Look for match at current position. + t, ok, err := matchChunk(chunk, name) + // if we're the last chunk, make sure we've exhausted the name + // otherwise we'll give a false result even if we could still match + // using the star + if ok && (len(t) == 0 || len(pattern) > 0) { + name = t + continue + } + if err != nil { + return false, err + } + if star { + // Look for match skipping i+1 bytes. + for i := 0; i < len(name); i++ { + t, ok, err := matchChunk(chunk, name[i+1:]) + if ok { + // if we're the last chunk, make sure we exhausted the name + if len(pattern) == 0 && len(t) > 0 { + continue + } + name = t + continue Pattern + } + if err != nil { + return false, err + } + } + } + return false, nil + } + return len(name) == 0, nil +} + +// scanChunk gets the next segment of pattern, which is a non-star string +// possibly preceded by a star. +func scanChunk(pattern string) (star bool, chunk, rest string) { + for len(pattern) > 0 && pattern[0] == '*' { + pattern = pattern[1:] + star = true + } + inrange := false + var i int +Scan: + for i = 0; i < len(pattern); i++ { + switch pattern[i] { + case '\\': + // error check handled in matchChunk: bad pattern. + if i+1 < len(pattern) { + i++ + } + case '[': + inrange = true + case ']': + inrange = false + case '*': + if !inrange { + break Scan + } + } + } + return star, pattern[0:i], pattern[i:] +} + +// matchChunk checks whether chunk matches the beginning of s. +// If so, it returns the remainder of s (after the match). +// Chunk is all single-character operators: literals, char classes, and ?. +func matchChunk(chunk, s string) (rest string, ok bool, err error) { + for len(chunk) > 0 { + if len(s) == 0 { + return + } + switch chunk[0] { + case '[': + // character class + r, n := utf8.DecodeRuneInString(s) + s = s[n:] + chunk = chunk[1:] + // possibly negated + notNegated := true + if len(chunk) > 0 && chunk[0] == '^' { + notNegated = false + chunk = chunk[1:] + } + // parse all ranges + match := false + nrange := 0 + for { + if len(chunk) > 0 && chunk[0] == ']' && nrange > 0 { + chunk = chunk[1:] + break + } + var lo, hi rune + if lo, chunk, err = getEsc(chunk); err != nil { + return + } + hi = lo + if chunk[0] == '-' { + if hi, chunk, err = getEsc(chunk[1:]); err != nil { + return + } + } + if lo <= r && r <= hi { + match = true + } + nrange++ + } + if match != notNegated { + return + } + + case '?': + _, n := utf8.DecodeRuneInString(s) + s = s[n:] + chunk = chunk[1:] + + case '\\': + chunk = chunk[1:] + if len(chunk) == 0 { + err = ErrBadPattern + return + } + fallthrough + + default: + if chunk[0] != s[0] { + return + } + s = s[1:] + chunk = chunk[1:] + } + } + return s, true, nil +} + +// getEsc gets a possibly-escaped character from chunk, for a character class. +func getEsc(chunk string) (r rune, nchunk string, err error) { + if len(chunk) == 0 || chunk[0] == '-' || chunk[0] == ']' { + err = ErrBadPattern + return + } + if chunk[0] == '\\' { + chunk = chunk[1:] + if len(chunk) == 0 { + err = ErrBadPattern + return + } + } + r, n := utf8.DecodeRuneInString(chunk) + if r == utf8.RuneError && n == 1 { + err = ErrBadPattern + } + nchunk = chunk[n:] + if len(nchunk) == 0 { + err = ErrBadPattern + } + return +} diff --git a/vendor/vendor.json b/vendor/vendor.json index e45986fa1..c57b90f83 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -476,16 +476,22 @@ "revisionTime": "2017-02-10T18:43:46Z" }, { - "checksumSHA1": "pjMV8mwWcQ0Kk9cbLWweTGiqYPk=", + "checksumSHA1": "oX91yMnimWNI17gVk7iQIE0p2pw=", "path": "github.com/drone/envsubst", - "revision": "523de92ea410a5756012669fb628fe42a3056b3e", - "revisionTime": "2017-03-25T05:49:59Z" + "revision": "15e3f9b7e16332eee3bbdff9ef31f95d23c5da2c", + "revisionTime": "2018-10-18T14:46:17Z" }, { - "checksumSHA1": "CVG/vocbXGLbGKRO//TOlicOBkw=", + "checksumSHA1": "CCV0ixQVgQNOsnUn8JlxGJ1v8c4=", "path": "github.com/drone/envsubst/parse", - "revision": "523de92ea410a5756012669fb628fe42a3056b3e", - "revisionTime": "2017-03-25T05:49:59Z" + "revision": "15e3f9b7e16332eee3bbdff9ef31f95d23c5da2c", + "revisionTime": "2018-10-18T14:46:17Z" + }, + { + "checksumSHA1": "k8a4yeccwcAfBwHgj16Da0F9iQE=", + "path": "github.com/drone/envsubst/path", + "revision": "15e3f9b7e16332eee3bbdff9ef31f95d23c5da2c", + "revisionTime": "2018-10-18T14:46:17Z" }, { "checksumSHA1": "AT++gcbYW/VQxkmbInFJk1Feg3o=",