Documentation
¶
Overview ¶
Package proto is a collection of libraries for parsing and indexing the type definitions. The openapi spec contains the object model definitions and extensions metadata.
Index ¶
Constants ¶
const ( Integer = "integer" Number = "number" String = "string" Boolean = "boolean" )
Defines openapi types.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type Arbitrary ¶
type Arbitrary struct {
BaseSchema
}
Arbitrary is a value of any type (primitive, object or array)
func (*Arbitrary) Accept ¶
func (a *Arbitrary) Accept(v SchemaVisitor)
type Array ¶
type Array struct {
BaseSchema
SubType Schema
}
Array must have all its element of the same `SubType`.
func (*Array) Accept ¶
func (a *Array) Accept(v SchemaVisitor)
type BaseSchema ¶
BaseSchema holds data used by each types of schema.
func (*BaseSchema) GetDescription ¶
func (b *BaseSchema) GetDescription() string
func (*BaseSchema) GetExtensions ¶
func (b *BaseSchema) GetExtensions() map[string]interface{}
func (*BaseSchema) GetPath ¶
func (b *BaseSchema) GetPath() *Path
type Definitions ¶
type Definitions struct {
// contains filtered or unexported fields
}
Definitions is an implementation of `Models`. It looks for models in an openapi Schema.
func (*Definitions) ListModels ¶
func (d *Definitions) ListModels() []string
func (*Definitions) LookupModel ¶
func (d *Definitions) LookupModel(model string) Schema
LookupModel is public through the interface of Models. It returns a visitable schema from the given model name.
func (*Definitions) ParseSchema ¶
func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, error)
ParseSchema creates a walkable Schema from an openapi schema. While this function is public, it doesn't leak through the interface.
type Kind ¶
type Kind struct {
BaseSchema
// Lists names of required fields.
RequiredFields []string
// Maps field names to types.
Fields map[string]Schema
// FieldOrder reports the canonical order for the fields.
FieldOrder []string
}
Kind is a complex object. It can have multiple different subtypes for each field, as defined in the `Fields` field. Mandatory fields are listed in `RequiredFields`. The key of the object is always of type `string`.
func (*Kind) Accept ¶
func (k *Kind) Accept(v SchemaVisitor)
func (*Kind) IsRequired ¶
IsRequired returns true if `field` is a required field for this type.
type Map ¶
type Map struct {
BaseSchema
SubType Schema
}
Map is an object who values must all be of the same `SubType`. The key of the object is always of type `string`.
func (*Map) Accept ¶
func (m *Map) Accept(v SchemaVisitor)
type Models ¶
Models interface describe a model provider. They can give you the schema for a specific model.
type Path ¶
type Path struct {
// contains filtered or unexported fields
}
Path helps us keep track of type paths
func (*Path) ArrayPath ¶
ArrayPath appends an array index and creates a new path
func (*Path) FieldPath ¶
FieldPath appends a field name and creates a new path
type Primitive ¶
type Primitive struct {
BaseSchema
// Type of a primitive must be one of: integer, number, string, boolean.
Type string
Format string
}
Primitive is a literal. There can be multiple types of primitives, and this subtype can be visited through the `subType` field.
func (*Primitive) Accept ¶
func (p *Primitive) Accept(v SchemaVisitor)
type Ref ¶
type Ref struct {
BaseSchema
// contains filtered or unexported fields
}
func (*Ref) Accept ¶
func (r *Ref) Accept(v SchemaVisitor)
type Reference ¶
Reference implementation depends on the type of document.
type Schema ¶
type Schema interface {
// Giving a visitor here will let you visit the actual type.
Accept(SchemaVisitor)
// Pretty print the name of the type.
GetName() string
// Describes how to access this field.
GetPath() *Path
// Describes the field.
GetDescription() string
// Returns type extensions.
GetExtensions() map[string]interface{}
}
Schema is the base definition of an openapi type.
type SchemaVisitor ¶
type SchemaVisitor interface {
VisitArray(*Array)
VisitMap(*Map)
VisitPrimitive(*Primitive)
VisitKind(*Kind)
VisitReference(Reference)
}
SchemaVisitor is an interface that you need to implement if you want to "visit" an openapi schema. A dispatch on the Schema type will call the appropriate function based on its actual type: - Array is a list of one and only one given subtype - Map is a map of string to one and only one given subtype - Primitive can be string, integer, number and boolean. - Kind is an object with specific fields mapping to specific types. - Reference is a link to another definition.
type SchemaVisitorArbitrary ¶
type SchemaVisitorArbitrary interface {
SchemaVisitor
VisitArbitrary(*Arbitrary)
}
SchemaVisitorArbitrary is an additional visitor interface which handles arbitrary types. For backwards compatibility, it's a separate interface which is checked for at runtime.
Source Files