dep ensure -update (#1001)

* dep ensure -update

Run "dep ensure -update` to update all dependencies.

No code changes; just the dependencies.

* dep prune

* add new venderod

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

@@ -36,8 +36,9 @@ var (
 
 // ExpandOptions provides options for expand.
 type ExpandOptions struct {
-	RelativeBase string
-	SkipSchemas  bool
+	RelativeBase    string
+	SkipSchemas     bool
+	ContinueOnError bool
 }
 
 // ResolutionCache a cache for resolving urls
@@ -510,7 +511,8 @@ func (r *schemaLoader) reset() {
 // ExpandSpec expands the references in a swagger spec
 func ExpandSpec(spec *Swagger, options *ExpandOptions) error {
 	resolver, err := defaultSchemaLoader(spec, nil, options, nil)
-	if err != nil {
+	// Just in case this ever returns an error.
+	if shouldStopOnError(err, resolver.options) {
 		return err
 	}
 
@@ -518,7 +520,7 @@ func ExpandSpec(spec *Swagger, options *ExpandOptions) error {
 		for key, definition := range spec.Definitions {
 			var def *Schema
 			var err error
-			if def, err = expandSchema(definition, []string{"#/definitions/" + key}, resolver); err != nil {
+			if def, err = expandSchema(definition, []string{"#/definitions/" + key}, resolver); shouldStopOnError(err, resolver.options) {
 				return err
 			}
 			resolver.reset()
@@ -527,14 +529,14 @@ func ExpandSpec(spec *Swagger, options *ExpandOptions) error {
 	}
 
 	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
@@ -542,7 +544,7 @@ func ExpandSpec(spec *Swagger, options *ExpandOptions) 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
@@ -552,6 +554,18 @@ func ExpandSpec(spec *Swagger, options *ExpandOptions) 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)
@@ -639,7 +653,7 @@ func expandSchema(target Schema, parentRefs []string, resolver *schemaLoader) (*
 			return &target, nil
 		}
 
-		if err := resolver.Resolve(&target.Ref, &t); err != nil {
+		if err := resolver.Resolve(&target.Ref, &t); shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
 
@@ -648,86 +662,108 @@ func expandSchema(target Schema, parentRefs []string, resolver *schemaLoader) (*
 			return &target, nil
 		}
 		parentRefs = append(parentRefs, target.Ref.String())
-		target = *t
+		if t != nil {
+			target = *t
+		}
 	}
 
 	t, err := expandItems(target, parentRefs, resolver)
-	if err != nil {
+	if shouldStopOnError(err, resolver.options) {
 		return &target, err
 	}
-	target = *t
+	if t != nil {
+		target = *t
+	}
 
 	for i := range target.AllOf {
 		t, err := expandSchema(target.AllOf[i], parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		target.AllOf[i] = *t
+		if t != nil {
+			target.AllOf[i] = *t
+		}
 	}
 	for i := range target.AnyOf {
 		t, err := expandSchema(target.AnyOf[i], parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
 		target.AnyOf[i] = *t
 	}
 	for i := range target.OneOf {
 		t, err := expandSchema(target.OneOf[i], parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		target.OneOf[i] = *t
+		if t != nil {
+			target.OneOf[i] = *t
+		}
 	}
 	if target.Not != nil {
 		t, err := expandSchema(*target.Not, parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		*target.Not = *t
+		if t != nil {
+			*target.Not = *t
+		}
 	}
 	for k := range target.Properties {
 		t, err := expandSchema(target.Properties[k], parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		target.Properties[k] = *t
+		if t != nil {
+			target.Properties[k] = *t
+		}
 	}
 	if target.AdditionalProperties != nil && target.AdditionalProperties.Schema != nil {
 		t, err := expandSchema(*target.AdditionalProperties.Schema, parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		*target.AdditionalProperties.Schema = *t
+		if t != nil {
+			*target.AdditionalProperties.Schema = *t
+		}
 	}
 	for k := range target.PatternProperties {
 		t, err := expandSchema(target.PatternProperties[k], parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		target.PatternProperties[k] = *t
+		if t != nil {
+			target.PatternProperties[k] = *t
+		}
 	}
 	for k := range target.Dependencies {
 		if target.Dependencies[k].Schema != nil {
 			t, err := expandSchema(*target.Dependencies[k].Schema, parentRefs, resolver)
-			if err != nil {
+			if shouldStopOnError(err, resolver.options) {
 				return &target, err
 			}
-			*target.Dependencies[k].Schema = *t
+			if t != nil {
+				*target.Dependencies[k].Schema = *t
+			}
 		}
 	}
 	if target.AdditionalItems != nil && target.AdditionalItems.Schema != nil {
 		t, err := expandSchema(*target.AdditionalItems.Schema, parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		*target.AdditionalItems.Schema = *t
+		if t != nil {
+			*target.AdditionalItems.Schema = *t
+		}
 	}
 	for k := range target.Definitions {
 		t, err := expandSchema(target.Definitions[k], parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return &target, err
 		}
-		target.Definitions[k] = *t
+		if t != nil {
+			target.Definitions[k] = *t
+		}
 	}
 	return &target, nil
 }
@@ -736,6 +772,7 @@ 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
@@ -745,29 +782,29 @@ func expandPathItem(pathItem *PathItem, resolver *schemaLoader) error {
 	}
 
 	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
@@ -777,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
@@ -786,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
@@ -805,9 +843,10 @@ func expandResponse(response *Response, resolver *schemaLoader) error {
 	}
 
 	var parentRefs []string
+
 	if response.Ref.String() != "" {
 		parentRefs = append(parentRefs, response.Ref.String())
-		if err := resolver.Resolve(&response.Ref, response); err != nil {
+		if err := resolver.Resolve(&response.Ref, response); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		resolver.reset()
@@ -817,11 +856,11 @@ func expandResponse(response *Response, resolver *schemaLoader) error {
 	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); err != nil {
+		if err := resolver.Resolve(&response.Schema.Ref, &response.Schema); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		s, err := expandSchema(*response.Schema, parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		resolver.reset()
@@ -836,9 +875,10 @@ func expandParameter(parameter *Parameter, resolver *schemaLoader) error {
 	}
 
 	var parentRefs []string
+
 	if parameter.Ref.String() != "" {
 		parentRefs = append(parentRefs, parameter.Ref.String())
-		if err := resolver.Resolve(&parameter.Ref, parameter); err != nil {
+		if err := resolver.Resolve(&parameter.Ref, parameter); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		resolver.reset()
@@ -846,11 +886,11 @@ func expandParameter(parameter *Parameter, resolver *schemaLoader) error {
 	}
 	if !resolver.options.SkipSchemas && parameter.Schema != nil {
 		parentRefs = append(parentRefs, parameter.Schema.Ref.String())
-		if err := resolver.Resolve(&parameter.Schema.Ref, &parameter.Schema); err != nil {
+		if err := resolver.Resolve(&parameter.Schema.Ref, &parameter.Schema); shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		s, err := expandSchema(*parameter.Schema, parentRefs, resolver)
-		if err != nil {
+		if shouldStopOnError(err, resolver.options) {
 			return err
 		}
 		resolver.reset()

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

@@ -197,6 +197,35 @@ func TestCircularRefsExpansion(t *testing.T) {
 	}, "Calling expand schema with circular refs, should not panic!")
 }
 
+func TestContinueOnErrorExpansion(t *testing.T) {
+	missingRefDoc, err := jsonDoc("fixtures/expansion/missingRef.json")
+	assert.NoError(t, err)
+
+	testCase := struct {
+		Input    *Swagger `json:"input"`
+		Expected *Swagger `json:"expected"`
+	}{}
+	err = json.Unmarshal(missingRefDoc, &testCase)
+	assert.NoError(t, err)
+
+	opts := &ExpandOptions{
+		ContinueOnError: true,
+	}
+	err = ExpandSpec(testCase.Input, opts)
+	assert.NoError(t, err)
+	assert.Equal(t, testCase.Input, testCase.Expected, "Should continue expanding spec when a definition can't be found.")
+
+	doc, err := jsonDoc("fixtures/expansion/missingItemRef.json")
+	spec := new(Swagger)
+	err = json.Unmarshal(doc, spec)
+	assert.NoError(t, err)
+
+	assert.NotPanics(t, func() {
+		err = ExpandSpec(spec, opts)
+		assert.NoError(t, err)
+	}, "Array of missing refs should not cause a panic, and continue to expand spec.")
+}
+
 func TestIssue415(t *testing.T) {
 	doc, err := jsonDoc("fixtures/expansion/clickmeter.json")
 	assert.NoError(t, err)

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

@@ -120,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/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"`

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

@@ -237,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 {
@@ -258,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)
@@ -267,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
@@ -282,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)