jsontoken

package
v0.306.1 Latest Latest
Warning

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

 Go to latest Published: Oct 20, 2025 License: Apache-2.0 Imports: 15 Imported by: 0

README

draft

how would you call when a json scanner that finds a valid raw encoded entity part within a json? In this example, I just called that as json field

For example, in this sample:

[{"key1":"value1","ary":[1, 2, 3]}]

the scanner would find:

  • path: ["array", "array-value", "object", "object-key"] raw: []byte("key1") kind: "string"
  • path: ["array", "array-value", "object", "object-value"] raw: []byte("value1") kind: "string" key: "key1"
  • path: ["array", "array-value", "object", "object-key"] raw: []byte("ary") kind: "string"
  • path: ["array", "array-value", "object", "object-value"] raw: []byte("[1, 2, 3]") kind: "array" key: "ary"
  • path: ["array", "array-value", "object", "object-value", "array", "array-value"] raw: []byte("1") kind: "number" index: 0
  • path: ["array", "array-value", "object", "object-value", "array", "array-value"] raw: []byte("2") kind: "number" index: 1
  • path: ["array", "array-value", "object", "object-value", "array", "array-value"] raw: []byte("3") kind: "number" index: 2
  • path: ["array", "array-value"] kind: "object" raw: []byte({"key1":"value1","ary":[1, 2, 3]})
  • path: [] kind: "array" raw: []byte([{"key1":"value1","ary":[1, 2, 3]}])

Documentation

Index

Examples

Constants

View Source 
const (
	KindString  strKind = "string"
	KindNumber  strKind = "number"
	KindBoolean strKind = "boolean"
	KindNull    strKind = "null"
)
View Source 
const (
	KindObject strKind = "object"
	KindName   strKind = "name"
)
View Source 
const ErrMalformed errorkit.Error = "[ErrMalformed] malformed JSON"
View Source 
const KindArray strKind = "array"

Variables

This section is empty.

Functions

func IterateArray 

func IterateArray(ctx context.Context, r io.Reader) iter.Seq2[json.RawMessage, error]

func Query 

func Query(r io.Reader, path ...Kind) iter.Seq2[json.RawMessage, error]

Query will turn the input reader into a json visitor that yields results when a path is matching. Think about it something similar as jq. It will not keep the visited json i n memory, to avoid problems with infinite streams.

Example 
package main

import (
	"fmt"
	"io"

	"go.llib.dev/frameless/pkg/jsonkit/jsontoken"
)

func main() {
	var body io.Reader

	result := jsontoken.Query(body, jsontoken.KindArray, jsontoken.KindElement{})
	for rawJSON, err := range result {
		if err != nil {
			fmt.Println(err.Error())
			continue
		}
		fmt.Println(string(rawJSON))
	}
}

func QueryMany added in v0.304.0 

func QueryMany(r io.Reader, selectors ...Selector) error

func Scan 

func Scan(in Input) (json.RawMessage, error)

Scan scan a json raw message out from an input source.

func ScanFrom 

func ScanFrom[T string | []byte | *bufio.Reader](v T) (json.RawMessage, error)

ScanFrom is a syntax sugar to use Scan with string and byte slices

func TrimSpace 

func TrimSpace(data []byte) []byte

Types

type ArrayIterator 

type ArrayIterator struct {
	Context context.Context
	Input   io.Reader
	// contains filtered or unexported fields
}

func (*ArrayIterator) Close 

func (c *ArrayIterator) Close() error

func (*ArrayIterator) Decode 

func (c *ArrayIterator) Decode(ptr any) error

func (*ArrayIterator) Err 

func (c *ArrayIterator) Err() error

func (*ArrayIterator) Next 

func (c *ArrayIterator) Next() bool

func (*ArrayIterator) Value 

func (c *ArrayIterator) Value() json.RawMessage

type Input 

type Input interface {
	iokit.RuneReader
	iokit.RuneUnreader
	iokit.ByteReader
}

type Kind 

type Kind interface {
	Equal(Kind) bool
	String() string
}

type KindElement added in v0.304.0 

type KindElement struct{ Index *int }

func (KindElement) Equal added in v0.304.1 

func (e KindElement) Equal(oth Kind) bool

func (KindElement) String added in v0.304.1 

func (e KindElement) String() string

type KindValue added in v0.304.0 

type KindValue struct{ Name *string }

func (KindValue) Equal added in v0.304.0 

func (v KindValue) Equal(oth Kind) bool

func (KindValue) String added in v0.304.0 

func (v KindValue) String() string

type LexingError added in v0.304.0 

type LexingError struct {
	Message string
	Path    Path
}

func (LexingError) Error added in v0.304.0 

func (err LexingError) Error() string

type Output 

type Output interface {
	io.Writer
	WriteTo(w io.Writer) (n int64, err error)
	WriteRune(r rune) (n int, err error)
	WriteByte(c byte) error
	Bytes() []byte
}

type Path 

type Path []Kind

func (Path) Equal 

func (p Path) Equal(oth Path) bool

func (Path) Match 

func (p Path) Match(oth Path) bool

Match check if the other path matches the

func (Path) String added in v0.304.0 

func (p Path) String() string

func (Path) With 

func (p Path) With(k Kind) Path

type Scanner 

type Scanner struct {
	// Selectors allows granual control on what should be kept during scanning of a JSON input stream.
	// When no Selectors is set, the default is to keep everything.
	Selectors []Selector
}

Scanner is a streaming lexer, that allows

func (*Scanner) Scan 

func (s *Scanner) Scan(in Input) error

type Selector added in v0.304.0 

type Selector struct {
	Path Path
	Func func(data json.RawMessage) 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.