Replace godep with dep

vendor/github.com/go-openapi/jsonpointer/.drone.yml

@@ -1,32 +0,0 @@
-clone:
-  path: github.com/go-openapi/jsonpointer
-
-matrix:
-  GO_VERSION:
-    - "1.6"
-
-build:
-  integration:
-    image: golang:$$GO_VERSION
-    pull: true
-    commands:
-      - go get -u github.com/stretchr/testify/assert
-      - go get -u github.com/go-openapi/swag
-      - go test -race
-      - go test -v -cover -coverprofile=coverage.out -covermode=count ./...
-
-notify:
-  slack:
-    channel: bots
-    webhook_url: $$SLACK_URL
-    username: drone
-
-publish:
-  coverage:
-    server: https://coverage.vmware.run
-    token: $$GITHUB_TOKEN
-    # threshold: 70
-    # must_increase: true
-    when:
-      matrix:
-        GO_VERSION: "1.6"

vendor/github.com/go-openapi/jsonpointer/.editorconfig

@@ -0,0 +1,26 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+# Set default charset
+[*.{js,py,go,scala,rb,java,html,css,less,sass,md}]
+charset = utf-8
+
+# Tab indentation (no size specified)
+[*.go]
+indent_style = tab
+
+[*.md]
+trim_trailing_whitespace = false
+
+# Matches the exact files either package.json or .travis.yml
+[{package.json,.travis.yml}]
+indent_style = space
+indent_size = 2

vendor/github.com/go-openapi/jsonpointer/.github/CONTRIBUTING.md

@@ -0,0 +1,117 @@
+## Contribution Guidelines
+
+### Pull requests are always welcome
+
+We are always thrilled to receive pull requests, and do our best to
+process them as fast as possible. Not sure if that typo is worth a pull
+request? Do it! We will appreciate it.
+
+If your pull request is not accepted on the first try, don't be
+discouraged! If there's a problem with the implementation, hopefully you
+received feedback on what to improve.
+
+We're trying very hard to keep go-swagger lean and focused. We don't want it
+to do everything for everybody. This means that we might decide against
+incorporating a new feature. However, there might be a way to implement
+that feature *on top of* go-swagger.
+
+
+### Conventions
+
+Fork the repo and make changes on your fork in a feature branch:
+
+- If it's a bugfix branch, name it XXX-something where XXX is the number of the
+  issue
+- If it's a feature branch, create an enhancement issue to announce your
+  intentions, and name it XXX-something where XXX is the number of the issue.
+
+Submit unit tests for your changes.  Go has a great test framework built in; use
+it! Take a look at existing tests for inspiration. Run the full test suite on
+your branch before submitting a pull request.
+
+Update the documentation when creating or modifying features. Test
+your documentation changes for clarity, concision, and correctness, as
+well as a clean documentation build. See ``docs/README.md`` for more
+information on building the docs and how docs get released.
+
+Write clean code. Universally formatted code promotes ease of writing, reading,
+and maintenance. Always run `gofmt -s -w file.go` on each changed file before
+committing your changes. Most editors have plugins that do this automatically.
+
+Pull requests descriptions should be as clear as possible and include a
+reference to all the issues that they address.
+
+Pull requests must not contain commits from other users or branches.
+
+Commit messages must start with a capitalized and short summary (max. 50
+chars) written in the imperative, followed by an optional, more detailed
+explanatory text which is separated from the summary by an empty line.
+
+Code review comments may be added to your pull request. Discuss, then make the
+suggested modifications and push additional commits to your feature branch. Be
+sure to post a comment after pushing. The new commits will show up in the pull
+request automatically, but the reviewers will not be notified unless you
+comment.
+
+Before the pull request is merged, make sure that you squash your commits into
+logical units of work using `git rebase -i` and `git push -f`. After every
+commit the test suite should be passing. Include documentation changes in the
+same commit so that a revert would remove all traces of the feature or fix.
+
+Commits that fix or close an issue should include a reference like `Closes #XXX`
+or `Fixes #XXX`, which will automatically close the issue when merged.
+
+### Sign your work
+
+The sign-off is a simple line at the end of the explanation for the
+patch, which certifies that you wrote it or otherwise have the right to
+pass it on as an open-source patch.  The rules are pretty simple: if you
+can certify the below (from
+[developercertificate.org](http://developercertificate.org/)):
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+then you just add a line to every git commit message:
+
+    Signed-off-by: Joe Smith <joe@gmail.com>
+
+using your real name (sorry, no pseudonyms or anonymous contributions.)
+
+You can add the sign off when creating the git commit via `git commit -s`.

vendor/github.com/go-openapi/jsonpointer/.pullapprove.yml

@@ -1,13 +0,0 @@
-approve_by_comment: true
-approve_regex: '^(:shipit:|:\+1:|\+1|LGTM|lgtm|Approved)'
-reject_regex: ^[Rr]ejected
-reset_on_push: false
-reviewers:
-  members:
-  - casualjim
-  - chancez
-  - frapposelli
-  - vburenin
-  - pytlesk4
-  name: pullapprove
-  required: 1

vendor/github.com/go-openapi/jsonpointer/.travis.yml

@@ -0,0 +1,13 @@
+language: go
+go:
+- 1.7
+install:
+- go get -u github.com/stretchr/testify/assert
+- go get -u github.com/go-openapi/swag
+script:
+- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./...
+after_success:
+- bash <(curl -s https://codecov.io/bash)
+notifications:
+  slack:
+    secure: a5VgoiwB1G/AZqzmephPZIhEB9avMlsWSlVnM1dSAtYAwdrQHGTQxAmpOxYIoSPDhWNN5bfZmjd29++UlTwLcHSR+e0kJhH6IfDlsHj/HplNCJ9tyI0zYc7XchtdKgeMxMzBKCzgwFXGSbQGydXTliDNBo0HOzmY3cou/daMFTP60K+offcjS+3LRAYb1EroSRXZqrk1nuF/xDL3792DZUdPMiFR/L/Df6y74D6/QP4sTkTDFQitz4Wy/7jbsfj8dG6qK2zivgV6/l+w4OVjFkxVpPXogDWY10vVXNVynqxfJ7to2d1I9lNCHE2ilBCkWMIPdyJF7hjF8pKW+82yP4EzRh0vu8Xn0HT5MZpQxdRY/YMxNrWaG7SxsoEaO4q5uhgdzAqLYY3TRa7MjIK+7Ur+aqOeTXn6OKwVi0CjvZ6mIU3WUKSwiwkFZMbjRAkSb5CYwMEfGFO/z964xz83qGt6WAtBXNotqCQpTIiKtDHQeLOMfksHImCg6JLhQcWBVxamVgu0G3Pdh8Y6DyPnxraXY95+QDavbjqv7TeYT9T/FNnrkXaTTK0s4iWE5H4ACU0Qvz0wUYgfQrZv0/Hp7V17+rabUwnzYySHCy9SWX/7OV9Cfh31iMp9ZIffr76xmmThtOEqs8TrTtU6BWI3rWwvA9cXQipZTVtL0oswrGw=

vendor/github.com/go-openapi/jsonpointer/README.md

@@ -1,4 +1,4 @@
-# gojsonpointer [![Build Status](https://ci.vmware.run/api/badges/go-openapi/jsonpointer/status.svg)](https://ci.vmware.run/go-openapi/jsonpointer) [![Coverage](https://coverage.vmware.run/badges/go-openapi/jsonpointer/coverage.svg)](https://coverage.vmware.run/go-openapi/jsonpointer) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
+# gojsonpointer [![Build Status](https://travis-ci.org/go-openapi/jsonpointer.svg?branch=master)](https://travis-ci.org/go-openapi/jsonpointer) [![codecov](https://codecov.io/gh/go-openapi/jsonpointer/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/jsonpointer) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
 
 [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/jsonpointer/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/jsonpointer?status.svg)](http://godoc.org/github.com/go-openapi/jsonpointer)
 An implementation of JSON Pointer - Go language

vendor/github.com/go-openapi/jsonpointer/pointer.go

@@ -43,6 +43,7 @@ const (
 )
 
 var jsonPointableType = reflect.TypeOf(new(JSONPointable)).Elem()
+var jsonSetableType = reflect.TypeOf(new(JSONSetable)).Elem()
 
 // JSONPointable is an interface for structs to implement when they need to customize the
 // json pointer process
@@ -50,16 +51,10 @@ type JSONPointable interface {
 	JSONLookup(string) (interface{}, error)
 }
 
-type implStruct struct {
-	mode string // "SET" or "GET"
-
-	inDocument interface{}
-
-	setInValue interface{}
-
-	getOutNode interface{}
-	getOutKind reflect.Kind
-	outError   error
+// JSONSetable is an interface for structs to implement when they need to customize the
+// json pointer process
+type JSONSetable interface {
+	JSONSet(string, interface{}) error
 }
 
 // New creates a new json pointer for the given string
@@ -100,15 +95,25 @@ func (p *Pointer) Get(document interface{}) (interface{}, reflect.Kind, error) {
 	return p.get(document, swag.DefaultJSONNameProvider)
 }
 
+// Set uses the pointer to set a value from a JSON document
+func (p *Pointer) Set(document interface{}, value interface{}) (interface{}, error) {
+	return document, p.set(document, value, swag.DefaultJSONNameProvider)
+}
+
 // GetForToken gets a value for a json pointer token 1 level deep
 func GetForToken(document interface{}, decodedToken string) (interface{}, reflect.Kind, error) {
 	return getSingleImpl(document, decodedToken, swag.DefaultJSONNameProvider)
 }
 
+// SetForToken gets a value for a json pointer token 1 level deep
+func SetForToken(document interface{}, decodedToken string, value interface{}) (interface{}, error) {
+	return document, setSingleImpl(document, value, decodedToken, swag.DefaultJSONNameProvider)
+}
+
 func getSingleImpl(node interface{}, decodedToken string, nameProvider *swag.NameProvider) (interface{}, reflect.Kind, error) {
-	kind := reflect.Invalid
 	rValue := reflect.Indirect(reflect.ValueOf(node))
-	kind = rValue.Kind()
+	kind := rValue.Kind()
+
 	switch kind {
 
 	case reflect.Struct:
@@ -129,6 +134,7 @@ func getSingleImpl(node interface{}, decodedToken string, nameProvider *swag.Nam
 	case reflect.Map:
 		kv := reflect.ValueOf(decodedToken)
 		mv := rValue.MapIndex(kv)
+
 		if mv.IsValid() && !swag.IsZero(mv) {
 			return mv.Interface(), kind, nil
 		}
@@ -141,7 +147,7 @@ func getSingleImpl(node interface{}, decodedToken string, nameProvider *swag.Nam
 		}
 		sLength := rValue.Len()
 		if tokenIndex < 0 || tokenIndex >= sLength {
-			return nil, kind, fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex)
+			return nil, kind, fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength-1, tokenIndex)
 		}
 
 		elem := rValue.Index(tokenIndex)
@@ -153,6 +159,57 @@ func getSingleImpl(node interface{}, decodedToken string, nameProvider *swag.Nam
 
 }
 
+func setSingleImpl(node, data interface{}, decodedToken string, nameProvider *swag.NameProvider) error {
+	rValue := reflect.Indirect(reflect.ValueOf(node))
+	switch rValue.Kind() {
+
+	case reflect.Struct:
+		if ns, ok := node.(JSONSetable); ok { // pointer impl
+			return ns.JSONSet(decodedToken, data)
+		}
+
+		if rValue.Type().Implements(jsonSetableType) {
+			return node.(JSONSetable).JSONSet(decodedToken, data)
+		}
+
+		nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
+		if !ok {
+			return fmt.Errorf("object has no field %q", decodedToken)
+		}
+		fld := rValue.FieldByName(nm)
+		if fld.IsValid() {
+			fld.Set(reflect.ValueOf(data))
+		}
+		return nil
+
+	case reflect.Map:
+		kv := reflect.ValueOf(decodedToken)
+		rValue.SetMapIndex(kv, reflect.ValueOf(data))
+		return nil
+
+	case reflect.Slice:
+		tokenIndex, err := strconv.Atoi(decodedToken)
+		if err != nil {
+			return err
+		}
+		sLength := rValue.Len()
+		if tokenIndex < 0 || tokenIndex >= sLength {
+			return fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex)
+		}
+
+		elem := rValue.Index(tokenIndex)
+		if !elem.CanSet() {
+			return fmt.Errorf("can't set slice index %s to %v", decodedToken, data)
+		}
+		elem.Set(reflect.ValueOf(data))
+		return nil
+
+	default:
+		return fmt.Errorf("invalid token reference %q", decodedToken)
+	}
+
+}
+
 func (p *Pointer) get(node interface{}, nameProvider *swag.NameProvider) (interface{}, reflect.Kind, error) {
 
 	if nameProvider == nil {
@@ -184,6 +241,101 @@ func (p *Pointer) get(node interface{}, nameProvider *swag.NameProvider) (interf
 	return node, kind, nil
 }
 
+func (p *Pointer) set(node, data interface{}, nameProvider *swag.NameProvider) error {
+	knd := reflect.ValueOf(node).Kind()
+
+	if knd != reflect.Ptr && knd != reflect.Struct && knd != reflect.Map && knd != reflect.Slice && knd != reflect.Array {
+		return fmt.Errorf("only structs, pointers, maps and slices are supported for setting values")
+	}
+
+	if nameProvider == nil {
+		nameProvider = swag.DefaultJSONNameProvider
+	}
+
+	// Full document when empty
+	if len(p.referenceTokens) == 0 {
+		return nil
+	}
+
+	lastI := len(p.referenceTokens) - 1
+	for i, token := range p.referenceTokens {
+		isLastToken := i == lastI
+		decodedToken := Unescape(token)
+
+		if isLastToken {
+
+			return setSingleImpl(node, data, decodedToken, nameProvider)
+		}
+
+		rValue := reflect.Indirect(reflect.ValueOf(node))
+		kind := rValue.Kind()
+
+		switch kind {
+
+		case reflect.Struct:
+			if rValue.Type().Implements(jsonPointableType) {
+				r, err := node.(JSONPointable).JSONLookup(decodedToken)
+				if err != nil {
+					return err
+				}
+				fld := reflect.ValueOf(r)
+				if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr {
+					node = fld.Addr().Interface()
+					continue
+				}
+				node = r
+				continue
+			}
+			nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
+			if !ok {
+				return fmt.Errorf("object has no field %q", decodedToken)
+			}
+			fld := rValue.FieldByName(nm)
+			if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr {
+				node = fld.Addr().Interface()
+				continue
+			}
+			node = fld.Interface()
+
+		case reflect.Map:
+			kv := reflect.ValueOf(decodedToken)
+			mv := rValue.MapIndex(kv)
+
+			if !mv.IsValid() {
+				return fmt.Errorf("object has no key %q", decodedToken)
+			}
+			if mv.CanAddr() && mv.Kind() != reflect.Interface && mv.Kind() != reflect.Map && mv.Kind() != reflect.Slice && mv.Kind() != reflect.Ptr {
+				node = mv.Addr().Interface()
+				continue
+			}
+			node = mv.Interface()
+
+		case reflect.Slice:
+			tokenIndex, err := strconv.Atoi(decodedToken)
+			if err != nil {
+				return err
+			}
+			sLength := rValue.Len()
+			if tokenIndex < 0 || tokenIndex >= sLength {
+				return fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex)
+			}
+
+			elem := rValue.Index(tokenIndex)
+			if elem.CanAddr() && elem.Kind() != reflect.Interface && elem.Kind() != reflect.Map && elem.Kind() != reflect.Slice && elem.Kind() != reflect.Ptr {
+				node = elem.Addr().Interface()
+				continue
+			}
+			node = elem.Interface()
+
+		default:
+			return fmt.Errorf("invalid token reference %q", decodedToken)
+		}
+
+	}
+
+	return nil
+}
+
 // DecodedTokens returns the decoded tokens
 func (p *Pointer) DecodedTokens() []string {
 	result := make([]string, 0, len(p.referenceTokens))

vendor/github.com/go-openapi/jsonpointer/pointer_test.go

@@ -0,0 +1,573 @@
+// Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
+//
+// 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.
+
+// author       sigu-399
+// author-github  https://github.com/sigu-399
+// author-mail    sigu.399@gmail.com
+//
+// repository-name  jsonpointer
+// repository-desc  An implementation of JSON Pointer - Go language
+//
+// description    Automated tests on package.
+//
+// created        03-03-2013
+
+package jsonpointer
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	TestDocumentNBItems = 11
+	TestNodeObjNBItems  = 4
+	TestDocumentString  = `{
+"foo": ["bar", "baz"],
+"obj": { "a":1, "b":2, "c":[3,4], "d":[ {"e":9}, {"f":[50,51]} ] },
+"": 0,
+"a/b": 1,
+"c%d": 2,
+"e^f": 3,
+"g|h": 4,
+"i\\j": 5,
+"k\"l": 6,
+" ": 7,
+"m~n": 8
+}`
+)
+
+var testDocumentJSON interface{}
+
+type testStructJSON struct {
+	Foo []string `json:"foo"`
+	Obj struct {
+		A int   `json:"a"`
+		B int   `json:"b"`
+		C []int `json:"c"`
+		D []struct {
+			E int   `json:"e"`
+			F []int `json:"f"`
+		} `json:"d"`
+	} `json:"obj"`
+}
+
+type aliasedMap map[string]interface{}
+
+var testStructJSONDoc testStructJSON
+var testStructJSONPtr *testStructJSON
+
+func init() {
+	json.Unmarshal([]byte(TestDocumentString), &testDocumentJSON)
+	json.Unmarshal([]byte(TestDocumentString), &testStructJSONDoc)
+	testStructJSONPtr = &testStructJSONDoc
+}
+
+func TestEscaping(t *testing.T) {
+
+	ins := []string{`/`, `/`, `/a~1b`, `/a~1b`, `/c%d`, `/e^f`, `/g|h`, `/i\j`, `/k"l`, `/ `, `/m~0n`}
+	outs := []float64{0, 0, 1, 1, 2, 3, 4, 5, 6, 7, 8}
+
+	for i := range ins {
+		p, err := New(ins[i])
+		if assert.NoError(t, err, "input: %v", ins[i]) {
+			result, _, err := p.Get(testDocumentJSON)
+			if assert.NoError(t, err, "input: %v", ins[i]) {
+				assert.Equal(t, outs[i], result, "input: %v", ins[i])
+			}
+		}
+	}
+
+}
+
+func TestFullDocument(t *testing.T) {
+
+	in := ``
+
+	p, err := New(in)
+	if err != nil {
+		t.Errorf("New(%v) error %v", in, err.Error())
+	}
+
+	result, _, err := p.Get(testDocumentJSON)
+	if err != nil {
+		t.Errorf("Get(%v) error %v", in, err.Error())
+	}
+
+	if len(result.(map[string]interface{})) != TestDocumentNBItems {
+		t.Errorf("Get(%v) = %v, expect full document", in, result)
+	}
+
+	result, _, err = p.get(testDocumentJSON, nil)
+	if err != nil {
+		t.Errorf("Get(%v) error %v", in, err.Error())
+	}
+
+	if len(result.(map[string]interface{})) != TestDocumentNBItems {
+		t.Errorf("Get(%v) = %v, expect full document", in, result)
+	}
+}
+
+func TestDecodedTokens(t *testing.T) {
+	p, err := New("/obj/a~1b")
+	assert.NoError(t, err)
+	assert.Equal(t, []string{"obj", "a/b"}, p.DecodedTokens())
+}
+
+func TestIsEmpty(t *testing.T) {
+	p, err := New("")
+	assert.NoError(t, err)
+	assert.True(t, p.IsEmpty())
+	p, err = New("/obj")
+	assert.NoError(t, err)
+	assert.False(t, p.IsEmpty())
+}
+
+func TestGetSingle(t *testing.T) {
+	in := `/obj`
+
+	_, err := New(in)
+	assert.NoError(t, err)
+	result, _, err := GetForToken(testDocumentJSON, "obj")
+	assert.NoError(t, err)
+	assert.Len(t, result, TestNodeObjNBItems)
+
+	result, _, err = GetForToken(testStructJSONDoc, "Obj")
+	assert.Error(t, err)
+	assert.Nil(t, result)
+
+	result, _, err = GetForToken(testStructJSONDoc, "Obj2")
+	assert.Error(t, err)
+	assert.Nil(t, result)
+}
+
+type pointableImpl struct {
+	a string
+}
+
+func (p pointableImpl) JSONLookup(token string) (interface{}, error) {
+	if token == "some" {
+		return p.a, nil
+	}
+	return nil, fmt.Errorf("object has no field %q", token)
+}
+
+func TestPointableInterface(t *testing.T) {
+	p := &pointableImpl{"hello"}
+
+	result, _, err := GetForToken(p, "some")
+	assert.NoError(t, err)
+	assert.Equal(t, p.a, result)
+
+	result, _, err = GetForToken(p, "something")
+	assert.Error(t, err)
+	assert.Nil(t, result)
+}
+
+func TestGetNode(t *testing.T) {
+
+	in := `/obj`
+
+	p, err := New(in)
+	assert.NoError(t, err)
+	result, _, err := p.Get(testDocumentJSON)
+	assert.NoError(t, err)
+	assert.Len(t, result, TestNodeObjNBItems)
+
+	result, _, err = p.Get(aliasedMap(testDocumentJSON.(map[string]interface{})))
+	assert.NoError(t, err)
+	assert.Len(t, result, TestNodeObjNBItems)
+
+	result, _, err = p.Get(testStructJSONDoc)
+	assert.NoError(t, err)
+	assert.Equal(t, testStructJSONDoc.Obj, result)
+
+	result, _, err = p.Get(testStructJSONPtr)
+	assert.NoError(t, err)
+	assert.Equal(t, testStructJSONDoc.Obj, result)
+}
+
+func TestArray(t *testing.T) {
+
+	ins := []string{`/foo/0`, `/foo/0`, `/foo/1`}
+	outs := []string{"bar", "bar", "baz"}
+
+	for i := range ins {
+		p, err := New(ins[i])
+		assert.NoError(t, err)
+
+		result, _, err := p.Get(testStructJSONDoc)
+		assert.NoError(t, err)
+		assert.Equal(t, outs[i], result)
+
+		result, _, err = p.Get(testStructJSONPtr)
+		assert.NoError(t, err)
+		assert.Equal(t, outs[i], result)
+
+		result, _, err = p.Get(testDocumentJSON)
+		assert.NoError(t, err)
+		assert.Equal(t, outs[i], result)
+	}
+}
+
+func TestOtherThings(t *testing.T) {
+	_, err := New("abc")
+	assert.Error(t, err)
+
+	p, err := New("")
+	assert.NoError(t, err)
+	assert.Equal(t, "", p.String())
+
+	p, err = New("/obj/a")
+	assert.Equal(t, "/obj/a", p.String())
+
+	s := Escape("m~n")
+	assert.Equal(t, "m~0n", s)
+	s = Escape("m/n")
+	assert.Equal(t, "m~1n", s)
+
+	p, err = New("/foo/3")
+	assert.NoError(t, err)
+	_, _, err = p.Get(testDocumentJSON)
+	assert.Error(t, err)
+
+	p, err = New("/foo/a")
+	assert.NoError(t, err)
+	_, _, err = p.Get(testDocumentJSON)
+	assert.Error(t, err)
+
+	p, err = New("/notthere")
+	assert.NoError(t, err)
+	_, _, err = p.Get(testDocumentJSON)
+	assert.Error(t, err)
+
+	p, err = New("/invalid")
+	assert.NoError(t, err)
+	_, _, err = p.Get(1234)
+	assert.Error(t, err)
+
+	p, err = New("/foo/1")
+	assert.NoError(t, err)
+	expected := "hello"
+	bbb := testDocumentJSON.(map[string]interface{})["foo"]
+	bbb.([]interface{})[1] = "hello"
+
+	v, _, err := p.Get(testDocumentJSON)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, v)
+
+	esc := Escape("a/")
+	assert.Equal(t, "a~1", esc)
+	unesc := Unescape(esc)
+	assert.Equal(t, "a/", unesc)
+
+	unesc = Unescape("~01")
+	assert.Equal(t, "~1", unesc)
+	assert.Equal(t, "~0~1", Escape("~/"))
+	assert.Equal(t, "~/", Unescape("~0~1"))
+}
+
+func TestObject(t *testing.T) {
+
+	ins := []string{`/obj/a`, `/obj/b`, `/obj/c/0`, `/obj/c/1`, `/obj/c/1`, `/obj/d/1/f/0`}
+	outs := []float64{1, 2, 3, 4, 4, 50}
+
+	for i := range ins {
+
+		p, err := New(ins[i])
+		assert.NoError(t, err)
+
+		result, _, err := p.Get(testDocumentJSON)
+		assert.NoError(t, err)
+		assert.Equal(t, outs[i], result)
+
+		result, _, err = p.Get(testStructJSONDoc)
+		assert.NoError(t, err)
+		assert.EqualValues(t, outs[i], result)
+
+		result, _, err = p.Get(testStructJSONPtr)
+		assert.NoError(t, err)
+		assert.EqualValues(t, outs[i], result)
+	}
+}
+
+type setJsonDocEle struct {
+	B int `json:"b"`
+	C int `json:"c"`
+}
+type setJsonDoc struct {
+	A []struct {
+		B int `json:"b"`
+		C int `json:"c"`
+	} `json:"a"`
+	D int `json:"d"`
+}
+
+type settableDoc struct {
+	Coll settableColl
+	Int  settableInt
+}
+
+func (s settableDoc) MarshalJSON() ([]byte, error) {
+	var res struct {
+		A settableColl `json:"a"`
+		D settableInt  `json:"d"`
+	}
+	res.A = s.Coll
+	res.D = s.Int
+	return json.Marshal(res)
+}
+func (s *settableDoc) UnmarshalJSON(data []byte) error {
+	var res struct {
+		A settableColl `json:"a"`
+		D settableInt  `json:"d"`
+	}
+
+	if err := json.Unmarshal(data, &res); err != nil {
+		return err
+	}
+	s.Coll = res.A
+	s.Int = res.D
+	return nil
+}
+
+// JSONLookup implements an interface to customize json pointer lookup
+func (s settableDoc) JSONLookup(token string) (interface{}, error) {
+	switch token {
+	case "a":
+		return &s.Coll, nil
+	case "d":
+		return &s.Int, nil
+	default:
+		return nil, fmt.Errorf("%s is not a known field", token)
+	}
+}
+
+// JSONLookup implements an interface to customize json pointer lookup
+func (s *settableDoc) JSONSet(token string, data interface{}) error {
+	switch token {
+	case "a":
+		switch dt := data.(type) {
+		case settableColl:
+			s.Coll = dt
+			return nil
+		case *settableColl:
+			if dt != nil {
+				s.Coll = *dt
+			} else {
+				s.Coll = settableColl{}
+			}
+			return nil
+		case []settableCollItem:
+			s.Coll.Items = dt
+			return nil
+		}
+	case "d":
+		switch dt := data.(type) {
+		case settableInt:
+			s.Int = dt
+			return nil
+		case int:
+			s.Int.Value = dt
+			return nil
+		case int8:
+			s.Int.Value = int(dt)
+			return nil
+		case int16:
+			s.Int.Value = int(dt)
+			return nil
+		case int32:
+			s.Int.Value = int(dt)
+			return nil
+		case int64:
+			s.Int.Value = int(dt)
+			return nil
+		default:
+			return fmt.Errorf("invalid type %T for %s", data, token)
+		}
+	}
+	return fmt.Errorf("%s is not a known field", token)
+}
+
+type settableColl struct {
+	Items []settableCollItem
+}
+
+func (s settableColl) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.Items)
+}
+func (s *settableColl) UnmarshalJSON(data []byte) error {
+	return json.Unmarshal(data, &s.Items)
+}
+
+// JSONLookup implements an interface to customize json pointer lookup
+func (s settableColl) JSONLookup(token string) (interface{}, error) {
+	if tok, err := strconv.Atoi(token); err == nil {
+		return &s.Items[tok], nil
+	}
+	return nil, fmt.Errorf("%s is not a valid index", token)
+}
+
+// JSONLookup implements an interface to customize json pointer lookup
+func (s *settableColl) JSONSet(token string, data interface{}) error {
+	if _, err := strconv.Atoi(token); err == nil {
+		_, err := SetForToken(s.Items, token, data)
+		return err
+	}
+	return fmt.Errorf("%s is not a valid index", token)
+}
+
+type settableCollItem struct {
+	B int `json:"b"`
+	C int `json:"c"`
+}
+
+type settableInt struct {
+	Value int
+}
+
+func (s settableInt) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.Value)
+}
+func (s *settableInt) UnmarshalJSON(data []byte) error {
+	return json.Unmarshal(data, &s.Value)
+}
+
+func TestSetNode(t *testing.T) {
+
+	jsonText := `{"a":[{"b": 1, "c": 2}], "d": 3}`
+
+	var jsonDocument interface{}
+	if assert.NoError(t, json.Unmarshal([]byte(jsonText), &jsonDocument)) {
+		in := "/a/0/c"
+		p, err := New(in)
+		if assert.NoError(t, err) {
+
+			_, err = p.Set(jsonDocument, 999)
+			assert.NoError(t, err)
+
+			firstNode := jsonDocument.(map[string]interface{})
+			assert.Len(t, firstNode, 2)
+
+			sliceNode := firstNode["a"].([]interface{})
+			assert.Len(t, sliceNode, 1)
+
+			changedNode := sliceNode[0].(map[string]interface{})
+			chNodeVI := changedNode["c"]
+			if assert.IsType(t, 0, chNodeVI) {
+				changedNodeValue := chNodeVI.(int)
+				if assert.Equal(t, 999, changedNodeValue) {
+					assert.Len(t, sliceNode, 1)
+				}
+			}
+		}
+
+		v, err := New("/a/0")
+		if assert.NoError(t, err) {
+			_, err = v.Set(jsonDocument, map[string]interface{}{"b": 3, "c": 8})
+			if assert.NoError(t, err) {
+				firstNode := jsonDocument.(map[string]interface{})
+				assert.Len(t, firstNode, 2)
+
+				sliceNode := firstNode["a"].([]interface{})
+				assert.Len(t, sliceNode, 1)
+				changedNode := sliceNode[0].(map[string]interface{})
+				assert.Equal(t, 3, changedNode["b"])
+				assert.Equal(t, 8, changedNode["c"])
+			}
+		}
+	}
+
+	var structDoc setJsonDoc
+	if assert.NoError(t, json.Unmarshal([]byte(jsonText), &structDoc)) {
+		g, err := New("/a")
+		if assert.NoError(t, err) {
+			_, err = g.Set(&structDoc, []struct {
+				B int `json:"b"`
+				C int `json:"c"`
+			}{{B: 4, C: 7}})
+
+			if assert.NoError(t, err) {
+				assert.Len(t, structDoc.A, 1)
+				changedNode := structDoc.A[0]
+				assert.Equal(t, 4, changedNode.B)
+				assert.Equal(t, 7, changedNode.C)
+			}
+		}
+
+		v, err := New("/a/0")
+		if assert.NoError(t, err) {
+			_, err = v.Set(structDoc, struct {
+				B int `json:"b"`
+				C int `json:"c"`
+			}{B: 3, C: 8})
+
+			if assert.NoError(t, err) {
+				assert.Len(t, structDoc.A, 1)
+				changedNode := structDoc.A[0]
+				assert.Equal(t, 3, changedNode.B)
+				assert.Equal(t, 8, changedNode.C)
+			}
+		}
+
+		p, err := New("/a/0/c")
+		if assert.NoError(t, err) {
+			_, err = p.Set(&structDoc, 999)
+			assert.NoError(t, err)
+			if assert.Len(t, structDoc.A, 1) {
+				assert.Equal(t, 999, structDoc.A[0].C)
+			}
+		}
+	}
+
+	var setDoc settableDoc
+	if assert.NoError(t, json.Unmarshal([]byte(jsonText), &setDoc)) {
+		g, err := New("/a")
+		if assert.NoError(t, err) {
+			_, err = g.Set(&setDoc, []settableCollItem{{B: 4, C: 7}})
+
+			if assert.NoError(t, err) {
+				assert.Len(t, setDoc.Coll.Items, 1)
+				changedNode := setDoc.Coll.Items[0]
+				assert.Equal(t, 4, changedNode.B)
+				assert.Equal(t, 7, changedNode.C)
+			}
+		}
+
+		v, err := New("/a/0")
+		if assert.NoError(t, err) {
+			_, err = v.Set(setDoc, settableCollItem{B: 3, C: 8})
+
+			if assert.NoError(t, err) {
+				assert.Len(t, setDoc.Coll.Items, 1)
+				changedNode := setDoc.Coll.Items[0]
+				assert.Equal(t, 3, changedNode.B)
+				assert.Equal(t, 8, changedNode.C)
+			}
+		}
+
+		p, err := New("/a/0/c")
+		if assert.NoError(t, err) {
+			_, err = p.Set(setDoc, 999)
+			assert.NoError(t, err)
+			if assert.Len(t, setDoc.Coll.Items, 1) {
+				assert.Equal(t, 999, setDoc.Coll.Items[0].C)
+			}
+		}
+	}
+}

vendor/github.com/go-openapi/jsonreference/.drone.yml

@@ -1,33 +0,0 @@
-clone:
-  path: github.com/go-openapi/jsonreference
-
-matrix:
-  GO_VERSION:
-    - "1.6"
-
-build:
-  integration:
-    image: golang:$$GO_VERSION
-    pull: true
-    commands:
-      - go get -u github.com/stretchr/testify/assert
-      - go get -u github.com/PuerkitoBio/purell
-      - go get -u github.com/go-openapi/jsonpointer
-      - go test -race
-      - go test -v -cover -coverprofile=coverage.out -covermode=count ./...
-
-notify:
-  slack:
-    channel: bots
-    webhook_url: $$SLACK_URL
-    username: drone
-
-publish:
-  coverage:
-    server: https://coverage.vmware.run
-    token: $$GITHUB_TOKEN
-    # threshold: 70
-    # must_increase: true
-    when:
-      matrix:
-        GO_VERSION: "1.6"

vendor/github.com/go-openapi/jsonreference/.github/CONTRIBUTING.md

@@ -0,0 +1,117 @@
+## Contribution Guidelines
+
+### Pull requests are always welcome
+
+We are always thrilled to receive pull requests, and do our best to
+process them as fast as possible. Not sure if that typo is worth a pull
+request? Do it! We will appreciate it.
+
+If your pull request is not accepted on the first try, don't be
+discouraged! If there's a problem with the implementation, hopefully you
+received feedback on what to improve.
+
+We're trying very hard to keep go-swagger lean and focused. We don't want it
+to do everything for everybody. This means that we might decide against
+incorporating a new feature. However, there might be a way to implement
+that feature *on top of* go-swagger.
+
+
+### Conventions
+
+Fork the repo and make changes on your fork in a feature branch:
+
+- If it's a bugfix branch, name it XXX-something where XXX is the number of the
+  issue
+- If it's a feature branch, create an enhancement issue to announce your
+  intentions, and name it XXX-something where XXX is the number of the issue.
+
+Submit unit tests for your changes.  Go has a great test framework built in; use
+it! Take a look at existing tests for inspiration. Run the full test suite on
+your branch before submitting a pull request.
+
+Update the documentation when creating or modifying features. Test
+your documentation changes for clarity, concision, and correctness, as
+well as a clean documentation build. See ``docs/README.md`` for more
+information on building the docs and how docs get released.
+
+Write clean code. Universally formatted code promotes ease of writing, reading,
+and maintenance. Always run `gofmt -s -w file.go` on each changed file before
+committing your changes. Most editors have plugins that do this automatically.
+
+Pull requests descriptions should be as clear as possible and include a
+reference to all the issues that they address.
+
+Pull requests must not contain commits from other users or branches.
+
+Commit messages must start with a capitalized and short summary (max. 50
+chars) written in the imperative, followed by an optional, more detailed
+explanatory text which is separated from the summary by an empty line.
+
+Code review comments may be added to your pull request. Discuss, then make the
+suggested modifications and push additional commits to your feature branch. Be
+sure to post a comment after pushing. The new commits will show up in the pull
+request automatically, but the reviewers will not be notified unless you
+comment.
+
+Before the pull request is merged, make sure that you squash your commits into
+logical units of work using `git rebase -i` and `git push -f`. After every
+commit the test suite should be passing. Include documentation changes in the
+same commit so that a revert would remove all traces of the feature or fix.
+
+Commits that fix or close an issue should include a reference like `Closes #XXX`
+or `Fixes #XXX`, which will automatically close the issue when merged.
+
+### Sign your work
+
+The sign-off is a simple line at the end of the explanation for the
+patch, which certifies that you wrote it or otherwise have the right to
+pass it on as an open-source patch.  The rules are pretty simple: if you
+can certify the below (from
+[developercertificate.org](http://developercertificate.org/)):
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+then you just add a line to every git commit message:
+
+    Signed-off-by: Joe Smith <joe@gmail.com>
+
+using your real name (sorry, no pseudonyms or anonymous contributions.)
+
+You can add the sign off when creating the git commit via `git commit -s`.

vendor/github.com/go-openapi/jsonreference/.pullapprove.yml

@@ -1,13 +0,0 @@
-approve_by_comment: true
-approve_regex: '^(:shipit:|:\+1:|\+1|LGTM|lgtm|Approved)'
-reject_regex: ^[Rr]ejected
-reset_on_push: false
-reviewers:
-  members:
-  - casualjim
-  - chancez
-  - frapposelli
-  - vburenin
-  - pytlesk4
-  name: pullapprove
-  required: 1

vendor/github.com/go-openapi/jsonreference/.travis.yml

@@ -0,0 +1,14 @@
+language: go
+go:
+- 1.7
+install:
+- go get -u github.com/stretchr/testify/assert
+- go get -u github.com/PuerkitoBio/purell
+- go get -u github.com/go-openapi/jsonpointer
+script:
+- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./...
+after_success:
+- bash <(curl -s https://codecov.io/bash)
+notifications:
+  slack:
+    secure: OpQG/36F7DSF00HLm9WZMhyqFCYYyYTsVDObW226cWiR8PWYiNfLZiSEvIzT1Gx4dDjhigKTIqcLhG34CkL5iNXDjm9Yyo2RYhQPlK8NErNqUEXuBqn4RqYHW48VGhEhOyDd4Ei0E2FN5ZbgpvHgtpkdZ6XDi64r3Ac89isP9aPHXQTuv2Jog6b4/OKKiUTftLcTIst0p4Cp3gqOJWf1wnoj+IadWiECNVQT6zb47IYjtyw6+uV8iUjTzdKcRB6Zc6b4Dq7JAg1Zd7Jfxkql3hlKp4PNlRf9Cy7y5iA3G7MLyg3FcPX5z2kmcyPt2jOTRMBWUJ5zIQpOxizAcN8WsT3WWBL5KbuYK6k0PzujrIDLqdxGpNmjkkMfDBT9cKmZpm2FdW+oZgPFJP+oKmAo4u4KJz/vjiPTXgQlN5bmrLuRMCp+AwC5wkIohTqWZVPE2TK6ZSnMYcg/W39s+RP/9mJoyryAvPSpBOLTI+biCgaUCTOAZxNTWpMFc3tPYntc41WWkdKcooZ9JA5DwfcaVFyTGQ3YXz+HvX6G1z/gW0Q/A4dBi9mj2iE1xm7tRTT+4VQ2AXFvSEI1HJpfPgYnwAtwOD1v3Qm2EUHk9sCdtEDR4wVGEPIVn44GnwFMnGKx9JWppMPYwFu3SVDdHt+E+LOlhZUply11Aa+IVrT2KUQ=

vendor/github.com/go-openapi/jsonreference/README.md

@@ -1,4 +1,4 @@
-# gojsonreference [![Build Status](https://ci.vmware.run/api/badges/go-openapi/jsonreference/status.svg)](https://ci.vmware.run/go-openapi/jsonreference) [![Coverage](https://coverage.vmware.run/badges/go-openapi/jsonreference/coverage.svg)](https://coverage.vmware.run/go-openapi/jsonreference) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
+# gojsonreference [![Build Status](https://travis-ci.org/go-openapi/jsonreference.svg?branch=master)](https://travis-ci.org/go-openapi/jsonreference) [![codecov](https://codecov.io/gh/go-openapi/jsonreference/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/jsonreference) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
 
 [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/jsonreference/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/jsonreference?status.svg)](http://godoc.org/github.com/go-openapi/jsonreference)
 An implementation of JSON Reference - Go language
@@ -7,7 +7,7 @@ An implementation of JSON Reference - Go language
 Work in progress ( 90% done )
 
 ## Dependencies
-https://github.com/xeipuuv/gojsonpointer
+https://github.com/go-openapi/jsonpointer
 
 ## References
 http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07

vendor/github.com/go-openapi/jsonreference/reference_test.go

@@ -0,0 +1,420 @@
+// Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
+//
+// 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.
+
+// author       sigu-399
+// author-github  https://github.com/sigu-399
+// author-mail    sigu.399@gmail.com
+//
+// repository-name  jsonreference
+// repository-desc  An implementation of JSON Reference - Go language
+//
+// description    Automated tests on package.
+//
+// created        03-03-2013
+
+package jsonreference
+
+import (
+	"testing"
+
+	"github.com/go-openapi/jsonpointer"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsRoot(t *testing.T) {
+	in := "#"
+	r1, err := New(in)
+	assert.NoError(t, err)
+	assert.True(t, r1.IsRoot())
+
+	in = "#/ok"
+	r1 = MustCreateRef(in)
+	assert.False(t, r1.IsRoot())
+
+	assert.Panics(t, assert.PanicTestFunc(func() {
+		MustCreateRef("%2")
+	}))
+}
+
+func TestFull(t *testing.T) {
+
+	in := "http://host/path/a/b/c#/f/a/b"
+
+	r1, err := New(in)
+	if err != nil {
+		t.Errorf("New(%v) error %s", in, err.Error())
+	}
+
+	if in != r1.String() {
+		t.Errorf("New(%v) = %v, expect %v", in, r1.String(), in)
+	}
+
+	if r1.HasFragmentOnly != false {
+		t.Errorf("New(%v)::HasFragmentOnly %v expect %v", in, r1.HasFragmentOnly, false)
+	}
+
+	if r1.HasFullURL != true {
+		t.Errorf("New(%v)::HasFullURL %v expect %v", in, r1.HasFullURL, true)
+	}
+
+	if r1.HasURLPathOnly != false {
+		t.Errorf("New(%v)::HasURLPathOnly %v expect %v", in, r1.HasURLPathOnly, false)
+	}
+
+	if r1.HasFileScheme != false {
+		t.Errorf("New(%v)::HasFileScheme %v expect %v", in, r1.HasFileScheme, false)
+	}
+
+	if r1.GetPointer().String() != "/f/a/b" {
+		t.Errorf("New(%v)::GetPointer() %v expect %v", in, r1.GetPointer().String(), "/f/a/b")
+	}
+}
+
+func TestFullURL(t *testing.T) {
+
+	in := "http://host/path/a/b/c"
+
+	r1, err := New(in)
+	if err != nil {
+		t.Errorf("New(%v) error %s", in, err.Error())
+	}
+
+	if in != r1.String() {
+		t.Errorf("New(%v) = %v, expect %v", in, r1.String(), in)
+	}
+
+	if r1.HasFragmentOnly != false {
+		t.Errorf("New(%v)::HasFragmentOnly %v expect %v", in, r1.HasFragmentOnly, false)
+	}
+
+	if r1.HasFullURL != true {
+		t.Errorf("New(%v)::HasFullURL %v expect %v", in, r1.HasFullURL, true)
+	}
+
+	if r1.HasURLPathOnly != false {
+		t.Errorf("New(%v)::HasURLPathOnly %v expect %v", in, r1.HasURLPathOnly, false)
+	}
+
+	if r1.HasFileScheme != false {
+		t.Errorf("New(%v)::HasFileScheme %v expect %v", in, r1.HasFileScheme, false)
+	}
+
+	if r1.GetPointer().String() != "" {
+		t.Errorf("New(%v)::GetPointer() %v expect %v", in, r1.GetPointer().String(), "")
+	}
+}
+
+func TestFragmentOnly(t *testing.T) {
+
+	in := "#/fragment/only"
+
+	r1, err := New(in)
+	if err != nil {
+		t.Errorf("New(%v) error %s", in, err.Error())
+	}
+
+	if in != r1.String() {
+		t.Errorf("New(%v) = %v, expect %v", in, r1.String(), in)
+	}
+
+	if r1.HasFragmentOnly != true {
+		t.Errorf("New(%v)::HasFragmentOnly %v expect %v", in, r1.HasFragmentOnly, true)
+	}
+
+	if r1.HasFullURL != false {
+		t.Errorf("New(%v)::HasFullURL %v expect %v", in, r1.HasFullURL, false)
+	}
+
+	if r1.HasURLPathOnly != false {
+		t.Errorf("New(%v)::HasURLPathOnly %v expect %v", in, r1.HasURLPathOnly, false)
+	}
+
+	if r1.HasFileScheme != false {
+		t.Errorf("New(%v)::HasFileScheme %v expect %v", in, r1.HasFileScheme, false)
+	}
+
+	if r1.GetPointer().String() != "/fragment/only" {
+		t.Errorf("New(%v)::GetPointer() %v expect %v", in, r1.GetPointer().String(), "/fragment/only")
+	}
+
+	p, _ := jsonpointer.New(r1.referenceURL.Fragment)
+	r2 := Ref{referencePointer: p, HasFragmentOnly: true}
+	assert.Equal(t, r2.String(), in)
+
+	r3 := Ref{referencePointer: p, HasFragmentOnly: false}
+	assert.Equal(t, r3.String(), in[1:])
+}
+
+func TestURLPathOnly(t *testing.T) {
+
+	in := "/documents/document.json"
+
+	r1, err := New(in)
+	if err != nil {
+		t.Errorf("New(%v) error %s", in, err.Error())
+	}
+
+	if in != r1.String() {
+		t.Errorf("New(%v) = %v, expect %v", in, r1.String(), in)
+	}
+
+	if r1.HasFragmentOnly != false {
+		t.Errorf("New(%v)::HasFragmentOnly %v expect %v", in, r1.HasFragmentOnly, false)
+	}
+
+	if r1.HasFullURL != false {
+		t.Errorf("New(%v)::HasFullURL %v expect %v", in, r1.HasFullURL, false)
+	}
+
+	if r1.HasURLPathOnly != true {
+		t.Errorf("New(%v)::HasURLPathOnly %v expect %v", in, r1.HasURLPathOnly, true)
+	}
+
+	if r1.HasFileScheme != false {
+		t.Errorf("New(%v)::HasFileScheme %v expect %v", in, r1.HasFileScheme, false)
+	}
+
+	if r1.GetPointer().String() != "" {
+		t.Errorf("New(%v)::GetPointer() %v expect %v", in, r1.GetPointer().String(), "")
+	}
+}
+
+func TestURLRelativePathOnly(t *testing.T) {
+
+	in := "document.json"
+
+	r1, err := New(in)
+	if err != nil {
+		t.Errorf("New(%v) error %s", in, err.Error())
+	}
+
+	if in != r1.String() {
+		t.Errorf("New(%v) = %v, expect %v", in, r1.String(), in)
+	}
+
+	if r1.HasFragmentOnly != false {
+		t.Errorf("New(%v)::HasFragmentOnly %v expect %v", in, r1.HasFragmentOnly, false)
+	}
+
+	if r1.HasFullURL != false {
+		t.Errorf("New(%v)::HasFullURL %v expect %v", in, r1.HasFullURL, false)
+	}
+
+	if r1.HasURLPathOnly != true {
+		t.Errorf("New(%v)::HasURLPathOnly %v expect %v", in, r1.HasURLPathOnly, true)
+	}
+
+	if r1.HasFileScheme != false {
+		t.Errorf("New(%v)::HasFileScheme %v expect %v", in, r1.HasFileScheme, false)
+	}
+
+	if r1.GetPointer().String() != "" {
+		t.Errorf("New(%v)::GetPointer() %v expect %v", in, r1.GetPointer().String(), "")
+	}
+}
+
+func TestInheritsInValid(t *testing.T) {
+	in1 := "http://www.test.com/doc.json"
+	in2 := "#/a/b"
+
+	r1, _ := New(in1)
+	r2 := Ref{}
+	result, err := r1.Inherits(r2)
+	assert.Error(t, err)
+	assert.Nil(t, result)
+
+	r1 = Ref{}
+	r2, _ = New(in2)
+	result, err = r1.Inherits(r2)
+	assert.NoError(t, err)
+	assert.Equal(t, r2, *result)
+}
+
+func TestInheritsValid(t *testing.T) {
+
+	in1 := "http://www.test.com/doc.json"
+	in2 := "#/a/b"
+	out := in1 + in2
+
+	r1, _ := New(in1)
+	r2, _ := New(in2)
+
+	result, err := r1.Inherits(r2)
+	if err != nil {
+		t.Errorf("Inherits(%s,%s) error %s", r1.String(), r2.String(), err.Error())
+	}
+
+	if result.String() != out {
+		t.Errorf("Inherits(%s,%s) = %s, expect %s", r1.String(), r2.String(), result.String(), out)
+	}
+
+	if result.GetPointer().String() != "/a/b" {
+		t.Errorf("result(%v)::GetPointer() %v expect %v", result.String(), result.GetPointer().String(), "/a/b")
+	}
+}
+
+func TestInheritsDifferentHost(t *testing.T) {
+
+	in1 := "http://www.test.com/doc.json"
+	in2 := "http://www.test2.com/doc.json#bla"
+
+	r1, _ := New(in1)
+	r2, _ := New(in2)
+
+	result, err := r1.Inherits(r2)
+
+	if err != nil {
+		t.Errorf("Inherits(%s,%s) should not fail. Error: %s", r1.String(), r2.String(), err.Error())
+	}
+
+	if result.String() != in2 {
+		t.Errorf("Inherits(%s,%s) should be %s but is %s", in1, in2, in2, result)
+	}
+
+	if result.GetPointer().String() != "" {
+		t.Errorf("result(%v)::GetPointer() %v expect %v", result.String(), result.GetPointer().String(), "")
+	}
+}
+
+func TestFileScheme(t *testing.T) {
+
+	in1 := "file:///Users/mac/1.json#a"
+	in2 := "file:///Users/mac/2.json#b"
+
+	r1, _ := New(in1)
+	r2, _ := New(in2)
+
+	if r1.HasFragmentOnly != false {
+		t.Errorf("New(%v)::HasFragmentOnly %v expect %v", in1, r1.HasFragmentOnly, false)
+	}
+
+	if r1.HasFileScheme != true {
+		t.Errorf("New(%v)::HasFileScheme %v expect %v", in1, r1.HasFileScheme, true)
+	}
+
+	if r1.HasFullFilePath != true {
+		t.Errorf("New(%v)::HasFullFilePath %v expect %v", in1, r1.HasFullFilePath, true)
+	}
+
+	if r1.IsCanonical() != true {
+		t.Errorf("New(%v)::IsCanonical %v expect %v", in1, r1.IsCanonical, true)
+	}
+
+	result, err := r1.Inherits(r2)
+	if err != nil {
+		t.Errorf("Inherits(%s,%s) should not fail. Error: %s", r1.String(), r2.String(), err.Error())
+	}
+	if result.String() != in2 {
+		t.Errorf("Inherits(%s,%s) should be %s but is %s", in1, in2, in2, result)
+	}
+
+	if result.GetPointer().String() != "" {
+		t.Errorf("result(%v)::GetPointer() %v expect %v", result.String(), result.GetPointer().String(), "")
+	}
+}
+
+func TestReferenceResolution(t *testing.T) {
+
+	// 5.4. Reference Resolution Examples
+	// http://tools.ietf.org/html/rfc3986#section-5.4
+
+	base := "http://a/b/c/d;p?q"
+	baseRef, err := New(base)
+
+	if err != nil {
+		t.Errorf("New(%s) failed error: %s", base, err.Error())
+	}
+	if baseRef.String() != base {
+		t.Errorf("New(%s) %s expected %s", base, baseRef.String(), base)
+	}
+
+	checks := []string{
+		// 5.4.1. Normal Examples
+		// http://tools.ietf.org/html/rfc3986#section-5.4.1
+
+		"g:h", "g:h",
+		"g", "http://a/b/c/g",
+		"./g", "http://a/b/c/g",
+		"g/", "http://a/b/c/g/",
+		"/g", "http://a/g",
+		"//g", "http://g",
+		"?y", "http://a/b/c/d;p?y",
+		"g?y", "http://a/b/c/g?y",
+		"#s", "http://a/b/c/d;p?q#s",
+		"g#s", "http://a/b/c/g#s",
+		"g?y#s", "http://a/b/c/g?y#s",
+		";x", "http://a/b/c/;x",
+		"g;x", "http://a/b/c/g;x",
+		"g;x?y#s", "http://a/b/c/g;x?y#s",
+		"", "http://a/b/c/d;p?q",
+		".", "http://a/b/c/",
+		"./", "http://a/b/c/",
+		"..", "http://a/b/",
+		"../", "http://a/b/",
+		"../g", "http://a/b/g",
+		"../..", "http://a/",
+		"../../", "http://a/",
+		"../../g", "http://a/g",
+
+		// 5.4.2. Abnormal Examples
+		// http://tools.ietf.org/html/rfc3986#section-5.4.2
+
+		"../../../g", "http://a/g",
+		"../../../../g", "http://a/g",
+
+		"/./g", "http://a/g",
+		"/../g", "http://a/g",
+		"g.", "http://a/b/c/g.",
+		".g", "http://a/b/c/.g",
+		"g..", "http://a/b/c/g..",
+		"..g", "http://a/b/c/..g",
+
+		"./../g", "http://a/b/g",
+		"./g/.", "http://a/b/c/g/",
+		"g/./h", "http://a/b/c/g/h",
+		"g/../h", "http://a/b/c/h",
+		"g;x=1/./y", "http://a/b/c/g;x=1/y",
+		"g;x=1/../y", "http://a/b/c/y",
+
+		"g?y/./x", "http://a/b/c/g?y/./x",
+		"g?y/../x", "http://a/b/c/g?y/../x",
+		"g#s/./x", "http://a/b/c/g#s/./x",
+		"g#s/../x", "http://a/b/c/g#s/../x",
+
+		"http:g", "http:g", // for strict parsers
+		//"http:g", "http://a/b/c/g", // for backward compatibility
+
+	}
+	for i := 0; i < len(checks); i += 2 {
+		child := checks[i]
+		expected := checks[i+1]
+		// fmt.Printf("%d:   %v  ->  %v\n", i/2, child, expected)
+
+		childRef, e := New(child)
+		if e != nil {
+			t.Errorf("%d: New(%s) failed error: %s", i/2, child, e.Error())
+		}
+
+		res, e := baseRef.Inherits(childRef)
+		if res == nil {
+			t.Errorf("%d: Inherits(%s, %s) nil not expected", i/2, base, child)
+		}
+		if e != nil {
+			t.Errorf("%d: Inherits(%s) failed error: %s", i/2, child, e.Error())
+		}
+		if res.String() != expected {
+			t.Errorf("%d: Inherits(%s, %s) %s expected %s", i/2, base, child, res.String(), expected)
+		}
+	}
+}

vendor/github.com/go-openapi/spec/.drone.yml

@@ -1,35 +0,0 @@
-clone:
-  path: github.com/go-openapi/spec
-
-matrix:
-  GO_VERSION:
-    - "1.6"
-
-build:
-  integration:
-    image: golang:$$GO_VERSION
-    pull: true
-    commands:
-      - go get -u github.com/stretchr/testify/assert
-      - go get -u gopkg.in/yaml.v2
-      - go get -u github.com/go-openapi/swag
-      - go get -u github.com/go-openapi/jsonpointer
-      - go get -u github.com/go-openapi/jsonreference
-      - go test -race
-      - go test -v -cover -coverprofile=coverage.out -covermode=count ./...
-
-notify:
-  slack:
-    channel: bots
-    webhook_url: $$SLACK_URL
-    username: drone
-
-publish:
-  coverage:
-    server: https://coverage.vmware.run
-    token: $$GITHUB_TOKEN
-    # threshold: 70
-    # must_increase: true
-    when:
-      matrix:
-        GO_VERSION: "1.6"

vendor/github.com/go-openapi/spec/.editorconfig

@@ -0,0 +1,26 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+# Set default charset
+[*.{js,py,go,scala,rb,java,html,css,less,sass,md}]
+charset = utf-8
+
+# Tab indentation (no size specified)
+[*.go]
+indent_style = tab
+
+[*.md]
+trim_trailing_whitespace = false
+
+# Matches the exact files either package.json or .travis.yml
+[{package.json,.travis.yml}]
+indent_style = space
+indent_size = 2

vendor/github.com/go-openapi/spec/.github/CONTRIBUTING.md

@@ -0,0 +1,117 @@
+## Contribution Guidelines
+
+### Pull requests are always welcome
+
+We are always thrilled to receive pull requests, and do our best to
+process them as fast as possible. Not sure if that typo is worth a pull
+request? Do it! We will appreciate it.
+
+If your pull request is not accepted on the first try, don't be
+discouraged! If there's a problem with the implementation, hopefully you
+received feedback on what to improve.
+
+We're trying very hard to keep go-swagger lean and focused. We don't want it
+to do everything for everybody. This means that we might decide against
+incorporating a new feature. However, there might be a way to implement
+that feature *on top of* go-swagger.
+
+
+### Conventions
+
+Fork the repo and make changes on your fork in a feature branch:
+
+- If it's a bugfix branch, name it XXX-something where XXX is the number of the
+  issue
+- If it's a feature branch, create an enhancement issue to announce your
+  intentions, and name it XXX-something where XXX is the number of the issue.
+
+Submit unit tests for your changes.  Go has a great test framework built in; use
+it! Take a look at existing tests for inspiration. Run the full test suite on
+your branch before submitting a pull request.
+
+Update the documentation when creating or modifying features. Test
+your documentation changes for clarity, concision, and correctness, as
+well as a clean documentation build. See ``docs/README.md`` for more
+information on building the docs and how docs get released.
+
+Write clean code. Universally formatted code promotes ease of writing, reading,
+and maintenance. Always run `gofmt -s -w file.go` on each changed file before
+committing your changes. Most editors have plugins that do this automatically.
+
+Pull requests descriptions should be as clear as possible and include a
+reference to all the issues that they address.
+
+Pull requests must not contain commits from other users or branches.
+
+Commit messages must start with a capitalized and short summary (max. 50
+chars) written in the imperative, followed by an optional, more detailed
+explanatory text which is separated from the summary by an empty line.
+
+Code review comments may be added to your pull request. Discuss, then make the
+suggested modifications and push additional commits to your feature branch. Be
+sure to post a comment after pushing. The new commits will show up in the pull
+request automatically, but the reviewers will not be notified unless you
+comment.
+
+Before the pull request is merged, make sure that you squash your commits into
+logical units of work using `git rebase -i` and `git push -f`. After every
+commit the test suite should be passing. Include documentation changes in the
+same commit so that a revert would remove all traces of the feature or fix.
+
+Commits that fix or close an issue should include a reference like `Closes #XXX`
+or `Fixes #XXX`, which will automatically close the issue when merged.
+
+### Sign your work
+
+The sign-off is a simple line at the end of the explanation for the
+patch, which certifies that you wrote it or otherwise have the right to
+pass it on as an open-source patch.  The rules are pretty simple: if you
+can certify the below (from
+[developercertificate.org](http://developercertificate.org/)):
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+then you just add a line to every git commit message:
+
+    Signed-off-by: Joe Smith <joe@gmail.com>
+
+using your real name (sorry, no pseudonyms or anonymous contributions.)
+
+You can add the sign off when creating the git commit via `git commit -s`.

vendor/github.com/go-openapi/spec/.pullapprove.yml

@@ -1,13 +0,0 @@
-approve_by_comment: true
-approve_regex: '^(:shipit:|:\+1:|\+1|LGTM|lgtm|Approved)'
-reject_regex: ^[Rr]ejected
-reset_on_push: false
-reviewers:
-  members:
-  - casualjim
-  - chancez
-  - frapposelli
-  - vburenin
-  - pytlesk4
-  name: pullapprove
-  required: 1

vendor/github.com/go-openapi/spec/.travis.yml

@@ -0,0 +1,16 @@
+language: go
+go:
+- 1.7
+install:
+- go get -u github.com/stretchr/testify
+- go get -u github.com/go-openapi/swag
+- go get -u gopkg.in/yaml.v2
+- go get -u github.com/go-openapi/jsonpointer
+- go get -u github.com/go-openapi/jsonreference
+script:
+- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./...
+after_success:
+- bash <(curl -s https://codecov.io/bash)
+notifications:
+  slack:
+    secure: QUWvCkBBK09GF7YtEvHHVt70JOkdlNBG0nIKu/5qc4/nW5HP8I2w0SEf/XR2je0eED1Qe3L/AfMCWwrEj+IUZc3l4v+ju8X8R3Lomhme0Eb0jd1MTMCuPcBT47YCj0M7RON7vXtbFfm1hFJ/jLe5+9FXz0hpXsR24PJc5ZIi/ogNwkaPqG4BmndzecpSh0vc2FJPZUD9LT0I09REY/vXR0oQAalLkW0asGD5taHZTUZq/kBpsNxaAFrLM23i4mUcf33M5fjLpvx5LRICrX/57XpBrDh2TooBU6Qj3CgoY0uPRYUmSNxbVx1czNzl2JtEpb5yjoxfVPQeg0BvQM00G8LJINISR+ohrjhkZmAqchDupAX+yFrxTtORa78CtnIL6z/aTNlgwwVD8kvL/1pFA/JWYmKDmz93mV/+6wubGzNSQCstzjkFA4/iZEKewKUoRIAi/fxyscP6L/rCpmY/4llZZvrnyTqVbt6URWpopUpH4rwYqreXAtJxJsfBJIeSmUIiDIOMGkCTvyTEW3fWGmGoqWtSHLoaWDyAIGb7azb+KvfpWtEcoPFWfSWU+LGee0A/YsUhBl7ADB9A0CJEuR8q4BPpKpfLwPKSiKSAXL7zDkyjExyhtgqbSl2jS+rKIHOZNL8JkCcTP2MKMVd563C5rC5FMKqu3S9m2b6380E=

vendor/github.com/go-openapi/spec/README.md

@@ -1,5 +1,5 @@
-# OAI object model [![Build Status](https://ci.vmware.run/api/badges/go-openapi/spec/status.svg)](https://ci.vmware.run/go-openapi/spec) [![Coverage](https://coverage.vmware.run/badges/go-openapi/spec/coverage.svg)](https://coverage.vmware.run/go-openapi/spec) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
+# OAI object model [![Build Status](https://travis-ci.org/go-openapi/spec.svg?branch=master)](https://travis-ci.org/go-openapi/spec) [![codecov](https://codecov.io/gh/go-openapi/spec/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/spec) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
 
 [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/spec/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/spec?status.svg)](http://godoc.org/github.com/go-openapi/spec)
 
-The object model for OpenAPI specification documents
+The object model for OpenAPI specification documents

vendor/github.com/go-openapi/spec/auth_test.go

@@ -0,0 +1,128 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"testing"
+)
+
+func TestSerialization_AuthSerialization(t *testing.T) {
+	assertSerializeJSON(t, BasicAuth(), `{"type":"basic"}`)
+
+	assertSerializeJSON(t, APIKeyAuth("api-key", "header"), `{"type":"apiKey","name":"api-key","in":"header"}`)
+
+	assertSerializeJSON(
+		t,
+		OAuth2Implicit("http://foo.com/authorization"),
+		`{"type":"oauth2","flow":"implicit","authorizationUrl":"http://foo.com/authorization"}`)
+
+	assertSerializeJSON(
+		t,
+		OAuth2Password("http://foo.com/token"),
+		`{"type":"oauth2","flow":"password","tokenUrl":"http://foo.com/token"}`)
+
+	assertSerializeJSON(t,
+		OAuth2Application("http://foo.com/token"),
+		`{"type":"oauth2","flow":"application","tokenUrl":"http://foo.com/token"}`)
+
+	assertSerializeJSON(
+		t,
+		OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token"),
+		`{"type":"oauth2","flow":"accessCode","authorizationUrl":"http://foo.com/authorization","tokenUrl":"http://foo.com/token"}`)
+
+	auth1 := OAuth2Implicit("http://foo.com/authorization")
+	auth1.AddScope("email", "read your email")
+	assertSerializeJSON(
+		t,
+		auth1,
+		`{"type":"oauth2","flow":"implicit","authorizationUrl":"http://foo.com/authorization","scopes":{"email":"read your email"}}`)
+
+	auth2 := OAuth2Password("http://foo.com/authorization")
+	auth2.AddScope("email", "read your email")
+	assertSerializeJSON(
+		t,
+		auth2,
+		`{"type":"oauth2","flow":"password","tokenUrl":"http://foo.com/authorization","scopes":{"email":"read your email"}}`)
+
+	auth3 := OAuth2Application("http://foo.com/token")
+	auth3.AddScope("email", "read your email")
+	assertSerializeJSON(
+		t,
+		auth3,
+		`{"type":"oauth2","flow":"application","tokenUrl":"http://foo.com/token","scopes":{"email":"read your email"}}`)
+
+	auth4 := OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token")
+	auth4.AddScope("email", "read your email")
+	assertSerializeJSON(
+		t,
+		auth4,
+		`{"type":"oauth2","flow":"accessCode","authorizationUrl":"http://foo.com/authorization","tokenUrl":"http://foo.com/token","scopes":{"email":"read your email"}}`)
+}
+
+func TestSerialization_AuthDeserialization(t *testing.T) {
+
+	assertParsesJSON(t, `{"type":"basic"}`, BasicAuth())
+
+	assertParsesJSON(
+		t,
+		`{"in":"header","name":"api-key","type":"apiKey"}`,
+		APIKeyAuth("api-key", "header"))
+
+	assertParsesJSON(
+		t,
+		`{"authorizationUrl":"http://foo.com/authorization","flow":"implicit","type":"oauth2"}`,
+		OAuth2Implicit("http://foo.com/authorization"))
+
+	assertParsesJSON(
+		t,
+		`{"flow":"password","tokenUrl":"http://foo.com/token","type":"oauth2"}`,
+		OAuth2Password("http://foo.com/token"))
+
+	assertParsesJSON(
+		t,
+		`{"flow":"application","tokenUrl":"http://foo.com/token","type":"oauth2"}`,
+		OAuth2Application("http://foo.com/token"))
+
+	assertParsesJSON(
+		t,
+		`{"authorizationUrl":"http://foo.com/authorization","flow":"accessCode","tokenUrl":"http://foo.com/token","type":"oauth2"}`,
+		OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token"))
+
+	auth1 := OAuth2Implicit("http://foo.com/authorization")
+	auth1.AddScope("email", "read your email")
+	assertParsesJSON(t,
+		`{"authorizationUrl":"http://foo.com/authorization","flow":"implicit","scopes":{"email":"read your email"},"type":"oauth2"}`,
+		auth1)
+
+	auth2 := OAuth2Password("http://foo.com/token")
+	auth2.AddScope("email", "read your email")
+	assertParsesJSON(t,
+		`{"flow":"password","scopes":{"email":"read your email"},"tokenUrl":"http://foo.com/token","type":"oauth2"}`,
+		auth2)
+
+	auth3 := OAuth2Application("http://foo.com/token")
+	auth3.AddScope("email", "read your email")
+	assertParsesJSON(t,
+		`{"flow":"application","scopes":{"email":"read your email"},"tokenUrl":"http://foo.com/token","type":"oauth2"}`,
+		auth3)
+
+	auth4 := OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token")
+	auth4.AddScope("email", "read your email")
+	assertParsesJSON(
+		t,
+		`{"authorizationUrl":"http://foo.com/authorization","flow":"accessCode","scopes":{"email":"read your email"},"tokenUrl":"http://foo.com/token","type":"oauth2"}`,
+		auth4)
+
+}

vendor/github.com/go-openapi/spec/contact_info_test.go

@@ -0,0 +1,37 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"testing"
+)
+
+var contactInfoJSON = `{"name":"wordnik api team","url":"http://developer.wordnik.com","email":"some@mailayada.dkdkd"}`
+var contactInfoYAML = `name: wordnik api team
+url: http://developer.wordnik.com
+email: some@mailayada.dkdkd
+`
+var contactInfo = ContactInfo{
+	Name:  "wordnik api team",
+	URL:   "http://developer.wordnik.com",
+	Email: "some@mailayada.dkdkd",
+}
+
+func TestIntegrationContactInfo(t *testing.T) {
+	assertSerializeJSON(t, contactInfo, contactInfoJSON)
+	assertSerializeYAML(t, contactInfo, contactInfoYAML)
+	assertParsesJSON(t, contactInfoJSON, contactInfo)
+	assertParsesYAML(t, contactInfoYAML, contactInfo)
+}

vendor/github.com/go-openapi/spec/expander.go

@@ -17,7 +17,10 @@ package spec
 import (
 	"encoding/json"
 	"fmt"
+	"log"
 	"net/url"
+	"os"
+	"path/filepath"
 	"reflect"
 	"strings"
 	"sync"
@@ -26,6 +29,18 @@ import (
 	"github.com/go-openapi/swag"
 )
 
+var (
+	// Debug enables logging when SWAGGER_DEBUG env var is not empty
+	Debug = os.Getenv("SWAGGER_DEBUG") != ""
+)
+
+// ExpandOptions provides options for expand.
+type ExpandOptions struct {
+	RelativeBase    string
+	SkipSchemas     bool
+	ContinueOnError bool
+}
+
 // ResolutionCache a cache for resolving urls
 type ResolutionCache interface {
 	Get(string) (interface{}, bool)
@@ -37,7 +52,11 @@ type simpleCache struct {
 	store map[string]interface{}
 }
 
-var resCache = initResolutionCache()
+var resCache ResolutionCache
+
+func init() {
+	resCache = initResolutionCache()
+}
 
 func initResolutionCache() ResolutionCache {
 	return &simpleCache{store: map[string]interface{}{
@@ -47,8 +66,11 @@ func initResolutionCache() ResolutionCache {
 }
 
 func (s *simpleCache) Get(uri string) (interface{}, bool) {
+	debugLog("getting %q from resolution cache", uri)
 	s.lock.Lock()
 	v, ok := s.store[uri]
+	debugLog("got %q from resolution cache: %t", uri, ok)
+
 	s.lock.Unlock()
 	return v, ok
 }
@@ -59,9 +81,9 @@ func (s *simpleCache) Set(uri string, data interface{}) {
 	s.lock.Unlock()
 }
 
-// ResolveRef resolves a reference against a context root
-func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
-	resolver, err := defaultSchemaLoader(root, nil, nil)
+// ResolveRefWithBase resolves a reference against a context root with preservation of base path
+func ResolveRefWithBase(root interface{}, ref *Ref, opts *ExpandOptions) (*Schema, error) {
+	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -73,9 +95,19 @@ func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
 	return result, nil
 }
 
+// ResolveRef resolves a reference against a context root
+func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
+	return ResolveRefWithBase(root, ref, nil)
+}
+
 // ResolveParameter resolves a paramter reference against a context root
 func ResolveParameter(root interface{}, ref Ref) (*Parameter, error) {
-	resolver, err := defaultSchemaLoader(root, nil, nil)
+	return ResolveParameterWithBase(root, ref, nil)
+}
+
+// ResolveParameterWithBase resolves a paramter reference against a context root and base path
+func ResolveParameterWithBase(root interface{}, ref Ref, opts *ExpandOptions) (*Parameter, error) {
+	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -89,7 +121,12 @@ func ResolveParameter(root interface{}, ref Ref) (*Parameter, error) {
 
 // ResolveResponse resolves response a reference against a context root
 func ResolveResponse(root interface{}, ref Ref) (*Response, error) {
-	resolver, err := defaultSchemaLoader(root, nil, nil)
+	return ResolveResponseWithBase(root, ref, nil)
+}
+
+// ResolveResponseWithBase resolves response a reference against a context root and base path
+func ResolveResponseWithBase(root interface{}, ref Ref, opts *ExpandOptions) (*Response, error) {
+	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -101,23 +138,72 @@ func ResolveResponse(root interface{}, ref Ref) (*Response, error) {
 	return result, nil
 }
 
+// ResolveItems resolves header and parameter items reference against a context root and base path
+func ResolveItems(root interface{}, ref Ref, opts *ExpandOptions) (*Items, error) {
+	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	result := new(Items)
+	if err := resolver.Resolve(&ref, result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+// ResolvePathItem resolves response a path item against a context root and base path
+func ResolvePathItem(root interface{}, ref Ref, opts *ExpandOptions) (*PathItem, error) {
+	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	result := new(PathItem)
+	if err := resolver.Resolve(&ref, result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
 type schemaLoader struct {
 	loadingRef  *Ref
 	startingRef *Ref
 	currentRef  *Ref
 	root        interface{}
+	options     *ExpandOptions
 	cache       ResolutionCache
 	loadDoc     func(string) (json.RawMessage, error)
 }
 
 var idPtr, _ = jsonpointer.New("/id")
-var schemaPtr, _ = jsonpointer.New("/$schema")
 var refPtr, _ = jsonpointer.New("/$ref")
 
-func defaultSchemaLoader(root interface{}, ref *Ref, cache ResolutionCache) (*schemaLoader, error) {
+// PathLoader function to use when loading remote refs
+var PathLoader func(string) (json.RawMessage, error)
+
+func init() {
+	PathLoader = func(path string) (json.RawMessage, error) {
+		data, err := swag.LoadFromFileOrHTTP(path)
+		if err != nil {
+			return nil, err
+		}
+		return json.RawMessage(data), nil
+	}
+}
+
+func defaultSchemaLoader(
+	root interface{},
+	ref *Ref,
+	expandOptions *ExpandOptions,
+	cache ResolutionCache) (*schemaLoader, error) {
+
 	if cache == nil {
 		cache = resCache
 	}
+	if expandOptions == nil {
+		expandOptions = &ExpandOptions{}
+	}
 
 	var ptr *jsonpointer.Pointer
 	if ref != nil {
@@ -127,18 +213,16 @@ func defaultSchemaLoader(root interface{}, ref *Ref, cache ResolutionCache) (*sc
 	currentRef := nextRef(root, ref, ptr)
 
 	return &schemaLoader{
-		root:        root,
 		loadingRef:  ref,
 		startingRef: ref,
+		currentRef:  currentRef,
+		root:        root,
+		options:     expandOptions,
 		cache:       cache,
 		loadDoc: func(path string) (json.RawMessage, error) {
-			data, err := swag.LoadFromFileOrHTTP(path)
-			if err != nil {
-				return nil, err
-			}
-			return json.RawMessage(data), nil
+			debugLog("fetching document at %q", path)
+			return PathLoader(path)
 		},
-		currentRef: currentRef,
 	}, nil
 }
 
@@ -159,6 +243,7 @@ func nextRef(startingNode interface{}, startingRef *Ref, ptr *jsonpointer.Pointe
 	if startingRef == nil {
 		return nil
 	}
+
 	if ptr == nil {
 		return startingRef
 	}
@@ -184,32 +269,111 @@ func nextRef(startingNode interface{}, startingRef *Ref, ptr *jsonpointer.Pointe
 
 		refRef, _, _ := refPtr.Get(node)
 		if refRef != nil {
-			rf, _ := NewRef(refRef.(string))
+			var rf Ref
+			switch value := refRef.(type) {
+			case string:
+				rf, _ = NewRef(value)
+			}
 			nw, err := ret.Inherits(rf)
 			if err != nil {
 				break
 			}
+			nwURL := nw.GetURL()
+			if nwURL.Scheme == "file" || (nwURL.Scheme == "" && nwURL.Host == "") {
+				nwpt := filepath.ToSlash(nwURL.Path)
+				if filepath.IsAbs(nwpt) {
+					_, err := os.Stat(nwpt)
+					if err != nil {
+						nwURL.Path = filepath.Join(".", nwpt)
+					}
+				}
+			}
+
 			ret = nw
 		}
 
 	}
+
 	return ret
 }
 
+func debugLog(msg string, args ...interface{}) {
+	if Debug {
+		log.Printf(msg, args...)
+	}
+}
+
+func normalizeFileRef(ref *Ref, relativeBase string) *Ref {
+	refURL := ref.GetURL()
+	debugLog("normalizing %s against %s (%s)", ref.String(), relativeBase, refURL.String())
+	if strings.HasPrefix(refURL.String(), "#") {
+		return ref
+	}
+
+	if refURL.Scheme == "file" || (refURL.Scheme == "" && refURL.Host == "") {
+		filePath := refURL.Path
+		debugLog("normalizing file path: %s", filePath)
+
+		if !filepath.IsAbs(filepath.FromSlash(filePath)) && len(relativeBase) != 0 {
+			debugLog("joining %s with %s", relativeBase, filePath)
+			if fi, err := os.Stat(filepath.FromSlash(relativeBase)); err == nil {
+				if !fi.IsDir() {
+					relativeBase = filepath.Dir(filepath.FromSlash(relativeBase))
+				}
+			}
+			filePath = filepath.Join(filepath.FromSlash(relativeBase), filepath.FromSlash(filePath))
+		}
+		if !filepath.IsAbs(filepath.FromSlash(filePath)) {
+			pwd, err := os.Getwd()
+			if err == nil {
+				debugLog("joining cwd %s with %s", pwd, filePath)
+				filePath = filepath.Join(pwd, filepath.FromSlash(filePath))
+			}
+		}
+
+		debugLog("cleaning %s", filePath)
+		filePath = filepath.Clean(filepath.FromSlash(filePath))
+		_, err := os.Stat(filepath.FromSlash(filePath))
+		if err == nil {
+			debugLog("rewriting url %s to scheme \"\" path %s", refURL.String(), filePath)
+			slp := filepath.FromSlash(filePath)
+			if filepath.IsAbs(slp) && filepath.Separator == '\\' && len(slp) > 1 && slp[1] == ':' && ('a' <= slp[0] && slp[0] <= 'z' || 'A' <= slp[0] && slp[0] <= 'Z') {
+				slp = slp[2:]
+			}
+			refURL.Scheme = ""
+			refURL.Path = filepath.ToSlash(slp)
+			debugLog("new url with joined filepath: %s", refURL.String())
+			*ref = MustCreateRef(refURL.String())
+		}
+	}
+
+	debugLog("refurl: %s", ref.GetURL().String())
+	return ref
+}
+
 func (r *schemaLoader) resolveRef(currentRef, ref *Ref, node, target interface{}) error {
+
 	tgt := reflect.ValueOf(target)
 	if tgt.Kind() != reflect.Ptr {
 		return fmt.Errorf("resolve ref: target needs to be a pointer")
 	}
 
 	oldRef := currentRef
+
 	if currentRef != nil {
+		debugLog("resolve ref current %s new %s", currentRef.String(), ref.String())
+		nextRef := nextRef(node, ref, currentRef.GetPointer())
+		if nextRef == nil || nextRef.GetURL() == nil {
+			return nil
+		}
 		var err error
-		currentRef, err = currentRef.Inherits(*nextRef(node, ref, currentRef.GetPointer()))
+		currentRef, err = currentRef.Inherits(*nextRef)
+		debugLog("resolved ref current %s", currentRef.String())
 		if err != nil {
 			return err
 		}
 	}
+
 	if currentRef == nil {
 		currentRef = ref
 	}
@@ -245,42 +409,71 @@ func (r *schemaLoader) resolveRef(currentRef, ref *Ref, node, target interface{}
 		return nil
 	}
 
-	if refURL.Scheme != "" && refURL.Host != "" {
-		// most definitely take the red pill
-		data, _, _, err := r.load(refURL)
+	relativeBase := ""
+	if r.options != nil && r.options.RelativeBase != "" {
+		relativeBase = r.options.RelativeBase
+	}
+	normalizeFileRef(currentRef, relativeBase)
+	debugLog("current ref normalized file: %s", currentRef.String())
+	normalizeFileRef(ref, relativeBase)
+	debugLog("ref normalized file: %s", currentRef.String())
+
+	data, _, _, err := r.load(currentRef.GetURL())
+	if err != nil {
+		return err
+	}
+
+	if ((oldRef == nil && currentRef != nil) ||
+		(oldRef != nil && currentRef == nil) ||
+		oldRef.String() != currentRef.String()) &&
+		((oldRef == nil && ref != nil) ||
+			(oldRef != nil && ref == nil) ||
+			(oldRef.String() != ref.String())) {
+
+		return r.resolveRef(currentRef, ref, data, target)
+	}
+
+	var res interface{}
+	if currentRef.String() != "" {
+		res, _, err = currentRef.GetPointer().Get(data)
 		if err != nil {
-			return err
-		}
+			if strings.HasPrefix(ref.String(), "#") {
+				if r.loadingRef != nil {
+					rr, er := r.loadingRef.Inherits(*ref)
+					if er != nil {
+						return er
+					}
+					refURL = rr.GetURL()
 
-		if ((oldRef == nil && currentRef != nil) ||
-			(oldRef != nil && currentRef == nil) ||
-			oldRef.String() != currentRef.String()) &&
-			((oldRef == nil && ref != nil) ||
-				(oldRef != nil && ref == nil) ||
-				(oldRef.String() != ref.String())) {
+					data, _, _, err = r.load(refURL)
+					if err != nil {
+						return err
+					}
+				} else {
+					data = r.root
+				}
+			}
 
-			return r.resolveRef(currentRef, ref, data, target)
-		}
-
-		var res interface{}
-		if currentRef.String() != "" {
-			res, _, err = currentRef.GetPointer().Get(data)
+			res, _, err = ref.GetPointer().Get(data)
 			if err != nil {
 				return err
 			}
-		} else {
-			res = data
 		}
-
-		if err := swag.DynamicJSONToStruct(res, target); err != nil {
-			return err
-		}
-
+	} else {
+		res = data
 	}
+
+	if err := swag.DynamicJSONToStruct(res, target); err != nil {
+		return err
+	}
+
+	r.currentRef = currentRef
+
 	return nil
 }
 
 func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error) {
+	debugLog("loading schema from url: %s", refURL)
 	toFetch := *refURL
 	toFetch.Fragment = ""
 
@@ -299,44 +492,51 @@ func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error)
 
 	return data, toFetch, fromCache, nil
 }
-func (r *schemaLoader) Resolve(ref *Ref, target interface{}) error {
-	if err := r.resolveRef(r.currentRef, ref, r.root, target); err != nil {
-		return err
-	}
 
-	return nil
+func (r *schemaLoader) Resolve(ref *Ref, target interface{}) error {
+	return r.resolveRef(r.currentRef, ref, r.root, target)
 }
 
-type specExpander struct {
-	spec     *Swagger
-	resolver *schemaLoader
+func (r *schemaLoader) reset() {
+	ref := r.startingRef
+
+	var ptr *jsonpointer.Pointer
+	if ref != nil {
+		ptr = ref.GetPointer()
+	}
+
+	r.currentRef = nextRef(r.root, ref, ptr)
 }
 
 // ExpandSpec expands the references in a swagger spec
-func ExpandSpec(spec *Swagger) error {
-	resolver, err := defaultSchemaLoader(spec, nil, nil)
-	if err != nil {
+func ExpandSpec(spec *Swagger, options *ExpandOptions) error {
+	resolver, err := defaultSchemaLoader(spec, nil, options, nil)
+	// Just in case this ever returns an error.
+	if shouldStopOnError(err, resolver.options) {
 		return err
 	}
 
-	for key, defintition := range spec.Definitions {
-		var def *Schema
-		var err error
-		if def, err = expandSchema(defintition, []string{"#/definitions/" + key}, resolver); err != nil {
-			return err
+	if options == nil || !options.SkipSchemas {
+		for key, definition := range spec.Definitions {
+			var def *Schema
+			var err error
+			if def, err = expandSchema(definition, []string{"#/definitions/" + key}, resolver); shouldStopOnError(err, resolver.options) {
+				return err
+			}
+			resolver.reset()
+			spec.Definitions[key] = *def
 		}
-		spec.Definitions[key] = *def
 	}
 
 	for key, parameter := range spec.Parameters {
-		if err := expandParameter(&parameter, resolver); err != nil {
+		if err := expandParameter(&parameter, resolver); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		spec.Parameters[key] = parameter
 	}
 
 	for key, response := range spec.Responses {
-		if err := expandResponse(&response, resolver); err != nil {
+		if err := expandResponse(&response, resolver); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		spec.Responses[key] = response
@@ -344,7 +544,7 @@ func ExpandSpec(spec *Swagger) error {
 
 	if spec.Paths != nil {
 		for key, path := range spec.Paths.Paths {
-			if err := expandPathItem(&path, resolver); err != nil {
+			if err := expandPathItem(&path, resolver); shouldStopOnError(err, resolver.options) {
 				return err
 			}
 			spec.Paths.Paths[key] = path
@@ -354,9 +554,25 @@ func ExpandSpec(spec *Swagger) error {
 	return nil
 }
 
+func shouldStopOnError(err error, opts *ExpandOptions) bool {
+	if err != nil && !opts.ContinueOnError {
+		return true
+	}
+
+	if err != nil {
+		log.Println(err)
+	}
+
+	return false
+}
+
 // ExpandSchema expands the refs in the schema object
 func ExpandSchema(schema *Schema, root interface{}, cache ResolutionCache) error {
+	return ExpandSchemaWithBasePath(schema, root, cache, nil)
+}
 
+// ExpandSchemaWithBasePath expands the refs in the schema object, base path configured through expand options
+func ExpandSchemaWithBasePath(schema *Schema, root interface{}, cache ResolutionCache, opts *ExpandOptions) error {
 	if schema == nil {
 		return nil
 	}
@@ -367,18 +583,17 @@ func ExpandSchema(schema *Schema, root interface{}, cache ResolutionCache) error
 	nrr, _ := NewRef(schema.ID)
 	var rrr *Ref
 	if nrr.String() != "" {
-		switch root.(type) {
+		switch rt := root.(type) {
 		case *Schema:
-			rid, _ := NewRef(root.(*Schema).ID)
+			rid, _ := NewRef(rt.ID)
 			rrr, _ = rid.Inherits(nrr)
 		case *Swagger:
-			rid, _ := NewRef(root.(*Swagger).ID)
+			rid, _ := NewRef(rt.ID)
 			rrr, _ = rid.Inherits(nrr)
 		}
-
 	}
 
-	resolver, err := defaultSchemaLoader(root, rrr, cache)
+	resolver, err := defaultSchemaLoader(root, rrr, opts, cache)
 	if err != nil {
 		return err
 	}
@@ -389,7 +604,7 @@ func ExpandSchema(schema *Schema, root interface{}, cache ResolutionCache) error
 	}
 	var s *Schema
 	if s, err = expandSchema(*schema, refs, resolver); err != nil {
-		return nil
+		return err
 	}
 	*schema = *s
 	return nil
@@ -400,7 +615,15 @@ func expandItems(target Schema, parentRefs []string, resolver *schemaLoader) (*S
 		if target.Items.Schema != nil {
 			t, err := expandSchema(*target.Items.Schema, parentRefs, resolver)
 			if err != nil {
-				return nil, err
+				if target.Items.Schema.ID == "" {
+					target.Items.Schema.ID = target.ID
+					if err != nil {
+						t, err = expandSchema(*target.Items.Schema, parentRefs, resolver)
+						if err != nil {
+							return nil, err
+						}
+					}
+				}
 			}
 			*target.Items.Schema = *t
 		}
@@ -415,137 +638,173 @@ func expandItems(target Schema, parentRefs []string, resolver *schemaLoader) (*S
 	return &target, nil
 }
 
-func expandSchema(target Schema, parentRefs []string, resolver *schemaLoader) (schema *Schema, err error) {
-	defer func() {
-		schema = &target
-	}()
+func expandSchema(target Schema, parentRefs []string, resolver *schemaLoader) (*Schema, error) {
 	if target.Ref.String() == "" && target.Ref.IsRoot() {
-		target = *resolver.root.(*Schema)
-		return
+		debugLog("skipping expand schema for no ref and root: %v", resolver.root)
+
+		return resolver.root.(*Schema), nil
 	}
 
 	// t is the new expanded schema
 	var t *Schema
+
 	for target.Ref.String() != "" {
-		// var newTarget Schema
-		pRefs := strings.Join(parentRefs, ",")
-		pRefs += ","
-		if strings.Contains(pRefs, target.Ref.String()+",") {
-			err = nil
-			return
+		if swag.ContainsStringsCI(parentRefs, target.Ref.String()) {
+			return &target, nil
 		}
 
-		if err = resolver.Resolve(&target.Ref, &t); err != nil {
-			return
+		if err := resolver.Resolve(&target.Ref, &t); shouldStopOnError(err, resolver.options) {
+			return &target, err
+		}
+
+		if swag.ContainsStringsCI(parentRefs, target.Ref.String()) {
+			debugLog("ref already exists in parent")
+			return &target, nil
 		}
 		parentRefs = append(parentRefs, target.Ref.String())
+		if t != nil {
+			target = *t
+		}
+	}
+
+	t, err := expandItems(target, parentRefs, resolver)
+	if shouldStopOnError(err, resolver.options) {
+		return &target, err
+	}
+	if t != nil {
 		target = *t
 	}
 
-	if t, err = expandItems(target, parentRefs, resolver); err != nil {
-		return
-	}
-	target = *t
-
 	for i := range target.AllOf {
-		if t, err = expandSchema(target.AllOf[i], parentRefs, resolver); err != nil {
-			return
+		t, err := expandSchema(target.AllOf[i], parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
+		}
+		if t != nil {
+			target.AllOf[i] = *t
 		}
-		target.AllOf[i] = *t
 	}
 	for i := range target.AnyOf {
-		if t, err = expandSchema(target.AnyOf[i], parentRefs, resolver); err != nil {
-			return
+		t, err := expandSchema(target.AnyOf[i], parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
 		}
 		target.AnyOf[i] = *t
 	}
 	for i := range target.OneOf {
-		if t, err = expandSchema(target.OneOf[i], parentRefs, resolver); err != nil {
-			return
+		t, err := expandSchema(target.OneOf[i], parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
+		}
+		if t != nil {
+			target.OneOf[i] = *t
 		}
-		target.OneOf[i] = *t
 	}
 	if target.Not != nil {
-		if t, err = expandSchema(*target.Not, parentRefs, resolver); err != nil {
-			return
+		t, err := expandSchema(*target.Not, parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
+		}
+		if t != nil {
+			*target.Not = *t
 		}
-		*target.Not = *t
 	}
-	for k, _ := range target.Properties {
-		if t, err = expandSchema(target.Properties[k], parentRefs, resolver); err != nil {
-			return
+	for k := range target.Properties {
+		t, err := expandSchema(target.Properties[k], parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
+		}
+		if t != nil {
+			target.Properties[k] = *t
 		}
-		target.Properties[k] = *t
 	}
 	if target.AdditionalProperties != nil && target.AdditionalProperties.Schema != nil {
-		if t, err = expandSchema(*target.AdditionalProperties.Schema, parentRefs, resolver); err != nil {
-			return
+		t, err := expandSchema(*target.AdditionalProperties.Schema, parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
 		}
-		*target.AdditionalProperties.Schema = *t
-	}
-	for k, _ := range target.PatternProperties {
-		if t, err = expandSchema(target.PatternProperties[k], parentRefs, resolver); err != nil {
-			return
+		if t != nil {
+			*target.AdditionalProperties.Schema = *t
 		}
-		target.PatternProperties[k] = *t
 	}
-	for k, _ := range target.Dependencies {
+	for k := range target.PatternProperties {
+		t, err := expandSchema(target.PatternProperties[k], parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
+		}
+		if t != nil {
+			target.PatternProperties[k] = *t
+		}
+	}
+	for k := range target.Dependencies {
 		if target.Dependencies[k].Schema != nil {
-			if t, err = expandSchema(*target.Dependencies[k].Schema, parentRefs, resolver); err != nil {
-				return
+			t, err := expandSchema(*target.Dependencies[k].Schema, parentRefs, resolver)
+			if shouldStopOnError(err, resolver.options) {
+				return &target, err
+			}
+			if t != nil {
+				*target.Dependencies[k].Schema = *t
 			}
-			*target.Dependencies[k].Schema = *t
 		}
 	}
 	if target.AdditionalItems != nil && target.AdditionalItems.Schema != nil {
-		if t, err = expandSchema(*target.AdditionalItems.Schema, parentRefs, resolver); err != nil {
-			return
+		t, err := expandSchema(*target.AdditionalItems.Schema, parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
 		}
-		*target.AdditionalItems.Schema = *t
-	}
-	for k, _ := range target.Definitions {
-		if t, err = expandSchema(target.Definitions[k], parentRefs, resolver); err != nil {
-			return
+		if t != nil {
+			*target.AdditionalItems.Schema = *t
 		}
-		target.Definitions[k] = *t
 	}
-	return
+	for k := range target.Definitions {
+		t, err := expandSchema(target.Definitions[k], parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
+			return &target, err
+		}
+		if t != nil {
+			target.Definitions[k] = *t
+		}
+	}
+	return &target, nil
 }
 
 func expandPathItem(pathItem *PathItem, resolver *schemaLoader) error {
 	if pathItem == nil {
 		return nil
 	}
+
 	if pathItem.Ref.String() != "" {
 		if err := resolver.Resolve(&pathItem.Ref, &pathItem); err != nil {
 			return err
 		}
+		resolver.reset()
+		pathItem.Ref = Ref{}
 	}
 
 	for idx := range pathItem.Parameters {
-		if err := expandParameter(&(pathItem.Parameters[idx]), resolver); err != nil {
+		if err := expandParameter(&(pathItem.Parameters[idx]), resolver); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 	}
-	if err := expandOperation(pathItem.Get, resolver); err != nil {
+	if err := expandOperation(pathItem.Get, resolver); shouldStopOnError(err, resolver.options) {
 		return err
 	}
-	if err := expandOperation(pathItem.Head, resolver); err != nil {
+	if err := expandOperation(pathItem.Head, resolver); shouldStopOnError(err, resolver.options) {
 		return err
 	}
-	if err := expandOperation(pathItem.Options, resolver); err != nil {
+	if err := expandOperation(pathItem.Options, resolver); shouldStopOnError(err, resolver.options) {
 		return err
 	}
-	if err := expandOperation(pathItem.Put, resolver); err != nil {
+	if err := expandOperation(pathItem.Put, resolver); shouldStopOnError(err, resolver.options) {
 		return err
 	}
-	if err := expandOperation(pathItem.Post, resolver); err != nil {
+	if err := expandOperation(pathItem.Post, resolver); shouldStopOnError(err, resolver.options) {
 		return err
 	}
-	if err := expandOperation(pathItem.Patch, resolver); err != nil {
+	if err := expandOperation(pathItem.Patch, resolver); shouldStopOnError(err, resolver.options) {
 		return err
 	}
-	if err := expandOperation(pathItem.Delete, resolver); err != nil {
+	if err := expandOperation(pathItem.Delete, resolver); shouldStopOnError(err, resolver.options) {
 		return err
 	}
 	return nil
@@ -555,8 +814,9 @@ func expandOperation(op *Operation, resolver *schemaLoader) error {
 	if op == nil {
 		return nil
 	}
+
 	for i, param := range op.Parameters {
-		if err := expandParameter(&param, resolver); err != nil {
+		if err := expandParameter(&param, resolver); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		op.Parameters[i] = param
@@ -564,11 +824,11 @@ func expandOperation(op *Operation, resolver *schemaLoader) error {
 
 	if op.Responses != nil {
 		responses := op.Responses
-		if err := expandResponse(responses.Default, resolver); err != nil {
+		if err := expandResponse(responses.Default, resolver); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		for code, response := range responses.StatusCodeResponses {
-			if err := expandResponse(&response, resolver); err != nil {
+			if err := expandResponse(&response, resolver); shouldStopOnError(err, resolver.options) {
 				return err
 			}
 			responses.StatusCodeResponses[code] = response
@@ -582,22 +842,29 @@ func expandResponse(response *Response, resolver *schemaLoader) error {
 		return nil
 	}
 
+	var parentRefs []string
+
 	if response.Ref.String() != "" {
-		if err := resolver.Resolve(&response.Ref, response); err != nil {
+		parentRefs = append(parentRefs, response.Ref.String())
+		if err := resolver.Resolve(&response.Ref, response); shouldStopOnError(err, resolver.options) {
 			return err
 		}
+		resolver.reset()
+		response.Ref = Ref{}
 	}
 
-	if response.Schema != nil {
-		parentRefs := []string{response.Schema.Ref.String()}
-		if err := resolver.Resolve(&response.Schema.Ref, &response.Schema); err != nil {
+	if !resolver.options.SkipSchemas && response.Schema != nil {
+		parentRefs = append(parentRefs, response.Schema.Ref.String())
+		debugLog("response ref: %s", response.Schema.Ref)
+		if err := resolver.Resolve(&response.Schema.Ref, &response.Schema); shouldStopOnError(err, resolver.options) {
 			return err
 		}
-		if s, err := expandSchema(*response.Schema, parentRefs, resolver); err != nil {
+		s, err := expandSchema(*response.Schema, parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
 			return err
-		} else {
-			*response.Schema = *s
 		}
+		resolver.reset()
+		*response.Schema = *s
 	}
 	return nil
 }
@@ -606,21 +873,28 @@ func expandParameter(parameter *Parameter, resolver *schemaLoader) error {
 	if parameter == nil {
 		return nil
 	}
+
+	var parentRefs []string
+
 	if parameter.Ref.String() != "" {
-		if err := resolver.Resolve(&parameter.Ref, parameter); err != nil {
+		parentRefs = append(parentRefs, parameter.Ref.String())
+		if err := resolver.Resolve(&parameter.Ref, parameter); shouldStopOnError(err, resolver.options) {
 			return err
 		}
+		resolver.reset()
+		parameter.Ref = Ref{}
 	}
-	if parameter.Schema != nil {
-		parentRefs := []string{parameter.Schema.Ref.String()}
-		if err := resolver.Resolve(&parameter.Schema.Ref, &parameter.Schema); err != nil {
+	if !resolver.options.SkipSchemas && parameter.Schema != nil {
+		parentRefs = append(parentRefs, parameter.Schema.Ref.String())
+		if err := resolver.Resolve(&parameter.Schema.Ref, &parameter.Schema); shouldStopOnError(err, resolver.options) {
 			return err
 		}
-		if s, err := expandSchema(*parameter.Schema, parentRefs, resolver); err != nil {
+		s, err := expandSchema(*parameter.Schema, parentRefs, resolver)
+		if shouldStopOnError(err, resolver.options) {
 			return err
-		} else {
-			*parameter.Schema = *s
 		}
+		resolver.reset()
+		*parameter.Schema = *s
 	}
 	return nil
 }

vendor/github.com/go-openapi/spec/external_docs_test.go

@@ -0,0 +1,29 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"testing"
+)
+
+func TestIntegrationExternalDocs(t *testing.T) {
+	var extDocs = ExternalDocumentation{"the name", "the url"}
+	const extDocsYAML = "description: the name\nurl: the url\n"
+	const extDocsJSON = `{"description":"the name","url":"the url"}`
+	assertSerializeJSON(t, extDocs, extDocsJSON)
+	assertSerializeYAML(t, extDocs, extDocsYAML)
+	assertParsesJSON(t, extDocsJSON, extDocs)
+	assertParsesYAML(t, extDocsYAML, extDocs)
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/all-the-things.json

@@ -0,0 +1,254 @@
+{
+  "swagger": "2.0",
+  "info": {
+    "version": "1.0.0",
+    "title": "Swagger Petstore",
+    "description": "A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification",
+    "termsOfService": "http://helloreverb.com/terms/",
+    "contact": {
+      "name": "Wordnik API Team"
+    },
+    "license": {
+      "name": "MIT"
+    }
+  },
+  "host": "petstore.swagger.wordnik.com",
+  "basePath": "/api",
+  "schemes": [
+    "http"
+  ],
+  "consumes": [
+    "application/json"
+  ],
+  "produces": [
+    "application/json"
+  ],
+  "parameters": {
+    "idParam": {
+      "name": "id",
+      "in": "path",
+      "description": "ID of pet to fetch",
+      "required": true,
+      "type": "integer",
+      "format": "int64"
+    },
+    "tag": {
+      "type": "string",
+      "in": "query",
+      "required": false
+    },
+    "query": {
+      "$ref": "#/parameters/tag"
+    }
+  },
+  "responses": {
+    "petResponse": {
+      "description": "pet response",
+      "schema": {
+        "$ref": "#/definitions/pet"
+      }
+    },
+    "stringResponse": {
+      "descripion": "string response",
+      "schema": {
+        "type": "string"
+      }
+    },
+    "anotherPet": {
+      "$ref": "#/responses/petResponse"
+    }
+  },
+  "paths": {
+    "/": {
+      "get": {
+        "operationId": "indexStuff",
+        "responses": {
+          "default": {
+            "$ref": "#/responses/stringResponse"
+          },
+          "200": {
+            "$ref": "#/responses/anotherPet"
+          }
+        }
+      }
+    },
+    "/pets": {
+      "get": {
+        "description": "Returns all pets from the system that the user has access to",
+        "operationId": "findPets",
+        "produces": [
+          "application/json",
+          "application/xml",
+          "text/xml",
+          "text/html"
+        ],
+        "parameters": [
+          {
+            "name": "tags",
+            "in": "query",
+            "description": "tags to filter by",
+            "required": false,
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "collectionFormat": "csv"
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "description": "maximum number of results to return",
+            "required": false,
+            "type": "integer",
+            "format": "int32"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "pet response",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/pet"
+              }
+            }
+          },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      },
+      "post": {
+        "description": "Creates a new pet in the store.  Duplicates are allowed",
+        "operationId": "addPet",
+        "produces": [
+          "application/json"
+        ],
+        "parameters": [
+          {
+            "name": "pet",
+            "in": "body",
+            "description": "Pet to add to the store",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/petInput"
+            }
+          }
+        ],
+        "responses": {
+          "200": { "$ref": "#/responses/petResponse" },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      }
+    },
+    "/pets/{id}": {
+      "get": {
+        "description": "Returns a user based on a single ID, if the user does not have access to the pet",
+        "operationId": "findPetById",
+        "produces": [
+          "application/json",
+          "application/xml",
+          "text/xml",
+          "text/html"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/parameters/idParam"
+          }
+        ],
+        "responses": {
+          "200": {
+            "$ref": "#/responses/petResponse"
+          },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      },
+      "delete": {
+        "description": "deletes a single pet based on the ID supplied",
+        "operationId": "deletePet",
+        "parameters": [
+          {
+            "$ref": "#/parameters/idParam"
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "pet deleted"
+          },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      }
+    }
+  },
+  "definitions": {
+    "pet": {
+      "required": [
+        "id",
+        "name"
+      ],
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "name": {
+          "type": "string"
+        },
+        "tag": {
+          "type": "string"
+        }
+      }
+    },
+    "petInput": {
+      "allOf": [
+        {
+          "$ref": "#/definitions/pet"
+        },
+        {
+          "required": [
+            "name"
+          ],
+          "properties": {
+            "id": {
+              "type": "integer",
+              "format": "int64"
+            }
+          }
+        }
+      ]
+    },
+    "errorModel": {
+      "required": [
+        "code",
+        "message"
+      ],
+      "properties": {
+        "code": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "message": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/circularRefs.json

@@ -0,0 +1,54 @@
+{
+  "definitions": {
+    "brand": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+    "category": {
+      "type": "object",
+      "properties": {
+        "children": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/category"
+          }
+        }
+      }
+    },
+    "car": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "make": {
+          "type": "string"
+        },
+        "similar": {
+          "items": {
+            "$ref": "#/definitions/car"
+          }
+        },
+        "notSimilar": {
+          "additionalProperties": {
+            "$ref": "#/definitions/car"
+          }
+        },
+        "oneCar": {
+          "$ref": "#/definitions/car"
+        },
+        "category": {
+          "$ref": "#/definitions/category"
+        },
+        "brand": {
+          "$ref": "#/definitions/brand"
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/circularSpec.json

@@ -0,0 +1 @@
+{"swagger":"2.0","info":{"title":"Swagger Sample","description":"Sample API Playground.","version":"1.0.0"},"basePath":"/v1","schemes":["http"],"consumes":["application/vdn.sample.v1+json"],"produces":["application/vdn.sample.v1+json"],"paths":{"/books":{"get":{"summary":"List all books","operationId":"listBooks","tags":["books"],"responses":{"200":{"headers":{"Link":{"type":"string"}},"description":"An array of books","schema":{"type":"array","items":{"$ref":"#/definitions/Book"}}},"default":{"description":"generic error response","schema":{"$ref":"#/definitions/Error"}}}}}},"definitions":{"Book":{"type":"object","required":["title","summary"],"properties":{"title":{"type":"string","example":"Winnie the Pooh"},"summary":{"type":"string","example":"Famous children's book"},"related_books":{"type":"array","items":{"$ref":"#/definitions/Book"}}}},"Error":{"type":"object","readOnly":true,"properties":{"code":{"type":"integer","format":"int64","example":400},"message":{"type":"string","example":"Unexpected error"}},"required":["message"]}}}

vendor/github.com/go-openapi/spec/fixtures/expansion/circularSpec.yaml

@@ -0,0 +1,67 @@
+---
+swagger: "2.0"
+info:
+  title: Swagger Sample
+  description: Sample API Playground.
+  version: 1.0.0
+basePath: /v1
+schemes:
+- http
+consumes:
+- application/vdn.sample.v1+json
+produces:
+- application/vdn.sample.v1+json
+
+paths:
+  /books:
+    get:
+      summary: List all books
+      operationId: listBooks
+      tags:
+        - books
+      responses:
+        200:
+          headers:
+            Link:
+              type: string
+          description: An array of books
+          schema:
+            type: array
+            items:
+              $ref: "#/definitions/Book"
+        default:
+          description: generic error response
+          schema:
+            $ref: "#/definitions/Error"
+
+definitions:
+  Book:
+    type: object
+    required:
+      - title
+      - summary
+    properties:
+      title:
+        type: string
+        example: Winnie the Pooh
+      summary:
+        type: string
+        example: Famous children's book
+      related_books:
+        type: array
+        items:
+          $ref: "#/definitions/Book"
+
+  Error:
+    type: object
+    readOnly: true
+    properties:
+      code:
+        type: integer
+        format: int64
+        example: 400
+      message:
+        type: string
+        example: Unexpected error
+    required:
+      - message

vendor/github.com/go-openapi/spec/fixtures/expansion/invalid-refs.json

@@ -0,0 +1,85 @@
+{
+  "swagger": "2.0",
+  "info": {
+    "version": "1.0.0",
+    "title": "Swagger Petstore",
+    "contact": {
+      "name": "wordnik api team",
+      "url": "http://developer.wordnik.com"
+    },
+    "license": {
+      "name": "Creative Commons 4.0 International",
+      "url": "http://creativecommons.org/licenses/by/4.0/"
+    }
+  },
+  "host": "petstore.swagger.wordnik.com",
+  "basePath": "/api",
+  "schemes": [
+    "http"
+  ],
+  "paths": {
+    "/pets": {
+      "get": {
+        "tags": [ "Pet Operations" ],
+        "summary": "finds pets in the system",
+        "responses": {
+          "200": {
+            "description": "pet response",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "NotCorrectRef"
+              }
+            },
+            "headers": {
+              "x-expires": {
+                "type": "string"
+              }
+            }
+          },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "NotCorrectRef"
+            }
+          }
+        }
+      }
+    }
+  },
+  "definitions": {
+    "Pet": {
+      "required": [
+        "id",
+        "name"
+      ],
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "name": {
+          "type": "string"
+        },
+        "tag": {
+          "type": "string"
+        }
+      }
+    },
+    "Error": {
+      "required": [
+        "code",
+        "message"
+      ],
+      "properties": {
+        "code": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "message": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/missingItemRef.json

@@ -0,0 +1,31 @@
+{
+  "swagger": "2.0",
+  "info": {
+    "version": "2.1.0",
+    "title": "Missing Item API"
+  },
+  "host": "item.com",
+  "basePath": "/missing/ref",
+  "schemes": [
+    "http"
+  ],
+  "paths": {
+    "/employees": {
+      "get": {
+        "operationId": "LIST-Employees",
+        "summary": "List Employee Types",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/employees-output"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/missingRef.json

@@ -0,0 +1,165 @@
+{
+  "input": {
+    "swagger": "2.0",
+    "info": {
+      "version": "1.0",
+      "title": "Continue On Error"
+    },
+    "paths": {
+      "/todos": {
+        "get": {
+          "responses": {
+            "200": {
+              "description": "List Todos",
+              "schema": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/definitions/todo-full"
+                }
+              }
+            },
+            "404": {
+              "$ref": "#/responses/404"
+            }
+          }
+        }
+      }
+    },
+    "definitions": {
+      "todo-partial": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "completed": {
+            "type": "boolean"
+          }
+        }
+      },
+      "todo-full": {
+        "allOf": [
+          {
+            "$ref": "#/definitions/todo-partial"
+          },
+          {
+            "type": "object",
+            "properties": {
+              "id": {
+                "type": "integer"
+              },
+              "completed_at": {
+                "type": "string"
+              },
+              "created_at": {
+                "type": "string"
+              },
+              "updated_at": {
+                "type": "string"
+              }
+            }
+          }
+        ]
+      }
+    }
+  },
+  "expected": {
+    "swagger": "2.0",
+    "info": {
+      "title": "Continue On Error",
+      "version": "1.0"
+    },
+    "paths": {
+      "/todos": {
+        "get": {
+          "responses": {
+            "200": {
+              "description": "List Todos",
+              "schema": {
+                "type": "array",
+                "items": {
+                  "allOf": [
+                    {
+                      "type": "object",
+                      "properties": {
+                        "completed": {
+                          "type": "boolean"
+                        },
+                        "name": {
+                          "type": "string"
+                        }
+                      }
+                    },
+                    {
+                      "type": "object",
+                      "properties": {
+                        "completed_at": {
+                          "type": "string"
+                        },
+                        "created_at": {
+                          "type": "string"
+                        },
+                        "id": {
+                          "type": "integer"
+                        },
+                        "updated_at": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            },
+            "404": {}
+          }
+        }
+      }
+    },
+    "definitions": {
+      "todo-full": {
+        "allOf": [
+          {
+            "type": "object",
+            "properties": {
+              "completed": {
+                "type": "boolean"
+              },
+              "name": {
+                "type": "string"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "properties": {
+              "completed_at": {
+                "type": "string"
+              },
+              "created_at": {
+                "type": "string"
+              },
+              "id": {
+                "type": "integer"
+              },
+              "updated_at": {
+                "type": "string"
+              }
+            }
+          }
+        ]
+      },
+      "todo-partial": {
+        "type": "object",
+        "properties": {
+          "completed": {
+            "type": "boolean"
+          },
+          "name": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/overflow.json

@@ -0,0 +1,124 @@
+{
+    "swagger": "2.0",
+    "info": {
+        "title": "Swagger Sample",
+        "description": "Sample API Playground.",
+        "version": "1.0.0"
+    },
+    "basePath": "/v1",
+    "schemes": [
+        "http"
+    ],
+    "consumes": [
+        "application/vdn.sample.v1+json"
+    ],
+    "produces": [
+        "application/vdn.sample.v1+json"
+    ],
+    "paths": {
+        "/books": {
+            "get": {
+                "summary": "List all books",
+                "operationId": "listBooks",
+                "tags": [
+                    "books"
+                ],
+                "responses": {
+                    "200": {
+                        "headers": {
+                            "Link": {
+                                "type": "string"
+                            }
+                        },
+                        "description": "An array of books",
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/definitions/Book"
+                            }
+                        }
+                    },
+                    "default": {
+                        "description": "generic error response",
+                        "schema": {
+                            "$ref": "#/definitions/Error"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "definitions": {
+        "Store": {
+            "type": "object",
+            "properties": {
+                "title": {
+                    "type": "string",
+                    "example": "Book Shop"
+                },
+                "categories": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/Category"
+                    }
+                }
+            }
+        },
+        "Category": {
+            "type": "object",
+            "properties": {
+                "title": {
+                    "type": "string",
+                    "example": "Drama"
+                },
+                "books": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/Book"
+                    }
+                }
+            }
+        },
+        "Book": {
+            "type": "object",
+            "required": [
+                "title",
+                "summary"
+            ],
+            "properties": {
+                "title": {
+                    "type": "string",
+                    "example": "Winnie the Pooh"
+                },
+                "summary": {
+                    "type": "string",
+                    "example": "Famous children's book"
+                },
+                "related_books": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/Book"
+                    }
+                }
+            }
+        },
+        "Error": {
+            "type": "object",
+            "readOnly": true,
+            "properties": {
+                "code": {
+                    "type": "integer",
+                    "format": "int64",
+                    "example": 400
+                },
+                "message": {
+                    "type": "string",
+                    "example": "Unexpected error"
+                }
+            },
+            "required": [
+                "message"
+            ]
+        }
+    }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/params.json

@@ -0,0 +1,25 @@
+{
+  "parameters": {
+    "id": {
+      "type": "integer",
+      "format": "int64",
+      "in": "path",
+      "required": true
+    },
+    "tag": {
+      "type": "string",
+      "in": "query",
+      "required": false
+    },
+    "query": {
+      "$ref": "#/parameters/tag"
+    }
+  },
+  "paths": {
+    "/cars/{id}": {
+      "parameters": [
+        { "$ref": "#/parameters/id"}
+      ]
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/schemas1.json

@@ -0,0 +1,127 @@
+{
+  "definitions": {
+    "car": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "make": {
+          "type": "string"
+        },
+        "brand": {
+          "$ref": "#/definitions/brand"
+        }
+      }
+    },
+    "tag": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "value": {
+          "type": "string"
+        }
+      }
+    },
+    "brand": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+    "truck": {
+      "$ref": "#/definitions/car"
+    },
+    "batch": {
+      "items": {
+        "$ref": "#/definitions/brand"
+      }
+    },
+    "batch2": {
+      "items": [
+        {
+          "$ref": "#/definitions/brand"
+        },
+        {
+          "$ref": "#/definitions/tag"
+        }
+      ]
+    },
+    "allofBoth": {
+      "allOf": [
+        {
+          "$ref": "#/definitions/brand"
+        },
+        {
+          "$ref": "#/definitions/tag"
+        }
+      ]
+    },
+    "anyofBoth": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/brand"
+        },
+        {
+          "$ref": "#/definitions/tag"
+        }
+      ]
+    },
+    "oneofBoth": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/brand"
+        },
+        {
+          "$ref": "#/definitions/tag"
+        }
+      ]
+    },
+    "notSomething": {
+      "not": {
+        "$ref": "#/definitions/tag"
+      }
+    },
+    "withAdditional": {
+      "additionalProperties": {
+        "$ref": "#/definitions/tag"
+      }
+    },
+    "withPattern": {
+      "patternProperties": {
+        "^x-ab": {
+          "$ref": "#/definitions/tag"
+        }
+      }
+    },
+    "withAdditionalItems": {
+      "additionalItems": {
+        "$ref": "#/definitions/tag"
+      }
+    },
+    "deps": {
+      "dependencies": {
+        "something": {
+          "$ref": "#/definitions/tag"
+        }
+      }
+    },
+    "defined": {
+      "definitions": {
+        "something": {
+          "$ref": "#/definitions/tag"
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/expansion/schemas2.json

@@ -0,0 +1,161 @@
+{
+  "definitions": {
+    "car": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "make": {
+          "type": "string"
+        },
+        "brand": {
+          "items": {
+            "$ref": "#/definitions/brand"
+          }
+        }
+      }
+    },
+    "tag": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "value": {
+          "type": "string"
+        }
+      }
+    },
+    "brand": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+    "truck": {
+      "items": {
+        "$ref": "#/definitions/car"
+      }
+    },
+    "batch": {
+      "items": {
+        "items": {
+          "$ref": "#/definitions/brand"
+        }
+      }
+    },
+    "batch2": {
+      "items": [
+        {
+          "items": {
+            "$ref": "#/definitions/brand"
+          }
+        },
+        {
+          "items": {
+            "$ref": "#/definitions/tag"
+          }
+        }
+      ]
+    },
+    "allofBoth": {
+      "allOf": [
+        {
+          "items": {
+            "$ref": "#/definitions/brand"
+          }
+        },
+        {
+          "items": {
+            "$ref": "#/definitions/tag"
+          }
+        }
+      ]
+    },
+    "anyofBoth": {
+      "anyOf": [
+        {
+          "items": {
+            "$ref": "#/definitions/brand"
+          }
+        },
+        {
+          "items": {
+            "$ref": "#/definitions/tag"
+          }
+        }
+      ]
+    },
+    "oneofBoth": {
+      "oneOf": [
+        {
+          "items": {
+            "$ref": "#/definitions/brand"
+          }
+        },
+        {
+          "items": {
+            "$ref": "#/definitions/tag"
+          }
+        }
+      ]
+    },
+    "notSomething": {
+      "not": {
+        "items": {
+          "$ref": "#/definitions/tag"
+        }
+      }
+    },
+    "withAdditional": {
+      "additionalProperties": {
+        "items": {
+          "$ref": "#/definitions/tag"
+        }
+      }
+    },
+    "withPattern": {
+      "patternProperties": {
+        "^x-ab": {
+          "items": {
+            "$ref": "#/definitions/tag"
+          }
+        }
+      }
+    },
+    "withAdditionalItems": {
+      "additionalItems": {
+        "items": {
+          "$ref": "#/definitions/tag"
+        }
+      }
+    },
+    "deps": {
+      "dependencies": {
+        "something": {
+          "items": {
+            "$ref": "#/definitions/tag"
+          }
+        }
+      }
+    },
+    "defined": {
+      "definitions": {
+        "something": {
+          "items": {
+            "$ref": "#/definitions/tag"
+          }
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/local_expansion/item.json

@@ -0,0 +1,18 @@
+{
+  "properties": {
+    "id": {
+      "format": "int64",
+      "readOnly": true,
+      "type": "integer"
+    },
+    "title": {
+      "maxLength": 80,
+      "minLength": 2,
+      "type": "string"
+    }
+  },
+  "required": [
+    "title"
+  ],
+  "type": "object"
+}

vendor/github.com/go-openapi/spec/fixtures/local_expansion/spec.json

@@ -0,0 +1,46 @@
+{
+  "basePath": "/v1",
+  "consumes": [
+    "application/json"
+  ],
+  "host": "item.api.local",
+  "info": {
+    "description": "Item API",
+    "title": "Item API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/item": {
+      "get": {
+        "operationId": "GetItem",
+        "responses": {
+          "200": {
+            "description": "item detail response",
+            "schema": {
+              "$ref": "item.json"
+            }
+          }
+        }
+      }
+    }
+  },
+  "produces": [
+    "application/json"
+  ],
+  "schemes": [
+    "http"
+  ],
+  "security": [
+    {
+      "key": []
+    }
+  ],
+  "securityDefinitions": {
+    "key": {
+      "in": "header",
+      "name": "x-item-token",
+      "type": "apiKey"
+    }
+  },
+  "swagger": "2.0"
+}

vendor/github.com/go-openapi/spec/fixtures/specs/deeper/arrayProp.json

@@ -0,0 +1,6 @@
+{
+  "type":"array",
+  "items": {
+    "type": "string"
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/specs/deeper/stringProp.json

@@ -0,0 +1,3 @@
+{
+  "type": "string"
+}

vendor/github.com/go-openapi/spec/fixtures/specs/refed.json

@@ -0,0 +1,224 @@
+{
+  "swagger": "2.0",
+  "info": {
+    "version": "1.0.0",
+    "title": "Swagger Petstore",
+    "description": "A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification",
+    "termsOfService": "http://helloreverb.com/terms/",
+    "contact": {
+      "name": "Wordnik API Team"
+    },
+    "license": {
+      "name": "MIT"
+    }
+  },
+  "host": "petstore.swagger.wordnik.com",
+  "basePath": "/api",
+  "schemes": [
+    "http"
+  ],
+  "consumes": [
+    "application/json"
+  ],
+  "produces": [
+    "application/json"
+  ],
+  "parameters": {
+    "idParam": {
+      "name": "id",
+      "in": "path",
+      "description": "ID of pet to fetch",
+      "required": true,
+      "type": "integer",
+      "format": "int64"
+    }
+  },
+  "responses": {
+    "petResponse": {
+      "description": "pet response",
+      "schema": {
+        "$ref": "#/definitions/pet"
+      }
+    }
+  },
+  "paths": {
+    "/pets": {
+      "get": {
+        "description": "Returns all pets from the system that the user has access to",
+        "operationId": "findPets",
+        "produces": [
+          "application/json",
+          "application/xml",
+          "text/xml",
+          "text/html"
+        ],
+        "parameters": [
+          {
+            "name": "tags",
+            "in": "query",
+            "description": "tags to filter by",
+            "required": false,
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "collectionFormat": "csv"
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "description": "maximum number of results to return",
+            "required": false,
+            "type": "integer",
+            "format": "int32"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "pet response",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/pet"
+              }
+            }
+          },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      },
+      "post": {
+        "description": "Creates a new pet in the store.  Duplicates are allowed",
+        "operationId": "addPet",
+        "produces": [
+          "application/json"
+        ],
+        "parameters": [
+          {
+            "name": "pet",
+            "in": "body",
+            "description": "Pet to add to the store",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/petInput"
+            }
+          }
+        ],
+        "responses": {
+          "200": { "$ref": "#/responses/petResponse" },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      }
+    },
+    "/pets/{id}": {
+      "get": {
+        "description": "Returns a user based on a single ID, if the user does not have access to the pet",
+        "operationId": "findPetById",
+        "produces": [
+          "application/json",
+          "application/xml",
+          "text/xml",
+          "text/html"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/parameters/idParam"
+          }
+        ],
+        "responses": {
+          "200": {
+            "$ref": "#/responses/petResponse"
+          },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      },
+      "delete": {
+        "description": "deletes a single pet based on the ID supplied",
+        "operationId": "deletePet",
+        "parameters": [
+          {
+            "$ref": "#/parameters/idParam"
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "pet deleted"
+          },
+          "default": {
+            "description": "unexpected error",
+            "schema": {
+              "$ref": "#/definitions/errorModel"
+            }
+          }
+        }
+      }
+    }
+  },
+  "definitions": {
+    "pet": {
+      "required": [
+        "id",
+        "name"
+      ],
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "name": {
+          "type": "string"
+        },
+        "tag": {
+          "type": "string"
+        }
+      }
+    },
+    "petInput": {
+      "allOf": [
+        {
+          "$ref": "pet"
+        },
+        {
+          "required": [
+            "name"
+          ],
+          "properties": {
+            "id": {
+              "type": "integer",
+              "format": "int64"
+            }
+          }
+        }
+      ]
+    },
+    "errorModel": {
+      "required": [
+        "code",
+        "message"
+      ],
+      "properties": {
+        "code": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "message": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/specs/resolution.json

@@ -0,0 +1,14 @@
+{
+  "id": "http://localhost:1234",
+  "items": {
+    "id": "deeper/",
+    "items": {
+      "$ref": "stringProp.json"
+    }
+  },
+  "definitions": {
+    "bool": {
+      "$ref": "boolProp.json"
+    }
+  }
+}

vendor/github.com/go-openapi/spec/fixtures/specs/resolution2.json

@@ -0,0 +1,9 @@
+{
+  "id": "http://localhost:1234",
+  "items": {
+    "id": "deeper/",
+    "items": {
+      "$ref": "arrayProp.json#/items"
+    }
+  }
+}

vendor/github.com/go-openapi/spec/header.go

@@ -16,7 +16,9 @@ package spec
 
 import (
 	"encoding/json"
+	"strings"
 
+	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
 )
 
@@ -30,6 +32,7 @@ type HeaderProps struct {
 type Header struct {
 	CommonValidations
 	SimpleSchema
+	VendorExtensible
 	HeaderProps
 }
 
@@ -158,8 +161,35 @@ func (h *Header) UnmarshalJSON(data []byte) error {
 	if err := json.Unmarshal(data, &h.SimpleSchema); err != nil {
 		return err
 	}
+	if err := json.Unmarshal(data, &h.VendorExtensible); err != nil {
+		return err
+	}
 	if err := json.Unmarshal(data, &h.HeaderProps); err != nil {
 		return err
 	}
 	return nil
 }
+
+// JSONLookup look up a value by the json property name
+func (p Header) JSONLookup(token string) (interface{}, error) {
+	if ex, ok := p.Extensions[token]; ok {
+		return &ex, nil
+	}
+
+	r, _, err := jsonpointer.GetForToken(p.CommonValidations, token)
+	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
+		return nil, err
+	}
+	if r != nil {
+		return r, nil
+	}
+	r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token)
+	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
+		return nil, err
+	}
+	if r != nil {
+		return r, nil
+	}
+	r, _, err = jsonpointer.GetForToken(p.HeaderProps, token)
+	return r, err
+}

vendor/github.com/go-openapi/spec/header_test.go

@@ -0,0 +1,90 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func float64Ptr(f float64) *float64 {
+	return &f
+}
+func int64Ptr(f int64) *int64 {
+	return &f
+}
+
+var header = Header{
+	VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{
+		"x-framework": "swagger-go",
+	}},
+	HeaderProps: HeaderProps{Description: "the description of this header"},
+	SimpleSchema: SimpleSchema{
+		Items: &Items{
+			Refable: Refable{Ref: MustCreateRef("Cat")},
+		},
+		Type:    "string",
+		Format:  "date",
+		Default: "8",
+	},
+	CommonValidations: CommonValidations{
+		Maximum:          float64Ptr(100),
+		ExclusiveMaximum: true,
+		ExclusiveMinimum: true,
+		Minimum:          float64Ptr(5),
+		MaxLength:        int64Ptr(100),
+		MinLength:        int64Ptr(5),
+		Pattern:          "\\w{1,5}\\w+",
+		MaxItems:         int64Ptr(100),
+		MinItems:         int64Ptr(5),
+		UniqueItems:      true,
+		MultipleOf:       float64Ptr(5),
+		Enum:             []interface{}{"hello", "world"},
+	},
+}
+
+var headerJSON = `{
+  "items": {
+    "$ref": "Cat"
+  },
+  "x-framework": "swagger-go",
+  "description": "the description of this header",
+  "maximum": 100,
+  "minimum": 5,
+  "exclusiveMaximum": true,
+  "exclusiveMinimum": true,
+  "maxLength": 100,
+  "minLength": 5,
+  "pattern": "\\w{1,5}\\w+",
+  "maxItems": 100,
+  "minItems": 5,
+  "uniqueItems": true,
+  "multipleOf": 5,
+  "enum": ["hello", "world"],
+  "type": "string",
+  "format": "date",
+  "default": "8"
+}`
+
+func TestIntegrationHeader(t *testing.T) {
+	var actual Header
+	if assert.NoError(t, json.Unmarshal([]byte(headerJSON), &actual)) {
+		assert.EqualValues(t, actual, header)
+	}
+
+	assertParsesJSON(t, headerJSON, header)
+}

vendor/github.com/go-openapi/spec/info_test.go

@@ -0,0 +1,65 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var infoJSON = `{
+	"description": "A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification",
+	"title": "Swagger Sample API",
+	"termsOfService": "http://helloreverb.com/terms/",
+	"contact": {
+		"name": "wordnik api team",
+		"url": "http://developer.wordnik.com"
+	},
+	"license": {
+		"name": "Creative Commons 4.0 International",
+		"url": "http://creativecommons.org/licenses/by/4.0/"
+	},
+	"version": "1.0.9-abcd",
+	"x-framework": "go-swagger"
+}`
+
+var info = Info{
+	InfoProps: InfoProps{
+		Version:        "1.0.9-abcd",
+		Title:          "Swagger Sample API",
+		Description:    "A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification",
+		TermsOfService: "http://helloreverb.com/terms/",
+		Contact:        &ContactInfo{Name: "wordnik api team", URL: "http://developer.wordnik.com"},
+		License:        &License{Name: "Creative Commons 4.0 International", URL: "http://creativecommons.org/licenses/by/4.0/"},
+	},
+	VendorExtensible: VendorExtensible{map[string]interface{}{"x-framework": "go-swagger"}},
+}
+
+func TestIntegrationInfo_Serialize(t *testing.T) {
+	b, err := json.MarshalIndent(info, "", "\t")
+	if assert.NoError(t, err) {
+		assert.Equal(t, infoJSON, string(b))
+	}
+}
+
+func TestIntegrationInfo_Deserialize(t *testing.T) {
+	actual := Info{}
+	err := json.Unmarshal([]byte(infoJSON), &actual)
+	if assert.NoError(t, err) {
+		assert.EqualValues(t, info, actual)
+	}
+}

vendor/github.com/go-openapi/spec/items.go

@@ -16,7 +16,9 @@ package spec
 
 import (
 	"encoding/json"
+	"strings"
 
+	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
 )
 
@@ -60,11 +62,12 @@ type CommonValidations struct {
 // Items a limited subset of JSON-Schema's items object.
 // It is used by parameter definitions that are not located in "body".
 //
-// For more information: http://goo.gl/8us55a#items-object-
+// For more information: http://goo.gl/8us55a#items-object
 type Items struct {
 	Refable
 	CommonValidations
 	SimpleSchema
+	VendorExtensible
 }
 
 // NewItems creates a new instance of items
@@ -175,9 +178,14 @@ func (i *Items) UnmarshalJSON(data []byte) error {
 	if err := json.Unmarshal(data, &simpleSchema); err != nil {
 		return err
 	}
+	var vendorExtensible VendorExtensible
+	if err := json.Unmarshal(data, &vendorExtensible); err != nil {
+		return err
+	}
 	i.Refable = ref
 	i.CommonValidations = validations
 	i.SimpleSchema = simpleSchema
+	i.VendorExtensible = vendorExtensible
 	return nil
 }
 
@@ -195,5 +203,26 @@ func (i Items) MarshalJSON() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return swag.ConcatJSON(b3, b1, b2), nil
+	b4, err := json.Marshal(i.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b4, b3, b1, b2), nil
+}
+
+// JSONLookup look up a value by the json property name
+func (p Items) JSONLookup(token string) (interface{}, error) {
+	if token == "$ref" {
+		return &p.Ref, nil
+	}
+
+	r, _, err := jsonpointer.GetForToken(p.CommonValidations, token)
+	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
+		return nil, err
+	}
+	if r != nil {
+		return r, nil
+	}
+	r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token)
+	return r, err
 }

vendor/github.com/go-openapi/spec/items_test.go

@@ -0,0 +1,81 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var items = Items{
+	Refable: Refable{Ref: MustCreateRef("Dog")},
+	CommonValidations: CommonValidations{
+		Maximum:          float64Ptr(100),
+		ExclusiveMaximum: true,
+		ExclusiveMinimum: true,
+		Minimum:          float64Ptr(5),
+		MaxLength:        int64Ptr(100),
+		MinLength:        int64Ptr(5),
+		Pattern:          "\\w{1,5}\\w+",
+		MaxItems:         int64Ptr(100),
+		MinItems:         int64Ptr(5),
+		UniqueItems:      true,
+		MultipleOf:       float64Ptr(5),
+		Enum:             []interface{}{"hello", "world"},
+	},
+	SimpleSchema: SimpleSchema{
+		Type:   "string",
+		Format: "date",
+		Items: &Items{
+			Refable: Refable{Ref: MustCreateRef("Cat")},
+		},
+		CollectionFormat: "csv",
+		Default:          "8",
+	},
+}
+
+var itemsJSON = `{
+	"items": {
+		"$ref": "Cat"
+	},
+  "$ref": "Dog",
+  "maximum": 100,
+  "minimum": 5,
+  "exclusiveMaximum": true,
+  "exclusiveMinimum": true,
+  "maxLength": 100,
+  "minLength": 5,
+  "pattern": "\\w{1,5}\\w+",
+  "maxItems": 100,
+  "minItems": 5,
+  "uniqueItems": true,
+  "multipleOf": 5,
+  "enum": ["hello", "world"],
+  "type": "string",
+  "format": "date",
+	"collectionFormat": "csv",
+	"default": "8"
+}`
+
+func TestIntegrationItems(t *testing.T) {
+	var actual Items
+	if assert.NoError(t, json.Unmarshal([]byte(itemsJSON), &actual)) {
+		assert.EqualValues(t, actual, items)
+	}
+
+	assertParsesJSON(t, itemsJSON, items)
+}

vendor/github.com/go-openapi/spec/license_test.go

@@ -0,0 +1,28 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import "testing"
+
+func TestIntegrationLicense(t *testing.T) {
+	license := License{"the name", "the url"}
+	const licenseJSON = `{"name":"the name","url":"the url"}`
+	const licenseYAML = "name: the name\nurl: the url\n"
+
+	assertSerializeJSON(t, license, licenseJSON)
+	assertSerializeYAML(t, license, licenseYAML)
+	assertParsesJSON(t, licenseJSON, license)
+	assertParsesYAML(t, licenseYAML, license)
+}

vendor/github.com/go-openapi/spec/operation_test.go

@@ -0,0 +1,85 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var operation = Operation{
+	VendorExtensible: VendorExtensible{
+		Extensions: map[string]interface{}{
+			"x-framework": "go-swagger",
+		},
+	},
+	OperationProps: OperationProps{
+		Description: "operation description",
+		Consumes:    []string{"application/json", "application/x-yaml"},
+		Produces:    []string{"application/json", "application/x-yaml"},
+		Schemes:     []string{"http", "https"},
+		Tags:        []string{"dogs"},
+		Summary:     "the summary of the operation",
+		ID:          "sendCat",
+		Deprecated:  true,
+		Security: []map[string][]string{
+			map[string][]string{
+				"apiKey": []string{},
+			},
+		},
+		Parameters: []Parameter{
+			Parameter{Refable: Refable{Ref: MustCreateRef("Cat")}},
+		},
+		Responses: &Responses{
+			ResponsesProps: ResponsesProps{
+				Default: &Response{
+					ResponseProps: ResponseProps{
+						Description: "void response",
+					},
+				},
+			},
+		},
+	},
+}
+
+var operationJSON = `{
+	"description": "operation description",
+	"x-framework": "go-swagger",
+	"consumes": [ "application/json", "application/x-yaml" ],
+	"produces": [ "application/json", "application/x-yaml" ],
+	"schemes": ["http", "https"],
+	"tags": ["dogs"],
+	"summary": "the summary of the operation",
+	"operationId": "sendCat",
+	"deprecated": true,
+	"security": [ { "apiKey": [] } ],
+	"parameters": [{"$ref":"Cat"}],
+	"responses": {
+		"default": {
+			"description": "void response"
+		}
+	}
+}`
+
+func TestIntegrationOperation(t *testing.T) {
+	var actual Operation
+	if assert.NoError(t, json.Unmarshal([]byte(operationJSON), &actual)) {
+		assert.EqualValues(t, actual, operation)
+	}
+
+	assertParsesJSON(t, operationJSON, operation)
+}

vendor/github.com/go-openapi/spec/parameter.go

@@ -16,6 +16,7 @@ package spec
 
 import (
 	"encoding/json"
+	"strings"
 
 	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
@@ -100,15 +101,16 @@ func (p Parameter) JSONLookup(token string) (interface{}, error) {
 	if token == "$ref" {
 		return &p.Ref, nil
 	}
+
 	r, _, err := jsonpointer.GetForToken(p.CommonValidations, token)
-	if err != nil {
+	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
 		return nil, err
 	}
 	if r != nil {
 		return r, nil
 	}
 	r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token)
-	if err != nil {
+	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
 		return nil, err
 	}
 	if r != nil {

vendor/github.com/go-openapi/spec/parameters_test.go

@@ -0,0 +1,156 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var parameter = Parameter{
+	VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{
+		"x-framework": "swagger-go",
+	}},
+	Refable: Refable{Ref: MustCreateRef("Dog")},
+	CommonValidations: CommonValidations{
+		Maximum:          float64Ptr(100),
+		ExclusiveMaximum: true,
+		ExclusiveMinimum: true,
+		Minimum:          float64Ptr(5),
+		MaxLength:        int64Ptr(100),
+		MinLength:        int64Ptr(5),
+		Pattern:          "\\w{1,5}\\w+",
+		MaxItems:         int64Ptr(100),
+		MinItems:         int64Ptr(5),
+		UniqueItems:      true,
+		MultipleOf:       float64Ptr(5),
+		Enum:             []interface{}{"hello", "world"},
+	},
+	SimpleSchema: SimpleSchema{
+		Type:             "string",
+		Format:           "date",
+		CollectionFormat: "csv",
+		Items: &Items{
+			Refable: Refable{Ref: MustCreateRef("Cat")},
+		},
+		Default: "8",
+	},
+	ParamProps: ParamProps{
+		Name:        "param-name",
+		In:          "header",
+		Required:    true,
+		Schema:      &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+		Description: "the description of this parameter",
+	},
+}
+
+var parameterJSON = `{
+	"items": {
+		"$ref": "Cat"
+	},
+	"x-framework": "swagger-go",
+  "$ref": "Dog",
+  "description": "the description of this parameter",
+  "maximum": 100,
+  "minimum": 5,
+  "exclusiveMaximum": true,
+  "exclusiveMinimum": true,
+  "maxLength": 100,
+  "minLength": 5,
+  "pattern": "\\w{1,5}\\w+",
+  "maxItems": 100,
+  "minItems": 5,
+  "uniqueItems": true,
+  "multipleOf": 5,
+  "enum": ["hello", "world"],
+  "type": "string",
+  "format": "date",
+	"name": "param-name",
+	"in": "header",
+	"required": true,
+	"schema": {
+		"type": "string"
+	},
+	"collectionFormat": "csv",
+	"default": "8"
+}`
+
+func TestIntegrationParameter(t *testing.T) {
+	var actual Parameter
+	if assert.NoError(t, json.Unmarshal([]byte(parameterJSON), &actual)) {
+		assert.EqualValues(t, actual, parameter)
+	}
+
+	assertParsesJSON(t, parameterJSON, parameter)
+}
+
+func TestParameterSerialization(t *testing.T) {
+	items := &Items{
+		SimpleSchema: SimpleSchema{Type: "string"},
+	}
+
+	intItems := &Items{
+		SimpleSchema: SimpleSchema{Type: "int", Format: "int32"},
+	}
+
+	assertSerializeJSON(t, QueryParam("").Typed("string", ""), `{"type":"string","in":"query"}`)
+
+	assertSerializeJSON(t,
+		QueryParam("").CollectionOf(items, "multi"),
+		`{"type":"array","items":{"type":"string"},"collectionFormat":"multi","in":"query"}`)
+
+	assertSerializeJSON(t, PathParam("").Typed("string", ""), `{"type":"string","in":"path","required":true}`)
+
+	assertSerializeJSON(t,
+		PathParam("").CollectionOf(items, "multi"),
+		`{"type":"array","items":{"type":"string"},"collectionFormat":"multi","in":"path","required":true}`)
+
+	assertSerializeJSON(t,
+		PathParam("").CollectionOf(intItems, "multi"),
+		`{"type":"array","items":{"type":"int","format":"int32"},"collectionFormat":"multi","in":"path","required":true}`)
+
+	assertSerializeJSON(t, HeaderParam("").Typed("string", ""), `{"type":"string","in":"header","required":true}`)
+
+	assertSerializeJSON(t,
+		HeaderParam("").CollectionOf(items, "multi"),
+		`{"type":"array","items":{"type":"string"},"collectionFormat":"multi","in":"header","required":true}`)
+	schema := &Schema{SchemaProps: SchemaProps{
+		Properties: map[string]Schema{
+			"name": Schema{SchemaProps: SchemaProps{
+				Type: []string{"string"},
+			}},
+		},
+	}}
+
+	refSchema := &Schema{
+		SchemaProps: SchemaProps{Ref: MustCreateRef("Cat")},
+	}
+
+	assertSerializeJSON(t,
+		BodyParam("", schema),
+		`{"type":"object","in":"body","schema":{"properties":{"name":{"type":"string"}}}}`)
+
+	assertSerializeJSON(t,
+		BodyParam("", refSchema),
+		`{"type":"object","in":"body","schema":{"$ref":"Cat"}}`)
+
+	// array body param
+	assertSerializeJSON(t,
+		BodyParam("", ArrayProperty(RefProperty("Cat"))),
+		`{"type":"object","in":"body","schema":{"type":"array","items":{"$ref":"Cat"}}}`)
+
+}

vendor/github.com/go-openapi/spec/path_item_test.go

@@ -0,0 +1,81 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var pathItem = PathItem{
+	Refable: Refable{Ref: MustCreateRef("Dog")},
+	VendorExtensible: VendorExtensible{
+		Extensions: map[string]interface{}{
+			"x-framework": "go-swagger",
+		},
+	},
+	PathItemProps: PathItemProps{
+		Get: &Operation{
+			OperationProps: OperationProps{Description: "get operation description"},
+		},
+		Put: &Operation{
+			OperationProps: OperationProps{Description: "put operation description"},
+		},
+		Post: &Operation{
+			OperationProps: OperationProps{Description: "post operation description"},
+		},
+		Delete: &Operation{
+			OperationProps: OperationProps{Description: "delete operation description"},
+		},
+		Options: &Operation{
+			OperationProps: OperationProps{Description: "options operation description"},
+		},
+		Head: &Operation{
+			OperationProps: OperationProps{Description: "head operation description"},
+		},
+		Patch: &Operation{
+			OperationProps: OperationProps{Description: "patch operation description"},
+		},
+		Parameters: []Parameter{
+			Parameter{
+				ParamProps: ParamProps{In: "path"},
+			},
+		},
+	},
+}
+
+var pathItemJSON = `{
+	"$ref": "Dog",
+	"x-framework": "go-swagger",
+	"get": { "description": "get operation description" },
+	"put": { "description": "put operation description" },
+	"post": { "description": "post operation description" },
+	"delete": { "description": "delete operation description" },
+	"options": { "description": "options operation description" },
+	"head": { "description": "head operation description" },
+	"patch": { "description": "patch operation description" },
+	"parameters": [{"in":"path"}]
+}`
+
+func TestIntegrationPathItem(t *testing.T) {
+	var actual PathItem
+	if assert.NoError(t, json.Unmarshal([]byte(pathItemJSON), &actual)) {
+		assert.EqualValues(t, actual, pathItem)
+	}
+
+	assertParsesJSON(t, pathItemJSON, pathItem)
+}

vendor/github.com/go-openapi/spec/paths_test.go

@@ -0,0 +1,43 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var paths = Paths{
+	VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{"x-framework": "go-swagger"}},
+	Paths: map[string]PathItem{
+		"/": PathItem{
+			Refable: Refable{Ref: MustCreateRef("cats")},
+		},
+	},
+}
+
+var pathsJSON = `{"x-framework":"go-swagger","/":{"$ref":"cats"}}`
+
+func TestIntegrationPaths(t *testing.T) {
+	var actual Paths
+	if assert.NoError(t, json.Unmarshal([]byte(pathsJSON), &actual)) {
+		assert.EqualValues(t, actual, paths)
+	}
+
+	assertParsesJSON(t, pathsJSON, paths)
+
+}

vendor/github.com/go-openapi/spec/properties_test.go

@@ -0,0 +1,58 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"testing"
+)
+
+func TestPropertySerialization(t *testing.T) {
+	strProp := StringProperty()
+	strProp.Enum = append(strProp.Enum, "a", "b")
+
+	prop := &Schema{SchemaProps: SchemaProps{
+		Items: &SchemaOrArray{Schemas: []Schema{
+			Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+			Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+		}},
+	}}
+
+	var propSerData = []struct {
+		Schema *Schema
+		JSON   string
+	}{
+		{BooleanProperty(), `{"type":"boolean"}`},
+		{DateProperty(), `{"type":"string","format":"date"}`},
+		{DateTimeProperty(), `{"type":"string","format":"date-time"}`},
+		{Float64Property(), `{"type":"number","format":"double"}`},
+		{Float32Property(), `{"type":"number","format":"float"}`},
+		{Int32Property(), `{"type":"integer","format":"int32"}`},
+		{Int64Property(), `{"type":"integer","format":"int64"}`},
+		{MapProperty(StringProperty()), `{"type":"object","additionalProperties":{"type":"string"}}`},
+		{MapProperty(Int32Property()), `{"type":"object","additionalProperties":{"type":"integer","format":"int32"}}`},
+		{RefProperty("Dog"), `{"$ref":"Dog"}`},
+		{StringProperty(), `{"type":"string"}`},
+		{strProp, `{"type":"string","enum":["a","b"]}`},
+		{ArrayProperty(StringProperty()), `{"type":"array","items":{"type":"string"}}`},
+		{prop, `{"items":[{"type":"string"},{"type":"string"}]}`},
+	}
+
+	for _, v := range propSerData {
+		t.Log("roundtripping for", v.JSON)
+		assertSerializeJSON(t, v.Schema, v.JSON)
+		assertParsesJSON(t, v.JSON, v.Schema)
+	}
+
+}

vendor/github.com/go-openapi/spec/ref.go

@@ -55,7 +55,7 @@ func (r *Ref) RemoteURI() string {
 }
 
 // IsValidURI returns true when the url the ref points to can be found
-func (r *Ref) IsValidURI() bool {
+func (r *Ref) IsValidURI(basepaths ...string) bool {
 	if r.String() == "" {
 		return true
 	}
@@ -81,14 +81,18 @@ func (r *Ref) IsValidURI() bool {
 	// check for local file
 	pth := v
 	if r.HasURLPathOnly {
-		p, e := filepath.Abs(pth)
+		base := "."
+		if len(basepaths) > 0 {
+			base = filepath.Dir(filepath.Join(basepaths...))
+		}
+		p, e := filepath.Abs(filepath.ToSlash(filepath.Join(base, pth)))
 		if e != nil {
 			return false
 		}
 		pth = p
 	}
 
-	fi, err := os.Stat(pth)
+	fi, err := os.Stat(filepath.ToSlash(pth))
 	if err != nil {
 		return false
 	}
@@ -116,25 +120,18 @@ func NewRef(refURI string) (Ref, error) {
 	return Ref{Ref: ref}, nil
 }
 
-// MustCreateRef creates a ref object but
+// MustCreateRef creates a ref object but panics when refURI is invalid.
+// Use the NewRef method for a version that returns an error.
 func MustCreateRef(refURI string) Ref {
 	return Ref{Ref: jsonreference.MustCreateRef(refURI)}
 }
 
-// // NewResolvedRef creates a resolved ref
-// func NewResolvedRef(refURI string, data interface{}) Ref {
-// 	return Ref{
-// 		Ref:      jsonreference.MustCreateRef(refURI),
-// 		Resolved: data,
-// 	}
-// }
-
 // MarshalJSON marshals this ref into a JSON object
 func (r Ref) MarshalJSON() ([]byte, error) {
 	str := r.String()
 	if str == "" {
 		if r.IsRoot() {
-			return []byte(`{"$ref":"#"}`), nil
+			return []byte(`{"$ref":""}`), nil
 		}
 		return []byte("{}"), nil
 	}

vendor/github.com/go-openapi/spec/response.go

@@ -17,6 +17,7 @@ package spec
 import (
 	"encoding/json"
 
+	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
 )
 
@@ -34,6 +35,19 @@ type ResponseProps struct {
 type Response struct {
 	Refable
 	ResponseProps
+	VendorExtensible
+}
+
+// JSONLookup look up a value by the json property name
+func (p Response) JSONLookup(token string) (interface{}, error) {
+	if ex, ok := p.Extensions[token]; ok {
+		return &ex, nil
+	}
+	if token == "$ref" {
+		return &p.Ref, nil
+	}
+	r, _, err := jsonpointer.GetForToken(p.ResponseProps, token)
+	return r, err
 }
 
 // UnmarshalJSON hydrates this items instance with the data from JSON
@@ -44,6 +58,9 @@ func (r *Response) UnmarshalJSON(data []byte) error {
 	if err := json.Unmarshal(data, &r.Refable); err != nil {
 		return err
 	}
+	if err := json.Unmarshal(data, &r.VendorExtensible); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -57,7 +74,11 @@ func (r Response) MarshalJSON() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return swag.ConcatJSON(b1, b2), nil
+	b3, err := json.Marshal(r.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
 }
 
 // NewResponse creates a new response instance

vendor/github.com/go-openapi/spec/response_test.go

@@ -0,0 +1,53 @@
+// Copyright 2017 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var response = Response{
+	Refable: Refable{Ref: MustCreateRef("Dog")},
+	VendorExtensible: VendorExtensible{
+		Extensions: map[string]interface{}{
+			"x-go-name": "PutDogExists",
+		},
+	},
+	ResponseProps: ResponseProps{
+		Description: "Dog exists",
+		Schema:      &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+	},
+}
+
+var responseJSON = `{
+	"$ref": "Dog",
+	"x-go-name": "PutDogExists",
+	"description": "Dog exists",
+	"schema": {
+		"type": "string"
+	}
+}`
+
+func TestIntegrationResponse(t *testing.T) {
+	var actual Response
+	if assert.NoError(t, json.Unmarshal([]byte(responseJSON), &actual)) {
+		assert.EqualValues(t, actual, response)
+	}
+
+	assertParsesJSON(t, responseJSON, response)
+}

vendor/github.com/go-openapi/spec/responses.go

@@ -51,7 +51,7 @@ func (r Responses) JSONLookup(token string) (interface{}, error) {
 	}
 	if i, err := strconv.Atoi(token); err == nil {
 		if scr, ok := r.StatusCodeResponses[i]; ok {
-			return &scr, nil
+			return scr, nil
 		}
 	}
 	return nil, fmt.Errorf("object has no field %q", token)

vendor/github.com/go-openapi/spec/schema.go

@@ -201,8 +201,8 @@ func (r *SchemaURL) UnmarshalJSON(data []byte) error {
 
 type SchemaProps struct {
 	ID                   string            `json:"id,omitempty"`
-	Ref                  Ref               `json:"-,omitempty"`
-	Schema               SchemaURL         `json:"-,omitempty"`
+	Ref                  Ref               `json:"-"`
+	Schema               SchemaURL         `json:"-"`
 	Description          string            `json:"description,omitempty"`
 	Type                 StringOrArray     `json:"type,omitempty"`
 	Format               string            `json:"format,omitempty"`
@@ -269,7 +269,7 @@ func (s Schema) JSONLookup(token string) (interface{}, error) {
 	}
 
 	r, _, err := jsonpointer.GetForToken(s.SchemaProps, token)
-	if r != nil || err != nil {
+	if r != nil || (err != nil && !strings.HasPrefix(err.Error(), "object has no field")) {
 		return r, err
 	}
 	r, _, err = jsonpointer.GetForToken(s.SwaggerSchemaProps, token)

vendor/github.com/go-openapi/spec/schema_test.go

@@ -0,0 +1,205 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var schema = Schema{
+	VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{"x-framework": "go-swagger"}},
+	SchemaProps: SchemaProps{
+		Ref:              MustCreateRef("Cat"),
+		Type:             []string{"string"},
+		Format:           "date",
+		Description:      "the description of this schema",
+		Title:            "the title",
+		Default:          "blah",
+		Maximum:          float64Ptr(100),
+		ExclusiveMaximum: true,
+		ExclusiveMinimum: true,
+		Minimum:          float64Ptr(5),
+		MaxLength:        int64Ptr(100),
+		MinLength:        int64Ptr(5),
+		Pattern:          "\\w{1,5}\\w+",
+		MaxItems:         int64Ptr(100),
+		MinItems:         int64Ptr(5),
+		UniqueItems:      true,
+		MultipleOf:       float64Ptr(5),
+		Enum:             []interface{}{"hello", "world"},
+		MaxProperties:    int64Ptr(5),
+		MinProperties:    int64Ptr(1),
+		Required:         []string{"id", "name"},
+		Items:            &SchemaOrArray{Schema: &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}},
+		AllOf:            []Schema{Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}},
+		Properties: map[string]Schema{
+			"id":   Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int64"}},
+			"name": Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+		},
+		AdditionalProperties: &SchemaOrBool{Allows: true, Schema: &Schema{SchemaProps: SchemaProps{
+			Type:   []string{"integer"},
+			Format: "int32",
+		}}},
+	},
+	SwaggerSchemaProps: SwaggerSchemaProps{
+		Discriminator: "not this",
+		ReadOnly:      true,
+		XML:           &XMLObject{"sch", "io", "sw", true, true},
+		ExternalDocs: &ExternalDocumentation{
+			Description: "the documentation etc",
+			URL:         "http://readthedocs.org/swagger",
+		},
+		Example: []interface{}{
+			map[string]interface{}{
+				"id":   1,
+				"name": "a book",
+			},
+			map[string]interface{}{
+				"id":   2,
+				"name": "the thing",
+			},
+		},
+	},
+}
+
+var schemaJSON = `{
+	"x-framework": "go-swagger",
+  "$ref": "Cat",
+  "description": "the description of this schema",
+  "maximum": 100,
+  "minimum": 5,
+  "exclusiveMaximum": true,
+  "exclusiveMinimum": true,
+  "maxLength": 100,
+  "minLength": 5,
+  "pattern": "\\w{1,5}\\w+",
+  "maxItems": 100,
+  "minItems": 5,
+  "uniqueItems": true,
+  "multipleOf": 5,
+  "enum": ["hello", "world"],
+  "type": "string",
+  "format": "date",
+  "title": "the title",
+  "default": "blah",
+  "maxProperties": 5,
+  "minProperties": 1,
+  "required": ["id", "name"],
+  "items": {
+    "type": "string"
+  },
+  "allOf": [
+    {
+      "type": "string"
+    }
+  ],
+  "properties": {
+    "id": {
+      "type": "integer",
+      "format": "int64"
+    },
+    "name": {
+      "type": "string"
+    }
+  },
+  "discriminator": "not this",
+  "readOnly": true,
+  "xml": {
+    "name": "sch",
+    "namespace": "io",
+    "prefix": "sw",
+    "wrapped": true,
+    "attribute": true
+  },
+  "externalDocs": {
+    "description": "the documentation etc",
+    "url": "http://readthedocs.org/swagger"
+  },
+  "example": [
+    {
+      "id": 1,
+      "name": "a book"
+    },
+    {
+      "id": 2,
+      "name": "the thing"
+    }
+  ],
+  "additionalProperties": {
+    "type": "integer",
+    "format": "int32"
+  }
+}
+`
+
+func TestSchema(t *testing.T) {
+
+	expected := map[string]interface{}{}
+	json.Unmarshal([]byte(schemaJSON), &expected)
+	b, err := json.Marshal(schema)
+	if assert.NoError(t, err) {
+		var actual map[string]interface{}
+		json.Unmarshal(b, &actual)
+		assert.Equal(t, expected, actual)
+	}
+
+	actual2 := Schema{}
+	if assert.NoError(t, json.Unmarshal([]byte(schemaJSON), &actual2)) {
+		assert.Equal(t, schema.Ref, actual2.Ref)
+		assert.Equal(t, schema.Description, actual2.Description)
+		assert.Equal(t, schema.Maximum, actual2.Maximum)
+		assert.Equal(t, schema.Minimum, actual2.Minimum)
+		assert.Equal(t, schema.ExclusiveMinimum, actual2.ExclusiveMinimum)
+		assert.Equal(t, schema.ExclusiveMaximum, actual2.ExclusiveMaximum)
+		assert.Equal(t, schema.MaxLength, actual2.MaxLength)
+		assert.Equal(t, schema.MinLength, actual2.MinLength)
+		assert.Equal(t, schema.Pattern, actual2.Pattern)
+		assert.Equal(t, schema.MaxItems, actual2.MaxItems)
+		assert.Equal(t, schema.MinItems, actual2.MinItems)
+		assert.True(t, actual2.UniqueItems)
+		assert.Equal(t, schema.MultipleOf, actual2.MultipleOf)
+		assert.Equal(t, schema.Enum, actual2.Enum)
+		assert.Equal(t, schema.Type, actual2.Type)
+		assert.Equal(t, schema.Format, actual2.Format)
+		assert.Equal(t, schema.Title, actual2.Title)
+		assert.Equal(t, schema.MaxProperties, actual2.MaxProperties)
+		assert.Equal(t, schema.MinProperties, actual2.MinProperties)
+		assert.Equal(t, schema.Required, actual2.Required)
+		assert.Equal(t, schema.Items, actual2.Items)
+		assert.Equal(t, schema.AllOf, actual2.AllOf)
+		assert.Equal(t, schema.Properties, actual2.Properties)
+		assert.Equal(t, schema.Discriminator, actual2.Discriminator)
+		assert.Equal(t, schema.ReadOnly, actual2.ReadOnly)
+		assert.Equal(t, schema.XML, actual2.XML)
+		assert.Equal(t, schema.ExternalDocs, actual2.ExternalDocs)
+		assert.Equal(t, schema.AdditionalProperties, actual2.AdditionalProperties)
+		assert.Equal(t, schema.Extensions, actual2.Extensions)
+		examples := actual2.Example.([]interface{})
+		expEx := schema.Example.([]interface{})
+		ex1 := examples[0].(map[string]interface{})
+		ex2 := examples[1].(map[string]interface{})
+		exp1 := expEx[0].(map[string]interface{})
+		exp2 := expEx[1].(map[string]interface{})
+
+		assert.EqualValues(t, exp1["id"], ex1["id"])
+		assert.Equal(t, exp1["name"], ex1["name"])
+		assert.EqualValues(t, exp2["id"], ex2["id"])
+		assert.Equal(t, exp2["name"], ex2["name"])
+	}
+
+}

vendor/github.com/go-openapi/spec/schemas/jsonschema-draft-04.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

vendor/github.com/go-openapi/spec/schemas/v2/README.md

@@ -0,0 +1,5 @@
+# Swagger 2.0 specification schema
+
+This folder contains the Swagger 2.0 specification schema files maintained here:
+
+https://github.com/reverb/swagger-spec/blob/master/schemas/v2.0

vendor/github.com/go-openapi/spec/spec.go

@@ -16,6 +16,8 @@ package spec
 
 import "encoding/json"
 
+//go:generate curl -L --progress -o ./schemas/v2/schema.json http://swagger.io/v2/schema.json
+//go:generate curl -L --progress  -o ./schemas/jsonschema-draft-04.json http://json-schema.org/draft-04/schema
 //go:generate go-bindata -pkg=spec -prefix=./schemas -ignore=.*\.md ./schemas/...
 //go:generate perl -pi -e s,Json,JSON,g bindata.go
 
@@ -27,10 +29,15 @@ const (
 )
 
 var (
-	jsonSchema    = MustLoadJSONSchemaDraft04()
-	swaggerSchema = MustLoadSwagger20Schema()
+	jsonSchema    *Schema
+	swaggerSchema *Schema
 )
 
+func init() {
+	jsonSchema = MustLoadJSONSchemaDraft04()
+	swaggerSchema = MustLoadSwagger20Schema()
+}
+
 // MustLoadJSONSchemaDraft04 panics when Swagger20Schema returns an error
 func MustLoadJSONSchemaDraft04() *Schema {
 	d, e := JSONSchemaDraft04()

vendor/github.com/go-openapi/spec/structs_test.go

@@ -0,0 +1,110 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v2"
+)
+
+func assertSerializeJSON(t testing.TB, actual interface{}, expected string) bool {
+	ser, err := json.Marshal(actual)
+	if err != nil {
+		return assert.Fail(t, "unable to marshal to json (%s): %#v", err, actual)
+	}
+	return assert.Equal(t, string(ser), expected)
+}
+
+func assertParsesJSON(t testing.TB, actual string, expected interface{}) bool {
+	tpe := reflect.TypeOf(expected)
+	var pointed bool
+	if tpe.Kind() == reflect.Ptr {
+		tpe = tpe.Elem()
+		pointed = true
+	}
+
+	parsed := reflect.New(tpe)
+	err := json.Unmarshal([]byte(actual), parsed.Interface())
+	if err != nil {
+		return assert.Fail(t, "unable to unmarshal from json (%s): %s", err, actual)
+	}
+	act := parsed.Interface()
+	if !pointed {
+		act = reflect.Indirect(parsed).Interface()
+	}
+	return assert.Equal(t, act, expected)
+}
+
+func assertSerializeYAML(t testing.TB, actual interface{}, expected string) bool {
+	ser, err := yaml.Marshal(actual)
+	if err != nil {
+		return assert.Fail(t, "unable to marshal to yaml (%s): %#v", err, actual)
+	}
+	return assert.Equal(t, string(ser), expected)
+}
+
+func assertParsesYAML(t testing.TB, actual string, expected interface{}) bool {
+	tpe := reflect.TypeOf(expected)
+	var pointed bool
+	if tpe.Kind() == reflect.Ptr {
+		tpe = tpe.Elem()
+		pointed = true
+	}
+	parsed := reflect.New(tpe)
+	err := yaml.Unmarshal([]byte(actual), parsed.Interface())
+	if err != nil {
+		return assert.Fail(t, "unable to unmarshal from yaml (%s): %s", err, actual)
+	}
+	act := parsed.Interface()
+	if !pointed {
+		act = reflect.Indirect(parsed).Interface()
+	}
+	return assert.EqualValues(t, act, expected)
+}
+
+func TestSerialization_SerializeJSON(t *testing.T) {
+	assertSerializeJSON(t, []string{"hello"}, "[\"hello\"]")
+	assertSerializeJSON(t, []string{"hello", "world", "and", "stuff"}, "[\"hello\",\"world\",\"and\",\"stuff\"]")
+	assertSerializeJSON(t, StringOrArray(nil), "null")
+	assertSerializeJSON(t, SchemaOrArray{Schemas: []Schema{Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}}}, "[{\"type\":\"string\"}]")
+	assertSerializeJSON(t, SchemaOrArray{
+		Schemas: []Schema{
+			Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+			Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+		}}, "[{\"type\":\"string\"},{\"type\":\"string\"}]")
+	assertSerializeJSON(t, SchemaOrArray{}, "null")
+}
+
+func TestSerialization_DeserializeJSON(t *testing.T) {
+	// String
+	assertParsesJSON(t, "\"hello\"", StringOrArray([]string{"hello"}))
+	assertParsesJSON(t, "[\"hello\",\"world\",\"and\",\"stuff\"]", StringOrArray([]string{"hello", "world", "and", "stuff"}))
+	assertParsesJSON(t, "[\"hello\",\"world\",null,\"stuff\"]", StringOrArray([]string{"hello", "world", "", "stuff"}))
+	assertParsesJSON(t, "null", StringOrArray(nil))
+
+	// Schema
+	assertParsesJSON(t, "{\"type\":\"string\"}", SchemaOrArray{Schema: &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}})
+	assertParsesJSON(t, "[{\"type\":\"string\"},{\"type\":\"string\"}]", &SchemaOrArray{
+		Schemas: []Schema{
+			Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+			Schema{SchemaProps: SchemaProps{Type: []string{"string"}}},
+		},
+	})
+	assertParsesJSON(t, "null", SchemaOrArray{})
+}

vendor/github.com/go-openapi/spec/swagger.go

@@ -77,7 +77,7 @@ type SwaggerProps struct {
 	Host                string                 `json:"host,omitempty"`
 	BasePath            string                 `json:"basePath,omitempty"` // must start with a leading "/"
 	Paths               *Paths                 `json:"paths"`              // required
-	Definitions         Definitions            `json:"definitions"`
+	Definitions         Definitions            `json:"definitions,omitempty"`
 	Parameters          map[string]Parameter   `json:"parameters,omitempty"`
 	Responses           map[string]Response    `json:"responses,omitempty"`
 	SecurityDefinitions SecurityDefinitions    `json:"securityDefinitions,omitempty"`
@@ -156,7 +156,7 @@ func (s SchemaOrStringArray) MarshalJSON() ([]byte, error) {
 	if s.Schema != nil {
 		return json.Marshal(s.Schema)
 	}
-	return nil, nil
+	return []byte("null"), nil
 }
 
 // UnmarshalJSON converts this schema object or array from a JSON structure

vendor/github.com/go-openapi/spec/swagger_test.go

@@ -0,0 +1,365 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/go-openapi/swag"
+	"github.com/stretchr/testify/assert"
+)
+
+var spec = Swagger{
+	SwaggerProps: SwaggerProps{
+		ID:          "http://localhost:3849/api-docs",
+		Swagger:     "2.0",
+		Consumes:    []string{"application/json", "application/x-yaml"},
+		Produces:    []string{"application/json"},
+		Schemes:     []string{"http", "https"},
+		Info:        &info,
+		Host:        "some.api.out.there",
+		BasePath:    "/",
+		Paths:       &paths,
+		Definitions: map[string]Schema{"Category": {SchemaProps: SchemaProps{Type: []string{"string"}}}},
+		Parameters: map[string]Parameter{
+			"categoryParam": {ParamProps: ParamProps{Name: "category", In: "query"}, SimpleSchema: SimpleSchema{Type: "string"}},
+		},
+		Responses: map[string]Response{
+			"EmptyAnswer": {
+				ResponseProps: ResponseProps{
+					Description: "no data to return for this operation",
+				},
+			},
+		},
+		SecurityDefinitions: map[string]*SecurityScheme{
+			"internalApiKey": APIKeyAuth("api_key", "header"),
+		},
+		Security: []map[string][]string{
+			{"internalApiKey": {}},
+		},
+		Tags:         []Tag{NewTag("pets", "", nil)},
+		ExternalDocs: &ExternalDocumentation{"the name", "the url"},
+	},
+	VendorExtensible: VendorExtensible{map[string]interface{}{
+		"x-some-extension": "vendor",
+		"x-schemes":        []interface{}{"unix", "amqp"},
+	}},
+}
+
+var specJSON = `{
+	"id": "http://localhost:3849/api-docs",
+	"consumes": ["application/json", "application/x-yaml"],
+	"produces": ["application/json"],
+	"schemes": ["http", "https"],
+	"swagger": "2.0",
+	"info": {
+		"contact": {
+			"name": "wordnik api team",
+			"url": "http://developer.wordnik.com"
+		},
+		"description": "A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification",
+		"license": {
+			"name": "Creative Commons 4.0 International",
+			"url": "http://creativecommons.org/licenses/by/4.0/"
+		},
+		"termsOfService": "http://helloreverb.com/terms/",
+		"title": "Swagger Sample API",
+		"version": "1.0.9-abcd",
+		"x-framework": "go-swagger"
+	},
+	"host": "some.api.out.there",
+	"basePath": "/",
+	"paths": {"x-framework":"go-swagger","/":{"$ref":"cats"}},
+	"definitions": { "Category": { "type": "string"} },
+	"parameters": {
+		"categoryParam": {
+			"name": "category",
+			"in": "query",
+			"type": "string"
+		}
+	},
+	"responses": { "EmptyAnswer": { "description": "no data to return for this operation" } },
+	"securityDefinitions": {
+		"internalApiKey": {
+			"type": "apiKey",
+			"in": "header",
+			"name": "api_key"
+		}
+	},
+	"security": [{"internalApiKey":[]}],
+	"tags": [{"name":"pets"}],
+	"externalDocs": {"description":"the name","url":"the url"},
+	"x-some-extension": "vendor",
+	"x-schemes": ["unix","amqp"]
+}`
+
+//
+// func verifySpecSerialize(specJSON []byte, spec Swagger) {
+// 	expected := map[string]interface{}{}
+// 	json.Unmarshal(specJSON, &expected)
+// 	b, err := json.MarshalIndent(spec, "", "  ")
+// 	So(err, ShouldBeNil)
+// 	var actual map[string]interface{}
+// 	err = json.Unmarshal(b, &actual)
+// 	So(err, ShouldBeNil)
+// 	compareSpecMaps(actual, expected)
+// }
+
+func assertEquivalent(t testing.TB, actual, expected interface{}) bool {
+	if actual == nil || expected == nil || reflect.DeepEqual(actual, expected) {
+		return true
+	}
+
+	actualType := reflect.TypeOf(actual)
+	expectedType := reflect.TypeOf(expected)
+	if reflect.TypeOf(actual).ConvertibleTo(expectedType) {
+		expectedValue := reflect.ValueOf(expected)
+		if swag.IsZero(expectedValue) && swag.IsZero(reflect.ValueOf(actual)) {
+			return true
+		}
+
+		// Attempt comparison after type conversion
+		if reflect.DeepEqual(actual, expectedValue.Convert(actualType).Interface()) {
+			return true
+		}
+	}
+
+	// Last ditch effort
+	if fmt.Sprintf("%#v", expected) == fmt.Sprintf("%#v", actual) {
+		return true
+	}
+	errFmt := "Expected: '%T(%#v)'\nActual:   '%T(%#v)'\n(Should be equivalent)!"
+	return assert.Fail(t, errFmt, expected, expected, actual, actual)
+}
+
+func ShouldBeEquivalentTo(actual interface{}, expecteds ...interface{}) string {
+	expected := expecteds[0]
+	if actual == nil || expected == nil {
+		return ""
+	}
+
+	if reflect.DeepEqual(expected, actual) {
+		return ""
+	}
+
+	actualType := reflect.TypeOf(actual)
+	expectedType := reflect.TypeOf(expected)
+	if reflect.TypeOf(actual).ConvertibleTo(expectedType) {
+		expectedValue := reflect.ValueOf(expected)
+		if swag.IsZero(expectedValue) && swag.IsZero(reflect.ValueOf(actual)) {
+			return ""
+		}
+
+		// Attempt comparison after type conversion
+		if reflect.DeepEqual(actual, expectedValue.Convert(actualType).Interface()) {
+			return ""
+		}
+	}
+
+	// Last ditch effort
+	if fmt.Sprintf("%#v", expected) == fmt.Sprintf("%#v", actual) {
+		return ""
+	}
+	errFmt := "Expected: '%T(%#v)'\nActual:   '%T(%#v)'\n(Should be equivalent)!"
+	return fmt.Sprintf(errFmt, expected, expected, actual, actual)
+
+}
+
+func assertSpecMaps(t testing.TB, actual, expected map[string]interface{}) bool {
+	res := true
+	if id, ok := expected["id"]; ok {
+		res = assert.Equal(t, id, actual["id"])
+	}
+	res = res && assert.Equal(t, expected["consumes"], actual["consumes"])
+	res = res && assert.Equal(t, expected["produces"], actual["produces"])
+	res = res && assert.Equal(t, expected["schemes"], actual["schemes"])
+	res = res && assert.Equal(t, expected["swagger"], actual["swagger"])
+	res = res && assert.Equal(t, expected["info"], actual["info"])
+	res = res && assert.Equal(t, expected["host"], actual["host"])
+	res = res && assert.Equal(t, expected["basePath"], actual["basePath"])
+	res = res && assert.Equal(t, expected["paths"], actual["paths"])
+	res = res && assert.Equal(t, expected["definitions"], actual["definitions"])
+	res = res && assert.Equal(t, expected["responses"], actual["responses"])
+	res = res && assert.Equal(t, expected["securityDefinitions"], actual["securityDefinitions"])
+	res = res && assert.Equal(t, expected["tags"], actual["tags"])
+	res = res && assert.Equal(t, expected["externalDocs"], actual["externalDocs"])
+	res = res && assert.Equal(t, expected["x-some-extension"], actual["x-some-extension"])
+	res = res && assert.Equal(t, expected["x-schemes"], actual["x-schemes"])
+
+	return res
+}
+
+//
+// func compareSpecMaps(actual, expected map[string]interface{}) {
+// 	if id, ok := expected["id"]; ok {
+// 		So(actual["id"], ShouldEqual, id)
+// 	}
+// 	//So(actual["$schema"], ShouldEqual, SwaggerSchemaURL)
+// 	So(actual["consumes"], ShouldResemble, expected["consumes"])
+// 	So(actual["produces"], ShouldResemble, expected["produces"])
+// 	So(actual["schemes"], ShouldResemble, expected["schemes"])
+// 	So(actual["swagger"], ShouldEqual, expected["swagger"])
+// 	So(actual["info"], ShouldResemble, expected["info"])
+// 	So(actual["host"], ShouldEqual, expected["host"])
+// 	So(actual["basePath"], ShouldEqual, expected["basePath"])
+// 	So(actual["paths"], ShouldBeEquivalentTo, expected["paths"])
+// 	So(actual["definitions"], ShouldBeEquivalentTo, expected["definitions"])
+// 	So(actual["responses"], ShouldBeEquivalentTo, expected["responses"])
+// 	So(actual["securityDefinitions"], ShouldResemble, expected["securityDefinitions"])
+// 	So(actual["tags"], ShouldResemble, expected["tags"])
+// 	So(actual["externalDocs"], ShouldResemble, expected["externalDocs"])
+// 	So(actual["x-some-extension"], ShouldResemble, expected["x-some-extension"])
+// 	So(actual["x-schemes"], ShouldResemble, expected["x-schemes"])
+// }
+
+func assertSpecs(t testing.TB, actual, expected Swagger) bool {
+	expected.Swagger = "2.0"
+	return assert.Equal(t, actual, expected)
+}
+
+//
+// func compareSpecs(actual Swagger, spec Swagger) {
+// 	spec.Swagger = "2.0"
+// 	So(actual, ShouldBeEquivalentTo, spec)
+// }
+
+func assertSpecJSON(t testing.TB, specJSON []byte) bool {
+	var expected map[string]interface{}
+	if !assert.NoError(t, json.Unmarshal(specJSON, &expected)) {
+		return false
+	}
+
+	obj := Swagger{}
+	if !assert.NoError(t, json.Unmarshal(specJSON, &obj)) {
+		return false
+	}
+
+	cb, err := json.MarshalIndent(obj, "", "  ")
+	if assert.NoError(t, err) {
+		return false
+	}
+	var actual map[string]interface{}
+	if !assert.NoError(t, json.Unmarshal(cb, &actual)) {
+		return false
+	}
+	return assertSpecMaps(t, actual, expected)
+}
+
+// func verifySpecJSON(specJSON []byte) {
+// 	//Println()
+// 	//Println("json to verify", string(specJson))
+// 	var expected map[string]interface{}
+// 	err := json.Unmarshal(specJSON, &expected)
+// 	So(err, ShouldBeNil)
+//
+// 	obj := Swagger{}
+// 	err = json.Unmarshal(specJSON, &obj)
+// 	So(err, ShouldBeNil)
+//
+// 	//spew.Dump(obj)
+//
+// 	cb, err := json.MarshalIndent(obj, "", "  ")
+// 	So(err, ShouldBeNil)
+// 	//Println()
+// 	//Println("Marshalling to json returned", string(cb))
+//
+// 	var actual map[string]interface{}
+// 	err = json.Unmarshal(cb, &actual)
+// 	So(err, ShouldBeNil)
+// 	//Println()
+// 	//spew.Dump(expected)
+// 	//spew.Dump(actual)
+// 	//fmt.Printf("comparing %s\n\t%#v\nto\n\t%#+v\n", fileName, expected, actual)
+// 	compareSpecMaps(actual, expected)
+// }
+
+func TestSwaggerSpec_Serialize(t *testing.T) {
+	expected := make(map[string]interface{})
+	json.Unmarshal([]byte(specJSON), &expected)
+	b, err := json.MarshalIndent(spec, "", "  ")
+	if assert.NoError(t, err) {
+		var actual map[string]interface{}
+		err := json.Unmarshal(b, &actual)
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, actual, expected)
+		}
+	}
+}
+
+func TestSwaggerSpec_Deserialize(t *testing.T) {
+	var actual Swagger
+	err := json.Unmarshal([]byte(specJSON), &actual)
+	if assert.NoError(t, err) {
+		assert.EqualValues(t, actual, spec)
+	}
+}
+
+func TestVendorExtensionStringSlice(t *testing.T) {
+	var actual Swagger
+	err := json.Unmarshal([]byte(specJSON), &actual)
+	if assert.NoError(t, err) {
+		schemes, ok := actual.Extensions.GetStringSlice("x-schemes")
+		if assert.True(t, ok) {
+			assert.EqualValues(t, []string{"unix", "amqp"}, schemes)
+		}
+	}
+}
+
+func TestOptionalSwaggerProps_Serialize(t *testing.T) {
+	minimalJsonSpec := []byte(`{
+	"swagger": "2.0",
+	"info": {
+		"version": "0.0.0",
+		"title": "Simple API"
+	},
+	"paths": {
+		"/": {
+			"get": {
+				"responses": {
+					"200": {
+						"description": "OK"
+					}
+				}
+			}
+		}
+	}
+}`)
+
+	var minimalSpec Swagger
+	err := json.Unmarshal(minimalJsonSpec, &minimalSpec)
+	if assert.NoError(t, err) {
+		bytes, err := json.Marshal(&minimalSpec)
+		if assert.NoError(t, err) {
+			var ms map[string]interface{}
+			if err := json.Unmarshal(bytes, &ms); assert.NoError(t, err) {
+				assert.NotContains(t, ms, "consumes")
+				assert.NotContains(t, ms, "produces")
+				assert.NotContains(t, ms, "schemes")
+				assert.NotContains(t, ms, "host")
+				assert.NotContains(t, ms, "basePath")
+				assert.NotContains(t, ms, "definitions")
+				assert.NotContains(t, ms, "parameters")
+				assert.NotContains(t, ms, "responses")
+				assert.NotContains(t, ms, "securityDefinitions")
+				assert.NotContains(t, ms, "security")
+				assert.NotContains(t, ms, "tags")
+				assert.NotContains(t, ms, "externalDocs")
+			}
+		}
+	}
+}

vendor/github.com/go-openapi/spec/xml_object_test.go

@@ -0,0 +1,65 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestXmlObject_Serialize(t *testing.T) {
+	obj1 := XMLObject{}
+	actual, err := json.Marshal(obj1)
+	if assert.NoError(t, err) {
+		assert.Equal(t, "{}", string(actual))
+	}
+
+	obj2 := XMLObject{
+		Name:      "the name",
+		Namespace: "the namespace",
+		Prefix:    "the prefix",
+		Attribute: true,
+		Wrapped:   true,
+	}
+
+	actual, err = json.Marshal(obj2)
+	if assert.NoError(t, err) {
+		var ad map[string]interface{}
+		if assert.NoError(t, json.Unmarshal(actual, &ad)) {
+			assert.Equal(t, obj2.Name, ad["name"])
+			assert.Equal(t, obj2.Namespace, ad["namespace"])
+			assert.Equal(t, obj2.Prefix, ad["prefix"])
+			assert.True(t, ad["attribute"].(bool))
+			assert.True(t, ad["wrapped"].(bool))
+		}
+	}
+}
+
+func TestXmlObject_Deserialize(t *testing.T) {
+	expected := XMLObject{}
+	actual := XMLObject{}
+	if assert.NoError(t, json.Unmarshal([]byte("{}"), &actual)) {
+		assert.Equal(t, expected, actual)
+	}
+
+	completed := `{"name":"the name","namespace":"the namespace","prefix":"the prefix","attribute":true,"wrapped":true}`
+	expected = XMLObject{"the name", "the namespace", "the prefix", true, true}
+	actual = XMLObject{}
+	if assert.NoError(t, json.Unmarshal([]byte(completed), &actual)) {
+		assert.Equal(t, expected, actual)
+	}
+}

vendor/github.com/go-openapi/swag/.drone.yml

@@ -1,32 +0,0 @@
-clone:
-  path: github.com/go-openapi/swag
-
-matrix:
-  GO_VERSION:
-    - "1.6"
-
-build:
-  integration:
-    image: golang:$$GO_VERSION
-    pull: true
-    commands:
-      - go get -u github.com/stretchr/testify
-      - go get -u github.com/mailru/easyjson
-      - go test -race
-      - go test -v -cover -coverprofile=coverage.out -covermode=count ./...
-
-notify:
-  slack:
-    channel: bots
-    webhook_url: $$SLACK_URL
-    username: drone
-
-publish:
-  coverage:
-    server: https://coverage.vmware.run
-    token: $$GITHUB_TOKEN
-    # threshold: 70
-    # must_increase: true
-    when:
-      matrix:
-        GO_VERSION: "1.6"

vendor/github.com/go-openapi/swag/.editorconfig

@@ -0,0 +1,26 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+# Set default charset
+[*.{js,py,go,scala,rb,java,html,css,less,sass,md}]
+charset = utf-8
+
+# Tab indentation (no size specified)
+[*.go]
+indent_style = tab
+
+[*.md]
+trim_trailing_whitespace = false
+
+# Matches the exact files either package.json or .travis.yml
+[{package.json,.travis.yml}]
+indent_style = space
+indent_size = 2

vendor/github.com/go-openapi/swag/.github/CONTRIBUTING.md

@@ -0,0 +1,117 @@
+## Contribution Guidelines
+
+### Pull requests are always welcome
+
+We are always thrilled to receive pull requests, and do our best to
+process them as fast as possible. Not sure if that typo is worth a pull
+request? Do it! We will appreciate it.
+
+If your pull request is not accepted on the first try, don't be
+discouraged! If there's a problem with the implementation, hopefully you
+received feedback on what to improve.
+
+We're trying very hard to keep go-swagger lean and focused. We don't want it
+to do everything for everybody. This means that we might decide against
+incorporating a new feature. However, there might be a way to implement
+that feature *on top of* go-swagger.
+
+
+### Conventions
+
+Fork the repo and make changes on your fork in a feature branch:
+
+- If it's a bugfix branch, name it XXX-something where XXX is the number of the
+  issue
+- If it's a feature branch, create an enhancement issue to announce your
+  intentions, and name it XXX-something where XXX is the number of the issue.
+
+Submit unit tests for your changes.  Go has a great test framework built in; use
+it! Take a look at existing tests for inspiration. Run the full test suite on
+your branch before submitting a pull request.
+
+Update the documentation when creating or modifying features. Test
+your documentation changes for clarity, concision, and correctness, as
+well as a clean documentation build. See ``docs/README.md`` for more
+information on building the docs and how docs get released.
+
+Write clean code. Universally formatted code promotes ease of writing, reading,
+and maintenance. Always run `gofmt -s -w file.go` on each changed file before
+committing your changes. Most editors have plugins that do this automatically.
+
+Pull requests descriptions should be as clear as possible and include a
+reference to all the issues that they address.
+
+Pull requests must not contain commits from other users or branches.
+
+Commit messages must start with a capitalized and short summary (max. 50
+chars) written in the imperative, followed by an optional, more detailed
+explanatory text which is separated from the summary by an empty line.
+
+Code review comments may be added to your pull request. Discuss, then make the
+suggested modifications and push additional commits to your feature branch. Be
+sure to post a comment after pushing. The new commits will show up in the pull
+request automatically, but the reviewers will not be notified unless you
+comment.
+
+Before the pull request is merged, make sure that you squash your commits into
+logical units of work using `git rebase -i` and `git push -f`. After every
+commit the test suite should be passing. Include documentation changes in the
+same commit so that a revert would remove all traces of the feature or fix.
+
+Commits that fix or close an issue should include a reference like `Closes #XXX`
+or `Fixes #XXX`, which will automatically close the issue when merged.
+
+### Sign your work
+
+The sign-off is a simple line at the end of the explanation for the
+patch, which certifies that you wrote it or otherwise have the right to
+pass it on as an open-source patch.  The rules are pretty simple: if you
+can certify the below (from
+[developercertificate.org](http://developercertificate.org/)):
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+then you just add a line to every git commit message:
+
+    Signed-off-by: Joe Smith <joe@gmail.com>
+
+using your real name (sorry, no pseudonyms or anonymous contributions.)
+
+You can add the sign off when creating the git commit via `git commit -s`.

vendor/github.com/go-openapi/swag/.pullapprove.yml

@@ -1,13 +0,0 @@
-approve_by_comment: true
-approve_regex: '^(:shipit:|:\+1:|\+1|LGTM|lgtm|Approved)'
-reject_regex: ^[Rr]ejected
-reset_on_push: false
-reviewers:
-  members:
-  - casualjim
-  - chancez
-  - frapposelli
-  - vburenin
-  - pytlesk4
-  name: pullapprove
-  required: 1

vendor/github.com/go-openapi/swag/.travis.yml

@@ -0,0 +1,14 @@
+language: go
+go:
+- 1.8
+install:
+- go get -u github.com/stretchr/testify
+- go get -u github.com/mailru/easyjson
+- go get -u gopkg.in/yaml.v2
+script:
+- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./...
+after_success:
+- bash <(curl -s https://codecov.io/bash)
+notifications:
+  slack:
+    secure: QUWvCkBBK09GF7YtEvHHVt70JOkdlNBG0nIKu/5qc4/nW5HP8I2w0SEf/XR2je0eED1Qe3L/AfMCWwrEj+IUZc3l4v+ju8X8R3Lomhme0Eb0jd1MTMCuPcBT47YCj0M7RON7vXtbFfm1hFJ/jLe5+9FXz0hpXsR24PJc5ZIi/ogNwkaPqG4BmndzecpSh0vc2FJPZUD9LT0I09REY/vXR0oQAalLkW0asGD5taHZTUZq/kBpsNxaAFrLM23i4mUcf33M5fjLpvx5LRICrX/57XpBrDh2TooBU6Qj3CgoY0uPRYUmSNxbVx1czNzl2JtEpb5yjoxfVPQeg0BvQM00G8LJINISR+ohrjhkZmAqchDupAX+yFrxTtORa78CtnIL6z/aTNlgwwVD8kvL/1pFA/JWYmKDmz93mV/+6wubGzNSQCstzjkFA4/iZEKewKUoRIAi/fxyscP6L/rCpmY/4llZZvrnyTqVbt6URWpopUpH4rwYqreXAtJxJsfBJIeSmUIiDIOMGkCTvyTEW3fWGmGoqWtSHLoaWDyAIGb7azb+KvfpWtEcoPFWfSWU+LGee0A/YsUhBl7ADB9A0CJEuR8q4BPpKpfLwPKSiKSAXL7zDkyjExyhtgqbSl2jS+rKIHOZNL8JkCcTP2MKMVd563C5rC5FMKqu3S9m2b6380E=

vendor/github.com/go-openapi/swag/README.md

@@ -1,4 +1,4 @@
-# Swag [![Build Status](https://ci.vmware.run/api/badges/go-openapi/swag/status.svg)](https://ci.vmware.run/go-openapi/swag) [![Coverage](https://coverage.vmware.run/badges/go-openapi/swag/coverage.svg)](https://coverage.vmware.run/go-openapi/swag) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
+# Swag [![Build Status](https://travis-ci.org/go-openapi/swag.svg?branch=master)](https://travis-ci.org/go-openapi/swag) [![codecov](https://codecov.io/gh/go-openapi/swag/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/swag) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
 
 [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/swag/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/swag?status.svg)](http://godoc.org/github.com/go-openapi/swag)
 

vendor/github.com/go-openapi/swag/convert.go

@@ -159,7 +159,7 @@ func FormatInt16(value int16) string {
 
 // FormatInt32 turns an int32 into a string
 func FormatInt32(value int32) string {
-	return strconv.FormatInt(int64(value), 10)
+	return strconv.Itoa(int(value))
 }
 
 // FormatInt64 turns an int64 into a string

vendor/github.com/go-openapi/swag/convert_test.go

@@ -0,0 +1,215 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 swag
+
+import (
+	"math"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// These are really dumb tests
+
+func TestConvertBool(t *testing.T) {
+	for k := range evaluatesAsTrue {
+		r, err := ConvertBool(k)
+		if assert.NoError(t, err) {
+			assert.True(t, r)
+		}
+	}
+	for _, k := range []string{"a", "", "0", "false", "unchecked"} {
+		r, err := ConvertBool(k)
+		if assert.NoError(t, err) {
+			assert.False(t, r)
+		}
+	}
+}
+
+func TestConvertFloat32(t *testing.T) {
+	validFloats := []float32{1.0, -1, math.MaxFloat32, math.SmallestNonzeroFloat32, 0, 5.494430303}
+	invalidFloats := []string{"a", strconv.FormatFloat(math.MaxFloat64, 'f', -1, 64), "true"}
+
+	for _, f := range validFloats {
+		c, err := ConvertFloat32(FormatFloat32(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidFloats {
+		_, err := ConvertFloat32(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertFloat64(t *testing.T) {
+	validFloats := []float64{1.0, -1, float64(math.MaxFloat32), float64(math.SmallestNonzeroFloat32), math.MaxFloat64, math.SmallestNonzeroFloat64, 0, 5.494430303}
+	invalidFloats := []string{"a", "true"}
+
+	for _, f := range validFloats {
+		c, err := ConvertFloat64(FormatFloat64(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidFloats {
+		_, err := ConvertFloat64(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertInt8(t *testing.T) {
+	validInts := []int8{0, 1, -1, math.MaxInt8, math.MinInt8}
+	invalidInts := []string{"1.233", "a", "false", strconv.Itoa(int(math.MaxInt64))}
+
+	for _, f := range validInts {
+		c, err := ConvertInt8(FormatInt8(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidInts {
+		_, err := ConvertInt8(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertInt16(t *testing.T) {
+	validInts := []int16{0, 1, -1, math.MaxInt8, math.MinInt8, math.MaxInt16, math.MinInt16}
+	invalidInts := []string{"1.233", "a", "false", strconv.Itoa(int(math.MaxInt64))}
+
+	for _, f := range validInts {
+		c, err := ConvertInt16(FormatInt16(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidInts {
+		_, err := ConvertInt16(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertInt32(t *testing.T) {
+	validInts := []int32{0, 1, -1, math.MaxInt8, math.MinInt8, math.MaxInt16, math.MinInt16, math.MinInt32, math.MaxInt32}
+	invalidInts := []string{"1.233", "a", "false", strconv.Itoa(int(math.MaxInt64))}
+
+	for _, f := range validInts {
+		c, err := ConvertInt32(FormatInt32(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidInts {
+		_, err := ConvertInt32(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertInt64(t *testing.T) {
+	validInts := []int64{0, 1, -1, math.MaxInt8, math.MinInt8, math.MaxInt16, math.MinInt16, math.MinInt32, math.MaxInt32, math.MaxInt64, math.MinInt64}
+	invalidInts := []string{"1.233", "a", "false"}
+
+	for _, f := range validInts {
+		c, err := ConvertInt64(FormatInt64(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidInts {
+		_, err := ConvertInt64(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertUint8(t *testing.T) {
+	validInts := []uint8{0, 1, math.MaxUint8}
+	invalidInts := []string{"1.233", "a", "false", strconv.FormatUint(math.MaxUint64, 10)}
+
+	for _, f := range validInts {
+		c, err := ConvertUint8(FormatUint8(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidInts {
+		_, err := ConvertUint8(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertUint16(t *testing.T) {
+	validUints := []uint16{0, 1, math.MaxUint8, math.MaxUint16}
+	invalidUints := []string{"1.233", "a", "false", strconv.FormatUint(math.MaxUint64, 10)}
+
+	for _, f := range validUints {
+		c, err := ConvertUint16(FormatUint16(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidUints {
+		_, err := ConvertUint16(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertUint32(t *testing.T) {
+	validUints := []uint32{0, 1, math.MaxUint8, math.MaxUint16, math.MaxUint32}
+	invalidUints := []string{"1.233", "a", "false", strconv.FormatUint(math.MaxUint64, 10)}
+
+	for _, f := range validUints {
+		c, err := ConvertUint32(FormatUint32(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidUints {
+		_, err := ConvertUint32(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestConvertUint64(t *testing.T) {
+	validUints := []uint64{0, 1, math.MaxUint8, math.MaxUint16, math.MaxUint32, math.MaxUint64}
+	invalidUints := []string{"1.233", "a", "false"}
+
+	for _, f := range validUints {
+		c, err := ConvertUint64(FormatUint64(f))
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, f, c)
+		}
+	}
+	for _, f := range invalidUints {
+		_, err := ConvertUint64(f)
+		assert.Error(t, err, "expected '"+f+"' to generate an error")
+	}
+}
+
+func TestIsFloat64AJSONInteger(t *testing.T) {
+	assert.False(t, IsFloat64AJSONInteger(math.Inf(1)))
+	assert.False(t, IsFloat64AJSONInteger(maxJSONFloat+1))
+
+	assert.False(t, IsFloat64AJSONInteger(minJSONFloat-1))
+	assert.True(t, IsFloat64AJSONInteger(1.0))
+	assert.True(t, IsFloat64AJSONInteger(maxJSONFloat))
+	assert.True(t, IsFloat64AJSONInteger(minJSONFloat))
+}
+
+func TestFormatBool(t *testing.T) {
+	assert.Equal(t, "true", FormatBool(true))
+	assert.Equal(t, "false", FormatBool(false))
+}

vendor/github.com/go-openapi/swag/convert_types_test.go

@@ -0,0 +1,579 @@
+package swag
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var testCasesStringSlice = [][]string{
+	{"a", "b", "c", "d", "e"},
+	{"a", "b", "", "", "e"},
+}
+
+func TestStringSlice(t *testing.T) {
+	for idx, in := range testCasesStringSlice {
+		if in == nil {
+			continue
+		}
+		out := StringSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := StringValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesStringValueSlice = [][]*string{
+	{String("a"), String("b"), nil, String("c")},
+}
+
+func TestStringValueSlice(t *testing.T) {
+	for idx, in := range testCasesStringValueSlice {
+		if in == nil {
+			continue
+		}
+		out := StringValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := StringSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesStringMap = []map[string]string{
+	{"a": "1", "b": "2", "c": "3"},
+}
+
+func TestStringMap(t *testing.T) {
+	for idx, in := range testCasesStringMap {
+		if in == nil {
+			continue
+		}
+		out := StringMap(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := StringValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesBoolSlice = [][]bool{
+	{true, true, false, false},
+}
+
+func TestBoolSlice(t *testing.T) {
+	for idx, in := range testCasesBoolSlice {
+		if in == nil {
+			continue
+		}
+		out := BoolSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := BoolValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesBoolValueSlice = [][]*bool{}
+
+func TestBoolValueSlice(t *testing.T) {
+	for idx, in := range testCasesBoolValueSlice {
+		if in == nil {
+			continue
+		}
+		out := BoolValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := BoolSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesBoolMap = []map[string]bool{
+	{"a": true, "b": false, "c": true},
+}
+
+func TestBoolMap(t *testing.T) {
+	for idx, in := range testCasesBoolMap {
+		if in == nil {
+			continue
+		}
+		out := BoolMap(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := BoolValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesIntSlice = [][]int{
+	{1, 2, 3, 4},
+}
+
+func TestIntSlice(t *testing.T) {
+	for idx, in := range testCasesIntSlice {
+		if in == nil {
+			continue
+		}
+		out := IntSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := IntValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesIntValueSlice = [][]*int{}
+
+func TestIntValueSlice(t *testing.T) {
+	for idx, in := range testCasesIntValueSlice {
+		if in == nil {
+			continue
+		}
+		out := IntValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := IntSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesIntMap = []map[string]int{
+	{"a": 3, "b": 2, "c": 1},
+}
+
+func TestIntMap(t *testing.T) {
+	for idx, in := range testCasesIntMap {
+		if in == nil {
+			continue
+		}
+		out := IntMap(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := IntValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesInt64Slice = [][]int64{
+	{1, 2, 3, 4},
+}
+
+func TestInt64Slice(t *testing.T) {
+	for idx, in := range testCasesInt64Slice {
+		if in == nil {
+			continue
+		}
+		out := Int64Slice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := Int64ValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesInt64ValueSlice = [][]*int64{}
+
+func TestInt64ValueSlice(t *testing.T) {
+	for idx, in := range testCasesInt64ValueSlice {
+		if in == nil {
+			continue
+		}
+		out := Int64ValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := Int64Slice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesInt64Map = []map[string]int64{
+	{"a": 3, "b": 2, "c": 1},
+}
+
+func TestInt64Map(t *testing.T) {
+	for idx, in := range testCasesInt64Map {
+		if in == nil {
+			continue
+		}
+		out := Int64Map(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := Int64ValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesFloat64Slice = [][]float64{
+	{1, 2, 3, 4},
+}
+
+func TestFloat64Slice(t *testing.T) {
+	for idx, in := range testCasesFloat64Slice {
+		if in == nil {
+			continue
+		}
+		out := Float64Slice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := Float64ValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesUintSlice = [][]uint{
+	{1, 2, 3, 4},
+}
+
+func TestUintSlice(t *testing.T) {
+	for idx, in := range testCasesUintSlice {
+		if in == nil {
+			continue
+		}
+		out := UintSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := UintValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesUintValueSlice = [][]*uint{}
+
+func TestUintValueSlice(t *testing.T) {
+	for idx, in := range testCasesUintValueSlice {
+		if in == nil {
+			continue
+		}
+		out := UintValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := UintSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesUintMap = []map[string]uint{
+	{"a": 3, "b": 2, "c": 1},
+}
+
+func TestUintMap(t *testing.T) {
+	for idx, in := range testCasesUintMap {
+		if in == nil {
+			continue
+		}
+		out := UintMap(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := UintValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesUint64Slice = [][]uint64{
+	{1, 2, 3, 4},
+}
+
+func TestUint64Slice(t *testing.T) {
+	for idx, in := range testCasesUint64Slice {
+		if in == nil {
+			continue
+		}
+		out := Uint64Slice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := Uint64ValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesUint64ValueSlice = [][]*uint64{}
+
+func TestUint64ValueSlice(t *testing.T) {
+	for idx, in := range testCasesUint64ValueSlice {
+		if in == nil {
+			continue
+		}
+		out := Uint64ValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := Uint64Slice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesUint64Map = []map[string]uint64{
+	{"a": 3, "b": 2, "c": 1},
+}
+
+func TestUint64Map(t *testing.T) {
+	for idx, in := range testCasesUint64Map {
+		if in == nil {
+			continue
+		}
+		out := Uint64Map(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := Uint64ValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesFloat64ValueSlice = [][]*float64{}
+
+func TestFloat64ValueSlice(t *testing.T) {
+	for idx, in := range testCasesFloat64ValueSlice {
+		if in == nil {
+			continue
+		}
+		out := Float64ValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := Float64Slice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesFloat64Map = []map[string]float64{
+	{"a": 3, "b": 2, "c": 1},
+}
+
+func TestFloat64Map(t *testing.T) {
+	for idx, in := range testCasesFloat64Map {
+		if in == nil {
+			continue
+		}
+		out := Float64Map(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := Float64ValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesTimeSlice = [][]time.Time{
+	{time.Now(), time.Now().AddDate(100, 0, 0)},
+}
+
+func TestTimeSlice(t *testing.T) {
+	for idx, in := range testCasesTimeSlice {
+		if in == nil {
+			continue
+		}
+		out := TimeSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := TimeValueSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}
+
+var testCasesTimeValueSlice = [][]*time.Time{}
+
+func TestTimeValueSlice(t *testing.T) {
+	for idx, in := range testCasesTimeValueSlice {
+		if in == nil {
+			continue
+		}
+		out := TimeValueSlice(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			if in[i] == nil {
+				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
+			}
+		}
+
+		out2 := TimeSlice(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		for i := range out2 {
+			if in[i] == nil {
+				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
+			} else {
+				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
+			}
+		}
+	}
+}
+
+var testCasesTimeMap = []map[string]time.Time{
+	{"a": time.Now().AddDate(-100, 0, 0), "b": time.Now()},
+}
+
+func TestTimeMap(t *testing.T) {
+	for idx, in := range testCasesTimeMap {
+		if in == nil {
+			continue
+		}
+		out := TimeMap(in)
+		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
+		for i := range out {
+			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
+		}
+
+		out2 := TimeValueMap(out)
+		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
+		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
+	}
+}

vendor/github.com/go-openapi/swag/json.go

@@ -17,6 +17,7 @@ package swag
 import (
 	"bytes"
 	"encoding/json"
+	"log"
 	"reflect"
 	"strings"
 	"sync"
@@ -110,28 +111,40 @@ func ConcatJSON(blobs ...[]byte) []byte {
 
 		if len(b) < 3 { // yep empty but also the last one, so closing this thing
 			if i == last && a > 0 {
-				buf.WriteByte(closing)
+				if err := buf.WriteByte(closing); err != nil {
+					log.Println(err)
+				}
 			}
 			continue
 		}
 
 		idx = 0
 		if a > 0 { // we need to join with a comma for everything beyond the first non-empty item
-			buf.WriteByte(comma)
+			if err := buf.WriteByte(comma); err != nil {
+				log.Println(err)
+			}
 			idx = 1 // this is not the first or the last so we want to drop the leading bracket
 		}
 
 		if i != last { // not the last one, strip brackets
-			buf.Write(b[idx : len(b)-1])
+			if _, err := buf.Write(b[idx : len(b)-1]); err != nil {
+				log.Println(err)
+			}
 		} else { // last one, strip only the leading bracket
-			buf.Write(b[idx:])
+			if _, err := buf.Write(b[idx:]); err != nil {
+				log.Println(err)
+			}
 		}
 		a++
 	}
 	// somehow it ended up being empty, so provide a default value
 	if buf.Len() == 0 {
-		buf.WriteByte(opening)
-		buf.WriteByte(closing)
+		if err := buf.WriteByte(opening); err != nil {
+			log.Println(err)
+		}
+		if err := buf.WriteByte(closing); err != nil {
+			log.Println(err)
+		}
 	}
 	return buf.Bytes()
 }
@@ -139,15 +152,23 @@ func ConcatJSON(blobs ...[]byte) []byte {
 // ToDynamicJSON turns an object into a properly JSON typed structure
 func ToDynamicJSON(data interface{}) interface{} {
 	// TODO: convert straight to a json typed map (mergo + iterate?)
-	b, _ := json.Marshal(data)
+	b, err := json.Marshal(data)
+	if err != nil {
+		log.Println(err)
+	}
 	var res interface{}
-	json.Unmarshal(b, &res)
+	if err := json.Unmarshal(b, &res); err != nil {
+		log.Println(err)
+	}
 	return res
 }
 
 // FromDynamicJSON turns an object into a properly JSON typed structure
 func FromDynamicJSON(data, target interface{}) error {
-	b, _ := json.Marshal(data)
+	b, err := json.Marshal(data)
+	if err != nil {
+		log.Println(err)
+	}
 	return json.Unmarshal(b, target)
 }
 
@@ -216,6 +237,8 @@ func newNameIndex(tpe reflect.Type) nameIndex {
 
 // GetJSONNames gets all the json property names for a type
 func (n *NameProvider) GetJSONNames(subject interface{}) []string {
+	n.lock.Lock()
+	defer n.lock.Unlock()
 	tpe := reflect.Indirect(reflect.ValueOf(subject)).Type()
 	names, ok := n.index[tpe]
 	if !ok {
@@ -237,6 +260,8 @@ func (n *NameProvider) GetJSONName(subject interface{}, name string) (string, bo
 
 // GetJSONNameForType gets the json name for a go property name on a given type
 func (n *NameProvider) GetJSONNameForType(tpe reflect.Type, name string) (string, bool) {
+	n.lock.Lock()
+	defer n.lock.Unlock()
 	names, ok := n.index[tpe]
 	if !ok {
 		names = n.makeNameIndex(tpe)
@@ -246,8 +271,6 @@ func (n *NameProvider) GetJSONNameForType(tpe reflect.Type, name string) (string
 }
 
 func (n *NameProvider) makeNameIndex(tpe reflect.Type) nameIndex {
-	n.lock.Lock()
-	defer n.lock.Unlock()
 	names := newNameIndex(tpe)
 	n.index[tpe] = names
 	return names
@@ -261,6 +284,8 @@ func (n *NameProvider) GetGoName(subject interface{}, name string) (string, bool
 
 // GetGoNameForType gets the go name for a given type for a json property name
 func (n *NameProvider) GetGoNameForType(tpe reflect.Type, name string) (string, bool) {
+	n.lock.Lock()
+	defer n.lock.Unlock()
 	names, ok := n.index[tpe]
 	if !ok {
 		names = n.makeNameIndex(tpe)

vendor/github.com/go-openapi/swag/json_test.go

@@ -0,0 +1,163 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 swag
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type testNameStruct struct {
+	Name       string `json:"name"`
+	NotTheSame int64  `json:"plain"`
+	Ignored    string `json:"-"`
+}
+
+func TestNameProvider(t *testing.T) {
+
+	provider := NewNameProvider()
+
+	var obj = testNameStruct{}
+
+	nm, ok := provider.GetGoName(obj, "name")
+	assert.True(t, ok)
+	assert.Equal(t, "Name", nm)
+
+	nm, ok = provider.GetGoName(obj, "plain")
+	assert.True(t, ok)
+	assert.Equal(t, "NotTheSame", nm)
+
+	nm, ok = provider.GetGoName(obj, "doesNotExist")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetGoName(obj, "ignored")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	tpe := reflect.TypeOf(obj)
+	nm, ok = provider.GetGoNameForType(tpe, "name")
+	assert.True(t, ok)
+	assert.Equal(t, "Name", nm)
+
+	nm, ok = provider.GetGoNameForType(tpe, "plain")
+	assert.True(t, ok)
+	assert.Equal(t, "NotTheSame", nm)
+
+	nm, ok = provider.GetGoNameForType(tpe, "doesNotExist")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetGoNameForType(tpe, "ignored")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	ptr := &obj
+	nm, ok = provider.GetGoName(ptr, "name")
+	assert.True(t, ok)
+	assert.Equal(t, "Name", nm)
+
+	nm, ok = provider.GetGoName(ptr, "plain")
+	assert.True(t, ok)
+	assert.Equal(t, "NotTheSame", nm)
+
+	nm, ok = provider.GetGoName(ptr, "doesNotExist")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetGoName(ptr, "ignored")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetJSONName(obj, "Name")
+	assert.True(t, ok)
+	assert.Equal(t, "name", nm)
+
+	nm, ok = provider.GetJSONName(obj, "NotTheSame")
+	assert.True(t, ok)
+	assert.Equal(t, "plain", nm)
+
+	nm, ok = provider.GetJSONName(obj, "DoesNotExist")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetJSONName(obj, "Ignored")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetJSONNameForType(tpe, "Name")
+	assert.True(t, ok)
+	assert.Equal(t, "name", nm)
+
+	nm, ok = provider.GetJSONNameForType(tpe, "NotTheSame")
+	assert.True(t, ok)
+	assert.Equal(t, "plain", nm)
+
+	nm, ok = provider.GetJSONNameForType(tpe, "doesNotExist")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetJSONNameForType(tpe, "Ignored")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetJSONName(ptr, "Name")
+	assert.True(t, ok)
+	assert.Equal(t, "name", nm)
+
+	nm, ok = provider.GetJSONName(ptr, "NotTheSame")
+	assert.True(t, ok)
+	assert.Equal(t, "plain", nm)
+
+	nm, ok = provider.GetJSONName(ptr, "doesNotExist")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nm, ok = provider.GetJSONName(ptr, "Ignored")
+	assert.False(t, ok)
+	assert.Empty(t, nm)
+
+	nms := provider.GetJSONNames(ptr)
+	assert.Len(t, nms, 2)
+
+	assert.Len(t, provider.index, 1)
+
+}
+
+func TestJSONConcatenation(t *testing.T) {
+	assert.Nil(t, ConcatJSON())
+	assert.Equal(t, ConcatJSON([]byte(`{"id":1}`)), []byte(`{"id":1}`))
+	assert.Equal(t, ConcatJSON([]byte(`{}`), []byte(`{}`)), []byte(`{}`))
+	assert.Equal(t, ConcatJSON([]byte(`[]`), []byte(`[]`)), []byte(`[]`))
+	assert.Equal(t, ConcatJSON([]byte(`{"id":1}`), []byte(`{"name":"Rachel"}`)), []byte(`{"id":1,"name":"Rachel"}`))
+	assert.Equal(t, ConcatJSON([]byte(`[{"id":1}]`), []byte(`[{"name":"Rachel"}]`)), []byte(`[{"id":1},{"name":"Rachel"}]`))
+	assert.Equal(t, ConcatJSON([]byte(`{}`), []byte(`{"name":"Rachel"}`)), []byte(`{"name":"Rachel"}`))
+	assert.Equal(t, ConcatJSON([]byte(`[]`), []byte(`[{"name":"Rachel"}]`)), []byte(`[{"name":"Rachel"}]`))
+	assert.Equal(t, ConcatJSON([]byte(`{"id":1}`), []byte(`{}`)), []byte(`{"id":1}`))
+	assert.Equal(t, ConcatJSON([]byte(`[{"id":1}]`), []byte(`[]`)), []byte(`[{"id":1}]`))
+	assert.Equal(t, ConcatJSON([]byte(`{}`), []byte(`{}`), []byte(`{}`)), []byte(`{}`))
+	assert.Equal(t, ConcatJSON([]byte(`[]`), []byte(`[]`), []byte(`[]`)), []byte(`[]`))
+	assert.Equal(t, ConcatJSON([]byte(`{"id":1}`), []byte(`{"name":"Rachel"}`), []byte(`{"age":32}`)), []byte(`{"id":1,"name":"Rachel","age":32}`))
+	assert.Equal(t, ConcatJSON([]byte(`[{"id":1}]`), []byte(`[{"name":"Rachel"}]`), []byte(`[{"age":32}]`)), []byte(`[{"id":1},{"name":"Rachel"},{"age":32}]`))
+	assert.Equal(t, ConcatJSON([]byte(`{}`), []byte(`{"name":"Rachel"}`), []byte(`{"age":32}`)), []byte(`{"name":"Rachel","age":32}`))
+	assert.Equal(t, ConcatJSON([]byte(`[]`), []byte(`[{"name":"Rachel"}]`), []byte(`[{"age":32}]`)), []byte(`[{"name":"Rachel"},{"age":32}]`))
+	assert.Equal(t, ConcatJSON([]byte(`{"id":1}`), []byte(`{}`), []byte(`{"age":32}`)), []byte(`{"id":1,"age":32}`))
+	assert.Equal(t, ConcatJSON([]byte(`[{"id":1}]`), []byte(`[]`), []byte(`[{"age":32}]`)), []byte(`[{"id":1},{"age":32}]`))
+	assert.Equal(t, ConcatJSON([]byte(`{"id":1}`), []byte(`{"name":"Rachel"}`), []byte(`{}`)), []byte(`{"id":1,"name":"Rachel"}`))
+	assert.Equal(t, ConcatJSON([]byte(`[{"id":1}]`), []byte(`[{"name":"Rachel"}]`), []byte(`[]`)), []byte(`[{"id":1},{"name":"Rachel"}]`))
+
+}

vendor/github.com/go-openapi/swag/loading.go

@@ -17,13 +17,25 @@ package swag
 import (
 	"fmt"
 	"io/ioutil"
+	"log"
 	"net/http"
+	"path/filepath"
 	"strings"
+	"time"
 )
 
+// LoadHTTPTimeout the default timeout for load requests
+var LoadHTTPTimeout = 30 * time.Second
+
 // LoadFromFileOrHTTP loads the bytes from a file or a remote http server based on the path passed in
 func LoadFromFileOrHTTP(path string) ([]byte, error) {
-	return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes)(path)
+	return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes(LoadHTTPTimeout))(path)
+}
+
+// LoadFromFileOrHTTPWithTimeout loads the bytes from a file or a remote http server based on the path passed in
+// timeout arg allows for per request overriding of the request timeout
+func LoadFromFileOrHTTPWithTimeout(path string, timeout time.Duration) ([]byte, error) {
+	return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes(timeout))(path)
 }
 
 // LoadStrategy returns a loader function for a given path or uri
@@ -31,19 +43,32 @@ func LoadStrategy(path string, local, remote func(string) ([]byte, error)) func(
 	if strings.HasPrefix(path, "http") {
 		return remote
 	}
-	return local
+	return func(pth string) ([]byte, error) { return local(filepath.FromSlash(pth)) }
 }
 
-func loadHTTPBytes(path string) ([]byte, error) {
-	resp, err := http.Get(path)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
+func loadHTTPBytes(timeout time.Duration) func(path string) ([]byte, error) {
+	return func(path string) ([]byte, error) {
+		client := &http.Client{Timeout: timeout}
+		req, err := http.NewRequest("GET", path, nil)
+		if err != nil {
+			return nil, err
+		}
+		resp, err := client.Do(req)
+		defer func() {
+			if resp != nil {
+				if e := resp.Body.Close(); e != nil {
+					log.Println(e)
+				}
+			}
+		}()
+		if err != nil {
+			return nil, err
+		}
 
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("could not access document at %q [%s] ", path, resp.Status)
-	}
+		if resp.StatusCode != http.StatusOK {
+			return nil, fmt.Errorf("could not access document at %q [%s] ", path, resp.Status)
+		}
 
-	return ioutil.ReadAll(resp.Body)
+		return ioutil.ReadAll(resp.Body)
+	}
 }

vendor/github.com/go-openapi/swag/loading_test.go

@@ -0,0 +1,47 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 swag
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLoadFromHTTP(t *testing.T) {
+
+	_, err := LoadFromFileOrHTTP("httx://12394:abd")
+	assert.Error(t, err)
+
+	serv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.WriteHeader(http.StatusNotFound)
+	}))
+	defer serv.Close()
+
+	_, err = LoadFromFileOrHTTP(serv.URL)
+	assert.Error(t, err)
+
+	ts2 := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.WriteHeader(http.StatusOK)
+		rw.Write([]byte("the content"))
+	}))
+	defer ts2.Close()
+
+	d, err := LoadFromFileOrHTTP(ts2.URL)
+	assert.NoError(t, err)
+	assert.Equal(t, []byte("the content"), d)
+}

vendor/github.com/go-openapi/swag/net_test.go

@@ -0,0 +1,30 @@
+package swag
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSplitHostPort(t *testing.T) {
+	data := []struct {
+		Input string
+		Host  string
+		Port  int
+		Err   bool
+	}{
+		{"localhost:3933", "localhost", 3933, false},
+		{"localhost:yellow", "", -1, true},
+		{"localhost", "", -1, true},
+		{"localhost:", "", -1, true},
+		{"localhost:3933", "localhost", 3933, false},
+	}
+
+	for _, e := range data {
+		h, p, err := SplitHostPort(e.Input)
+		if (!e.Err && assert.NoError(t, err)) || (e.Err && assert.Error(t, err)) {
+			assert.Equal(t, e.Host, h)
+			assert.Equal(t, e.Port, p)
+		}
+	}
+}

vendor/github.com/go-openapi/swag/path.go

@@ -47,6 +47,9 @@ func FindInGoSearchPath(pkg string) string {
 // FullGoSearchPath gets the search paths for finding packages
 func FullGoSearchPath() string {
 	allPaths := os.Getenv(GOPATHKey)
+	if allPaths == "" {
+		allPaths = filepath.Join(os.Getenv("HOME"), "go")
+	}
 	if allPaths != "" {
 		allPaths = strings.Join([]string{allPaths, runtime.GOROOT()}, ":")
 	} else {

vendor/github.com/go-openapi/swag/path_test.go

@@ -0,0 +1,118 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 swag
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func makeDirStructure(t *testing.T, tgt string) (string, string, error) {
+	if tgt == "" {
+		tgt = "pkgpaths"
+	}
+	td, err := ioutil.TempDir("", tgt)
+	if err != nil {
+		return "", "", err
+	}
+	td2, err := ioutil.TempDir("", tgt+"-2")
+	if err != nil {
+		return "", "", err
+	}
+	realPath := filepath.Join(td, "src", "foo", "bar")
+	if err := os.MkdirAll(realPath, os.ModePerm); err != nil {
+		return "", "", err
+	}
+	linkPathBase := filepath.Join(td, "src", "baz")
+	if err := os.MkdirAll(linkPathBase, os.ModePerm); err != nil {
+		return "", "", err
+	}
+	linkPath := filepath.Join(linkPathBase, "das")
+	if err := os.Symlink(realPath, linkPath); err != nil {
+		return "", "", err
+	}
+
+	realPath = filepath.Join(td2, "src", "fuu", "bir")
+	if err := os.MkdirAll(realPath, os.ModePerm); err != nil {
+		return "", "", err
+	}
+	linkPathBase = filepath.Join(td2, "src", "biz")
+	if err := os.MkdirAll(linkPathBase, os.ModePerm); err != nil {
+		return "", "", err
+	}
+	linkPath = filepath.Join(linkPathBase, "dis")
+	if err := os.Symlink(realPath, linkPath); err != nil {
+		return "", "", err
+	}
+	return td, td2, nil
+}
+
+func TestFindPackage(t *testing.T) {
+	pth, pth2, err := makeDirStructure(t, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		os.RemoveAll(pth)
+		os.RemoveAll(pth2)
+	}()
+
+	searchPath := pth + string(filepath.ListSeparator)  + pth2
+	// finds package when real name mentioned
+	pkg := FindInSearchPath(searchPath, "foo/bar")
+	assert.NotEmpty(t, pkg)
+	assertPath(t, path.Join(pth, "src", "foo", "bar"), pkg)
+	// finds package when real name is mentioned in secondary
+	pkg = FindInSearchPath(searchPath, "fuu/bir")
+	assert.NotEmpty(t, pkg)
+	assertPath(t, path.Join(pth2, "src", "fuu", "bir"), pkg)
+	// finds package when symlinked
+	pkg = FindInSearchPath(searchPath, "baz/das")
+	assert.NotEmpty(t, pkg)
+	assertPath(t, path.Join(pth, "src", "foo", "bar"), pkg)
+	// finds package when symlinked in secondary
+	pkg = FindInSearchPath(searchPath, "biz/dis")
+	assert.NotEmpty(t, pkg)
+	assertPath(t, path.Join(pth2, "src", "fuu", "bir"), pkg)
+	// return empty string when nothing is found
+	pkg = FindInSearchPath(searchPath, "not/there")
+	assert.Empty(t, pkg)
+}
+
+func assertPath(t testing.TB, expected, actual string) bool {
+	fp, err := filepath.EvalSymlinks(expected)
+	if assert.NoError(t, err) {
+		return assert.Equal(t, fp, actual)
+	}
+	return true
+}
+
+func TestFullGOPATH(t *testing.T) {
+	os.Unsetenv(GOPATHKey)
+	ngp := "/some/where:/other/place"
+	os.Setenv(GOPATHKey, ngp)
+
+	ogp := os.Getenv(GOPATHKey)
+	defer os.Setenv(GOPATHKey, ogp)
+
+	expected := ngp + ":" + runtime.GOROOT()
+	assert.Equal(t, expected, FullGoSearchPath())
+}

vendor/github.com/go-openapi/swag/util.go

@@ -20,10 +20,12 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"unicode"
 )
 
-// Taken from https://github.com/golang/lint/blob/1fab560e16097e5b69afb66eb93aab843ef77845/lint.go#L663-L698
+// Taken from https://github.com/golang/lint/blob/3390df4df2787994aea98de825b964ac7944b817/lint.go#L732-L769
 var commonInitialisms = map[string]bool{
+	"ACL":   true,
 	"API":   true,
 	"ASCII": true,
 	"CPU":   true,
@@ -44,19 +46,21 @@ var commonInitialisms = map[string]bool{
 	"RPC":   true,
 	"SLA":   true,
 	"SMTP":  true,
+	"SQL":   true,
 	"SSH":   true,
 	"TCP":   true,
 	"TLS":   true,
 	"TTL":   true,
 	"UDP":   true,
-	"UUID":  true,
-	"UID":   true,
 	"UI":    true,
+	"UID":   true,
+	"UUID":  true,
 	"URI":   true,
 	"URL":   true,
 	"UTF8":  true,
 	"VM":    true,
 	"XML":   true,
+	"XMPP":  true,
 	"XSRF":  true,
 	"XSS":   true,
 }
@@ -246,6 +250,9 @@ func ToJSONName(name string) string {
 // ToVarName camelcases a name which can be underscored or pascal cased
 func ToVarName(name string) string {
 	res := ToGoName(name)
+	if _, ok := commonInitialisms[res]; ok {
+		return lower(res)
+	}
 	if len(res) <= 1 {
 		return lower(res)
 	}
@@ -263,7 +270,18 @@ func ToGoName(name string) string {
 		}
 		out = append(out, uw)
 	}
-	return strings.Join(out, "")
+
+	result := strings.Join(out, "")
+	if len(result) > 0 {
+		ud := upper(result[:1])
+		ru := []rune(ud)
+		if unicode.IsUpper(ru[0]) {
+			result = ud + result[1:]
+		} else {
+			result = "X" + ud + result[1:]
+		}
+	}
+	return result
 }
 
 // ContainsStringsCI searches a slice of strings for a case-insensitive match

vendor/github.com/go-openapi/swag/util_test.go

@@ -0,0 +1,277 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 swag
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type translationSample struct {
+	str, out string
+}
+
+func titleize(s string) string { return strings.ToTitle(s[:1]) + lower(s[1:]) }
+
+func TestToGoName(t *testing.T) {
+	samples := []translationSample{
+		{"sample text", "SampleText"},
+		{"sample-text", "SampleText"},
+		{"sample_text", "SampleText"},
+		{"sampleText", "SampleText"},
+		{"sample 2 Text", "Sample2Text"},
+		{"findThingById", "FindThingByID"},
+		{"日本語sample 2 Text", "X日本語sample2Text"},
+		{"日本語findThingById", "X日本語findThingByID"},
+	}
+
+	for k := range commonInitialisms {
+		samples = append(samples,
+			translationSample{"sample " + lower(k) + " text", "Sample" + k + "Text"},
+			translationSample{"sample-" + lower(k) + "-text", "Sample" + k + "Text"},
+			translationSample{"sample_" + lower(k) + "_text", "Sample" + k + "Text"},
+			translationSample{"sample" + titleize(k) + "Text", "Sample" + k + "Text"},
+			translationSample{"sample " + lower(k), "Sample" + k},
+			translationSample{"sample-" + lower(k), "Sample" + k},
+			translationSample{"sample_" + lower(k), "Sample" + k},
+			translationSample{"sample" + titleize(k), "Sample" + k},
+			translationSample{"sample " + titleize(k) + " text", "Sample" + k + "Text"},
+			translationSample{"sample-" + titleize(k) + "-text", "Sample" + k + "Text"},
+			translationSample{"sample_" + titleize(k) + "_text", "Sample" + k + "Text"},
+		)
+	}
+
+	for _, sample := range samples {
+		assert.Equal(t, sample.out, ToGoName(sample.str))
+	}
+}
+
+func TestContainsStringsCI(t *testing.T) {
+	list := []string{"hello", "world", "and", "such"}
+
+	assert.True(t, ContainsStringsCI(list, "hELLo"))
+	assert.True(t, ContainsStringsCI(list, "world"))
+	assert.True(t, ContainsStringsCI(list, "AND"))
+	assert.False(t, ContainsStringsCI(list, "nuts"))
+}
+
+func TestSplitByFormat(t *testing.T) {
+	expected := []string{"one", "two", "three"}
+	for _, fmt := range []string{"csv", "pipes", "tsv", "ssv", "multi"} {
+
+		var actual []string
+		switch fmt {
+		case "multi":
+			assert.Nil(t, SplitByFormat("", fmt))
+			assert.Nil(t, SplitByFormat("blah", fmt))
+		case "ssv":
+			actual = SplitByFormat(strings.Join(expected, " "), fmt)
+			assert.EqualValues(t, expected, actual)
+		case "pipes":
+			actual = SplitByFormat(strings.Join(expected, "|"), fmt)
+			assert.EqualValues(t, expected, actual)
+		case "tsv":
+			actual = SplitByFormat(strings.Join(expected, "\t"), fmt)
+			assert.EqualValues(t, expected, actual)
+		default:
+			actual = SplitByFormat(strings.Join(expected, ","), fmt)
+			assert.EqualValues(t, expected, actual)
+		}
+	}
+}
+
+func TestJoinByFormat(t *testing.T) {
+	for _, fmt := range []string{"csv", "pipes", "tsv", "ssv", "multi"} {
+
+		lval := []string{"one", "two", "three"}
+		var expected []string
+		switch fmt {
+		case "multi":
+			expected = lval
+		case "ssv":
+			expected = []string{strings.Join(lval, " ")}
+		case "pipes":
+			expected = []string{strings.Join(lval, "|")}
+		case "tsv":
+			expected = []string{strings.Join(lval, "\t")}
+		default:
+			expected = []string{strings.Join(lval, ",")}
+		}
+		assert.Nil(t, JoinByFormat(nil, fmt))
+		assert.EqualValues(t, expected, JoinByFormat(lval, fmt))
+	}
+}
+
+func TestToFileName(t *testing.T) {
+	samples := []translationSample{
+		{"SampleText", "sample_text"},
+		{"FindThingByID", "find_thing_by_id"},
+	}
+
+	for k := range commonInitialisms {
+		samples = append(samples,
+			translationSample{"Sample" + k + "Text", "sample_" + lower(k) + "_text"},
+		)
+	}
+
+	for _, sample := range samples {
+		assert.Equal(t, sample.out, ToFileName(sample.str))
+	}
+}
+
+func TestToCommandName(t *testing.T) {
+	samples := []translationSample{
+		{"SampleText", "sample-text"},
+		{"FindThingByID", "find-thing-by-id"},
+	}
+
+	for k := range commonInitialisms {
+		samples = append(samples,
+			translationSample{"Sample" + k + "Text", "sample-" + lower(k) + "-text"},
+		)
+	}
+
+	for _, sample := range samples {
+		assert.Equal(t, sample.out, ToCommandName(sample.str))
+	}
+}
+
+func TestToHumanName(t *testing.T) {
+	samples := []translationSample{
+		{"SampleText", "sample text"},
+		{"FindThingByID", "find thing by ID"},
+	}
+
+	for k := range commonInitialisms {
+		samples = append(samples,
+			translationSample{"Sample" + k + "Text", "sample " + k + " text"},
+		)
+	}
+
+	for _, sample := range samples {
+		assert.Equal(t, sample.out, ToHumanNameLower(sample.str))
+	}
+}
+
+func TestToJSONName(t *testing.T) {
+	samples := []translationSample{
+		{"SampleText", "sampleText"},
+		{"FindThingByID", "findThingById"},
+	}
+
+	for k := range commonInitialisms {
+		samples = append(samples,
+			translationSample{"Sample" + k + "Text", "sample" + titleize(k) + "Text"},
+		)
+	}
+
+	for _, sample := range samples {
+		assert.Equal(t, sample.out, ToJSONName(sample.str))
+	}
+}
+
+type SimpleZeroes struct {
+	ID   string
+	Name string
+}
+type ZeroesWithTime struct {
+	Time time.Time
+}
+
+func TestIsZero(t *testing.T) {
+	var strs [5]string
+	var strss []string
+	var a int
+	var b int8
+	var c int16
+	var d int32
+	var e int64
+	var f uint
+	var g uint8
+	var h uint16
+	var i uint32
+	var j uint64
+	var k map[string]string
+	var l interface{}
+	var m *SimpleZeroes
+	var n string
+	var o SimpleZeroes
+	var p ZeroesWithTime
+	var q time.Time
+	data := []struct {
+		Data     interface{}
+		Expected bool
+	}{
+		{a, true},
+		{b, true},
+		{c, true},
+		{d, true},
+		{e, true},
+		{f, true},
+		{g, true},
+		{h, true},
+		{i, true},
+		{j, true},
+		{k, true},
+		{l, true},
+		{m, true},
+		{n, true},
+		{o, true},
+		{p, true},
+		{q, true},
+		{strss, true},
+		{strs, true},
+		{"", true},
+		{nil, true},
+		{1, false},
+		{0, true},
+		{int8(1), false},
+		{int8(0), true},
+		{int16(1), false},
+		{int16(0), true},
+		{int32(1), false},
+		{int32(0), true},
+		{int64(1), false},
+		{int64(0), true},
+		{uint(1), false},
+		{uint(0), true},
+		{uint8(1), false},
+		{uint8(0), true},
+		{uint16(1), false},
+		{uint16(0), true},
+		{uint32(1), false},
+		{uint32(0), true},
+		{uint64(1), false},
+		{uint64(0), true},
+		{0.0, true},
+		{0.1, false},
+		{float32(0.0), true},
+		{float32(0.1), false},
+		{float64(0.0), true},
+		{float64(0.1), false},
+		{[...]string{}, true},
+		{[...]string{"hello"}, false},
+		{[]string(nil), true},
+		{[]string{"a"}, false},
+	}
+
+	for _, it := range data {
+		assert.Equal(t, it.Expected, IsZero(it.Data), fmt.Sprintf("%#v", it.Data))
+	}
+}

vendor/github.com/go-openapi/swag/yaml.go

@@ -0,0 +1,215 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 swag
+
+import (
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"strconv"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+
+	yaml "gopkg.in/yaml.v2"
+)
+
+// YAMLMatcher matches yaml
+func YAMLMatcher(path string) bool {
+	ext := filepath.Ext(path)
+	return ext == ".yaml" || ext == ".yml"
+}
+
+// YAMLToJSON converts YAML unmarshaled data into json compatible data
+func YAMLToJSON(data interface{}) (json.RawMessage, error) {
+	jm, err := transformData(data)
+	if err != nil {
+		return nil, err
+	}
+	b, err := WriteJSON(jm)
+	return json.RawMessage(b), err
+}
+
+func BytesToYAMLDoc(data []byte) (interface{}, error) {
+	var canary map[interface{}]interface{} // validate this is an object and not a different type
+	if err := yaml.Unmarshal(data, &canary); err != nil {
+		return nil, err
+	}
+
+	var document yaml.MapSlice // preserve order that is present in the document
+	if err := yaml.Unmarshal(data, &document); err != nil {
+		return nil, err
+	}
+	return document, nil
+}
+
+type JSONMapSlice []JSONMapItem
+
+func (s JSONMapSlice) MarshalJSON() ([]byte, error) {
+	w := &jwriter.Writer{Flags: jwriter.NilMapAsEmpty | jwriter.NilSliceAsEmpty}
+	s.MarshalEasyJSON(w)
+	return w.BuildBytes()
+}
+
+func (s JSONMapSlice) MarshalEasyJSON(w *jwriter.Writer) {
+	w.RawByte('{')
+
+	ln := len(s)
+	last := ln - 1
+	for i := 0; i < ln; i++ {
+		s[i].MarshalEasyJSON(w)
+		if i != last { // last item
+			w.RawByte(',')
+		}
+	}
+
+	w.RawByte('}')
+}
+
+func (s *JSONMapSlice) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{Data: data}
+	s.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+func (s *JSONMapSlice) UnmarshalEasyJSON(in *jlexer.Lexer) {
+	if in.IsNull() {
+		in.Skip()
+		return
+	}
+
+	var result JSONMapSlice
+	in.Delim('{')
+	for !in.IsDelim('}') {
+		var mi JSONMapItem
+		mi.UnmarshalEasyJSON(in)
+		result = append(result, mi)
+	}
+	*s = result
+}
+
+type JSONMapItem struct {
+	Key   string
+	Value interface{}
+}
+
+func (s JSONMapItem) MarshalJSON() ([]byte, error) {
+	w := &jwriter.Writer{Flags: jwriter.NilMapAsEmpty | jwriter.NilSliceAsEmpty}
+	s.MarshalEasyJSON(w)
+	return w.BuildBytes()
+}
+
+func (s JSONMapItem) MarshalEasyJSON(w *jwriter.Writer) {
+	w.String(s.Key)
+	w.RawByte(':')
+	w.Raw(WriteJSON(s.Value))
+}
+
+func (s *JSONMapItem) UnmarshalEasyJSON(in *jlexer.Lexer) {
+	key := in.UnsafeString()
+	in.WantColon()
+	value := in.Interface()
+	in.WantComma()
+	s.Key = key
+	s.Value = value
+}
+func (s *JSONMapItem) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{Data: data}
+	s.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+func transformData(input interface{}) (out interface{}, err error) {
+	switch in := input.(type) {
+	case yaml.MapSlice:
+
+		o := make(JSONMapSlice, len(in))
+		for i, mi := range in {
+			var nmi JSONMapItem
+			switch k := mi.Key.(type) {
+			case string:
+				nmi.Key = k
+			case int:
+				nmi.Key = strconv.Itoa(k)
+			default:
+				return nil, fmt.Errorf("types don't match expect map key string or int got: %T", mi.Key)
+			}
+
+			v, err := transformData(mi.Value)
+			if err != nil {
+				return nil, err
+			}
+			nmi.Value = v
+			o[i] = nmi
+		}
+		return o, nil
+	case map[interface{}]interface{}:
+		o := make(JSONMapSlice, 0, len(in))
+		for ke, va := range in {
+			var nmi JSONMapItem
+			switch k := ke.(type) {
+			case string:
+				nmi.Key = k
+			case int:
+				nmi.Key = strconv.Itoa(k)
+			default:
+				return nil, fmt.Errorf("types don't match expect map key string or int got: %T", ke)
+			}
+
+			v, err := transformData(va)
+			if err != nil {
+				return nil, err
+			}
+			nmi.Value = v
+			o = append(o, nmi)
+		}
+		return o, nil
+	case []interface{}:
+		len1 := len(in)
+		o := make([]interface{}, len1)
+		for i := 0; i < len1; i++ {
+			o[i], err = transformData(in[i])
+			if err != nil {
+				return nil, err
+			}
+		}
+		return o, nil
+	}
+	return input, nil
+}
+
+// YAMLDoc loads a yaml document from either http or a file and converts it to json
+func YAMLDoc(path string) (json.RawMessage, error) {
+	yamlDoc, err := YAMLData(path)
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := YAMLToJSON(yamlDoc)
+	if err != nil {
+		return nil, err
+	}
+
+	return json.RawMessage(data), nil
+}
+
+// YAMLData loads a yaml document from either http or a file
+func YAMLData(path string) (interface{}, error) {
+	data, err := LoadFromFileOrHTTP(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return BytesToYAMLDoc(data)
+}

vendor/github.com/go-openapi/swag/yaml_test.go

@@ -0,0 +1,444 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 swag
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	yaml "gopkg.in/yaml.v2"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type failJSONMarhal struct {
+}
+
+func (f failJSONMarhal) MarshalJSON() ([]byte, error) {
+	return nil, errors.New("expected")
+}
+
+func TestLoadHTTPBytes(t *testing.T) {
+	_, err := LoadFromFileOrHTTP("httx://12394:abd")
+	assert.Error(t, err)
+
+	serv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.WriteHeader(http.StatusNotFound)
+	}))
+	defer serv.Close()
+
+	_, err = LoadFromFileOrHTTP(serv.URL)
+	assert.Error(t, err)
+
+	ts2 := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.WriteHeader(http.StatusOK)
+		rw.Write([]byte("the content"))
+	}))
+	defer ts2.Close()
+
+	d, err := LoadFromFileOrHTTP(ts2.URL)
+	assert.NoError(t, err)
+	assert.Equal(t, []byte("the content"), d)
+}
+
+func TestYAMLToJSON(t *testing.T) {
+
+	sd := `---
+1: the int key value
+name: a string value
+'y': some value
+`
+	var data yaml.MapSlice
+	yaml.Unmarshal([]byte(sd), &data)
+
+	d, err := YAMLToJSON(data)
+	if assert.NoError(t, err) {
+		assert.Equal(t, `{"1":"the int key value","name":"a string value","y":"some value"}`, string(d))
+	}
+
+	data = append(data, yaml.MapItem{Key: true, Value: "the bool value"})
+	d, err = YAMLToJSON(data)
+	assert.Error(t, err)
+	assert.Nil(t, d)
+
+	data = data[:len(data)-1]
+
+	tag := yaml.MapSlice{{Key: "name", Value: "tag name"}}
+	data = append(data, yaml.MapItem{Key: "tag", Value: tag})
+
+	d, err = YAMLToJSON(data)
+	assert.NoError(t, err)
+	assert.Equal(t, `{"1":"the int key value","name":"a string value","y":"some value","tag":{"name":"tag name"}}`, string(d))
+
+	tag = yaml.MapSlice{{Key: true, Value: "bool tag name"}}
+	data = append(data[:len(data)-1], yaml.MapItem{Key: "tag", Value: tag})
+
+	d, err = YAMLToJSON(data)
+	assert.Error(t, err)
+	assert.Nil(t, d)
+
+	var lst []interface{}
+	lst = append(lst, "hello")
+
+	d, err = YAMLToJSON(lst)
+	assert.NoError(t, err)
+	assert.Equal(t, []byte(`["hello"]`), []byte(d))
+
+	lst = append(lst, data)
+
+	d, err = YAMLToJSON(lst)
+	assert.Error(t, err)
+	assert.Nil(t, d)
+
+	// _, err := yamlToJSON(failJSONMarhal{})
+	// assert.Error(t, err)
+
+	_, err = BytesToYAMLDoc([]byte("- name: hello\n"))
+	assert.Error(t, err)
+
+	dd, err := BytesToYAMLDoc([]byte("description: 'object created'\n"))
+	assert.NoError(t, err)
+
+	d, err = YAMLToJSON(dd)
+	assert.NoError(t, err)
+	assert.Equal(t, json.RawMessage(`{"description":"object created"}`), d)
+}
+
+func TestLoadStrategy(t *testing.T) {
+
+	loader := func(p string) ([]byte, error) {
+		return []byte(yamlPetStore), nil
+	}
+	remLoader := func(p string) ([]byte, error) {
+		return []byte("not it"), nil
+	}
+
+	ld := LoadStrategy("blah", loader, remLoader)
+	b, _ := ld("")
+	assert.Equal(t, []byte(yamlPetStore), b)
+
+	serv := httptest.NewServer(http.HandlerFunc(yamlPestoreServer))
+	defer serv.Close()
+
+	s, err := YAMLDoc(serv.URL)
+	assert.NoError(t, err)
+	assert.NotNil(t, s)
+
+	ts2 := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.WriteHeader(http.StatusNotFound)
+		rw.Write([]byte("\n"))
+	}))
+	defer ts2.Close()
+	_, err = YAMLDoc(ts2.URL)
+	assert.Error(t, err)
+}
+
+var yamlPestoreServer = func(rw http.ResponseWriter, r *http.Request) {
+	rw.WriteHeader(http.StatusOK)
+	rw.Write([]byte(yamlPetStore))
+}
+
+func TestWithYKey(t *testing.T) {
+	doc, err := BytesToYAMLDoc([]byte(withYKey))
+	if assert.NoError(t, err) {
+		_, err := YAMLToJSON(doc)
+		if assert.Error(t, err) {
+			doc, err := BytesToYAMLDoc([]byte(withQuotedYKey))
+			if assert.NoError(t, err) {
+				jsond, err := YAMLToJSON(doc)
+				if assert.NoError(t, err) {
+					var yt struct {
+						Definitions struct {
+							Viewbox struct {
+								Properties struct {
+									Y struct {
+										Type string `json:"type"`
+									} `json:"y"`
+								} `json:"properties"`
+							} `json:"viewbox"`
+						} `json:"definitions"`
+					}
+					if assert.NoError(t, json.Unmarshal(jsond, &yt)) {
+						assert.Equal(t, "integer", yt.Definitions.Viewbox.Properties.Y.Type)
+					}
+				}
+			}
+		}
+
+	}
+}
+
+const withQuotedYKey = `consumes:
+- application/json
+definitions:
+  viewBox:
+    type: object
+    properties:
+      x:
+        type: integer
+        format: int16
+      # y -> types don't match: expect map key string or int get: bool
+      "y":
+        type: integer
+        format: int16
+      width:
+        type: integer
+        format: int16
+      height:
+        type: integer
+        format: int16
+info:
+  description: Test RESTful APIs
+  title: Test Server
+  version: 1.0.0
+basePath: /api
+paths:
+  /test:
+    get:
+      operationId: findAll
+      parameters:
+        - name: since
+          in: query
+          type: integer
+          format: int64
+        - name: limit
+          in: query
+          type: integer
+          format: int32
+          default: 20
+      responses:
+        200:
+          description: Array[Trigger]
+          schema:
+            type: array
+            items:
+              $ref: "#/definitions/viewBox"
+produces:
+- application/json
+schemes:
+- https
+swagger: "2.0"
+`
+
+const withYKey = `consumes:
+- application/json
+definitions:
+  viewBox:
+    type: object
+    properties:
+      x:
+        type: integer
+        format: int16
+      # y -> types don't match: expect map key string or int get: bool
+      y:
+        type: integer
+        format: int16
+      width:
+        type: integer
+        format: int16
+      height:
+        type: integer
+        format: int16
+info:
+  description: Test RESTful APIs
+  title: Test Server
+  version: 1.0.0
+basePath: /api
+paths:
+  /test:
+    get:
+      operationId: findAll
+      parameters:
+        - name: since
+          in: query
+          type: integer
+          format: int64
+        - name: limit
+          in: query
+          type: integer
+          format: int32
+          default: 20
+      responses:
+        200:
+          description: Array[Trigger]
+          schema:
+            type: array
+            items:
+              $ref: "#/definitions/viewBox"
+produces:
+- application/json
+schemes:
+- https
+swagger: "2.0"
+`
+
+const yamlPetStore = `swagger: '2.0'
+info:
+  version: '1.0.0'
+  title: Swagger Petstore
+  description: A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification
+  termsOfService: http://helloreverb.com/terms/
+  contact:
+    name: Swagger API team
+    email: foo@example.com
+    url: http://swagger.io
+  license:
+    name: MIT
+    url: http://opensource.org/licenses/MIT
+host: petstore.swagger.wordnik.com
+basePath: /api
+schemes:
+  - http
+consumes:
+  - application/json
+produces:
+  - application/json
+paths:
+  /pets:
+    get:
+      description: Returns all pets from the system that the user has access to
+      operationId: findPets
+      produces:
+        - application/json
+        - application/xml
+        - text/xml
+        - text/html
+      parameters:
+        - name: tags
+          in: query
+          description: tags to filter by
+          required: false
+          type: array
+          items:
+            type: string
+          collectionFormat: csv
+        - name: limit
+          in: query
+          description: maximum number of results to return
+          required: false
+          type: integer
+          format: int32
+      responses:
+        '200':
+          description: pet response
+          schema:
+            type: array
+            items:
+              $ref: '#/definitions/pet'
+        default:
+          description: unexpected error
+          schema:
+            $ref: '#/definitions/errorModel'
+    post:
+      description: Creates a new pet in the store.  Duplicates are allowed
+      operationId: addPet
+      produces:
+        - application/json
+      parameters:
+        - name: pet
+          in: body
+          description: Pet to add to the store
+          required: true
+          schema:
+            $ref: '#/definitions/newPet'
+      responses:
+        '200':
+          description: pet response
+          schema:
+            $ref: '#/definitions/pet'
+        default:
+          description: unexpected error
+          schema:
+            $ref: '#/definitions/errorModel'
+  /pets/{id}:
+    get:
+      description: Returns a user based on a single ID, if the user does not have access to the pet
+      operationId: findPetById
+      produces:
+        - application/json
+        - application/xml
+        - text/xml
+        - text/html
+      parameters:
+        - name: id
+          in: path
+          description: ID of pet to fetch
+          required: true
+          type: integer
+          format: int64
+      responses:
+        '200':
+          description: pet response
+          schema:
+            $ref: '#/definitions/pet'
+        default:
+          description: unexpected error
+          schema:
+            $ref: '#/definitions/errorModel'
+    delete:
+      description: deletes a single pet based on the ID supplied
+      operationId: deletePet
+      parameters:
+        - name: id
+          in: path
+          description: ID of pet to delete
+          required: true
+          type: integer
+          format: int64
+      responses:
+        '204':
+          description: pet deleted
+        default:
+          description: unexpected error
+          schema:
+            $ref: '#/definitions/errorModel'
+definitions:
+  pet:
+    required:
+      - id
+      - name
+    properties:
+      id:
+        type: integer
+        format: int64
+      name:
+        type: string
+      tag:
+        type: string
+  newPet:
+    allOf:
+      - $ref: '#/definitions/pet'
+      - required:
+          - name
+        properties:
+          id:
+            type: integer
+            format: int64
+          name:
+            type: string
+  errorModel:
+    required:
+      - code
+      - message
+    properties:
+      code:
+        type: integer
+        format: int32
+      message:
+        type: string
+`