vendor: improve vendor dependencies (#67)

* vendor: remove stray github.com/Sirupsen/logrus
* vendor: remove ory/common

compiler/README.md

@@ -0,0 +1,3 @@
+# compiler
+
+[Read the docs.](https://godoc.org/github.com/ory-am/common/compiler)

compiler/regex.go

@@ -0,0 +1,125 @@
+// Package compiler offers a regexp compiler which compiles regex templates to regexp.Regexp
+//
+//  reg, err := compiler.CompileRegex("foo:bar.baz:<[0-9]{2,10}>", '<', '>')
+//  // if err != nil ...
+//  reg.MatchString("foo:bar.baz:123")
+//
+//  reg, err := compiler.CompileRegex("/foo/bar/url/{[a-z]+}", '{', '}')
+//  // if err != nil ...
+//  reg.MatchString("/foo/bar/url/abz")
+//
+// This package is adapts github.com/gorilla/mux/regexp.go
+package compiler
+
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license as follows:
+
+//Copyright (c) 2012 Rodrigo Moraes. 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.
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+)
+
+// delimiterIndices returns the first level delimiter indices from a string.
+// It returns an error in case of unbalanced delimiters.
+func delimiterIndices(s string, delimiterStart, delimiterEnd byte) ([]int, error) {
+	var level, idx int
+	idxs := make([]int, 0)
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case delimiterStart:
+			if level++; level == 1 {
+				idx = i
+			}
+		case delimiterEnd:
+			if level--; level == 0 {
+				idxs = append(idxs, idx, i+1)
+			} else if level < 0 {
+				return nil, fmt.Errorf(`Unbalanced braces in "%q"`, s)
+			}
+		}
+	}
+
+	if level != 0 {
+		return nil, fmt.Errorf(`Unbalanced braces in "%q"`, s)
+	}
+
+	return idxs, nil
+}
+
+// CompileRegex parses a template and returns a Regexp.
+//
+// You can define your own delimiters. It is e.g. common to use curly braces {} but I recommend using characters
+// which have no special meaning in Regex, e.g.: <, >
+//
+//  reg, err := compiler.CompileRegex("foo:bar.baz:<[0-9]{2,10}>", '<', '>')
+//  // if err != nil ...
+//  reg.MatchString("foo:bar.baz:123")
+func CompileRegex(tpl string, delimiterStart, delimiterEnd byte) (*regexp.Regexp, error) {
+	// Check if it is well-formed.
+	idxs, errBraces := delimiterIndices(tpl, delimiterStart, delimiterEnd)
+	if errBraces != nil {
+		return nil, errBraces
+	}
+	varsR := make([]*regexp.Regexp, len(idxs)/2)
+	pattern := bytes.NewBufferString("")
+	pattern.WriteByte('^')
+
+	var end int
+	var err error
+	for i := 0; i < len(idxs); i += 2 {
+		// Set all values we are interested in.
+		raw := tpl[end:idxs[i]]
+		end = idxs[i+1]
+		patt := tpl[idxs[i]+1 : end-1]
+		// Build the regexp pattern.
+		varIdx := i / 2
+		fmt.Fprintf(pattern, "%s(%s)", regexp.QuoteMeta(raw), patt)
+		varsR[varIdx], err = regexp.Compile(fmt.Sprintf("^%s$", patt))
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Add the remaining.
+	raw := tpl[end:]
+	pattern.WriteString(regexp.QuoteMeta(raw))
+	pattern.WriteByte('$')
+
+	// Compile full regexp.
+	reg, errCompile := regexp.Compile(pattern.String())
+	if errCompile != nil {
+		return nil, errCompile
+	}
+
+	return reg, nil
+}

compiler/regex_test.go

@@ -0,0 +1,43 @@
+package compiler
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRegexCompiler(t *testing.T) {
+	for k, c := range []struct {
+		template       string
+		delimiterStart byte
+		delimiterEnd   byte
+		failCompile    bool
+		matchAgainst   string
+		failMatch      bool
+	}{
+		{"urn:foo:{.*}", '{', '}', false, "urn:foo:bar:baz", false},
+		{"urn:foo.bar.com:{.*}", '{', '}', false, "urn:foo.bar.com:bar:baz", false},
+		{"urn:foo.bar.com:{.*}", '{', '}', false, "urn:foo.com:bar:baz", true},
+		{"urn:foo.bar.com:{.*}", '{', '}', false, "foobar", true},
+		{"urn:foo.bar.com:{.{1,2}}", '{', '}', false, "urn:foo.bar.com:aa", false},
+
+		{"urn:foo.bar.com:{.*{}", '{', '}', true, "", true},
+		{"urn:foo:<.*>", '<', '>', false, "urn:foo:bar:baz", false},
+
+		// Ignoring this case for now...
+		//{"urn:foo.bar.com:{.*\\{}", '{', '}', false, "", true},
+	} {
+		k++
+		result, err := CompileRegex(c.template, c.delimiterStart, c.delimiterEnd)
+		assert.Equal(t, c.failCompile, err != nil, "Case %d", k)
+		if c.failCompile || err != nil {
+			continue
+		}
+
+		t.Logf("Case %d compiled to: %s", k, result.String())
+		ok, err := regexp.MatchString(result.String(), c.matchAgainst)
+		assert.Nil(t, err, "Case %d", k)
+		assert.Equal(t, !c.failMatch, ok, "Case %d", k)
+	}
+}

errors.go

@@ -22,6 +22,13 @@ var (
 		status: http.StatusText(http.StatusForbidden),
 		reason: "The request was denied because a policy denied request.",
 	})
+
+	// ErrNotFound is returned when a resource can not be found.
+	ErrNotFound = errors.WithStack(&errorWithContext{
+		error:  errors.New("Resource could not be found"),
+		code:   http.StatusNotFound,
+		status: http.StatusText(http.StatusNotFound),
+	})
 )
 
 func NewErrResourceNotFound(err error) error {

glide.yaml

@@ -1,22 +1,23 @@
 package: github.com/ory/ladon
 import:
+- package: github.com/go-redis/redis
+  version: ~6.4.1
+- package: github.com/go-sql-driver/mysql
+  version: ~1.3.0
 - package: github.com/hashicorp/golang-lru
 - package: github.com/jmoiron/sqlx
-- package: github.com/ory-am/common
-  version: ~0.4.0
-  subpackages:
-  - compiler
-  - pkg
+- package: github.com/lib/pq
+- package: github.com/ory/dockertest
+  version: ~3.0.7
 - package: github.com/pkg/errors
   version: ~0.8.0
 - package: github.com/rubenv/sql-migrate
+- package: gopkg.in/gorethink/gorethink.v3
+  version: ~3.0.2
 testImport:
-- package: github.com/go-sql-driver/mysql
-  version: ~1.3.0
 - package: github.com/golang/mock
   subpackages:
   - gomock
-- package: github.com/lib/pq
 - package: github.com/pborman/uuid
   version: ~1.0.0
 - package: github.com/stretchr/testify