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

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
 }