vendor cleanup: remove unused,non-go and test files

vendor/github.com/googleapis/gnostic/jsonschema/README.md

@@ -1,3 +0,0 @@
-# jsonschema
-
-This directory contains code for reading, writing, and manipulating JSON schemas.

vendor/github.com/googleapis/gnostic/jsonschema/display.go

@@ -1,229 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// 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 jsonschema
-
-import (
-	"fmt"
-	"strings"
-)
-
-//
-// DISPLAY
-// The following methods display Schemas.
-//
-
-// Description returns a string representation of a string or string array.
-func (s *StringOrStringArray) Description() string {
-	if s.String != nil {
-		return *s.String
-	}
-	if s.StringArray != nil {
-		return strings.Join(*s.StringArray, ", ")
-	}
-	return ""
-}
-
-// Returns a string representation of a Schema.
-func (schema *Schema) String() string {
-	return schema.describeSchema("")
-}
-
-// Helper: Returns a string representation of a Schema indented by a specified string.
-func (schema *Schema) describeSchema(indent string) string {
-	result := ""
-	if schema.Schema != nil {
-		result += indent + "$schema: " + *(schema.Schema) + "\n"
-	}
-	if schema.ID != nil {
-		result += indent + "id: " + *(schema.ID) + "\n"
-	}
-	if schema.MultipleOf != nil {
-		result += indent + fmt.Sprintf("multipleOf: %+v\n", *(schema.MultipleOf))
-	}
-	if schema.Maximum != nil {
-		result += indent + fmt.Sprintf("maximum: %+v\n", *(schema.Maximum))
-	}
-	if schema.ExclusiveMaximum != nil {
-		result += indent + fmt.Sprintf("exclusiveMaximum: %+v\n", *(schema.ExclusiveMaximum))
-	}
-	if schema.Minimum != nil {
-		result += indent + fmt.Sprintf("minimum: %+v\n", *(schema.Minimum))
-	}
-	if schema.ExclusiveMinimum != nil {
-		result += indent + fmt.Sprintf("exclusiveMinimum: %+v\n", *(schema.ExclusiveMinimum))
-	}
-	if schema.MaxLength != nil {
-		result += indent + fmt.Sprintf("maxLength: %+v\n", *(schema.MaxLength))
-	}
-	if schema.MinLength != nil {
-		result += indent + fmt.Sprintf("minLength: %+v\n", *(schema.MinLength))
-	}
-	if schema.Pattern != nil {
-		result += indent + fmt.Sprintf("pattern: %+v\n", *(schema.Pattern))
-	}
-	if schema.AdditionalItems != nil {
-		s := schema.AdditionalItems.Schema
-		if s != nil {
-			result += indent + "additionalItems:\n"
-			result += s.describeSchema(indent + "  ")
-		} else {
-			b := *(schema.AdditionalItems.Boolean)
-			result += indent + fmt.Sprintf("additionalItems: %+v\n", b)
-		}
-	}
-	if schema.Items != nil {
-		result += indent + "items:\n"
-		items := schema.Items
-		if items.SchemaArray != nil {
-			for i, s := range *(items.SchemaArray) {
-				result += indent + "  " + fmt.Sprintf("%d", i) + ":\n"
-				result += s.describeSchema(indent + "  " + "  ")
-			}
-		} else if items.Schema != nil {
-			result += items.Schema.describeSchema(indent + "  " + "  ")
-		}
-	}
-	if schema.MaxItems != nil {
-		result += indent + fmt.Sprintf("maxItems: %+v\n", *(schema.MaxItems))
-	}
-	if schema.MinItems != nil {
-		result += indent + fmt.Sprintf("minItems: %+v\n", *(schema.MinItems))
-	}
-	if schema.UniqueItems != nil {
-		result += indent + fmt.Sprintf("uniqueItems: %+v\n", *(schema.UniqueItems))
-	}
-	if schema.MaxProperties != nil {
-		result += indent + fmt.Sprintf("maxProperties: %+v\n", *(schema.MaxProperties))
-	}
-	if schema.MinProperties != nil {
-		result += indent + fmt.Sprintf("minProperties: %+v\n", *(schema.MinProperties))
-	}
-	if schema.Required != nil {
-		result += indent + fmt.Sprintf("required: %+v\n", *(schema.Required))
-	}
-	if schema.AdditionalProperties != nil {
-		s := schema.AdditionalProperties.Schema
-		if s != nil {
-			result += indent + "additionalProperties:\n"
-			result += s.describeSchema(indent + "  ")
-		} else {
-			b := *(schema.AdditionalProperties.Boolean)
-			result += indent + fmt.Sprintf("additionalProperties: %+v\n", b)
-		}
-	}
-	if schema.Properties != nil {
-		result += indent + "properties:\n"
-		for _, pair := range *(schema.Properties) {
-			name := pair.Name
-			s := pair.Value
-			result += indent + "  " + name + ":\n"
-			result += s.describeSchema(indent + "  " + "  ")
-		}
-	}
-	if schema.PatternProperties != nil {
-		result += indent + "patternProperties:\n"
-		for _, pair := range *(schema.PatternProperties) {
-			name := pair.Name
-			s := pair.Value
-			result += indent + "  " + name + ":\n"
-			result += s.describeSchema(indent + "  " + "  ")
-		}
-	}
-	if schema.Dependencies != nil {
-		result += indent + "dependencies:\n"
-		for _, pair := range *(schema.Dependencies) {
-			name := pair.Name
-			schemaOrStringArray := pair.Value
-			s := schemaOrStringArray.Schema
-			if s != nil {
-				result += indent + "  " + name + ":\n"
-				result += s.describeSchema(indent + "  " + "  ")
-			} else {
-				a := schemaOrStringArray.StringArray
-				if a != nil {
-					result += indent + "  " + name + ":\n"
-					for _, s2 := range *a {
-						result += indent + "  " + "  " + s2 + "\n"
-					}
-				}
-			}
-
-		}
-	}
-	if schema.Enumeration != nil {
-		result += indent + "enumeration:\n"
-		for _, value := range *(schema.Enumeration) {
-			if value.String != nil {
-				result += indent + "  " + fmt.Sprintf("%+v\n", *value.String)
-			} else {
-				result += indent + "  " + fmt.Sprintf("%+v\n", *value.Bool)
-			}
-		}
-	}
-	if schema.Type != nil {
-		result += indent + fmt.Sprintf("type: %+v\n", schema.Type.Description())
-	}
-	if schema.AllOf != nil {
-		result += indent + "allOf:\n"
-		for _, s := range *(schema.AllOf) {
-			result += s.describeSchema(indent + "  ")
-			result += indent + "-\n"
-		}
-	}
-	if schema.AnyOf != nil {
-		result += indent + "anyOf:\n"
-		for _, s := range *(schema.AnyOf) {
-			result += s.describeSchema(indent + "  ")
-			result += indent + "-\n"
-		}
-	}
-	if schema.OneOf != nil {
-		result += indent + "oneOf:\n"
-		for _, s := range *(schema.OneOf) {
-			result += s.describeSchema(indent + "  ")
-			result += indent + "-\n"
-		}
-	}
-	if schema.Not != nil {
-		result += indent + "not:\n"
-		result += schema.Not.describeSchema(indent + "  ")
-	}
-	if schema.Definitions != nil {
-		result += indent + "definitions:\n"
-		for _, pair := range *(schema.Definitions) {
-			name := pair.Name
-			s := pair.Value
-			result += indent + "  " + name + ":\n"
-			result += s.describeSchema(indent + "  " + "  ")
-		}
-	}
-	if schema.Title != nil {
-		result += indent + "title: " + *(schema.Title) + "\n"
-	}
-	if schema.Description != nil {
-		result += indent + "description: " + *(schema.Description) + "\n"
-	}
-	if schema.Default != nil {
-		result += indent + "default:\n"
-		result += indent + fmt.Sprintf("  %+v\n", *(schema.Default))
-	}
-	if schema.Format != nil {
-		result += indent + "format: " + *(schema.Format) + "\n"
-	}
-	if schema.Ref != nil {
-		result += indent + "$ref: " + *(schema.Ref) + "\n"
-	}
-	return result
-}

vendor/github.com/googleapis/gnostic/jsonschema/models.go

@@ -1,226 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// 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 jsonschema supports the reading, writing, and manipulation
-// of JSON Schemas.
-package jsonschema
-
-// The Schema struct models a JSON Schema and, because schemas are
-// defined hierarchically, contains many references to itself.
-// All fields are pointers and are nil if the associated values
-// are not specified.
-type Schema struct {
-	Schema *string // $schema
-	ID     *string // id keyword used for $ref resolution scope
-	Ref    *string // $ref, i.e. JSON Pointers
-
-	// http://json-schema.org/latest/json-schema-validation.html
-	// 5.1.  Validation keywords for numeric instances (number and integer)
-	MultipleOf       *SchemaNumber
-	Maximum          *SchemaNumber
-	ExclusiveMaximum *bool
-	Minimum          *SchemaNumber
-	ExclusiveMinimum *bool
-
-	// 5.2.  Validation keywords for strings
-	MaxLength *int64
-	MinLength *int64
-	Pattern   *string
-
-	// 5.3.  Validation keywords for arrays
-	AdditionalItems *SchemaOrBoolean
-	Items           *SchemaOrSchemaArray
-	MaxItems        *int64
-	MinItems        *int64
-	UniqueItems     *bool
-
-	// 5.4.  Validation keywords for objects
-	MaxProperties        *int64
-	MinProperties        *int64
-	Required             *[]string
-	AdditionalProperties *SchemaOrBoolean
-	Properties           *[]*NamedSchema
-	PatternProperties    *[]*NamedSchema
-	Dependencies         *[]*NamedSchemaOrStringArray
-
-	// 5.5.  Validation keywords for any instance type
-	Enumeration *[]SchemaEnumValue
-	Type        *StringOrStringArray
-	AllOf       *[]*Schema
-	AnyOf       *[]*Schema
-	OneOf       *[]*Schema
-	Not         *Schema
-	Definitions *[]*NamedSchema
-
-	// 6.  Metadata keywords
-	Title       *string
-	Description *string
-	Default     *interface{}
-
-	// 7.  Semantic validation with "format"
-	Format *string
-}
-
-// These helper structs represent "combination" types that generally can
-// have values of one type or another. All are used to represent parts
-// of Schemas.
-
-// SchemaNumber represents a value that can be either an Integer or a Float.
-type SchemaNumber struct {
-	Integer *int64
-	Float   *float64
-}
-
-// NewSchemaNumberWithInteger creates and returns a new object
-func NewSchemaNumberWithInteger(i int64) *SchemaNumber {
-	result := &SchemaNumber{}
-	result.Integer = &i
-	return result
-}
-
-// NewSchemaNumberWithFloat creates and returns a new object
-func NewSchemaNumberWithFloat(f float64) *SchemaNumber {
-	result := &SchemaNumber{}
-	result.Float = &f
-	return result
-}
-
-// SchemaOrBoolean represents a value that can be either a Schema or a Boolean.
-type SchemaOrBoolean struct {
-	Schema  *Schema
-	Boolean *bool
-}
-
-// NewSchemaOrBooleanWithSchema creates and returns a new object
-func NewSchemaOrBooleanWithSchema(s *Schema) *SchemaOrBoolean {
-	result := &SchemaOrBoolean{}
-	result.Schema = s
-	return result
-}
-
-// NewSchemaOrBooleanWithBoolean creates and returns a new object
-func NewSchemaOrBooleanWithBoolean(b bool) *SchemaOrBoolean {
-	result := &SchemaOrBoolean{}
-	result.Boolean = &b
-	return result
-}
-
-// StringOrStringArray represents a value that can be either
-// a String or an Array of Strings.
-type StringOrStringArray struct {
-	String      *string
-	StringArray *[]string
-}
-
-// NewStringOrStringArrayWithString creates and returns a new object
-func NewStringOrStringArrayWithString(s string) *StringOrStringArray {
-	result := &StringOrStringArray{}
-	result.String = &s
-	return result
-}
-
-// NewStringOrStringArrayWithStringArray creates and returns a new object
-func NewStringOrStringArrayWithStringArray(a []string) *StringOrStringArray {
-	result := &StringOrStringArray{}
-	result.StringArray = &a
-	return result
-}
-
-// SchemaOrStringArray represents a value that can be either
-// a Schema or an Array of Strings.
-type SchemaOrStringArray struct {
-	Schema      *Schema
-	StringArray *[]string
-}
-
-// SchemaOrSchemaArray represents a value that can be either
-// a Schema or an Array of Schemas.
-type SchemaOrSchemaArray struct {
-	Schema      *Schema
-	SchemaArray *[]*Schema
-}
-
-// NewSchemaOrSchemaArrayWithSchema creates and returns a new object
-func NewSchemaOrSchemaArrayWithSchema(s *Schema) *SchemaOrSchemaArray {
-	result := &SchemaOrSchemaArray{}
-	result.Schema = s
-	return result
-}
-
-// NewSchemaOrSchemaArrayWithSchemaArray creates and returns a new object
-func NewSchemaOrSchemaArrayWithSchemaArray(a []*Schema) *SchemaOrSchemaArray {
-	result := &SchemaOrSchemaArray{}
-	result.SchemaArray = &a
-	return result
-}
-
-// SchemaEnumValue represents a value that can be part of an
-// enumeration in a Schema.
-type SchemaEnumValue struct {
-	String *string
-	Bool   *bool
-}
-
-// NamedSchema is a name-value pair that is used to emulate maps
-// with ordered keys.
-type NamedSchema struct {
-	Name  string
-	Value *Schema
-}
-
-// NewNamedSchema creates and returns a new object
-func NewNamedSchema(name string, value *Schema) *NamedSchema {
-	return &NamedSchema{Name: name, Value: value}
-}
-
-// NamedSchemaOrStringArray is a name-value pair that is used
-// to emulate maps with ordered keys.
-type NamedSchemaOrStringArray struct {
-	Name  string
-	Value *SchemaOrStringArray
-}
-
-// Access named subschemas by name
-
-func namedSchemaArrayElementWithName(array *[]*NamedSchema, name string) *Schema {
-	if array == nil {
-		return nil
-	}
-	for _, pair := range *array {
-		if pair.Name == name {
-			return pair.Value
-		}
-	}
-	return nil
-}
-
-// PropertyWithName returns the selected element.
-func (s *Schema) PropertyWithName(name string) *Schema {
-	return namedSchemaArrayElementWithName(s.Properties, name)
-}
-
-// PatternPropertyWithName returns the selected element.
-func (s *Schema) PatternPropertyWithName(name string) *Schema {
-	return namedSchemaArrayElementWithName(s.PatternProperties, name)
-}
-
-// DefinitionWithName returns the selected element.
-func (s *Schema) DefinitionWithName(name string) *Schema {
-	return namedSchemaArrayElementWithName(s.Definitions, name)
-}
-
-// AddProperty adds a named property.
-func (s *Schema) AddProperty(name string, property *Schema) {
-	*s.Properties = append(*s.Properties, NewNamedSchema(name, property))
-}

vendor/github.com/googleapis/gnostic/jsonschema/operations.go

@@ -1,394 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// 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 jsonschema
-
-import (
-	"fmt"
-	"log"
-	"strings"
-)
-
-//
-// OPERATIONS
-// The following methods perform operations on Schemas.
-//
-
-// IsEmpty returns true if no members of the Schema are specified.
-func (schema *Schema) IsEmpty() bool {
-	return (schema.Schema == nil) &&
-		(schema.ID == nil) &&
-		(schema.MultipleOf == nil) &&
-		(schema.Maximum == nil) &&
-		(schema.ExclusiveMaximum == nil) &&
-		(schema.Minimum == nil) &&
-		(schema.ExclusiveMinimum == nil) &&
-		(schema.MaxLength == nil) &&
-		(schema.MinLength == nil) &&
-		(schema.Pattern == nil) &&
-		(schema.AdditionalItems == nil) &&
-		(schema.Items == nil) &&
-		(schema.MaxItems == nil) &&
-		(schema.MinItems == nil) &&
-		(schema.UniqueItems == nil) &&
-		(schema.MaxProperties == nil) &&
-		(schema.MinProperties == nil) &&
-		(schema.Required == nil) &&
-		(schema.AdditionalProperties == nil) &&
-		(schema.Properties == nil) &&
-		(schema.PatternProperties == nil) &&
-		(schema.Dependencies == nil) &&
-		(schema.Enumeration == nil) &&
-		(schema.Type == nil) &&
-		(schema.AllOf == nil) &&
-		(schema.AnyOf == nil) &&
-		(schema.OneOf == nil) &&
-		(schema.Not == nil) &&
-		(schema.Definitions == nil) &&
-		(schema.Title == nil) &&
-		(schema.Description == nil) &&
-		(schema.Default == nil) &&
-		(schema.Format == nil) &&
-		(schema.Ref == nil)
-}
-
-// IsEqual returns true if two schemas are equal.
-func (schema *Schema) IsEqual(schema2 *Schema) bool {
-	return schema.String() == schema2.String()
-}
-
-// SchemaOperation represents a function that can be applied to a Schema.
-type SchemaOperation func(schema *Schema, context string)
-
-// Applies a specified function to a Schema and all of the Schemas that it contains.
-func (schema *Schema) applyToSchemas(operation SchemaOperation, context string) {
-
-	if schema.AdditionalItems != nil {
-		s := schema.AdditionalItems.Schema
-		if s != nil {
-			s.applyToSchemas(operation, "AdditionalItems")
-		}
-	}
-
-	if schema.Items != nil {
-		if schema.Items.SchemaArray != nil {
-			for _, s := range *(schema.Items.SchemaArray) {
-				s.applyToSchemas(operation, "Items.SchemaArray")
-			}
-		} else if schema.Items.Schema != nil {
-			schema.Items.Schema.applyToSchemas(operation, "Items.Schema")
-		}
-	}
-
-	if schema.AdditionalProperties != nil {
-		s := schema.AdditionalProperties.Schema
-		if s != nil {
-			s.applyToSchemas(operation, "AdditionalProperties")
-		}
-	}
-
-	if schema.Properties != nil {
-		for _, pair := range *(schema.Properties) {
-			s := pair.Value
-			s.applyToSchemas(operation, "Properties")
-		}
-	}
-	if schema.PatternProperties != nil {
-		for _, pair := range *(schema.PatternProperties) {
-			s := pair.Value
-			s.applyToSchemas(operation, "PatternProperties")
-		}
-	}
-
-	if schema.Dependencies != nil {
-		for _, pair := range *(schema.Dependencies) {
-			schemaOrStringArray := pair.Value
-			s := schemaOrStringArray.Schema
-			if s != nil {
-				s.applyToSchemas(operation, "Dependencies")
-			}
-		}
-	}
-
-	if schema.AllOf != nil {
-		for _, s := range *(schema.AllOf) {
-			s.applyToSchemas(operation, "AllOf")
-		}
-	}
-	if schema.AnyOf != nil {
-		for _, s := range *(schema.AnyOf) {
-			s.applyToSchemas(operation, "AnyOf")
-		}
-	}
-	if schema.OneOf != nil {
-		for _, s := range *(schema.OneOf) {
-			s.applyToSchemas(operation, "OneOf")
-		}
-	}
-	if schema.Not != nil {
-		schema.Not.applyToSchemas(operation, "Not")
-	}
-
-	if schema.Definitions != nil {
-		for _, pair := range *(schema.Definitions) {
-			s := pair.Value
-			s.applyToSchemas(operation, "Definitions")
-		}
-	}
-
-	operation(schema, context)
-}
-
-// CopyProperties copies all non-nil properties from the source Schema to the schema Schema.
-func (schema *Schema) CopyProperties(source *Schema) {
-	if source.Schema != nil {
-		schema.Schema = source.Schema
-	}
-	if source.ID != nil {
-		schema.ID = source.ID
-	}
-	if source.MultipleOf != nil {
-		schema.MultipleOf = source.MultipleOf
-	}
-	if source.Maximum != nil {
-		schema.Maximum = source.Maximum
-	}
-	if source.ExclusiveMaximum != nil {
-		schema.ExclusiveMaximum = source.ExclusiveMaximum
-	}
-	if source.Minimum != nil {
-		schema.Minimum = source.Minimum
-	}
-	if source.ExclusiveMinimum != nil {
-		schema.ExclusiveMinimum = source.ExclusiveMinimum
-	}
-	if source.MaxLength != nil {
-		schema.MaxLength = source.MaxLength
-	}
-	if source.MinLength != nil {
-		schema.MinLength = source.MinLength
-	}
-	if source.Pattern != nil {
-		schema.Pattern = source.Pattern
-	}
-	if source.AdditionalItems != nil {
-		schema.AdditionalItems = source.AdditionalItems
-	}
-	if source.Items != nil {
-		schema.Items = source.Items
-	}
-	if source.MaxItems != nil {
-		schema.MaxItems = source.MaxItems
-	}
-	if source.MinItems != nil {
-		schema.MinItems = source.MinItems
-	}
-	if source.UniqueItems != nil {
-		schema.UniqueItems = source.UniqueItems
-	}
-	if source.MaxProperties != nil {
-		schema.MaxProperties = source.MaxProperties
-	}
-	if source.MinProperties != nil {
-		schema.MinProperties = source.MinProperties
-	}
-	if source.Required != nil {
-		schema.Required = source.Required
-	}
-	if source.AdditionalProperties != nil {
-		schema.AdditionalProperties = source.AdditionalProperties
-	}
-	if source.Properties != nil {
-		schema.Properties = source.Properties
-	}
-	if source.PatternProperties != nil {
-		schema.PatternProperties = source.PatternProperties
-	}
-	if source.Dependencies != nil {
-		schema.Dependencies = source.Dependencies
-	}
-	if source.Enumeration != nil {
-		schema.Enumeration = source.Enumeration
-	}
-	if source.Type != nil {
-		schema.Type = source.Type
-	}
-	if source.AllOf != nil {
-		schema.AllOf = source.AllOf
-	}
-	if source.AnyOf != nil {
-		schema.AnyOf = source.AnyOf
-	}
-	if source.OneOf != nil {
-		schema.OneOf = source.OneOf
-	}
-	if source.Not != nil {
-		schema.Not = source.Not
-	}
-	if source.Definitions != nil {
-		schema.Definitions = source.Definitions
-	}
-	if source.Title != nil {
-		schema.Title = source.Title
-	}
-	if source.Description != nil {
-		schema.Description = source.Description
-	}
-	if source.Default != nil {
-		schema.Default = source.Default
-	}
-	if source.Format != nil {
-		schema.Format = source.Format
-	}
-	if source.Ref != nil {
-		schema.Ref = source.Ref
-	}
-}
-
-// TypeIs returns true if the Type of a Schema includes the specified type
-func (schema *Schema) TypeIs(typeName string) bool {
-	if schema.Type != nil {
-		// the schema Type is either a string or an array of strings
-		if schema.Type.String != nil {
-			return (*(schema.Type.String) == typeName)
-		} else if schema.Type.StringArray != nil {
-			for _, n := range *(schema.Type.StringArray) {
-				if n == typeName {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}
-
-// ResolveRefs resolves "$ref" elements in a Schema and its children.
-// But if a reference refers to an object type, is inside a oneOf, or contains a oneOf,
-// the reference is kept and we expect downstream tools to separately model these
-// referenced schemas.
-func (schema *Schema) ResolveRefs() {
-	rootSchema := schema
-	count := 1
-	for count > 0 {
-		count = 0
-		schema.applyToSchemas(
-			func(schema *Schema, context string) {
-				if schema.Ref != nil {
-					resolvedRef, err := rootSchema.resolveJSONPointer(*(schema.Ref))
-					if err != nil {
-						log.Printf("%+v", err)
-					} else if resolvedRef.TypeIs("object") {
-						// don't substitute for objects, we'll model the referenced schema with a class
-					} else if context == "OneOf" {
-						// don't substitute for references inside oneOf declarations
-					} else if resolvedRef.OneOf != nil {
-						// don't substitute for references that contain oneOf declarations
-					} else if resolvedRef.AdditionalProperties != nil {
-						// don't substitute for references that look like objects
-					} else {
-						schema.Ref = nil
-						schema.CopyProperties(resolvedRef)
-						count++
-					}
-				}
-			}, "")
-	}
-}
-
-// resolveJSONPointer resolves JSON pointers.
-// This current implementation is very crude and custom for OpenAPI 2.0 schemas.
-// It panics for any pointer that it is unable to resolve.
-func (schema *Schema) resolveJSONPointer(ref string) (result *Schema, err error) {
-	parts := strings.Split(ref, "#")
-	if len(parts) == 2 {
-		documentName := parts[0] + "#"
-		if documentName == "#" && schema.ID != nil {
-			documentName = *(schema.ID)
-		}
-		path := parts[1]
-		document := schemas[documentName]
-		pathParts := strings.Split(path, "/")
-
-		// we currently do a very limited (hard-coded) resolution of certain paths and log errors for missed cases
-		if len(pathParts) == 1 {
-			return document, nil
-		} else if len(pathParts) == 3 {
-			switch pathParts[1] {
-			case "definitions":
-				dictionary := document.Definitions
-				for _, pair := range *dictionary {
-					if pair.Name == pathParts[2] {
-						result = pair.Value
-					}
-				}
-			case "properties":
-				dictionary := document.Properties
-				for _, pair := range *dictionary {
-					if pair.Name == pathParts[2] {
-						result = pair.Value
-					}
-				}
-			default:
-				break
-			}
-		}
-	}
-	if result == nil {
-		return nil, fmt.Errorf("unresolved pointer: %+v", ref)
-	}
-	return result, nil
-}
-
-// ResolveAllOfs replaces "allOf" elements by merging their properties into the parent Schema.
-func (schema *Schema) ResolveAllOfs() {
-	schema.applyToSchemas(
-		func(schema *Schema, context string) {
-			if schema.AllOf != nil {
-				for _, allOf := range *(schema.AllOf) {
-					schema.CopyProperties(allOf)
-				}
-				schema.AllOf = nil
-			}
-		}, "resolveAllOfs")
-}
-
-// ResolveAnyOfs replaces all "anyOf" elements with "oneOf".
-func (schema *Schema) ResolveAnyOfs() {
-	schema.applyToSchemas(
-		func(schema *Schema, context string) {
-			if schema.AnyOf != nil {
-				schema.OneOf = schema.AnyOf
-				schema.AnyOf = nil
-			}
-		}, "resolveAnyOfs")
-}
-
-// return a pointer to a copy of a passed-in string
-func stringptr(input string) (output *string) {
-	return &input
-}
-
-// CopyOfficialSchemaProperty copies a named property from the official JSON Schema definition
-func (schema *Schema) CopyOfficialSchemaProperty(name string) {
-	*schema.Properties = append(*schema.Properties,
-		NewNamedSchema(name,
-			&Schema{Ref: stringptr("http://json-schema.org/draft-04/schema#/properties/" + name)}))
-}
-
-// CopyOfficialSchemaProperties copies named properties from the official JSON Schema definition
-func (schema *Schema) CopyOfficialSchemaProperties(names []string) {
-	for _, name := range names {
-		schema.CopyOfficialSchemaProperty(name)
-	}
-}

vendor/github.com/googleapis/gnostic/jsonschema/reader.go

@@ -1,409 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// 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 jsonschema
-
-import (
-	"fmt"
-	"io/ioutil"
-
-	"gopkg.in/yaml.v2"
-)
-
-// This is a global map of all known Schemas.
-// It is initialized when the first Schema is created and inserted.
-var schemas map[string]*Schema
-
-// NewSchemaFromFile reads a schema from a file.
-// Currently this assumes that schemas are stored in the source distribution of this project.
-func NewSchemaFromFile(filename string) (schema *Schema, err error) {
-	file, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	var info yaml.MapSlice
-	err = yaml.Unmarshal(file, &info)
-	if err != nil {
-		return nil, err
-	}
-	return NewSchemaFromObject(info), nil
-}
-
-// NewSchemaFromObject constructs a schema from a parsed JSON object.
-// Due to the complexity of the schema representation, this is a
-// custom reader and not the standard Go JSON reader (encoding/json).
-func NewSchemaFromObject(jsonData interface{}) *Schema {
-	switch t := jsonData.(type) {
-	default:
-		fmt.Printf("schemaValue: unexpected type %T\n", t)
-		return nil
-	case yaml.MapSlice:
-		schema := &Schema{}
-		for _, mapItem := range t {
-			k := mapItem.Key.(string)
-			v := mapItem.Value
-
-			switch k {
-			case "$schema":
-				schema.Schema = schema.stringValue(v)
-			case "id":
-				schema.ID = schema.stringValue(v)
-
-			case "multipleOf":
-				schema.MultipleOf = schema.numberValue(v)
-			case "maximum":
-				schema.Maximum = schema.numberValue(v)
-			case "exclusiveMaximum":
-				schema.ExclusiveMaximum = schema.boolValue(v)
-			case "minimum":
-				schema.Minimum = schema.numberValue(v)
-			case "exclusiveMinimum":
-				schema.ExclusiveMinimum = schema.boolValue(v)
-
-			case "maxLength":
-				schema.MaxLength = schema.intValue(v)
-			case "minLength":
-				schema.MinLength = schema.intValue(v)
-			case "pattern":
-				schema.Pattern = schema.stringValue(v)
-
-			case "additionalItems":
-				schema.AdditionalItems = schema.schemaOrBooleanValue(v)
-			case "items":
-				schema.Items = schema.schemaOrSchemaArrayValue(v)
-			case "maxItems":
-				schema.MaxItems = schema.intValue(v)
-			case "minItems":
-				schema.MinItems = schema.intValue(v)
-			case "uniqueItems":
-				schema.UniqueItems = schema.boolValue(v)
-
-			case "maxProperties":
-				schema.MaxProperties = schema.intValue(v)
-			case "minProperties":
-				schema.MinProperties = schema.intValue(v)
-			case "required":
-				schema.Required = schema.arrayOfStringsValue(v)
-			case "additionalProperties":
-				schema.AdditionalProperties = schema.schemaOrBooleanValue(v)
-			case "properties":
-				schema.Properties = schema.mapOfSchemasValue(v)
-			case "patternProperties":
-				schema.PatternProperties = schema.mapOfSchemasValue(v)
-			case "dependencies":
-				schema.Dependencies = schema.mapOfSchemasOrStringArraysValue(v)
-
-			case "enum":
-				schema.Enumeration = schema.arrayOfEnumValuesValue(v)
-
-			case "type":
-				schema.Type = schema.stringOrStringArrayValue(v)
-			case "allOf":
-				schema.AllOf = schema.arrayOfSchemasValue(v)
-			case "anyOf":
-				schema.AnyOf = schema.arrayOfSchemasValue(v)
-			case "oneOf":
-				schema.OneOf = schema.arrayOfSchemasValue(v)
-			case "not":
-				schema.Not = NewSchemaFromObject(v)
-			case "definitions":
-				schema.Definitions = schema.mapOfSchemasValue(v)
-
-			case "title":
-				schema.Title = schema.stringValue(v)
-			case "description":
-				schema.Description = schema.stringValue(v)
-
-			case "default":
-				schema.Default = &v
-
-			case "format":
-				schema.Format = schema.stringValue(v)
-			case "$ref":
-				schema.Ref = schema.stringValue(v)
-			default:
-				fmt.Printf("UNSUPPORTED (%s)\n", k)
-			}
-		}
-
-		// insert schema in global map
-		if schema.ID != nil {
-			if schemas == nil {
-				schemas = make(map[string]*Schema, 0)
-			}
-			schemas[*(schema.ID)] = schema
-		}
-		return schema
-	}
-	return nil
-}
-
-//
-// BUILDERS
-// The following methods build elements of Schemas from interface{} values.
-// Each returns nil if it is unable to build the desired element.
-//
-
-// Gets the string value of an interface{} value if possible.
-func (schema *Schema) stringValue(v interface{}) *string {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("stringValue: unexpected type %T\n", v)
-	case string:
-		return &v
-	}
-	return nil
-}
-
-// Gets the numeric value of an interface{} value if possible.
-func (schema *Schema) numberValue(v interface{}) *SchemaNumber {
-	number := &SchemaNumber{}
-	switch v := v.(type) {
-	default:
-		fmt.Printf("numberValue: unexpected type %T\n", v)
-	case float64:
-		v2 := float64(v)
-		number.Float = &v2
-		return number
-	case float32:
-		v2 := float64(v)
-		number.Float = &v2
-		return number
-	case int:
-		v2 := int64(v)
-		number.Integer = &v2
-	}
-	return nil
-}
-
-// Gets the integer value of an interface{} value if possible.
-func (schema *Schema) intValue(v interface{}) *int64 {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("intValue: unexpected type %T\n", v)
-	case float64:
-		v2 := int64(v)
-		return &v2
-	case int64:
-		return &v
-	case int:
-		v2 := int64(v)
-		return &v2
-	}
-	return nil
-}
-
-// Gets the bool value of an interface{} value if possible.
-func (schema *Schema) boolValue(v interface{}) *bool {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("boolValue: unexpected type %T\n", v)
-	case bool:
-		return &v
-	}
-	return nil
-}
-
-// Gets a map of Schemas from an interface{} value if possible.
-func (schema *Schema) mapOfSchemasValue(v interface{}) *[]*NamedSchema {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("mapOfSchemasValue: unexpected type %T\n", v)
-	case yaml.MapSlice:
-		m := make([]*NamedSchema, 0)
-		for _, mapItem := range v {
-			k2 := mapItem.Key.(string)
-			v2 := mapItem.Value
-			pair := &NamedSchema{Name: k2, Value: NewSchemaFromObject(v2)}
-			m = append(m, pair)
-		}
-		return &m
-	}
-	return nil
-}
-
-// Gets an array of Schemas from an interface{} value if possible.
-func (schema *Schema) arrayOfSchemasValue(v interface{}) *[]*Schema {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("arrayOfSchemasValue: unexpected type %T\n", v)
-	case []interface{}:
-		m := make([]*Schema, 0)
-		for _, v2 := range v {
-			switch v2 := v2.(type) {
-			default:
-				fmt.Printf("arrayOfSchemasValue: unexpected type %T\n", v2)
-			case yaml.MapSlice:
-				s := NewSchemaFromObject(v2)
-				m = append(m, s)
-			}
-		}
-		return &m
-	case yaml.MapSlice:
-		m := make([]*Schema, 0)
-		s := NewSchemaFromObject(v)
-		m = append(m, s)
-		return &m
-	}
-	return nil
-}
-
-// Gets a Schema or an array of Schemas from an interface{} value if possible.
-func (schema *Schema) schemaOrSchemaArrayValue(v interface{}) *SchemaOrSchemaArray {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("schemaOrSchemaArrayValue: unexpected type %T\n", v)
-	case []interface{}:
-		m := make([]*Schema, 0)
-		for _, v2 := range v {
-			switch v2 := v2.(type) {
-			default:
-				fmt.Printf("schemaOrSchemaArrayValue: unexpected type %T\n", v2)
-			case map[string]interface{}:
-				s := NewSchemaFromObject(v2)
-				m = append(m, s)
-			}
-		}
-		return &SchemaOrSchemaArray{SchemaArray: &m}
-	case yaml.MapSlice:
-		s := NewSchemaFromObject(v)
-		return &SchemaOrSchemaArray{Schema: s}
-	}
-	return nil
-}
-
-// Gets an array of strings from an interface{} value if possible.
-func (schema *Schema) arrayOfStringsValue(v interface{}) *[]string {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("arrayOfStringsValue: unexpected type %T\n", v)
-	case []string:
-		return &v
-	case string:
-		a := []string{v}
-		return &a
-	case []interface{}:
-		a := make([]string, 0)
-		for _, v2 := range v {
-			switch v2 := v2.(type) {
-			default:
-				fmt.Printf("arrayOfStringsValue: unexpected type %T\n", v2)
-			case string:
-				a = append(a, v2)
-			}
-		}
-		return &a
-	}
-	return nil
-}
-
-// Gets a string or an array of strings from an interface{} value if possible.
-func (schema *Schema) stringOrStringArrayValue(v interface{}) *StringOrStringArray {
-	switch v := v.(type) {
-	default:
-		fmt.Printf("arrayOfStringsValue: unexpected type %T\n", v)
-	case []string:
-		s := &StringOrStringArray{}
-		s.StringArray = &v
-		return s
-	case string:
-		s := &StringOrStringArray{}
-		s.String = &v
-		return s
-	case []interface{}:
-		a := make([]string, 0)
-		for _, v2 := range v {
-			switch v2 := v2.(type) {
-			default:
-				fmt.Printf("arrayOfStringsValue: unexpected type %T\n", v2)
-			case string:
-				a = append(a, v2)
-			}
-		}
-		s := &StringOrStringArray{}
-		s.StringArray = &a
-		return s
-	}
-	return nil
-}
-
-// Gets an array of enum values from an interface{} value if possible.
-func (schema *Schema) arrayOfEnumValuesValue(v interface{}) *[]SchemaEnumValue {
-	a := make([]SchemaEnumValue, 0)
-	switch v := v.(type) {
-	default:
-		fmt.Printf("arrayOfEnumValuesValue: unexpected type %T\n", v)
-	case []interface{}:
-		for _, v2 := range v {
-			switch v2 := v2.(type) {
-			default:
-				fmt.Printf("arrayOfEnumValuesValue: unexpected type %T\n", v2)
-			case string:
-				a = append(a, SchemaEnumValue{String: &v2})
-			case bool:
-				a = append(a, SchemaEnumValue{Bool: &v2})
-			}
-		}
-	}
-	return &a
-}
-
-// Gets a map of schemas or string arrays from an interface{} value if possible.
-func (schema *Schema) mapOfSchemasOrStringArraysValue(v interface{}) *[]*NamedSchemaOrStringArray {
-	m := make([]*NamedSchemaOrStringArray, 0)
-	switch v := v.(type) {
-	default:
-		fmt.Printf("mapOfSchemasOrStringArraysValue: unexpected type %T %+v\n", v, v)
-	case yaml.MapSlice:
-		for _, mapItem := range v {
-			k2 := mapItem.Key.(string)
-			v2 := mapItem.Value
-			switch v2 := v2.(type) {
-			default:
-				fmt.Printf("mapOfSchemasOrStringArraysValue: unexpected type %T %+v\n", v2, v2)
-			case []interface{}:
-				a := make([]string, 0)
-				for _, v3 := range v2 {
-					switch v3 := v3.(type) {
-					default:
-						fmt.Printf("mapOfSchemasOrStringArraysValue: unexpected type %T %+v\n", v3, v3)
-					case string:
-						a = append(a, v3)
-					}
-				}
-				s := &SchemaOrStringArray{}
-				s.StringArray = &a
-				pair := &NamedSchemaOrStringArray{Name: k2, Value: s}
-				m = append(m, pair)
-			}
-		}
-	}
-	return &m
-}
-
-// Gets a schema or a boolean value from an interface{} value if possible.
-func (schema *Schema) schemaOrBooleanValue(v interface{}) *SchemaOrBoolean {
-	schemaOrBoolean := &SchemaOrBoolean{}
-	switch v := v.(type) {
-	case bool:
-		schemaOrBoolean.Boolean = &v
-	case yaml.MapSlice:
-		schemaOrBoolean.Schema = NewSchemaFromObject(v)
-	default:
-		fmt.Printf("schemaOrBooleanValue: unexpected type %T\n", v)
-	case []map[string]interface{}:
-
-	}
-	return schemaOrBoolean
-}

vendor/github.com/googleapis/gnostic/jsonschema/schema.json

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

vendor/github.com/googleapis/gnostic/jsonschema/writer.go

@@ -1,334 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// 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 jsonschema
-
-import (
-	"fmt"
-	"gopkg.in/yaml.v2"
-)
-
-const indentation = "  "
-
-func renderMap(info interface{}, indent string) (result string) {
-	result = "{\n"
-	innerIndent := indent + indentation
-	switch pairs := info.(type) {
-	case yaml.MapSlice:
-		for i, pair := range pairs {
-			// first print the key
-			result += fmt.Sprintf("%s\"%+v\": ", innerIndent, pair.Key)
-			// then the value
-			switch value := pair.Value.(type) {
-			case string:
-				result += "\"" + value + "\""
-			case bool:
-				if value {
-					result += "true"
-				} else {
-					result += "false"
-				}
-			case []interface{}:
-				result += renderArray(value, innerIndent)
-			case yaml.MapSlice:
-				result += renderMap(value, innerIndent)
-			case int:
-				result += fmt.Sprintf("%d", value)
-			case int64:
-				result += fmt.Sprintf("%d", value)
-			case []string:
-				result += renderStringArray(value, innerIndent)
-			default:
-				result += fmt.Sprintf("???MapItem(Key:%+v, Value:%T)", value, value)
-			}
-			if i < len(pairs)-1 {
-				result += ","
-			}
-			result += "\n"
-		}
-	default:
-		// t is some other type that we didn't name.
-	}
-
-	result += indent + "}"
-	return result
-}
-
-func renderArray(array []interface{}, indent string) (result string) {
-	result = "[\n"
-	innerIndent := indent + indentation
-	for i, item := range array {
-		switch item := item.(type) {
-		case string:
-			result += innerIndent + "\"" + item + "\""
-		case bool:
-			if item {
-				result += innerIndent + "true"
-			} else {
-				result += innerIndent + "false"
-			}
-		case yaml.MapSlice:
-			result += innerIndent + renderMap(item, innerIndent) + ""
-		default:
-			result += innerIndent + fmt.Sprintf("???ArrayItem(%+v)", item)
-		}
-		if i < len(array)-1 {
-			result += ","
-		}
-		result += "\n"
-	}
-	result += indent + "]"
-	return result
-}
-
-func renderStringArray(array []string, indent string) (result string) {
-	result = "[\n"
-	innerIndent := indent + indentation
-	for i, item := range array {
-		result += innerIndent + "\"" + item + "\""
-		if i < len(array)-1 {
-			result += ","
-		}
-		result += "\n"
-	}
-	result += indent + "]"
-	return result
-}
-
-func Render(info yaml.MapSlice) string {
-	return renderMap(info, "") + "\n"
-}
-
-func (object *SchemaNumber) jsonValue() interface{} {
-	if object.Integer != nil {
-		return object.Integer
-	} else if object.Float != nil {
-		return object.Float
-	} else {
-		return nil
-	}
-}
-
-func (object *SchemaOrBoolean) jsonValue() interface{} {
-	if object.Schema != nil {
-		return object.Schema.jsonValue()
-	} else if object.Boolean != nil {
-		return *object.Boolean
-	} else {
-		return nil
-	}
-}
-
-func (object *StringOrStringArray) jsonValue() interface{} {
-	if object.String != nil {
-		return *object.String
-	} else if object.StringArray != nil {
-		array := make([]interface{}, 0)
-		for _, item := range *(object.StringArray) {
-			array = append(array, item)
-		}
-		return array
-	} else {
-		return nil
-	}
-}
-
-func (object *SchemaOrStringArray) jsonValue() interface{} {
-	if object.Schema != nil {
-		return object.Schema.jsonValue()
-	} else if object.StringArray != nil {
-		array := make([]interface{}, 0)
-		for _, item := range *(object.StringArray) {
-			array = append(array, item)
-		}
-		return array
-	} else {
-		return nil
-	}
-}
-
-func (object *SchemaOrSchemaArray) jsonValue() interface{} {
-	if object.Schema != nil {
-		return object.Schema.jsonValue()
-	} else if object.SchemaArray != nil {
-		array := make([]interface{}, 0)
-		for _, item := range *(object.SchemaArray) {
-			array = append(array, item.jsonValue())
-		}
-		return array
-	} else {
-		return nil
-	}
-}
-
-func (object *SchemaEnumValue) jsonValue() interface{} {
-	if object.String != nil {
-		return *object.String
-	} else if object.Bool != nil {
-		return *object.Bool
-	} else {
-		return nil
-	}
-}
-
-func namedSchemaArrayValue(array *[]*NamedSchema) interface{} {
-	m2 := yaml.MapSlice{}
-	for _, pair := range *(array) {
-		var item2 yaml.MapItem
-		item2.Key = pair.Name
-		item2.Value = pair.Value.jsonValue()
-		m2 = append(m2, item2)
-	}
-	return m2
-}
-
-func namedSchemaOrStringArrayValue(array *[]*NamedSchemaOrStringArray) interface{} {
-	m2 := yaml.MapSlice{}
-	for _, pair := range *(array) {
-		var item2 yaml.MapItem
-		item2.Key = pair.Name
-		item2.Value = pair.Value.jsonValue()
-		m2 = append(m2, item2)
-	}
-	return m2
-}
-
-func schemaEnumArrayValue(array *[]SchemaEnumValue) []interface{} {
-	a := make([]interface{}, 0)
-	for _, item := range *array {
-		a = append(a, item.jsonValue())
-	}
-	return a
-}
-
-func schemaArrayValue(array *[]*Schema) []interface{} {
-	a := make([]interface{}, 0)
-	for _, item := range *array {
-		a = append(a, item.jsonValue())
-	}
-	return a
-}
-
-func (schema *Schema) jsonValue() yaml.MapSlice {
-	m := yaml.MapSlice{}
-	if schema.Title != nil {
-		m = append(m, yaml.MapItem{Key: "title", Value: *schema.Title})
-	}
-	if schema.ID != nil {
-		m = append(m, yaml.MapItem{Key: "id", Value: *schema.ID})
-	}
-	if schema.Schema != nil {
-		m = append(m, yaml.MapItem{Key: "$schema", Value: *schema.Schema})
-	}
-	if schema.Type != nil {
-		m = append(m, yaml.MapItem{Key: "type", Value: schema.Type.jsonValue()})
-	}
-	if schema.Items != nil {
-		m = append(m, yaml.MapItem{Key: "items", Value: schema.Items.jsonValue()})
-	}
-	if schema.Description != nil {
-		m = append(m, yaml.MapItem{Key: "description", Value: *schema.Description})
-	}
-	if schema.Required != nil {
-		m = append(m, yaml.MapItem{Key: "required", Value: *schema.Required})
-	}
-	if schema.AdditionalProperties != nil {
-		m = append(m, yaml.MapItem{Key: "additionalProperties", Value: schema.AdditionalProperties.jsonValue()})
-	}
-	if schema.PatternProperties != nil {
-		m = append(m, yaml.MapItem{Key: "patternProperties", Value: namedSchemaArrayValue(schema.PatternProperties)})
-	}
-	if schema.Properties != nil {
-		m = append(m, yaml.MapItem{Key: "properties", Value: namedSchemaArrayValue(schema.Properties)})
-	}
-	if schema.Dependencies != nil {
-		m = append(m, yaml.MapItem{Key: "dependencies", Value: namedSchemaOrStringArrayValue(schema.Dependencies)})
-	}
-	if schema.Ref != nil {
-		m = append(m, yaml.MapItem{Key: "$ref", Value: *schema.Ref})
-	}
-	if schema.MultipleOf != nil {
-		m = append(m, yaml.MapItem{Key: "multipleOf", Value: schema.MultipleOf.jsonValue()})
-	}
-	if schema.Maximum != nil {
-		m = append(m, yaml.MapItem{Key: "maximum", Value: schema.Maximum.jsonValue()})
-	}
-	if schema.ExclusiveMaximum != nil {
-		m = append(m, yaml.MapItem{Key: "exclusiveMaximum", Value: schema.ExclusiveMaximum})
-	}
-	if schema.Minimum != nil {
-		m = append(m, yaml.MapItem{Key: "minimum", Value: schema.Minimum.jsonValue()})
-	}
-	if schema.ExclusiveMinimum != nil {
-		m = append(m, yaml.MapItem{Key: "exclusiveMinimum", Value: schema.ExclusiveMinimum})
-	}
-	if schema.MaxLength != nil {
-		m = append(m, yaml.MapItem{Key: "maxLength", Value: *schema.MaxLength})
-	}
-	if schema.MinLength != nil {
-		m = append(m, yaml.MapItem{Key: "minLength", Value: *schema.MinLength})
-	}
-	if schema.Pattern != nil {
-		m = append(m, yaml.MapItem{Key: "pattern", Value: *schema.Pattern})
-	}
-	if schema.AdditionalItems != nil {
-		m = append(m, yaml.MapItem{Key: "additionalItems", Value: schema.AdditionalItems.jsonValue()})
-	}
-	if schema.MaxItems != nil {
-		m = append(m, yaml.MapItem{Key: "maxItems", Value: *schema.MaxItems})
-	}
-	if schema.MinItems != nil {
-		m = append(m, yaml.MapItem{Key: "minItems", Value: *schema.MinItems})
-	}
-	if schema.UniqueItems != nil {
-		m = append(m, yaml.MapItem{Key: "uniqueItems", Value: *schema.UniqueItems})
-	}
-	if schema.MaxProperties != nil {
-		m = append(m, yaml.MapItem{Key: "maxProperties", Value: *schema.MaxProperties})
-	}
-	if schema.MinProperties != nil {
-		m = append(m, yaml.MapItem{Key: "minProperties", Value: *schema.MinProperties})
-	}
-	if schema.Enumeration != nil {
-		m = append(m, yaml.MapItem{Key: "enum", Value: schemaEnumArrayValue(schema.Enumeration)})
-	}
-	if schema.AllOf != nil {
-		m = append(m, yaml.MapItem{Key: "allOf", Value: schemaArrayValue(schema.AllOf)})
-	}
-	if schema.AnyOf != nil {
-		m = append(m, yaml.MapItem{Key: "anyOf", Value: schemaArrayValue(schema.AnyOf)})
-	}
-	if schema.OneOf != nil {
-		m = append(m, yaml.MapItem{Key: "oneOf", Value: schemaArrayValue(schema.OneOf)})
-	}
-	if schema.Not != nil {
-		m = append(m, yaml.MapItem{Key: "not", Value: schema.Not.jsonValue()})
-	}
-	if schema.Definitions != nil {
-		m = append(m, yaml.MapItem{Key: "definitions", Value: namedSchemaArrayValue(schema.Definitions)})
-	}
-	if schema.Default != nil {
-		m = append(m, yaml.MapItem{Key: "default", Value: *schema.Default})
-	}
-	if schema.Format != nil {
-		m = append(m, yaml.MapItem{Key: "format", Value: *schema.Format})
-	}
-	return m
-}
-
-// JSONString returns a json representation of a schema.
-func (schema *Schema) JSONString() string {
-	info := schema.jsonValue()
-	return Render(info)
-}