gojsonschema: github.com/xeipuuv/gojsonschema Index | Files

package gojsonschema

import "github.com/xeipuuv/gojsonschema"

Index

Package Files

draft.go errors.go format_checkers.go internalLog.go jsonContext.go jsonLoader.go locales.go result.go schema.go schemaLoader.go schemaPool.go schemaReferencePool.go schemaType.go subSchema.go types.go utils.go validation.go

Constants

const (
    STRING_NUMBER                     = "number"
    STRING_ARRAY_OF_STRINGS           = "array of strings"
    STRING_ARRAY_OF_SCHEMAS           = "array of schemas"
    STRING_SCHEMA                     = "valid schema"
    STRING_SCHEMA_OR_ARRAY_OF_STRINGS = "schema or array of strings"
    STRING_PROPERTIES                 = "properties"
    STRING_DEPENDENCY                 = "dependency"
    STRING_PROPERTY                   = "property"
    STRING_UNDEFINED                  = "undefined"
    STRING_CONTEXT_ROOT               = "(root)"
    STRING_ROOT_SCHEMA_PROPERTY       = "(root)"
)

constants

const (
    KEY_SCHEMA                = "$schema"
    KEY_ID                    = "id"
    KEY_ID_NEW                = "$id"
    KEY_REF                   = "$ref"
    KEY_TITLE                 = "title"
    KEY_DESCRIPTION           = "description"
    KEY_TYPE                  = "type"
    KEY_ITEMS                 = "items"
    KEY_ADDITIONAL_ITEMS      = "additionalItems"
    KEY_PROPERTIES            = "properties"
    KEY_PATTERN_PROPERTIES    = "patternProperties"
    KEY_ADDITIONAL_PROPERTIES = "additionalProperties"
    KEY_PROPERTY_NAMES        = "propertyNames"
    KEY_DEFINITIONS           = "definitions"
    KEY_MULTIPLE_OF           = "multipleOf"
    KEY_MINIMUM               = "minimum"
    KEY_MAXIMUM               = "maximum"
    KEY_EXCLUSIVE_MINIMUM     = "exclusiveMinimum"
    KEY_EXCLUSIVE_MAXIMUM     = "exclusiveMaximum"
    KEY_MIN_LENGTH            = "minLength"
    KEY_MAX_LENGTH            = "maxLength"
    KEY_PATTERN               = "pattern"
    KEY_FORMAT                = "format"
    KEY_MIN_PROPERTIES        = "minProperties"
    KEY_MAX_PROPERTIES        = "maxProperties"
    KEY_DEPENDENCIES          = "dependencies"
    KEY_REQUIRED              = "required"
    KEY_MIN_ITEMS             = "minItems"
    KEY_MAX_ITEMS             = "maxItems"
    KEY_UNIQUE_ITEMS          = "uniqueItems"
    KEY_CONTAINS              = "contains"
    KEY_CONST                 = "const"
    KEY_ENUM                  = "enum"
    KEY_ONE_OF                = "oneOf"
    KEY_ANY_OF                = "anyOf"
    KEY_ALL_OF                = "allOf"
    KEY_NOT                   = "not"
    KEY_IF                    = "if"
    KEY_THEN                  = "then"
    KEY_ELSE                  = "else"
)

Constants

const (
    TYPE_ARRAY   = `array`
    TYPE_BOOLEAN = `boolean`
    TYPE_INTEGER = `integer`
    TYPE_NUMBER  = `number`
    TYPE_NULL    = `null`
    TYPE_OBJECT  = `object`
    TYPE_STRING  = `string`
)

Type constants

Variables

var (
    // Locale is the default locale to use
    // Library users can overwrite with their own implementation
    Locale locale = DefaultLocale{}

    // ErrorTemplateFuncs allows you to define custom template funcs for use in localization.
    ErrorTemplateFuncs template.FuncMap
)
var (
    // FormatCheckers holds the valid formatters, and is a public variable
    // so library users can add custom formatters
    FormatCheckers = FormatCheckerChain{
        // contains filtered or unexported fields
    }
)
var JSON_TYPES []string

JSON_TYPES hosts the list of type that are supported in JSON

var SCHEMA_TYPES []string

SCHEMA_TYPES hosts the list of type that are supported in schemas

type AdditionalPropertyNotAllowedError Uses

type AdditionalPropertyNotAllowedError struct {
    ResultErrorFields
}

AdditionalPropertyNotAllowedError is produced if an object has additional properties, but not allowed ErrorDetails: property

type ArrayContainsError Uses

type ArrayContainsError struct {
    ResultErrorFields
}

ArrayContainsError is produced if an array contains invalid items ErrorDetails:

type ArrayMaxItemsError Uses

type ArrayMaxItemsError struct {
    ResultErrorFields
}

ArrayMaxItemsError is produced if an array contains more items than the allowed maximum ErrorDetails: max

type ArrayMaxPropertiesError Uses

type ArrayMaxPropertiesError struct {
    ResultErrorFields
}

ArrayMaxPropertiesError is produced if an object contains more properties than the allowed maximum ErrorDetails: max

type ArrayMinItemsError Uses

type ArrayMinItemsError struct {
    ResultErrorFields
}

ArrayMinItemsError is produced if an array contains less items than the allowed minimum ErrorDetails: min

type ArrayMinPropertiesError Uses

type ArrayMinPropertiesError struct {
    ResultErrorFields
}

ArrayMinPropertiesError is produced if an object contains less properties than the allowed minimum ErrorDetails: min

type ArrayNoAdditionalItemsError Uses

type ArrayNoAdditionalItemsError struct {
    ResultErrorFields
}

ArrayNoAdditionalItemsError is produced if additional items were found, but not allowed ErrorDetails: -

type ConditionElseError Uses

type ConditionElseError struct {
    ResultErrorFields
}

ConditionElseError is produced if a condition's "else" condition is invalid ErrorDetails: -

type ConditionThenError Uses

type ConditionThenError struct {
    ResultErrorFields
}

ConditionThenError is produced if a condition's "then" validation is invalid ErrorDetails: -

type ConstError Uses

type ConstError struct {
    ResultErrorFields
}

ConstError indicates a const error ErrorDetails: allowed

type DateFormatChecker Uses

type DateFormatChecker struct{}

DateFormatChecker verifies date formats

Valid format:

	Full Date: YYYY-MM-DD

Where
	YYYY = 4DIGIT year
	MM = 2DIGIT month ; 01-12
	DD = 2DIGIT day-month ; 01-28, 01-29, 01-30, 01-31 based on month/year

func (DateFormatChecker) IsFormat Uses

func (f DateFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted date (YYYY-MM-DD)

type DateTimeFormatChecker Uses

type DateTimeFormatChecker struct{}

DateTimeFormatChecker verifies date/time formats per RFC3339 5.6

Valid formats:

	Partial Time: HH:MM:SS
	Full Date: YYYY-MM-DD
	Full Time: HH:MM:SSZ-07:00
	Date Time: YYYY-MM-DDTHH:MM:SSZ-0700

Where
	YYYY = 4DIGIT year
	MM = 2DIGIT month ; 01-12
	DD = 2DIGIT day-month ; 01-28, 01-29, 01-30, 01-31 based on month/year
	HH = 2DIGIT hour ; 00-23
	MM = 2DIGIT ; 00-59
	SS = 2DIGIT ; 00-58, 00-60 based on leap second rules
	T = Literal
	Z = Literal

Note: Nanoseconds are also suported in all formats

http://tools.ietf.org/html/rfc3339#section-5.6

func (DateTimeFormatChecker) IsFormat Uses

func (f DateTimeFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted date/time per RFC3339 5.6

type DefaultJSONLoaderFactory Uses

type DefaultJSONLoaderFactory struct {
}

DefaultJSONLoaderFactory is the default JSON loader factory

func (DefaultJSONLoaderFactory) New Uses

func (d DefaultJSONLoaderFactory) New(source string) JSONLoader

New creates a new JSON loader for the given source

type DefaultLocale Uses

type DefaultLocale struct{}

DefaultLocale is the default locale for this package

func (DefaultLocale) AdditionalPropertyNotAllowed Uses

func (l DefaultLocale) AdditionalPropertyNotAllowed() string

AdditionalPropertyNotAllowed returns a format-string to format an AdditionalPropertyNotAllowedError

func (DefaultLocale) ArrayContains Uses

func (l DefaultLocale) ArrayContains() string

ArrayContains returns a format-string to format an ArrayContainsError

func (DefaultLocale) ArrayMaxItems Uses

func (l DefaultLocale) ArrayMaxItems() string

ArrayMaxItems returns a format-string to format an ArrayMaxItemsError

func (DefaultLocale) ArrayMaxProperties Uses

func (l DefaultLocale) ArrayMaxProperties() string

ArrayMaxProperties returns a format-string to format an ArrayMaxPropertiesError

func (DefaultLocale) ArrayMinItems Uses

func (l DefaultLocale) ArrayMinItems() string

ArrayMinItems returns a format-string to format an ArrayMinItemsError

func (DefaultLocale) ArrayMinProperties Uses

func (l DefaultLocale) ArrayMinProperties() string

ArrayMinProperties returns a format-string to format an ArrayMinPropertiesError

func (DefaultLocale) ArrayNoAdditionalItems Uses

func (l DefaultLocale) ArrayNoAdditionalItems() string

ArrayNoAdditionalItems returns a format-string to format an ArrayNoAdditionalItemsError

func (DefaultLocale) ArrayNotEnoughItems Uses

func (l DefaultLocale) ArrayNotEnoughItems() string

ArrayNotEnoughItems returns a format-string to format an error for arrays having not enough items to match positional list of schema

func (DefaultLocale) CannotBeGT Uses

func (l DefaultLocale) CannotBeGT() string

CannotBeGT returns a format-string to format an error where a value are greater than allowed

func (DefaultLocale) CannotBeUsedWithout Uses

func (l DefaultLocale) CannotBeUsedWithout() string

CannotBeUsedWithout returns a format-string to format a "cannot be used without" error

func (DefaultLocale) ConditionElse Uses

func (l DefaultLocale) ConditionElse() string

ConditionElse returns a format-string for ConditionElseError errors

func (DefaultLocale) ConditionThen Uses

func (l DefaultLocale) ConditionThen() string

ConditionThen returns a format-string for ConditionThenError errors If/Else

func (DefaultLocale) Const Uses

func (l DefaultLocale) Const() string

Const returns a format-string to format a ConstError

func (DefaultLocale) DoesNotMatchFormat Uses

func (l DefaultLocale) DoesNotMatchFormat() string

DoesNotMatchFormat returns a format-string to format an DoesNotMatchFormatError

func (DefaultLocale) DoesNotMatchPattern Uses

func (l DefaultLocale) DoesNotMatchPattern() string

DoesNotMatchPattern returns a format-string to format an DoesNotMatchPatternError

func (DefaultLocale) Duplicated Uses

func (l DefaultLocale) Duplicated() string

Duplicated returns a format-string to format an error where types are duplicated

func (DefaultLocale) Enum Uses

func (l DefaultLocale) Enum() string

Enum returns a format-string to format an EnumError

func (DefaultLocale) ErrorFormat Uses

func (l DefaultLocale) ErrorFormat() string

ErrorFormat returns a format string for errors Replacement options: field, description, context, value

func (DefaultLocale) GreaterThanZero Uses

func (l DefaultLocale) GreaterThanZero() string

GreaterThanZero returns a format-string to format an error where a number must be greater than zero

func (DefaultLocale) HttpBadStatus Uses

func (l DefaultLocale) HttpBadStatus() string

HttpBadStatus returns a format-string for errors when loading a schema using HTTP

func (DefaultLocale) Internal Uses

func (l DefaultLocale) Internal() string

Internal returns a format-string for internal errors

func (DefaultLocale) InvalidPropertyName Uses

func (l DefaultLocale) InvalidPropertyName() string

InvalidPropertyName returns a format-string to format an InvalidPropertyNameError

func (DefaultLocale) InvalidPropertyPattern Uses

func (l DefaultLocale) InvalidPropertyPattern() string

InvalidPropertyPattern returns a format-string to format an InvalidPropertyPatternError

func (DefaultLocale) InvalidType Uses

func (l DefaultLocale) InvalidType() string

InvalidType returns a format-string for "invalid type" schema validation errors

func (DefaultLocale) KeyCannotBeGreaterThan Uses

func (l DefaultLocale) KeyCannotBeGreaterThan() string

KeyCannotBeGreaterThan returns a format-string to format an error where a value is greater than the maximum allowed

func (DefaultLocale) KeyItemsMustBeOfType Uses

func (l DefaultLocale) KeyItemsMustBeOfType() string

KeyItemsMustBeOfType returns a format-string to format an error where a key is of the wrong type

func (DefaultLocale) KeyItemsMustBeUnique Uses

func (l DefaultLocale) KeyItemsMustBeUnique() string

KeyItemsMustBeUnique returns a format-string to format an error where keys are not unique

func (DefaultLocale) MissingDependency Uses

func (l DefaultLocale) MissingDependency() string

MissingDependency returns a format-string for "missing dependency" schema validation errors

func (DefaultLocale) MultipleOf Uses

func (l DefaultLocale) MultipleOf() string

MultipleOf returns a format-string to format an MultipleOfError

func (DefaultLocale) MustBeGTEZero Uses

func (l DefaultLocale) MustBeGTEZero() string

MustBeGTEZero returns a format-string to format an error where a value must be greater or equal than 0

func (DefaultLocale) MustBeOfA Uses

func (l DefaultLocale) MustBeOfA() string

MustBeOfA returns a format-string to format an error where a value is of the wrong type

func (DefaultLocale) MustBeOfAn Uses

func (l DefaultLocale) MustBeOfAn() string

MustBeOfAn returns a format-string to format an error where a value is of the wrong type

func (DefaultLocale) MustBeOfType Uses

func (l DefaultLocale) MustBeOfType() string

MustBeOfType returns a format-string to format an error where a value does not match the required type

func (DefaultLocale) MustBeValidFormat Uses

func (l DefaultLocale) MustBeValidFormat() string

MustBeValidFormat returns a format-string to format an error where a value does not match the expected format

func (DefaultLocale) MustBeValidRegex Uses

func (l DefaultLocale) MustBeValidRegex() string

MustBeValidRegex returns a format-string to format an error where a regex is invalid

func (DefaultLocale) NotAValidType Uses

func (l DefaultLocale) NotAValidType() string

NotAValidType returns a format-string to format an invalid type error

func (DefaultLocale) NumberAllOf Uses

func (l DefaultLocale) NumberAllOf() string

NumberAllOf returns a format-string for "allOf" schema validation errors

func (DefaultLocale) NumberAnyOf Uses

func (l DefaultLocale) NumberAnyOf() string

NumberAnyOf returns a format-string for "anyOf" schema validation errors

func (DefaultLocale) NumberGT Uses

func (l DefaultLocale) NumberGT() string

NumberGT returns the format string to format a NumberGTError

func (DefaultLocale) NumberGTE Uses

func (l DefaultLocale) NumberGTE() string

NumberGTE returns the format string to format a NumberGTEError

func (DefaultLocale) NumberLT Uses

func (l DefaultLocale) NumberLT() string

NumberLT returns the format string to format a NumberLTError

func (DefaultLocale) NumberLTE Uses

func (l DefaultLocale) NumberLTE() string

NumberLTE returns the format string to format a NumberLTEError

func (DefaultLocale) NumberNot Uses

func (l DefaultLocale) NumberNot() string

NumberNot returns a format-string to format a NumberNotError

func (DefaultLocale) NumberOneOf Uses

func (l DefaultLocale) NumberOneOf() string

NumberOneOf returns a format-string for "oneOf" schema validation errors

func (DefaultLocale) ParseError Uses

func (l DefaultLocale) ParseError() string

ParseError returns a format-string for JSON parsing errors

func (DefaultLocale) ReferenceMustBeCanonical Uses

func (l DefaultLocale) ReferenceMustBeCanonical() string

ReferenceMustBeCanonical returns a format-string to format a "reference must be canonical" error

func (DefaultLocale) RegexPattern Uses

func (l DefaultLocale) RegexPattern() string

RegexPattern returns a format-string to format a regex-pattern error

func (DefaultLocale) Required Uses

func (l DefaultLocale) Required() string

Required returns a format-string for "required" schema validation errors

func (DefaultLocale) StringGTE Uses

func (l DefaultLocale) StringGTE() string

StringGTE returns a format-string to format an StringLengthGTEError

func (DefaultLocale) StringLTE Uses

func (l DefaultLocale) StringLTE() string

StringLTE returns a format-string to format an StringLengthLTEError

func (DefaultLocale) Unique Uses

func (l DefaultLocale) Unique() string

Unique returns a format-string to format an ItemsMustBeUniqueError

type DoesNotMatchFormatError Uses

type DoesNotMatchFormatError struct {
    ResultErrorFields
}

DoesNotMatchFormatError is produced if a string does not match the defined format ErrorDetails: format

type DoesNotMatchPatternError Uses

type DoesNotMatchPatternError struct {
    ResultErrorFields
}

DoesNotMatchPatternError is produced if a string does not match the defined pattern ErrorDetails: pattern

type Draft Uses

type Draft int

Draft is a JSON-schema draft version

const (
    Draft4 Draft = 4
    Draft6 Draft = 6
    Draft7 Draft = 7
    Hybrid Draft = math.MaxInt32
)

Supported Draft versions

type EmailFormatChecker Uses

type EmailFormatChecker struct{}

EmailFormatChecker verifies email address formats

func (EmailFormatChecker) IsFormat Uses

func (f EmailFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted e-mail address

type EnumError Uses

type EnumError struct {
    ResultErrorFields
}

EnumError indicates an enum error ErrorDetails: allowed

type ErrorDetails Uses

type ErrorDetails map[string]interface{}

ErrorDetails is a map of details specific to each error. While the values will vary, every error will contain a "field" value

type FileSystemJSONLoaderFactory Uses

type FileSystemJSONLoaderFactory struct {
    // contains filtered or unexported fields
}

FileSystemJSONLoaderFactory is a JSON loader factory that uses http.FileSystem

func (FileSystemJSONLoaderFactory) New Uses

func (f FileSystemJSONLoaderFactory) New(source string) JSONLoader

New creates a new JSON loader for the given source

type FormatChecker Uses

type FormatChecker interface {
    // IsFormat checks if input has the correct format and type
    IsFormat(input interface{}) bool
}

FormatChecker is the interface all formatters added to FormatCheckerChain must implement

type FormatCheckerChain Uses

type FormatCheckerChain struct {
    // contains filtered or unexported fields
}

FormatCheckerChain holds the formatters

func (*FormatCheckerChain) Add Uses

func (c *FormatCheckerChain) Add(name string, f FormatChecker) *FormatCheckerChain

Add adds a FormatChecker to the FormatCheckerChain The name used will be the value used for the format key in your json schema

func (*FormatCheckerChain) Has Uses

func (c *FormatCheckerChain) Has(name string) bool

Has checks to see if the FormatCheckerChain holds a FormatChecker with the given name

func (*FormatCheckerChain) IsFormat Uses

func (c *FormatCheckerChain) IsFormat(name string, input interface{}) bool

IsFormat will check an input against a FormatChecker with the given name to see if it is the correct format

func (*FormatCheckerChain) Remove Uses

func (c *FormatCheckerChain) Remove(name string) *FormatCheckerChain

Remove deletes a FormatChecker from the FormatCheckerChain (if it exists)

type HostnameFormatChecker Uses

type HostnameFormatChecker struct{}

HostnameFormatChecker validates a hostname is in the correct format

func (HostnameFormatChecker) IsFormat Uses

func (f HostnameFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted hostname

type IPV4FormatChecker Uses

type IPV4FormatChecker struct{}

IPV4FormatChecker verifies IP addresses in the IPv4 format

func (IPV4FormatChecker) IsFormat Uses

func (f IPV4FormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted IPv4-address

type IPV6FormatChecker Uses

type IPV6FormatChecker struct{}

IPV6FormatChecker verifies IP addresses in the IPv6 format

func (IPV6FormatChecker) IsFormat Uses

func (f IPV6FormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted IPv6=address

type InternalError Uses

type InternalError struct {
    ResultErrorFields
}

InternalError indicates an internal error ErrorDetails: error

type InvalidPropertyNameError Uses

type InvalidPropertyNameError struct {
    ResultErrorFields
}

InvalidPropertyNameError is produced if an invalid-named property was found ErrorDetails: property

type InvalidPropertyPatternError Uses

type InvalidPropertyPatternError struct {
    ResultErrorFields
}

InvalidPropertyPatternError is produced if an pattern was found ErrorDetails: property, pattern

type InvalidTypeError Uses

type InvalidTypeError struct {
    ResultErrorFields
}

InvalidTypeError indicates that a field has the incorrect type ErrorDetails: expected, given

type ItemsMustBeUniqueError Uses

type ItemsMustBeUniqueError struct {
    ResultErrorFields
}

ItemsMustBeUniqueError is produced if an array requires unique items, but contains non-unique items ErrorDetails: type, i, j

type JSONLoader Uses

type JSONLoader interface {
    JsonSource() interface{}
    LoadJSON() (interface{}, error)
    JsonReference() (gojsonreference.JsonReference, error)
    LoaderFactory() JSONLoaderFactory
}

JSONLoader defines the JSON loader interface

func NewBytesLoader Uses

func NewBytesLoader(source []byte) JSONLoader

NewBytesLoader creates a new JSONLoader, taking a `[]byte` as source

func NewGoLoader Uses

func NewGoLoader(source interface{}) JSONLoader

NewGoLoader creates a new JSONLoader from a given Go struct

func NewRawLoader Uses

func NewRawLoader(source interface{}) JSONLoader

NewRawLoader creates a new JSON raw loader for the given source

func NewReaderLoader Uses

func NewReaderLoader(source io.Reader) (JSONLoader, io.Reader)

NewReaderLoader creates a new JSON loader using the provided io.Reader

func NewReferenceLoader Uses

func NewReferenceLoader(source string) JSONLoader

NewReferenceLoader returns a JSON reference loader using the given source and the local OS file system.

func NewReferenceLoaderFileSystem Uses

func NewReferenceLoaderFileSystem(source string, fs http.FileSystem) JSONLoader

NewReferenceLoaderFileSystem returns a JSON reference loader using the given source and file system.

func NewStringLoader Uses

func NewStringLoader(source string) JSONLoader

NewStringLoader creates a new JSONLoader, taking a string as source

func NewWriterLoader Uses

func NewWriterLoader(source io.Writer) (JSONLoader, io.Writer)

NewWriterLoader creates a new JSON loader using the provided io.Writer

type JSONLoaderFactory Uses

type JSONLoaderFactory interface {
    // New creates a new JSON loader for the given source
    New(source string) JSONLoader
}

JSONLoaderFactory defines the JSON loader factory interface

type JSONPointerFormatChecker Uses

type JSONPointerFormatChecker struct{}

JSONPointerFormatChecker validates a JSON Pointer per RFC6901

func (JSONPointerFormatChecker) IsFormat Uses

func (f JSONPointerFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted JSON Pointer per RFC6901

type JsonContext Uses

type JsonContext struct {
    // contains filtered or unexported fields
}

JsonContext implements a persistent linked-list of strings

func NewJsonContext Uses

func NewJsonContext(head string, tail *JsonContext) *JsonContext

NewJsonContext creates a new JsonContext

func (*JsonContext) String Uses

func (c *JsonContext) String(del ...string) string

String displays the context in reverse. This plays well with the data structure's persistent nature with Cons and a json document's tree structure.

type MissingDependencyError Uses

type MissingDependencyError struct {
    ResultErrorFields
}

MissingDependencyError is produced in case of a "missing dependency" problem ErrorDetails: dependency

type MultipleOfError Uses

type MultipleOfError struct {
    ResultErrorFields
}

MultipleOfError is produced if a number is not a multiple of the defined multipleOf ErrorDetails: multiple

type NumberAllOfError Uses

type NumberAllOfError struct {
    ResultErrorFields
}

NumberAllOfError is produced in case of a failing "allOf" validation ErrorDetails: -

type NumberAnyOfError Uses

type NumberAnyOfError struct {
    ResultErrorFields
}

NumberAnyOfError is produced in case of a failing "anyOf" validation ErrorDetails: -

type NumberGTEError Uses

type NumberGTEError struct {
    ResultErrorFields
}

NumberGTEError is produced if a number is lower than the allowed minimum ErrorDetails: min

type NumberGTError Uses

type NumberGTError struct {
    ResultErrorFields
}

NumberGTError is produced if a number is lower than, or equal to the specified minimum, and exclusiveMinimum is set ErrorDetails: min

type NumberLTEError Uses

type NumberLTEError struct {
    ResultErrorFields
}

NumberLTEError is produced if a number is higher than the allowed maximum ErrorDetails: max

type NumberLTError Uses

type NumberLTError struct {
    ResultErrorFields
}

NumberLTError is produced if a number is higher than, or equal to the specified maximum, and exclusiveMaximum is set ErrorDetails: max

type NumberNotError Uses

type NumberNotError struct {
    ResultErrorFields
}

NumberNotError is produced if a "not" validation failed ErrorDetails: -

type NumberOneOfError Uses

type NumberOneOfError struct {
    ResultErrorFields
}

NumberOneOfError is produced in case of a failing "oneOf" validation ErrorDetails: -

type RegexFormatChecker Uses

type RegexFormatChecker struct{}

RegexFormatChecker validates a regex is in the correct format

func (RegexFormatChecker) IsFormat Uses

func (f RegexFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted regular expression

type RelativeJSONPointerFormatChecker Uses

type RelativeJSONPointerFormatChecker struct{}

RelativeJSONPointerFormatChecker validates a relative JSON Pointer is in the correct format

func (RelativeJSONPointerFormatChecker) IsFormat Uses

func (f RelativeJSONPointerFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted relative JSON Pointer

type RequiredError Uses

type RequiredError struct {
    ResultErrorFields
}

RequiredError indicates that a required field is missing ErrorDetails: property string

type Result Uses

type Result struct {
    // contains filtered or unexported fields
}

Result holds the result of a validation

func Validate Uses

func Validate(ls JSONLoader, ld JSONLoader) (*Result, error)

Validate loads and validates a JSON schema

func (*Result) AddError Uses

func (v *Result) AddError(err ResultError, details ErrorDetails)

AddError appends a fully filled error to the error set SetDescription() will be called with the result of the parsed err.DescriptionFormat()

func (*Result) Errors Uses

func (v *Result) Errors() []ResultError

Errors returns the errors that were found

func (*Result) Valid Uses

func (v *Result) Valid() bool

Valid indicates if no errors were found

type ResultError Uses

type ResultError interface {
    // Field returns the field name without the root context
    // i.e. firstName or person.firstName instead of (root).firstName or (root).person.firstName
    Field() string
    // SetType sets the error-type
    SetType(string)
    // Type returns the error-type
    Type() string
    // SetContext sets the JSON-context for the error
    SetContext(*JsonContext)
    // Context returns the JSON-context of the error
    Context() *JsonContext
    // SetDescription sets a description for the error
    SetDescription(string)
    // Description returns the description of the error
    Description() string
    // SetDescriptionFormat sets the format for the description in the default text/template format
    SetDescriptionFormat(string)
    // DescriptionFormat returns the format for the description in the default text/template format
    DescriptionFormat() string
    // SetValue sets the value related to the error
    SetValue(interface{})
    // Value returns the value related to the error
    Value() interface{}
    // SetDetails sets the details specific to the error
    SetDetails(ErrorDetails)
    // Details returns details about the error
    Details() ErrorDetails
    // String returns a string representation of the error
    String() string
}

ResultError is the interface that library errors must implement

type ResultErrorFields Uses

type ResultErrorFields struct {
    // contains filtered or unexported fields
}

ResultErrorFields holds the fields for each ResultError implementation. ResultErrorFields implements the ResultError interface, so custom errors can be defined by just embedding this type

func (*ResultErrorFields) Context Uses

func (v *ResultErrorFields) Context() *JsonContext

Context returns the JSON-context of the error

func (*ResultErrorFields) Description Uses

func (v *ResultErrorFields) Description() string

Description returns the description of the error

func (*ResultErrorFields) DescriptionFormat Uses

func (v *ResultErrorFields) DescriptionFormat() string

DescriptionFormat returns the format for the description in the default text/template format

func (*ResultErrorFields) Details Uses

func (v *ResultErrorFields) Details() ErrorDetails

Details returns details about the error

func (*ResultErrorFields) Field Uses

func (v *ResultErrorFields) Field() string

Field returns the field name without the root context i.e. firstName or person.firstName instead of (root).firstName or (root).person.firstName

func (*ResultErrorFields) SetContext Uses

func (v *ResultErrorFields) SetContext(context *JsonContext)

SetContext sets the JSON-context for the error

func (*ResultErrorFields) SetDescription Uses

func (v *ResultErrorFields) SetDescription(description string)

SetDescription sets a description for the error

func (*ResultErrorFields) SetDescriptionFormat Uses

func (v *ResultErrorFields) SetDescriptionFormat(descriptionFormat string)

SetDescriptionFormat sets the format for the description in the default text/template format

func (*ResultErrorFields) SetDetails Uses

func (v *ResultErrorFields) SetDetails(details ErrorDetails)

SetDetails sets the details specific to the error

func (*ResultErrorFields) SetType Uses

func (v *ResultErrorFields) SetType(errorType string)

SetType sets the error-type

func (*ResultErrorFields) SetValue Uses

func (v *ResultErrorFields) SetValue(value interface{})

SetValue sets the value related to the error

func (ResultErrorFields) String Uses

func (v ResultErrorFields) String() string

String returns a string representation of the error

func (*ResultErrorFields) Type Uses

func (v *ResultErrorFields) Type() string

Type returns the error-type

func (*ResultErrorFields) Value Uses

func (v *ResultErrorFields) Value() interface{}

Value returns the value related to the error

type Schema Uses

type Schema struct {
    // contains filtered or unexported fields
}

Schema holds a schema

func NewSchema Uses

func NewSchema(l JSONLoader) (*Schema, error)

NewSchema instances a schema using the given JSONLoader

func (*Schema) SetRootSchemaName Uses

func (d *Schema) SetRootSchemaName(name string)

SetRootSchemaName sets the root-schema name

func (*Schema) Validate Uses

func (v *Schema) Validate(l JSONLoader) (*Result, error)

Validate loads and validates a JSON document

type SchemaLoader Uses

type SchemaLoader struct {
    AutoDetect bool
    Validate   bool
    Draft      Draft
    // contains filtered or unexported fields
}

SchemaLoader is used to load schemas

func NewSchemaLoader Uses

func NewSchemaLoader() *SchemaLoader

NewSchemaLoader creates a new NewSchemaLoader

func (*SchemaLoader) AddSchema Uses

func (sl *SchemaLoader) AddSchema(url string, loader JSONLoader) error

AddSchema adds a schema under the provided URL to the schema cache

func (*SchemaLoader) AddSchemas Uses

func (sl *SchemaLoader) AddSchemas(loaders ...JSONLoader) error

AddSchemas adds an arbritrary amount of schemas to the schema cache. As this function does not require an explicit URL, every schema should contain an $id, so that it can be referenced by the main schema

func (*SchemaLoader) Compile Uses

func (sl *SchemaLoader) Compile(rootSchema JSONLoader) (*Schema, error)

Compile loads and compiles a schema

type StringLengthGTEError Uses

type StringLengthGTEError struct {
    ResultErrorFields
}

StringLengthGTEError is produced if a string is shorter than the minimum required length ErrorDetails: min

type StringLengthLTEError Uses

type StringLengthLTEError struct {
    ResultErrorFields
}

StringLengthLTEError is produced if a string is longer than the maximum allowed length ErrorDetails: max

type TimeFormatChecker Uses

type TimeFormatChecker struct{}

TimeFormatChecker verifies time formats

Valid formats:

	Partial Time: HH:MM:SS
	Full Time: HH:MM:SSZ-07:00

Where
	HH = 2DIGIT hour ; 00-23
	MM = 2DIGIT ; 00-59
	SS = 2DIGIT ; 00-58, 00-60 based on leap second rules
	T = Literal
	Z = Literal

func (TimeFormatChecker) IsFormat Uses

func (f TimeFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input correctly formatted time (HH:MM:SS or HH:MM:SSZ-07:00)

type URIFormatChecker Uses

type URIFormatChecker struct{}

URIFormatChecker validates a URI with a valid Scheme per RFC3986

func (URIFormatChecker) IsFormat Uses

func (f URIFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is correctly formatted URI with a valid Scheme per RFC3986

type URIReferenceFormatChecker Uses

type URIReferenceFormatChecker struct{}

URIReferenceFormatChecker validates a URI or relative-reference per RFC3986

func (URIReferenceFormatChecker) IsFormat Uses

func (f URIReferenceFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted URI or relative-reference per RFC3986

type URITemplateFormatChecker Uses

type URITemplateFormatChecker struct{}

URITemplateFormatChecker validates a URI template per RFC6570

func (URITemplateFormatChecker) IsFormat Uses

func (f URITemplateFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted URI template per RFC6570

type UUIDFormatChecker Uses

type UUIDFormatChecker struct{}

UUIDFormatChecker validates a UUID is in the correct format

func (UUIDFormatChecker) IsFormat Uses

func (f UUIDFormatChecker) IsFormat(input interface{}) bool

IsFormat checks if input is a correctly formatted UUID

Package gojsonschema imports 25 packages (graph) and is imported by 213 packages. Updated 2019-04-23. Refresh now. Tools for package owners.