json

package
v2.0.0+incompatible Latest Latest
Warning

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

Go to latest
Published: Apr 10, 2016 License: MIT Imports: 4 Imported by: 1

README

JSON GoDoc GoCover

This package is a JSON lexer (ECMA-404) written in Go. It follows the specification at JSON. The lexer takes an io.Reader and converts it into tokens until the EOF.

Installation

Run the following command

go get github.com/tdewolff/parse/json

or add the following import and run project with go get

import "github.com/tdewolff/parse/json"

Parser

Usage

The following initializes a new Parser with io.Reader r:

p := json.NewParser(r)

To tokenize until EOF an error, use:

for {
	gt, text := p.Next()
	switch gt {
	case json.ErrorGrammar:
		// error or EOF set in p.Err()
		return
	// ...
	}
}

All grammars:

ErrorGrammar       GrammarType = iota // extra grammar when errors occur
WhitespaceGrammar                     // space \t \r \n
LiteralGrammar                        // null true false
NumberGrammar
StringGrammar
StartObjectGrammar // {
EndObjectGrammar   // }
StartArrayGrammar  // [
EndArrayGrammar    // ]
Examples
package main

import (
	"os"

	"github.com/tdewolff/parse/json"
)

// Tokenize JSON from stdin.
func main() {
	p := json.NewParser(os.Stdin)
	for {
		gt, text := p.Next()
		switch gt {
		case json.ErrorGrammar:
			if p.Err() != io.EOF {
				fmt.Println("Error on line", p.Line(), ":", p.Err())
			}
			return
		case json.LiteralGrammar:
			fmt.Println("Literal", string(text))
		case json.NumberGrammar:
			fmt.Println("Number", string(text))
		// ...
		}
	}
}

License

Released under the MIT license.

Documentation

Overview

Package json is a JSON parser following the specifications at http://json.org/.

Index

Examples

Constants

This section is empty.

Variables

View Source
var ErrBadArrayEnding = errors.New("unexpected right bracket character")

ErrBadArrayEnding is returned when an unexpected right bracket is encountered.

View Source
var ErrBadComma = errors.New("unexpected comma character outside an array or object")

ErrBadComma is returned when an unexpected comma is encountered.

View Source
var ErrBadObjectDeclaration = errors.New("expected colon character after object key")

ErrBadObjectDeclaration is returned when the object key is not followed by a colon character.

View Source
var ErrBadObjectEnding = errors.New("unexpected right brace character")

ErrBadObjectEnding is returned when an unexpected right brace is encountered.

View Source
var ErrBadObjectKey = errors.New("expected object key to be a quoted string")

ErrBadObjectKey is returned when the object key is not a quoted string.

View Source
var ErrNoComma = errors.New("expected comma character or an array or object ending")

ErrNoComma is returned when no comma is present between two values.

Functions

This section is empty.

Types

type GrammarType

type GrammarType uint32

GrammarType determines the type of grammar

const (
	ErrorGrammar GrammarType = iota // extra grammar when errors occur
	WhitespaceGrammar
	LiteralGrammar
	NumberGrammar
	StringGrammar
	StartObjectGrammar // {
	EndObjectGrammar   // }
	StartArrayGrammar  // [
	EndArrayGrammar    // ]
)

GrammarType values.

func (GrammarType) String

func (gt GrammarType) String() string

String returns the string representation of a GrammarType.

type Parser

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

Parser is the state for the lexer.

func NewParser

func NewParser(r io.Reader) *Parser

NewParser returns a new Parser for a given io.Reader.

Example
p := NewParser(bytes.NewBufferString(`{"key": 5}`))
out := ""
for {
	state := p.State()
	tt, data := p.Next()
	if tt == ErrorGrammar {
		break
	}
	out += string(data)
	if state == ObjectKeyState && tt != EndObjectGrammar {
		out += ":"
	}
	// not handling comma insertion
}
fmt.Println(out)
Output:

{"key":5}

func (Parser) Err

func (p Parser) Err() error

Err returns the error encountered during tokenization, this is often io.EOF but also other errors can be returned.

func (*Parser) Next

func (p *Parser) Next() (GrammarType, []byte)

Next returns the next Grammar. It returns ErrorGrammar when an error was encountered. Using Err() one can retrieve the error message.

func (*Parser) State

func (p *Parser) State() State

State returns the state the parser is currently in (ie. which token is expected).

type State

type State uint32

State determines the current state the parser is in.

const (
	ValueState State = iota // extra token when errors occur
	ObjectKeyState
	ObjectValueState
	ArrayState
)

State values.

func (State) String

func (state State) String() string

String returns the string representation of a State.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL