bump(github.com/go-openapi/spec): 7abd5745472fff5eb3685386d5fb8bf38683154d

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

@@ -1 +0,0 @@
-eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ.Epk8dDFH8U1RPYIPDpajZO26L5zFJ1wnQNGWxVHHo5cXrWF148kENoZzh35FT9cAxxPS_4CeVVpf59EgvCc8bem1puuj0gBZptn-lYa7iXZdI-ESN2Te7nF5VbZfwbnI62nEikYGyxz-ozL_IFuMl-qWek4iLerF8Z_xh0MZOJ_w8Nog7qb2WQov72d997TJv5ZKjWcRYPbnsAy1q60-Cqxq3a6enhcSPXqpK46nYSXGKfHvognWBJ_pxwkEqIBPN6hE4EfNtJjMf2LFKEdYy02nbHz78d-2YZ8wIUSJ-IWIwn3GTzObdGqRed20Qf3JtWTsOespmexDrLSeo3HW6A.7XaHW-Y1jjRAWt_W.S1Adut62RLOYZc-lN02M0MGczEucch3zIr4J1UPBPnZooWzntiE5UaUz0UdhjHVszQE5hTfG-yocKD1rDQGER6qrLtnJVrCm9J3n4lHglM-xOz1eZln1XKrWcAgZnAKaKSzuAa5scPG4iTHW6RwbWi_PWm04tBJ1yazdjaVo3uvuhflwvU9if7uMPMtscrDesbBVvpG89xmeudiFjX-wjsV5oGBIjz6ukEBAMKzNDMqikNoG4SnGenpxUpjUjMkDXxiC3BC8oL2_myeIfFeEOF066DqEN3CLkqBVO25zdpWAF4Ou2jKv--mgGEb_E1aMgiSoAVBnybene0TKn2IJ8rtkyRdmWlLIRKZdDT3v775C1FPK6-tYzS7NVg9nnuvpta5PhzYNkqI1Ie74Sl0I-RFClhsdx9dLDhoFEKCx2etC4UDX9jhj2u0Y2MrL76dRGE9kEV1hL1fh6HMvS4ZAAWw3Qce4skCjcL-2YyIOHzKjgLGkZsR5cTUQwCJyacVkdHUOUKFdDGZaUzWkFyeZ1oyrlG2d52svaplpU5-vCOVbWkqUN9rOALGPTC51Ur0L7DFx29aDImhaxZqTe2t9mcdqY7VLcO3JgUiD3JKsEet7s2EDeN44MqITv9KBS8wqJW4.sRv4ov0wB0IxTHw90kJy-A

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/.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/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/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/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
@@ -197,3 +200,20 @@ func (i Items) MarshalJSON() ([]byte, error) {
 	}
 	return swag.ConcatJSON(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/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/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/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/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/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