1 files changed, 0 insertions, 356 deletions
diff --git a/vendor/github.com/go-openapi/validate/schema_props.go b/vendor/github.com/go-openapi/validate/schema_props.go
deleted file mode 100644
index 1ca379244..000000000
--- a/vendor/github.com/go-openapi/validate/schema_props.go
+++ /dev/null
@@ -1,356 +0,0 @@
-// 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 validate
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/go-openapi/spec"
-	"github.com/go-openapi/strfmt"
-)
-
-type schemaPropsValidator struct {
-	Path            string
-	In              string
-	AllOf           []spec.Schema
-	OneOf           []spec.Schema
-	AnyOf           []spec.Schema
-	Not             *spec.Schema
-	Dependencies    spec.Dependencies
-	anyOfValidators []*SchemaValidator
-	allOfValidators []*SchemaValidator
-	oneOfValidators []*SchemaValidator
-	notValidator    *SchemaValidator
-	Root            interface{}
-	KnownFormats    strfmt.Registry
-	Options         *SchemaValidatorOptions
-}
-
-func (s *schemaPropsValidator) SetPath(path string) {
-	s.Path = path
-}
-
-func newSchemaPropsValidator(
-	path string, in string, allOf, oneOf, anyOf []spec.Schema, not *spec.Schema, deps spec.Dependencies, root interface{}, formats strfmt.Registry,
-	opts *SchemaValidatorOptions) *schemaPropsValidator {
-	if opts == nil {
-		opts = new(SchemaValidatorOptions)
-	}
-
-	anyValidators := make([]*SchemaValidator, 0, len(anyOf))
-	for i := range anyOf {
-		anyValidators = append(anyValidators, newSchemaValidator(&anyOf[i], root, path, formats, opts))
-	}
-	allValidators := make([]*SchemaValidator, 0, len(allOf))
-	for i := range allOf {
-		allValidators = append(allValidators, newSchemaValidator(&allOf[i], root, path, formats, opts))
-	}
-	oneValidators := make([]*SchemaValidator, 0, len(oneOf))
-	for i := range oneOf {
-		oneValidators = append(oneValidators, newSchemaValidator(&oneOf[i], root, path, formats, opts))
-	}
-
-	var notValidator *SchemaValidator
-	if not != nil {
-		notValidator = newSchemaValidator(not, root, path, formats, opts)
-	}
-
-	var s *schemaPropsValidator
-	if opts.recycleValidators {
-		s = pools.poolOfSchemaPropsValidators.BorrowValidator()
-	} else {
-		s = new(schemaPropsValidator)
-	}
-
-	s.Path = path
-	s.In = in
-	s.AllOf = allOf
-	s.OneOf = oneOf
-	s.AnyOf = anyOf
-	s.Not = not
-	s.Dependencies = deps
-	s.anyOfValidators = anyValidators
-	s.allOfValidators = allValidators
-	s.oneOfValidators = oneValidators
-	s.notValidator = notValidator
-	s.Root = root
-	s.KnownFormats = formats
-	s.Options = opts
-
-	return s
-}
-
-func (s *schemaPropsValidator) Applies(source interface{}, _ reflect.Kind) bool {
-	_, isSchema := source.(*spec.Schema)
-	return isSchema
-}
-
-func (s *schemaPropsValidator) Validate(data interface{}) *Result {
-	var mainResult *Result
-	if s.Options.recycleResult {
-		mainResult = pools.poolOfResults.BorrowResult()
-	} else {
-		mainResult = new(Result)
-	}
-
-	// Intermediary error results
-
-	// IMPORTANT! messages from underlying validators
-	var keepResultAnyOf, keepResultOneOf, keepResultAllOf *Result
-
-	if s.Options.recycleValidators {
-		defer func() {
-			s.redeemChildren()
-			s.redeem()
-
-			// results are redeemed when merged
-		}()
-	}
-
-	if len(s.anyOfValidators) > 0 {
-		keepResultAnyOf = pools.poolOfResults.BorrowResult()
-		s.validateAnyOf(data, mainResult, keepResultAnyOf)
-	}
-
-	if len(s.oneOfValidators) > 0 {
-		keepResultOneOf = pools.poolOfResults.BorrowResult()
-		s.validateOneOf(data, mainResult, keepResultOneOf)
-	}
-
-	if len(s.allOfValidators) > 0 {
-		keepResultAllOf = pools.poolOfResults.BorrowResult()
-		s.validateAllOf(data, mainResult, keepResultAllOf)
-	}
-
-	if s.notValidator != nil {
-		s.validateNot(data, mainResult)
-	}
-
-	if s.Dependencies != nil && len(s.Dependencies) > 0 && reflect.TypeOf(data).Kind() == reflect.Map {
-		s.validateDependencies(data, mainResult)
-	}
-
-	mainResult.Inc()
-
-	// In the end we retain best failures for schema validation
-	// plus, if any, composite errors which may explain special cases (tagged as IMPORTANT!).
-	return mainResult.Merge(keepResultAllOf, keepResultOneOf, keepResultAnyOf)
-}
-
-func (s *schemaPropsValidator) validateAnyOf(data interface{}, mainResult, keepResultAnyOf *Result) {
-	// Validates at least one in anyOf schemas
-	var bestFailures *Result
-
-	for i, anyOfSchema := range s.anyOfValidators {
-		result := anyOfSchema.Validate(data)
-		if s.Options.recycleValidators {
-			s.anyOfValidators[i] = nil
-		}
-		// We keep inner IMPORTANT! errors no matter what MatchCount tells us
-		keepResultAnyOf.Merge(result.keepRelevantErrors()) // merges (and redeems) a new instance of Result
-
-		if result.IsValid() {
-			if bestFailures != nil && bestFailures.wantsRedeemOnMerge {
-				pools.poolOfResults.RedeemResult(bestFailures)
-			}
-
-			_ = keepResultAnyOf.cleared()
-			mainResult.Merge(result)
-
-			return
-		}
-
-		// MatchCount is used to select errors from the schema with most positive checks
-		if bestFailures == nil || result.MatchCount > bestFailures.MatchCount {
-			if bestFailures != nil && bestFailures.wantsRedeemOnMerge {
-				pools.poolOfResults.RedeemResult(bestFailures)
-			}
-			bestFailures = result
-
-			continue
-		}
-
-		if result.wantsRedeemOnMerge {
-			pools.poolOfResults.RedeemResult(result) // this result is ditched
-		}
-	}
-
-	mainResult.AddErrors(mustValidateAtLeastOneSchemaMsg(s.Path))
-	mainResult.Merge(bestFailures)
-}
-
-func (s *schemaPropsValidator) validateOneOf(data interface{}, mainResult, keepResultOneOf *Result) {
-	// Validates exactly one in oneOf schemas
-	var (
-		firstSuccess, bestFailures *Result
-		validated                  int
-	)
-
-	for i, oneOfSchema := range s.oneOfValidators {
-		result := oneOfSchema.Validate(data)
-		if s.Options.recycleValidators {
-			s.oneOfValidators[i] = nil
-		}
-
-		// We keep inner IMPORTANT! errors no matter what MatchCount tells us
-		keepResultOneOf.Merge(result.keepRelevantErrors()) // merges (and redeems) a new instance of Result
-
-		if result.IsValid() {
-			validated++
-			_ = keepResultOneOf.cleared()
-
-			if firstSuccess == nil {
-				firstSuccess = result
-			} else if result.wantsRedeemOnMerge {
-				pools.poolOfResults.RedeemResult(result) // this result is ditched
-			}
-
-			continue
-		}
-
-		// MatchCount is used to select errors from the schema with most positive checks
-		if validated == 0 && (bestFailures == nil || result.MatchCount > bestFailures.MatchCount) {
-			if bestFailures != nil && bestFailures.wantsRedeemOnMerge {
-				pools.poolOfResults.RedeemResult(bestFailures)
-			}
-			bestFailures = result
-		} else if result.wantsRedeemOnMerge {
-			pools.poolOfResults.RedeemResult(result) // this result is ditched
-		}
-	}
-
-	switch validated {
-	case 0:
-		mainResult.AddErrors(mustValidateOnlyOneSchemaMsg(s.Path, "Found none valid"))
-		mainResult.Merge(bestFailures)
-		// firstSucess necessarily nil
-	case 1:
-		mainResult.Merge(firstSuccess)
-		if bestFailures != nil && bestFailures.wantsRedeemOnMerge {
-			pools.poolOfResults.RedeemResult(bestFailures)
-		}
-	default:
-		mainResult.AddErrors(mustValidateOnlyOneSchemaMsg(s.Path, fmt.Sprintf("Found %d valid alternatives", validated)))
-		mainResult.Merge(bestFailures)
-		if firstSuccess != nil && firstSuccess.wantsRedeemOnMerge {
-			pools.poolOfResults.RedeemResult(firstSuccess)
-		}
-	}
-}
-
-func (s *schemaPropsValidator) validateAllOf(data interface{}, mainResult, keepResultAllOf *Result) {
-	// Validates all of allOf schemas
-	var validated int
-
-	for i, allOfSchema := range s.allOfValidators {
-		result := allOfSchema.Validate(data)
-		if s.Options.recycleValidators {
-			s.allOfValidators[i] = nil
-		}
-		// We keep inner IMPORTANT! errors no matter what MatchCount tells us
-		keepResultAllOf.Merge(result.keepRelevantErrors())
-		if result.IsValid() {
-			validated++
-		}
-		mainResult.Merge(result)
-	}
-
-	switch validated {
-	case 0:
-		mainResult.AddErrors(mustValidateAllSchemasMsg(s.Path, ". None validated"))
-	case len(s.allOfValidators):
-	default:
-		mainResult.AddErrors(mustValidateAllSchemasMsg(s.Path, ""))
-	}
-}
-
-func (s *schemaPropsValidator) validateNot(data interface{}, mainResult *Result) {
-	result := s.notValidator.Validate(data)
-	if s.Options.recycleValidators {
-		s.notValidator = nil
-	}
-	// We keep inner IMPORTANT! errors no matter what MatchCount tells us
-	if result.IsValid() {
-		mainResult.AddErrors(mustNotValidatechemaMsg(s.Path))
-	}
-	if result.wantsRedeemOnMerge {
-		pools.poolOfResults.RedeemResult(result) // this result is ditched
-	}
-}
-
-func (s *schemaPropsValidator) validateDependencies(data interface{}, mainResult *Result) {
-	val := data.(map[string]interface{})
-	for key := range val {
-		dep, ok := s.Dependencies[key]
-		if !ok {
-			continue
-		}
-
-		if dep.Schema != nil {
-			mainResult.Merge(
-				newSchemaValidator(dep.Schema, s.Root, s.Path+"."+key, s.KnownFormats, s.Options).Validate(data),
-			)
-			continue
-		}
-
-		if len(dep.Property) > 0 {
-			for _, depKey := range dep.Property {
-				if _, ok := val[depKey]; !ok {
-					mainResult.AddErrors(hasADependencyMsg(s.Path, depKey))
-				}
-			}
-		}
-	}
-}
-
-func (s *schemaPropsValidator) redeem() {
-	pools.poolOfSchemaPropsValidators.RedeemValidator(s)
-}
-
-func (s *schemaPropsValidator) redeemChildren() {
-	for _, v := range s.anyOfValidators {
-		if v == nil {
-			continue
-		}
-		v.redeemChildren()
-		v.redeem()
-	}
-	s.anyOfValidators = nil
-
-	for _, v := range s.allOfValidators {
-		if v == nil {
-			continue
-		}
-		v.redeemChildren()
-		v.redeem()
-	}
-	s.allOfValidators = nil
-
-	for _, v := range s.oneOfValidators {
-		if v == nil {
-			continue
-		}
-		v.redeemChildren()
-		v.redeem()
-	}
-	s.oneOfValidators = nil
-
-	if s.notValidator != nil {
-		s.notValidator.redeemChildren()
-		s.notValidator.redeem()
-		s.notValidator = nil
-	}
-}