gojsonschema

package module
v0.0.0-...-0b01062 Latest Latest
Warning

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

 Go to latest Published: Oct 28, 2014 License: Apache-2.0 Imports: 15 Imported by: 6

README

Build Status

gojsonschema

Description

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

Status

Test results: passed 100% of JSON Schema Test Suite (248/248).

Usage

Quick example

package main

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

func main() {

    // Loads a schema remotely
    schemaDocument, err := gojsonschema.NewJsonSchemaDocument("http://host/schema.json")
    if err != nil {
        panic(err.Error())
    }

    // Loads the JSON to validate from a local file
    jsonDocument, err := gojsonschema.GetFileJson("/home/me/data.json")
    if err != nil {
        panic(err.Error())
    }

	// Try to validate the Json against the schema
    result := schemaDocument.Validate(jsonDocument)

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

}
Loading a schema

Schemas can be loaded remotely from a Http Url:

    schemaDocument, err := gojsonschema.NewJsonSchemaDocument("http://myhost/schema.json")

Or a local file, using the file URI scheme:

	schemaDocument, err := gojsonschema.NewJsonSchemaDocument("file:///home/me/schema.json")

You may also load the schema from within your code, using a map[string]interface{} variable.

Note that schemas loaded that way are subject to limitations, they need to be standalone schemas; Which means references to local files and/or remote files within this schema will not work.

	schemaMap := map[string]interface{}{
		"type": "string"}

	schemaDocument, err := gojsonschema.NewJsonSchemaDocument(schemaMap)
Loading a JSON

The library virtually accepts any Json since it uses reflection to validate against the schema.

You may use and combine go types like

  • string (JSON string)
  • bool (JSON boolean)
  • float64 (JSON number)
  • nil (JSON null)
  • slice (JSON array)
  • map[string]interface{} (JSON object)

You may declare your Json from within your code:

	jsonDocument := map[string]interface{}{
		"name": "john"}

Helper functions are also available to load from a Http URL:

    jsonDocument, err := gojsonschema.GetHttpJson("http://host/data.json")

Or a local file:

	jsonDocument, err := gojsonschema.GetFileJson("/home/me/data.json")
Validation

Once the schema and the Json to validate are loaded, validation phase becomes easy:

	result := schemaDocument.Validate(jsonDocument)

Check the result validity with:

	if result.Valid() {
		// Your Json is valid
	}

If not valid, you can loop through the error messages returned by the validation phase:

	for _, desc := range result.Errors() {
    	fmt.Printf("Error: %s\n", desc)
	}

References

###Website http://json-schema.org

###Schema Core http://json-schema.org/latest/json-schema-core.html

###Schema Validation http://json-schema.org/latest/json-schema-validation.html

Dependencies

https://github.com/xeipuuv/gojsonpointer

https://github.com/xeipuuv/gojsonreference

Uses

gojsonschema uses the following test suite :

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

Documentation

Index

Constants

View Source 
const (
	KEY_SCHEMA                = "$schema"
	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"

	STRING_STRING                     = "string"
	STRING_BOOLEAN                    = "boolean"
	STRING_ARRAY_OF_STRINGS           = "array of strings"
	STRING_ARRAY_OF_SCHEMAS           = "array of schemas"
	STRING_OBJECT                     = "object"
	STRING_SCHEMA                     = "schema"
	STRING_SCHEMA_OR_ARRAY_OF_STRINGS = "schema or array of strings"
	STRING_PROPERTIES                 = "properties"
	STRING_DEPENDENCY                 = "dependency"

	CONTEXT_ROOT         = "(root)"
	ROOT_SCHEMA_PROPERTY = "(root)"
)
View Source 
const (
	ERROR_MESSAGE_X_MUST_BE_OF_TYPE_Y = `%s must be of type %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_ARRAY_ITEMS_MUST_BE_UNIQUE = `array items must be unique`
	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`
)
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 GetFileJson 

func GetFileJson(filepath string) (interface{}, error)

Helper function to read a JSON from a file path

func GetHttpJson 

func GetHttpJson(url string) (interface{}, error)

Helper function to read a JSON from a http request Http request must return 200 OK

func NewSchemaPool 

func NewSchemaPool() *schemaPool

Types

type JsonSchemaDocument 

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

func NewJsonSchemaDocument 

func NewJsonSchemaDocument(document interface{}, pool ...*schemaPool) (*JsonSchemaDocument, error)

func (*JsonSchemaDocument) SetRootSchemaName 

func (d *JsonSchemaDocument) SetRootSchemaName(name string)

func (*JsonSchemaDocument) Validate 

func (v *JsonSchemaDocument) Validate(document interface{}) *ValidationResult

type ValidationError 

type ValidationError 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 (ValidationError) String 

func (v ValidationError) String() string

type ValidationResult 

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

func (*ValidationResult) Errors 

func (v *ValidationResult) Errors() []ValidationError

func (*ValidationResult) Valid 

func (v *ValidationResult) Valid() bool

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.