gojsonschema

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Mar 12, 2015 License: Apache-2.0 Imports: 14 Imported by: 21

README

Build Status

gojsonschema

Description

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

References :

Installation

go get github.com/juju/gojsonschema

Dependencies :

Usage

Example

package main

import (
    "fmt"
    "github.com/juju/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         = "(root)"
	STRING_ROOT_SCHEMA_PROPERTY = "(root)"

	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_IS_MISSING_AND_REQUIRED  = `%s is missing and required`
	ERROR_MESSAGE_MUST_BE_OF_TYPE_X          = `must be of type %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_DOES_NOT_MATCH_PATTERN     = `does not match pattern '%s'`
	ERROR_MESSAGE_MUST_MATCH_ONE_ENUM_VALUES = `must match one of the enum values [%s]`

	ERROR_MESSAGE_STRING_LENGTH_MUST_BE_GREATER_OR_EQUAL = `string length must be greater or equal to %d`
	ERROR_MESSAGE_STRING_LENGTH_MUST_BE_LOWER_OR_EQUAL   = `string length must be lower or equal to %d`

	ERROR_MESSAGE_NUMBER_MUST_BE_LOWER_OR_EQUAL   = `must be lower than or equal to %s`
	ERROR_MESSAGE_NUMBER_MUST_BE_LOWER            = `must be lower than %s`
	ERROR_MESSAGE_NUMBER_MUST_BE_GREATER_OR_EQUAL = `must be greater than or equal to %s`
	ERROR_MESSAGE_NUMBER_MUST_BE_GREATER          = `must be greater than %s`

	ERROR_MESSAGE_NUMBER_MUST_VALIDATE_ALLOF = `must validate all the schemas (allOf)`
	ERROR_MESSAGE_NUMBER_MUST_VALIDATE_ONEOF = `must validate one and only one schema (oneOf)`
	ERROR_MESSAGE_NUMBER_MUST_VALIDATE_ANYOF = `must validate at least one schema (anyOf)`
	ERROR_MESSAGE_NUMBER_MUST_VALIDATE_NOT   = `must not validate the schema (not)`

	ERROR_MESSAGE_ARRAY_MIN_ITEMS = `array must have at least %d items`
	ERROR_MESSAGE_ARRAY_MAX_ITEMS = `array must have at the most %d items`

	ERROR_MESSAGE_ARRAY_MIN_PROPERTIES = `must have at least %d properties`
	ERROR_MESSAGE_ARRAY_MAX_PROPERTIES = `must have at the most %d properties`

	ERROR_MESSAGE_HAS_DEPENDENCY_ON = `has a dependency on %s`

	ERROR_MESSAGE_MULTIPLE_OF = `must be a multiple of %s`

	ERROR_MESSAGE_ARRAY_NO_ADDITIONAL_ITEM = `no additional item allowed on array`

	ERROR_MESSAGE_ADDITIONAL_PROPERTY_NOT_ALLOWED = `additional property "%s" is not allowed`
	ERROR_MESSAGE_INVALID_PATTERN_PROPERTY        = `property "%s" does not match pattern %s`

	ERROR_MESSAGE_INTERNAL = `internal error %s`

	ERROR_MESSAGE_GET_HTTP_BAD_STATUS = `Could not read schema from HTTP, response status is %d`

	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_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`

	RESULT_ERROR_FORMAT = `%s : %s, given %s` // context, description, value
)
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 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 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) Errors 

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

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 ...
	Description string       // A human readable error message
	Value       interface{}  // Value given by the JSON file that is the source of the error
}

func (ResultError) String 

func (v ResultError) String() string

type Schema 

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

func NewSchema 

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

func (*Schema) InsertDefaults 

func (s *Schema) InsertDefaults(into map[string]interface{}) (m map[string]interface{}, returnErr error)

InsertDefaults takes a map[string]interface{} and inserts any missing default values specified in the JSON-Schema document. If the given "into" map is nil, it will be created.

This is an initial implementation which does not support refs, etc. The schema must be for an object, not a bare value.

func (*Schema) SetRootSchemaName 

func (d *Schema) SetRootSchemaName(name string)

func (*Schema) Validate 

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

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.