json

README

JSON

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

• Variables
• type GrammarType
  • func (gt GrammarType) String() string
• type Parser
  • func NewParser(r io.Reader) *Parser
  • func (p Parser) Err() error
  • func (p *Parser) Next() (GrammarType, []byte)
  • func (p *Parser) State() State
• type State
  • func (state State) String() string

Examples

• NewParser

Variables

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

ErrBadArrayEnding is returned when an unexpected right bracket is encountered.

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

ErrBadComma is returned when an unexpected comma is encountered.

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

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

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

ErrBadObjectEnding is returned when an unexpected right brace is encountered.

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

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

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

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

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()
	gt, data := p.Next()
	if gt == ErrorGrammar {
		break
	}
	out += string(data)
	if state == ObjectKeyState && gt != 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.