delete path template again (#51)
The previous attempt was reverted because package managers
were picking up the latest tagged commit of google-cloud-go,
and the then-latest tag still depended on path template.
The now-latest tag of google-cloud-go does not use path template,
so we can delete this.
diff --git a/path_template.go b/path_template.go
deleted file mode 100644
index 41bda94..0000000
--- a/path_template.go
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package gax
-
-import (
- "errors"
- "fmt"
- "strings"
-)
-
-type matcher interface {
- match([]string) (int, error)
- String() string
-}
-
-type segment struct {
- matcher
- name string
-}
-
-type labelMatcher string
-
-func (ls labelMatcher) match(segments []string) (int, error) {
- if len(segments) == 0 {
- return 0, fmt.Errorf("expected %s but no more segments found", ls)
- }
- if segments[0] != string(ls) {
- return 0, fmt.Errorf("expected %s but got %s", ls, segments[0])
- }
- return 1, nil
-}
-
-func (ls labelMatcher) String() string {
- return string(ls)
-}
-
-type wildcardMatcher int
-
-func (wm wildcardMatcher) match(segments []string) (int, error) {
- if len(segments) == 0 {
- return 0, errors.New("no more segments found")
- }
- return 1, nil
-}
-
-func (wm wildcardMatcher) String() string {
- return "*"
-}
-
-type pathWildcardMatcher int
-
-func (pwm pathWildcardMatcher) match(segments []string) (int, error) {
- length := len(segments) - int(pwm)
- if length <= 0 {
- return 0, errors.New("not sufficient segments are supplied for path wildcard")
- }
- return length, nil
-}
-
-func (pwm pathWildcardMatcher) String() string {
- return "**"
-}
-
-type ParseError struct {
- Pos int
- Template string
- Message string
-}
-
-func (pe ParseError) Error() string {
- return fmt.Sprintf("at %d of template '%s', %s", pe.Pos, pe.Template, pe.Message)
-}
-
-// PathTemplate manages the template to build and match with paths used
-// by API services. It holds a template and variable names in it, and
-// it can extract matched patterns from a path string or build a path
-// string from a binding.
-//
-// See http.proto in github.com/googleapis/googleapis/ for the details of
-// the template syntax.
-type PathTemplate struct {
- segments []segment
-}
-
-// NewPathTemplate parses a path template, and returns a PathTemplate
-// instance if successful.
-func NewPathTemplate(template string) (*PathTemplate, error) {
- return parsePathTemplate(template)
-}
-
-// MustCompilePathTemplate is like NewPathTemplate but panics if the
-// expression cannot be parsed. It simplifies safe initialization of
-// global variables holding compiled regular expressions.
-func MustCompilePathTemplate(template string) *PathTemplate {
- pt, err := NewPathTemplate(template)
- if err != nil {
- panic(err)
- }
- return pt
-}
-
-// Match attempts to match the given path with the template, and returns
-// the mapping of the variable name to the matched pattern string.
-func (pt *PathTemplate) Match(path string) (map[string]string, error) {
- paths := strings.Split(path, "/")
- values := map[string]string{}
- for _, segment := range pt.segments {
- length, err := segment.match(paths)
- if err != nil {
- return nil, err
- }
- if segment.name != "" {
- value := strings.Join(paths[:length], "/")
- if oldValue, ok := values[segment.name]; ok {
- values[segment.name] = oldValue + "/" + value
- } else {
- values[segment.name] = value
- }
- }
- paths = paths[length:]
- }
- if len(paths) != 0 {
- return nil, fmt.Errorf("Trailing path %s remains after the matching", strings.Join(paths, "/"))
- }
- return values, nil
-}
-
-// Render creates a path string from its template and the binding from
-// the variable name to the value.
-func (pt *PathTemplate) Render(binding map[string]string) (string, error) {
- result := make([]string, 0, len(pt.segments))
- var lastVariableName string
- for _, segment := range pt.segments {
- name := segment.name
- if lastVariableName != "" && name == lastVariableName {
- continue
- }
- lastVariableName = name
- if name == "" {
- result = append(result, segment.String())
- } else if value, ok := binding[name]; ok {
- result = append(result, value)
- } else {
- return "", fmt.Errorf("%s is not found", name)
- }
- }
- built := strings.Join(result, "/")
- return built, nil
-}
diff --git a/path_template_parser.go b/path_template_parser.go
deleted file mode 100644
index 79c8e75..0000000
--- a/path_template_parser.go
+++ /dev/null
@@ -1,227 +0,0 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package gax
-
-import (
- "fmt"
- "io"
- "strings"
-)
-
-// This parser follows the syntax of path templates, from
-// https://github.com/googleapis/googleapis/blob/master/google/api/http.proto.
-// The differences are that there is no custom verb, we allow the initial slash
-// to be absent, and that we are not strict as
-// https://tools.ietf.org/html/rfc6570 about the characters in identifiers and
-// literals.
-
-type pathTemplateParser struct {
- r *strings.Reader
- runeCount int // the number of the current rune in the original string
- nextVar int // the number to use for the next unnamed variable
- seenName map[string]bool // names we've seen already
- seenPathWildcard bool // have we seen "**" already?
-}
-
-func parsePathTemplate(template string) (pt *PathTemplate, err error) {
- p := &pathTemplateParser{
- r: strings.NewReader(template),
- seenName: map[string]bool{},
- }
-
- // Handle panics with strings like errors.
- // See pathTemplateParser.error, below.
- defer func() {
- if x := recover(); x != nil {
- errmsg, ok := x.(errString)
- if !ok {
- panic(x)
- }
- pt = nil
- err = ParseError{p.runeCount, template, string(errmsg)}
- }
- }()
-
- segs := p.template()
- // If there is a path wildcard, set its length. We can't do this
- // until we know how many segments we've got all together.
- for i, seg := range segs {
- if _, ok := seg.matcher.(pathWildcardMatcher); ok {
- segs[i].matcher = pathWildcardMatcher(len(segs) - i - 1)
- break
- }
- }
- return &PathTemplate{segments: segs}, nil
-
-}
-
-// Used to indicate errors "thrown" by this parser. We don't use string because
-// many parts of the standard library panic with strings.
-type errString string
-
-// Terminates parsing immediately with an error.
-func (p *pathTemplateParser) error(msg string) {
- panic(errString(msg))
-}
-
-// Template = [ "/" ] Segments
-func (p *pathTemplateParser) template() []segment {
- var segs []segment
- if p.consume('/') {
- // Initial '/' needs an initial empty matcher.
- segs = append(segs, segment{matcher: labelMatcher("")})
- }
- return append(segs, p.segments("")...)
-}
-
-// Segments = Segment { "/" Segment }
-func (p *pathTemplateParser) segments(name string) []segment {
- var segs []segment
- for {
- subsegs := p.segment(name)
- segs = append(segs, subsegs...)
- if !p.consume('/') {
- break
- }
- }
- return segs
-}
-
-// Segment = "*" | "**" | LITERAL | Variable
-func (p *pathTemplateParser) segment(name string) []segment {
- if p.consume('*') {
- if name == "" {
- name = fmt.Sprintf("$%d", p.nextVar)
- p.nextVar++
- }
- if p.consume('*') {
- if p.seenPathWildcard {
- p.error("multiple '**' disallowed")
- }
- p.seenPathWildcard = true
- // We'll change 0 to the right number at the end.
- return []segment{{name: name, matcher: pathWildcardMatcher(0)}}
- }
- return []segment{{name: name, matcher: wildcardMatcher(0)}}
- }
- if p.consume('{') {
- if name != "" {
- p.error("recursive named bindings are not allowed")
- }
- return p.variable()
- }
- return []segment{{name: name, matcher: labelMatcher(p.literal())}}
-}
-
-// Variable = "{" FieldPath [ "=" Segments ] "}"
-// "{" is already consumed.
-func (p *pathTemplateParser) variable() []segment {
- // Simplification: treat FieldPath as LITERAL, instead of IDENT { '.' IDENT }
- name := p.literal()
- if p.seenName[name] {
- p.error(name + " appears multiple times")
- }
- p.seenName[name] = true
- var segs []segment
- if p.consume('=') {
- segs = p.segments(name)
- } else {
- // "{var}" is equivalent to "{var=*}"
- segs = []segment{{name: name, matcher: wildcardMatcher(0)}}
- }
- if !p.consume('}') {
- p.error("expected '}'")
- }
- return segs
-}
-
-// A literal is any sequence of characters other than a few special ones.
-// The list of stop characters is not quite the same as in the template RFC.
-func (p *pathTemplateParser) literal() string {
- lit := p.consumeUntil("/*}{=")
- if lit == "" {
- p.error("empty literal")
- }
- return lit
-}
-
-// Read runes until EOF or one of the runes in stopRunes is encountered.
-// If the latter, unread the stop rune. Return the accumulated runes as a string.
-func (p *pathTemplateParser) consumeUntil(stopRunes string) string {
- var runes []rune
- for {
- r, ok := p.readRune()
- if !ok {
- break
- }
- if strings.IndexRune(stopRunes, r) >= 0 {
- p.unreadRune()
- break
- }
- runes = append(runes, r)
- }
- return string(runes)
-}
-
-// If the next rune is r, consume it and return true.
-// Otherwise, leave the input unchanged and return false.
-func (p *pathTemplateParser) consume(r rune) bool {
- rr, ok := p.readRune()
- if !ok {
- return false
- }
- if r == rr {
- return true
- }
- p.unreadRune()
- return false
-}
-
-// Read the next rune from the input. Return it.
-// The second return value is false at EOF.
-func (p *pathTemplateParser) readRune() (rune, bool) {
- r, _, err := p.r.ReadRune()
- if err == io.EOF {
- return r, false
- }
- if err != nil {
- p.error(err.Error())
- }
- p.runeCount++
- return r, true
-}
-
-// Put the last rune that was read back on the input.
-func (p *pathTemplateParser) unreadRune() {
- if err := p.r.UnreadRune(); err != nil {
- p.error(err.Error())
- }
- p.runeCount--
-}
diff --git a/path_template_test.go b/path_template_test.go
deleted file mode 100644
index 49dea47..0000000
--- a/path_template_test.go
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package gax
-
-import "testing"
-
-func TestPathTemplateMatchRender(t *testing.T) {
- testCases := []struct {
- message string
- template string
- path string
- values map[string]string
- }{
- {
- "base",
- "buckets/*/*/objects/*",
- "buckets/f/o/objects/bar",
- map[string]string{"$0": "f", "$1": "o", "$2": "bar"},
- },
- {
- "path wildcards",
- "bar/**/foo/*",
- "bar/foo/foo/foo/bar",
- map[string]string{"$0": "foo/foo", "$1": "bar"},
- },
- {
- "named binding",
- "buckets/{foo}/objects/*",
- "buckets/foo/objects/bar",
- map[string]string{"$0": "bar", "foo": "foo"},
- },
- {
- "named binding with colon",
- "buckets/{foo}/objects/*",
- "buckets/foo:boo/objects/bar",
- map[string]string{"$0": "bar", "foo": "foo:boo"},
- },
- {
- "named binding with complex patterns",
- "buckets/{foo=x/*/y/**}/objects/*",
- "buckets/x/foo/y/bar/baz/objects/quox",
- map[string]string{"$0": "quox", "foo": "x/foo/y/bar/baz"},
- },
- {
- "starts with slash",
- "/foo/*",
- "/foo/bar",
- map[string]string{"$0": "bar"},
- },
- }
- for _, testCase := range testCases {
- pt, err := NewPathTemplate(testCase.template)
- if err != nil {
- t.Errorf("[%s] Failed to parse template %s: %v", testCase.message, testCase.template, err)
- continue
- }
- values, err := pt.Match(testCase.path)
- if err != nil {
- t.Errorf("[%s] PathTemplate '%s' failed to match with '%s', %v", testCase.message, testCase.template, testCase.path, err)
- continue
- }
- for key, expected := range testCase.values {
- actual, ok := values[key]
- if !ok {
- t.Errorf("[%s] The matched data misses the value for %s", testCase.message, key)
- continue
- }
- delete(values, key)
- if actual != expected {
- t.Errorf("[%s] Failed to match: value for '%s' is expected '%s' but is actually '%s'", testCase.message, key, expected, actual)
- }
- }
- if len(values) != 0 {
- t.Errorf("[%s] The matched data has unexpected keys: %v", testCase.message, values)
- }
- built, err := pt.Render(testCase.values)
- if err != nil || built != testCase.path {
- t.Errorf("[%s] Built path '%s' is different from the expected '%s', %v", testCase.message, built, testCase.path, err)
- }
- }
-}
-
-func TestPathTemplateMatchFailure(t *testing.T) {
- testCases := []struct {
- message string
- template string
- path string
- }{
- {
- "too many paths",
- "buckets/*/*/objects/*",
- "buckets/f/o/o/objects/bar",
- },
- {
- "missing last path",
- "buckets/*/*/objects/*",
- "buckets/f/o/objects",
- },
- {
- "too many paths at end",
- "buckets/*/*/objects/*",
- "buckets/f/o/objects/too/long",
- },
- }
- for _, testCase := range testCases {
- pt, err := NewPathTemplate(testCase.template)
- if err != nil {
- t.Errorf("[%s] Failed to parse path %s: %v", testCase.message, testCase.template, err)
- continue
- }
- if values, err := pt.Match(testCase.path); err == nil {
- t.Errorf("[%s] PathTemplate %s doesn't expect to match %s, but succeeded somehow. Match result: %v", testCase.message, testCase.template, testCase.path, values)
-
- }
- }
-}
-
-func TestPathTemplateRenderTooManyValues(t *testing.T) {
- // Test cases where Render() succeeds but Match() doesn't return the same map.
- testCases := []struct {
- message string
- template string
- values map[string]string
- expected string
- }{
- {
- "too many",
- "bar/*/foo/*",
- map[string]string{"$0": "_1", "$1": "_2", "$2": "_3"},
- "bar/_1/foo/_2",
- },
- }
- for _, testCase := range testCases {
- pt, err := NewPathTemplate(testCase.template)
- if err != nil {
- t.Errorf("[%s] Failed to parse template %s (error %v)", testCase.message, testCase.template, err)
- continue
- }
- if result, err := pt.Render(testCase.values); err != nil || result != testCase.expected {
- t.Errorf("[%s] Failed to build the path (expected '%s' but returned '%s'", testCase.message, testCase.expected, result)
- }
- }
-}
-
-func TestPathTemplateParseErrors(t *testing.T) {
- testCases := []struct {
- message string
- template string
- }{
- {
- "multiple path wildcards",
- "foo/**/bar/**",
- },
- {
- "recursive named bindings",
- "foo/{foo=foo/{bar}/baz/*}/baz/*",
- },
- {
- "complicated multiple path wildcards patterns",
- "foo/{foo=foo/**/bar/*}/baz/**",
- },
- {
- "consective slashes",
- "foo//bar",
- },
- {
- "invalid variable pattern",
- "foo/{foo=foo/*/}bar",
- },
- {
- "same name multiple times",
- "foo/{foo}/bar/{foo}",
- },
- {
- "empty string after '='",
- "foo/{foo=}/bar",
- },
- }
- for _, testCase := range testCases {
- if pt, err := NewPathTemplate(testCase.template); err == nil {
- t.Errorf("[%s] Template '%s' should fail to be parsed, but succeeded and returned %+v", testCase.message, testCase.template, pt)
- }
- }
-}
