gojsonschema

package module
v0.0.0-...-0138f5e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 24, 2015 License: Apache-2.0 Imports: 15 Imported by: 0

README

Build Status

gojsonschema

Description

An implementation of JSON Schema, based on IETF's draft v4 - Go language

References :

Installation

go get github.com/xeipuuv/gojsonschema

Dependencies :

Usage

Example

package main

import (
    "fmt"
    "github.com/xeipuuv/gojsonschema"
)

func main() {

    schemaLoader := gojsonschema.NewReferenceLoader("file:///home/me/schema.json")
    documentLoader := gojsonschema.NewReferenceLoader("file:///home/me/document.json")

    result, err := gojsonschema.Validate(schemaLoader, documentLoader)
    if err != nil {
        panic(err.Error())
    }

    if result.Valid() {
        fmt.Printf("The document is valid\n")
    } else {
        fmt.Printf("The document is not valid. see errors :\n")
        for _, desc := range result.Errors() {
            fmt.Printf("- %s\n", desc)
        }
    }

}
Loaders

There are various ways to load your JSON data. In order to load your schemas and documents, first declare an appropriate loader :

  • Web / HTTP, using a reference :
loader := gojsonschema.NewReferenceLoader("http://www.some_host.com/schema.json")
  • Local file, using a reference :
loader := gojsonschema.NewReferenceLoader("file:///home/me/schema.json")

References use the URI scheme, the prefix (file://) and a full path to the file are required.

  • JSON strings :
loader := gojsonschema.NewStringLoader(`{"type": "string"}`)
  • Custom Go types :
m := map[string]interface{}{"type": "string"}
loader := gojsonschema.NewGoLoader(m)

And

type Root struct {
	Users []User `json:"users"`
}

type User struct {
	Name string `json:"name"`
}

...

data := Root{}
data.Users = append(data.Users, User{"John"})
data.Users = append(data.Users, User{"Sophia"})
data.Users = append(data.Users, User{"Bill"})

loader := gojsonschema.NewGoLoader(data)
Validation

Once the loaders are set, validation is easy :

result, err := gojsonschema.Validate(schemaLoader, documentLoader)

Alternatively, you might want to load a schema only once and process to multiple validations :

schema, err := gojsonschema.NewSchema(schemaLoader)
...
result1, err := schema.Validate(documentLoader1)
...
result2, err := schema.Validate(documentLoader2)
...
// etc ...

To check the result :

    if result.Valid() {
    	fmt.Printf("The document is valid\n")
    } else {
        fmt.Printf("The document is not valid. see errors :\n")
        for _, desc := range result.Errors() {
            fmt.Printf("- %s\n", desc)
        }
    }

Uses

gojsonschema uses the following test suite :

https://github.com/json-schema/JSON-Schema-Test-Suite

Documentation

Index

Constants

View Source 
const (
	STRING_NUMBER                     = "number"
	STRING_ARRAY_OF_STRINGS           = "array of strings"
	STRING_ARRAY_OF_SCHEMAS           = "array of schemas"
	STRING_SCHEMA                     = "schema"
	STRING_SCHEMA_OR_ARRAY_OF_STRINGS = "schema or array of strings"
	STRING_PROPERTIES                 = "properties"
	STRING_DEPENDENCY                 = "dependency"
	STRING_PROPERTY                   = "property"

	STRING_CONTEXT_ROOT         = "#"
	STRING_ROOT_SCHEMA_PROPERTY = "#"

	STRING_UNDEFINED = "undefined"

	ERROR_MESSAGE_X_IS_NOT_A_VALID_TYPE                = `%s is not a valid type`
	ERROR_MESSAGE_X_TYPE_IS_DUPLICATED                 = `%s type is duplicated`
	ERROR_MESSAGE_X_MUST_BE_OF_TYPE_Y                  = `%s must be of type %s`
	ERROR_MESSAGE_X_MUST_BE_A_Y                        = `%s must be of a %s`
	ERROR_MESSAGE_X_MUST_BE_AN_Y                       = `%s must be of an %s`
	ERROR_MESSAGE_X_ITEMS_MUST_BE_UNIQUE               = `%s items must be unique`
	ERROR_MESSAGE_X_ITEMS_MUST_BE_TYPE_Y               = `%s items must be %s`
	ERROR_MESSAGE_NEW_SCHEMA_DOCUMENT_INVALID_ARGUMENT = `Invalid argument, must be a JSON string, a JSON reference string or a map[string]interface{}`

	ERROR_MESSAGE_INTERNAL                          = `internal error %s`
	ERROR_MESSAGE_GET_HTTP_BAD_STATUS               = `Could not read schema from HTTP, response status is %d`
	ERROR_MESSAGE_INVALID_REGEX_PATTERN             = `Invalid regex pattern '%s'`
	ERROR_MESSAGE_X_MUST_BE_VALID_REGEX             = `%s must be a valid regex`
	ERROR_MESSAGE_X_MUST_BE_GREATER_OR_TO_0         = `%s must be greater than or equal to 0`
	ERROR_MESSAGE_X_CANNOT_BE_GREATER_THAN_Y        = `%s cannot be greater than %s`
	ERROR_MESSAGE_X_MUST_BE_STRICTLY_GREATER_THAN_0 = `%s must be strictly greater than 0`
	ERROR_MESSAGE_X_CANNOT_BE_USED_WITHOUT_Y        = `%s cannot be used without %s`
	ERROR_MESSAGE_REFERENCE_X_MUST_BE_CANONICAL     = `Reference %s must be canonical`
)
View Source 
const (
	KEY_SCHEMA                = "$subSchema"
	KEY_ID                    = "$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_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_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_ENUM                  = "enum"
	KEY_ONE_OF                = "oneOf"
	KEY_ANY_OF                = "anyOf"
	KEY_ALL_OF                = "allOf"
	KEY_NOT                   = "not"
)
View Source 
const (
	TYPE_ARRAY   = `array`
	TYPE_BOOLEAN = `boolean`
	TYPE_INTEGER = `integer`
	TYPE_NUMBER  = `number`
	TYPE_NULL    = `null`
	TYPE_OBJECT  = `object`
	TYPE_STRING  = `string`
)

Variables

View Source 
var JSON_TYPES []string
View Source 
var ResultErrorsMarshalerFunc = func(rerrs ResultErrors) ([]byte, error) {
	return json.Marshal(rerrs.Map())
}

ResultErrorsMarshalerFunc is the function used when json.Marshal is called on ResultErrors. It's been set as package variable to allow importing packages to alter the default behavior when marshaling ResultErrors.

View Source 
var SCHEMA_TYPES []string

Functions

func NewGoLoader 

func NewGoLoader(source interface{}) *jsonGoLoader

func NewReferenceLoader 

func NewReferenceLoader(source string) *jsonReferenceLoader

func NewStringLoader 

func NewStringLoader(source string) *jsonStringLoader

Types

type JSONContext 

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

JSONContext implements a persistent linked-list of strings

func NewJSONContext 

func NewJSONContext(head string, tail *JSONContext) *JSONContext

func (*JSONContext) String 

func (c *JSONContext) 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 JSONLoader 

type JSONLoader interface {
	// contains filtered or unexported methods
}

type Result 

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

func Validate 

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

func (*Result) AddError 

func (v *Result) AddError(
	context *JSONContext,
	reason string,
	requirement interface{},
	value interface{},
)

AddError adds a context JSON schema error to Result using the failing schema attribute as the reason

func (*Result) Errors 

func (v *Result) Errors() ResultErrors

func (*Result) Valid 

func (v *Result) Valid() bool

type ResultError 

type ResultError struct {
	Context *JSONContext // Tree like notation of the part that failed the validation. ex (root).a.b ...
	Value   interface{}  // Value given by the JSON file that is the source of the error

	Reason      string      //JSON schema keyword responsible for this error
	Requirement interface{} // the schema attribute's requirement that caused this error
}

func (ResultError) String 

func (v ResultError) String() string

type ResultErrors 

type ResultErrors []ResultError

ResultErrors is a collection of JSON schema errors

func (ResultErrors) Error 

func (rerrs ResultErrors) Error() string

func (ResultErrors) Map 

func (rerrs ResultErrors) Map() map[string][]interface{}

Map parses ResultErrors into a map object for simpler error parsing/handling

func (ResultErrors) MarshalJSON 

func (rerrs ResultErrors) MarshalJSON() ([]byte, error)

type Schema 

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

func NewSchema 

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

func (*Schema) SetRootSchemaName 

func (d *Schema) SetRootSchemaName(name string)

func (*Schema) Unmarshal 

func (d *Schema) Unmarshal(data []byte, v interface{}) error

Unmarshal parses the JSON data according to its internal JSON schema and stores the result in the value pointed to by v

func (*Schema) Validate 

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

type Unmarshaler 

type Unmarshaler interface {
	SchemaUnmarshalJSON(data []byte) error
}

Unmarshaler is the interface implemented by objects that can unmarshal a JSON description of themselves while adhering to an internal JSON schema.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.