tree

package module
v0.10.0 Latest Latest
Warning

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

 Go to latest Published: Apr 9, 2026 License: MIT Imports: 14 Imported by: 0

README

Tree

Tests govulncheck PkgGoDev Report Card

Tree is a simple structure for dealing with dynamic or unknown JSON/YAML in Go.

Table of Contents

Features

  • Parses json/yaml of unknown structure to get to nodes with fluent interface.
  • Syntax similar to Go standard and map and slice.
  • Find function can be specified the Query expression with built-in methods.
  • Edit function can be specified the Edit expression.
  • Bundled 'tq' that is a portable command-line JSON/YAML processor.

Road to 1.0

  • Placeholders in query.
  • Merge support in tq.

Syntax

Go
tree.Map{
	"ID":     tree.ToValue(1),
	"Name":   tree.ToValue("Reds"),
	"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
}
JSON
{
	"ID": 1,
	"Name": "Reds",
	"Colors": ["Crimson", "Red", "Ruby", "Maroon"]
}
YAML
ID: 1
Name: Reds
Colors:
- Crimson
- Red
- Ruby
- Maroon

Marshal and Unmarshal

func ExampleMarshalJSON() {
	group := tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}
	b, err := json.Marshal(group)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b))

	// Output:
	// {"Colors":["Crimson","Red","Ruby","Maroon"],"ID":1,"Name":"Reds"}
}

func ExampleUnmarshalJSON() {
	data := []byte(`[
  {"Name": "Platypus", "Order": "Monotremata"},
  {"Name": "Quoll",    "Order": "Dasyuromorphia"}
]`)

	var animals tree.Array
	err := json.Unmarshal(data, &animals)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", animals)

	// Output:
	// [map[Name:Platypus Order:Monotremata] map[Name:Quoll Order:Dasyuromorphia]]
}
Using other parsers

Tree may work on other parsers that are compatible with "encoding/json" or "gopkg.in/yaml.v2". See examples directory.

Alternate json.RawMessage

For example, Dynamic JSON in Go shows an example of using json.RawMessage.

It may be simpler to use tree.Map instead of json.RawMessage.

package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

const input = `
{
	"type": "sound",
	"msg": {
		"description": "dynamite",
		"authority": "the Bruce Dickinson"
	}
}
`

type Envelope struct {
	Type string
	Msg  tree.Map
}

func main() {
	env := Envelope{}
	if err := json.Unmarshal([]byte(input), &env); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%#v\n", env)
	fmt.Printf("%#v\n", env.Msg.Get("description"))

	// Output:
	// main.Envelope{Type:"sound", Msg:tree.Map{"authority":"the Bruce Dickinson", "description":"dynamite"}}
	// "dynamite"
}

Get

func ExampleGet() {
	group := tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
		"Nil":    nil,
	}
	fmt.Println(group.Get("Colors").Get(1))
	fmt.Println(group.Get("Colors", 2))
	fmt.Println(group.Get("Colors").Get(5).IsNil())
	fmt.Println(group.Get("Nil").IsNil())

	// Output:
	// Red
	// Ruby
	// true
	// true
}

Find

func ExampleFind() {
	group := tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}

	rs, err := group.Find(".Colors[1:3]")
	if err != nil {
		log.Fatal(err)
	}
	for _, r := range rs {
		fmt.Println(r)
	}

	// Output:
	// Red
	// Ruby
}
Query

For more details on built-in methods, see the Built-in Methods section.

Query Description Results
.store.book[0] The first book {"category": "reference", "author": "Nigel Rees", "title": "Sayings of the Century", "price": 8.95, "tags": [...]}
.store.book[0].price The price of the first book 8.95
.store.book.0.price The price of the first book (using dot) 8.95
.store.book[:2].price All prices of books[0:2] (index 2 is exclusive) 8.95, 12.99
.store.book[].author All authors of all books "Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"
..author All authors "Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"
..author | [0] The first author "Nigel Rees"
.store.book[.tags[.name == "genre" and .value == "fiction"]].title All titles of books tagged "fiction" "Sword of Honour", "Moby Dick"
.store.book[(.category == "fiction" or .category == "reference") and .price < 10].title All titles of books that are categorized as "fiction" or "reference" and price < 10 "Sayings of the Century", "Moby Dick"
.store.book[.title ~= "^S"].title Titles beginning with "S" "Sayings of the Century", "Sword of Honour"
.store.book.count() Count books 4
.store.book[0].keys() Sorted keys of the first book ["author", "category", "price", "tags", "title"]
.store.book[0].values() Values of the first book ["Nigel Rees", "reference", 8.95, [tag objects], "Sayings of the Century"]
.store.book.last().has("isbn") Check if last book has ISBN true
.store.book[.author.contains("Tolkien")] Check if any author contains "Tolkien" [{"author": "J. R. R. Tolkien", ...}]
.store.book[0].category.type() Get type of category field "string"
.store.book[0].empty() Check if first book is empty false
.store.book.first().title Get title of first book "Sayings of the Century"
.store.book.last().author Get author of last book "J. R. R. Tolkien"
.store.book.sort(".price").first().title Cheapest book "Sayings of the Century"
.store.book.rsort(".price").first().title Most expensive book "The Lord of the Rings"
Illustrative Object
{
  "store": {
    "bicycle": {
      "color": "red",
      "price": 19.95
    },
    "book": [
      {
        "author": "Nigel Rees",
        "category": "reference",
        "price": 8.95,
        "title": "Sayings of the Century",
        "tags": [
          { "name": "genre", "value": "reference" },
          { "name": "era", "value": "20th century" },
          { "name": "theme", "value": "quotations" }
        ]
      },
      {
        "author": "Evelyn Waugh",
        "category": "fiction",
        "price": 12.99,
        "title": "Sword of Honour",
        "tags": [
          { "name": "genre", "value": "fiction" },
          { "name": "era", "value": "20th century" },
          { "name": "theme", "value": "WWII" }
        ]
      },
      {
        "author": "Herman Melville",
        "category": "fiction",
        "isbn": "0-553-21311-3",
        "price": 8.99,
        "title": "Moby Dick",
        "tags": [
          { "name": "genre", "value": "fiction" },
          { "name": "era", "value": "19th century" },
          { "name": "theme", "value": "whale hunting" }
        ]
      },
      {
        "author": "J. R. R. Tolkien",
        "category": "fiction",
        "isbn": "0-395-19395-8",
        "price": 22.99,
        "title": "The Lord of the Rings",
        "tags": [
          { "name": "genre", "value": "fantasy" },
          { "name": "era", "value": "20th century" },
          { "name": "theme", "value": "good vs evil" }
        ]
      }
    ]
  }
}
Built-in Methods

Tree provides several built-in methods for data manipulation and querying:

Aggregate Methods
  • count() - Returns the count of elements in arrays or maps
  • keys() - Returns the keys of arrays (as indices) or maps
  • values() - Returns the values of arrays or maps as an array
Condition Methods
  • empty() - Checks if the node is empty (empty arrays, maps, null values, or empty strings)
  • has(key) - Checks if the node has the specified key (works with arrays and maps)
  • contains(value) - Checks if the node contains the specified value (arrays, maps, or substring in strings)
Data Type Methods
  • type() - Returns the type name of the node ("array", "object", "string", "number", "boolean", "null")
Array Methods
  • first() - Returns the first element of an array
  • last() - Returns the last element of an array
  • sort([expr]) - Returns the array sorted in ascending order. With an optional query expression, sorts by the value that expression resolves to on each element.
  • rsort([expr]) - Same as sort() but in descending order.
Examples
// Count elements
node.Find(".store.book.count()")  // Returns: 4

// Check if key exists
node.Find(".store.book[0].has(\"title\")")  // Returns: true

// Check if contains value in string
node.Find(".store.book[0].author.contains(\"Nigel\")")  // Returns: true

// Get type
node.Find(".store.book[0].price.type()")  // Returns: "number"

// Array operations
node.Find(".store.book.first().title")  // Returns: "Sayings of the Century"
node.Find(".store.book.last().title")   // Returns: "The Lord of the Rings"

// Sort by a sub-expression
node.Find(".store.book.sort(\".price\")")   // Books ordered by ascending price
node.Find(".store.book.rsort(\".price\")")  // Books ordered by descending price

Edit

func ExampleEdit() {
	var group tree.Node = tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}

	if err := tree.Edit(&group, ".Colors += \"Pink\""); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Append Pink to Colors:\n  %+v\n", group)

	if err := tree.Edit(&group, ".Name = \"Blue\""); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Set Blue to Name:\n  %+v\n", group)

	if err := tree.Edit(&group, ".Colors ^?"); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Delete Colors:\n  %+v\n", group)

	// Output:
	// Append Pink to Colors:
	//   map[Colors:[Crimson Red Ruby Maroon Pink] ID:1 Name:Reds]
	// Set Blue to Name:
	//   map[Colors:[Crimson Red Ruby Maroon Pink] ID:1 Name:Blue]
	// Delete Colors:
	//   map[ID:1 Name:Blue]
}

tq

tq is a portable command-line JSON/YAML processor.

Installation
go install github.com/mojatter/tree/cmd/tq@latest

Using Homebrew

brew tap mojatter/tree
brew install mojatter/tree/tq

Download binary

# For macOS (Darwin)
VERSION=0.10.0 GOOS=Darwin GOARCH=arm64; curl -fsSL "https://github.com/mojatter/tree/releases/download/v${VERSION}/tree_${VERSION}_${GOOS}_${GOARCH}.tar.gz" | tar xz tq && mv tq /usr/local/bin

# For Linux x64
VERSION=0.10.0 GOOS=Linux GOARCH=amd64; curl -fsSL "https://github.com/mojatter/tree/releases/download/v${VERSION}/tree_${VERSION}_${GOOS}_${GOARCH}.tar.gz" | tar xz tq && mv tq /usr/local/bin

# For Windows x64
VERSION=0.10.0; curl -fsSL "https://github.com/mojatter/tree/releases/download/v${VERSION}/tree_${VERSION}_windows_amd64.zip" -o tq.zip && unzip tq.zip tq.exe
Usage
tq is a command-line JSON/YAML processor.

Usage:
  tq [flags] [query] ([file...])

Flags:
  -c, --color                  output with colors
  -e, --edit stringArray       edit expression
  -x, --expand                 expand results
  -h, --help                   help for tq
  -U, --inplace                update files, inplace
  -i, --input-format string    input format (json or yaml)
  -j, --input-json             alias --input-format json
  -y, --input-yaml             alias --input-format yaml
  -O, --output string          output file
  -o, --output-format string   output format (json or yaml, default json)
  -J, --output-json            alias --output-format json
  -Y, --output-yaml            alias --output-format yaml
  -r, --raw                    output raw strings
  -s, --slurp                  slurp all results into an array
  -t, --template string        golang text/template string
  -v, --version                print version

Examples:
  % echo '{"colors": ["red", "green", "blue"]}' | tq '.colors[0]'
  "red"

  % echo '{"users":[{"id":1,"name":"one"},{"id":2,"name":"two"}]}' | tq -x -t '{{.id}}: {{.name}}' '.users'
  1: one
  2: two

  % echo '{}' | tq -e '.colors = ["red", "green"]' -e '.colors += "blue"' .
  {
    "colors": [
      "red",
      "green",
      "blue"
    ]
  }

  # Using built-in methods
  % echo '{"books": [{"author": "Tolkien"}, {"author": "Hemingway"}]}' | tq '.books[.author.contains("Tol")]'
  [{"author": "Tolkien"}]
for jq user
tq jq
tq '.store.book[0]' jq '.store.book[0]'
tq '.store.book[]' jq '.store.book[]'
tq '.store.book[:2].price' jq '.store.book[:2][] | .price'
tq '.store.book[.category == "fiction" and .price < 10].title' jq '.store.book[] | select(.category == "fiction" and .price < 10) | .title'

Contributing

Bug reports, feature requests, and pull requests are welcome. See CONTRIBUTING.md for the local development workflow, the make targets that wrap the test/lint/fuzz/bench commands, and the project's code conventions.

Third-party library licenses

Documentation

Overview

Package tree provides a simple structure for dealing with dynamic or unknown JSON/YAML structures.

Index

Examples

Constants

This section is empty.

Variables

View Source 
var (
	Nil = NilValue{}
)
View Source 
var SkipWalk = errors.New("skip") //nolint:staticcheck // ST1012: sentinel value, see godoc

SkipWalk is used as a return value from WalkFunc to indicate that the node and its children in the call are to be skipped. It is not returned as an error by any function.

Like io/fs.SkipDir and io/fs.SkipAll, this is a sentinel control value rather than a failure, so it intentionally does not use the "Err" prefix recommended by ST1012.

View Source 
var VERSION = "dev"

VERSION is the version number. The default "dev" value is overridden at release build time via -ldflags by goreleaser: 

-X github.com/mojatter/tree.VERSION={{.Version}}

Functions

func Edit 

func Edit(pn *Node, expr string) error
Example 
package main

import (
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	var group tree.Node = tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}

	if err := tree.Edit(&group, ".Colors += \"Pink\""); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Append Pink to Colors:\n  %+v\n", group)

	if err := tree.Edit(&group, ".Name = \"Blue\""); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Set Blue to Name:\n  %+v\n", group)

	if err := tree.Edit(&group, ".Colors ^?"); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Delete Colors:\n  %+v\n", group)

}

Output:
Append Pink to Colors:
  map[Colors:[Crimson Red Ruby Maroon Pink] ID:1 Name:Reds]
Set Blue to Name:
  map[Colors:[Crimson Red Ruby Maroon Pink] ID:1 Name:Blue]
Delete Colors:
  map[ID:1 Name:Blue]

func MarshalJSON 

func MarshalJSON(n Node) ([]byte, error)

MarshalJSON returns the JSON encoding of the specified node.

Example 
package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	group := tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}
	b, err := json.Marshal(group)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b))

}

Output:
{"Colors":["Crimson","Red","Ruby","Maroon"],"ID":1,"Name":"Reds"}
Example (Combined) 
package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	type ColorGroup struct {
		ID     int
		Name   string
		Colors tree.Array
	}
	group := ColorGroup{
		ID:     1,
		Name:   "Reds",
		Colors: tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}
	b, err := json.Marshal(group)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b))

}

Output:
{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}

func MarshalYAML 

func MarshalYAML(n Node) ([]byte, error)

MarshalYAML returns the YAML encoding of the specified node using tree's default 2-space indentation.

Example 
package main

import (
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	group := tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}
	b, err := tree.MarshalYAML(group)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b))

}

Output:
Colors:
  - Crimson
  - Red
  - Ruby
  - Maroon
ID: 1
Name: Reds

func OutputColorJSON 

func OutputColorJSON(out io.Writer, n Node) error

OutputColorJSON writes JSON values with color to out.

func OutputColorYAML 

func OutputColorYAML(out io.Writer, n Node) error

OutputColorYAML writes YAML values with color to out.

func RegisterNewMethodQueryFunc 

func RegisterNewMethodQueryFunc(method string, fn NewMethodQueryFunc)

RegisterNewMethodQueryFunc registers a factory function for a method query. This allows dynamic registration of new method types at runtime.

func ToAny 

func ToAny(n Node) any

ToAny converts a Node back to a native Go any value. This is the reverse operation of ToNode.

func UnmarshalViaJSON 

func UnmarshalViaJSON(n Node, v any) error

UnmarshalViaJSON stores the node in the value pointed to by v via "encoding/json".

func UnmarshalViaYAML 

func UnmarshalViaYAML(n Node, v any) error

UnmarshalViaYAML stores the node in the value pointed to by v via "gopkg.in/yaml.v3".

func Walk 

func Walk(n Node, fn WalkFunc) error

Walk walks the node tree rooted at root, calling fn for each node or that children in the tree, including root.

Types

type And 

type And []Selector

And represents selectors that combines each selector with and.

func (And) Matches 

func (a And) Matches(n Node) (bool, error)

Matches returns true if all selectors returns true.

func (And) String 

func (a And) String() string

type Any 

type Any struct {
	Node
}

Any is an interface that defines any node.

func (Any) Array 

func (n Any) Array() Array

Array returns this node as an Array.

func (Any) Each 

func (n Any) Each(cb func(key any, n Node) error) error

Each calls the callback function for each Array values.

func (Any) Find 

func (n Any) Find(expr string) ([]Node, error)

Find finds a node using the query expression.

func (Any) Get 

func (n Any) Get(keys ...any) Node

Get returns an array value as Node.

func (Any) Has 

func (n Any) Has(keys ...any) bool

Has checks this node has key.

func (Any) IsNil 

func (n Any) IsNil() bool

IsNil returns true if this node is nil.

func (Any) Map 

func (n Any) Map() Map

Map returns nil.

func (Any) Type 

func (n Any) Type() Type

Type returns TypeArray.

func (*Any) UnmarshalJSON 

func (n *Any) UnmarshalJSON(data []byte) error

UnmarshalJSON is an implementation of json.Unmarshaler.

func (Any) Value 

func (n Any) Value() Value

Value returns nil.

type Array 

type Array []Node

Array represents an array of Node.

func ToArrayValues 

func ToArrayValues(vs ...any) Array

ToArrayValues calls ToValue for each provided vs and returns them as an Array.

func (*Array) Append 

func (n *Array) Append(v Node) error

Append appends v to *n.

func (Array) Array 

func (n Array) Array() Array

Array returns this node as an Array.

func (*Array) Delete 

func (n *Array) Delete(key any) error

Delete deletes n[key].

func (Array) Each 

func (n Array) Each(cb func(key any, n Node) error) error

Each calls the callback function for each Array values.

func (Array) Find 

func (n Array) Find(expr string) ([]Node, error)

Find finds a node using the query expression.

func (Array) Get 

func (n Array) Get(keys ...any) Node

Get returns an array value as Node.

func (Array) Has 

func (n Array) Has(keys ...any) bool

Has checks this node has key.

func (Array) IsNil 

func (n Array) IsNil() bool

IsNil returns true if this node is nil.

func (Array) Map 

func (n Array) Map() Map

Map returns nil.

func (*Array) Set 

func (n *Array) Set(key any, v Node) error

Set sets v to n[key].

func (Array) Type 

func (n Array) Type() Type

Type returns TypeArray.

func (*Array) UnmarshalJSON 

func (n *Array) UnmarshalJSON(data []byte) error

UnmarshalJSON is an implementation of json.Unmarshaler.

func (*Array) UnmarshalYAML 

func (n *Array) UnmarshalYAML(value *yaml.Node) error

UnmarshalYAML is an implementation of yaml.Unmarshaler (yaml.v3).

func (Array) Value 

func (n Array) Value() Value

Value returns nil.

type ArrayQuery 

type ArrayQuery int

ArrayQuery is an index of the Array that implements methods of the Query.

func (ArrayQuery) Append 

func (q ArrayQuery) Append(pn *Node, v Node) error

func (ArrayQuery) Delete 

func (q ArrayQuery) Delete(pn *Node) error

func (ArrayQuery) Exec 

func (q ArrayQuery) Exec(n Node) ([]Node, error)

func (ArrayQuery) Set 

func (q ArrayQuery) Set(pn *Node, v Node) error

func (ArrayQuery) String 

func (q ArrayQuery) String() string

type ArrayRangeQuery 

type ArrayRangeQuery []int

ArrayRangeQuery represents a range of the Array that implements methods of the Query.

func (ArrayRangeQuery) Exec 

func (q ArrayRangeQuery) Exec(n Node) ([]Node, error)

func (ArrayRangeQuery) String 

func (q ArrayRangeQuery) String() string

type BoolValue 

type BoolValue bool

A BoolValue represents a bool value.

func (BoolValue) Array 

func (n BoolValue) Array() Array

Array returns nil.

func (BoolValue) Bool 

func (n BoolValue) Bool() bool

Bool returns this.

func (BoolValue) Compare 

func (n BoolValue) Compare(op Operator, v Value) bool

Compare compares n and v.

func (BoolValue) Each 

func (n BoolValue) Each(cb func(key any, n Node) error) error

Each calls cb(nil, n).

func (BoolValue) Find 

func (n BoolValue) Find(expr string) ([]Node, error)

Find finds a node using the query expression.

func (BoolValue) Float64 

func (n BoolValue) Float64() float64

Float64 returns 0.

func (BoolValue) Get 

func (n BoolValue) Get(keys ...any) Node

Get returns nil.

func (BoolValue) Has 

func (n BoolValue) Has(keys ...any) bool

Has returns false.

func (BoolValue) Int 

func (n BoolValue) Int() int

Int returns 0.

func (BoolValue) Int64 

func (n BoolValue) Int64() int64

Int64 returns 0.

func (BoolValue) IsNil 

func (n BoolValue) IsNil() bool

IsNil returns true if this node is nil.

func (BoolValue) Map 

func (n BoolValue) Map() Map

Map returns nil.

func (BoolValue) String 

func (n BoolValue) String() string

String returns this as string.

func (BoolValue) Type 

func (n BoolValue) Type() Type

Type returns TypeValue.

func (BoolValue) Value 

func (n BoolValue) Value() Value

Value returns this.

type ColorEncoder 

type ColorEncoder struct {
	Out        io.Writer
	IndentSize int
	NoColor    bool
	// contains filtered or unexported fields
}

ColorEncoder writes JSON or YAML values with color to an output stream.

func (*ColorEncoder) EncodeJSON 

func (e *ColorEncoder) EncodeJSON(n Node) error

EncodeJSON writes JSON values with color to an output stream.

func (*ColorEncoder) EncodeYAML 

func (e *ColorEncoder) EncodeYAML(n Node) error

EncodeJSON writes JSON values with color to an output stream.

type Comparator 

type Comparator struct {
	Left  Query
	Op    Operator
	Right Query
}

Comparator represents a comparable selector.

func (Comparator) Matches 

func (c Comparator) Matches(n Node) (bool, error)

Matches evaluates left and right using the operator. (eg. .id == 0)

func (Comparator) String 

func (c Comparator) String() string

type ContainsQuery 

type ContainsQuery struct {
	Value string
}

ContainsQuery checks if the node contains the specified value. Works with arrays, maps, and string values.

func (*ContainsQuery) Exec 

func (q *ContainsQuery) Exec(n Node) ([]Node, error)

Exec returns whether the node contains the specified value. For arrays, checks if any element equals the value. For maps, checks if any value equals the value. For strings, checks if the string contains the substring.

func (*ContainsQuery) String 

func (q *ContainsQuery) String() string

type CountQuery 

type CountQuery struct{}

CountQuery returns the count of elements in arrays or maps. For other node types, returns 0.

func (*CountQuery) Exec 

func (q *CountQuery) Exec(n Node) ([]Node, error)

Exec returns the count of elements in the node. For arrays and maps, returns their length. For other types, returns 0.

func (*CountQuery) String 

func (q *CountQuery) String() string

type EditorNode 

type EditorNode interface {
	Node
	Append(v Node) error
	Set(key any, v Node) error
	Delete(key any) error
}

EditorNode is an interface that defines the methods to edit this node.

type EditorQuery 

type EditorQuery interface {
	Query
	Set(pn *Node, v Node) error
	Append(pn *Node, v Node) error
	Delete(pn *Node) error
}

EditorQuery is an interface that defines the methods to edit a node.

type EmptyQuery 

type EmptyQuery struct{}

EmptyQuery checks if the node is empty. Returns true for empty arrays, empty maps, null values, and empty strings.

func (*EmptyQuery) Exec 

func (q *EmptyQuery) Exec(n Node) ([]Node, error)

Exec returns whether the node is empty. Returns true for empty arrays, empty maps, null values, and empty strings.

func (*EmptyQuery) String 

func (q *EmptyQuery) String() string

type Evaluator 

type Evaluator struct {
	Query Query
}

Evaluator represents a evaluatable selector.

func (Evaluator) Matches 

func (e Evaluator) Matches(n Node) (bool, error)

func (Evaluator) String 

func (e Evaluator) String() string

type FilterQuery 

type FilterQuery []Query

FilterQuery consists of multiple queries that filter the nodes in order.

func (FilterQuery) Exec 

func (qs FilterQuery) Exec(n Node) ([]Node, error)

func (FilterQuery) String 

func (qs FilterQuery) String() string

type FirstQuery 

type FirstQuery struct{}

FirstQuery returns the first element of an array. Returns null for empty arrays or non-array types.

func (*FirstQuery) Exec 

func (q *FirstQuery) Exec(n Node) ([]Node, error)

Exec returns the first element of an array. Returns null for empty arrays or non-array types.

func (*FirstQuery) String 

func (q *FirstQuery) String() string

type HasQuery 

type HasQuery struct {
	Key string
}

HasQuery checks if the node has the specified key. Works with both arrays (numeric keys) and maps (string keys).

func (*HasQuery) Exec 

func (q *HasQuery) Exec(n Node) ([]Node, error)

Exec returns whether the node has the specified key. For arrays, checks numeric indices. For maps, checks string keys.

func (*HasQuery) String 

func (q *HasQuery) String() string

type KeysQuery 

type KeysQuery struct{}

KeysQuery returns the keys of arrays (as indices) or maps. For arrays, returns numeric indices. For maps, returns string keys.

func (*KeysQuery) Exec 

func (q *KeysQuery) Exec(n Node) ([]Node, error)

Exec returns the keys of the node as an array. For arrays, returns numeric indices. For maps, returns string keys. Returns nil for other node types.

func (*KeysQuery) String 

func (q *KeysQuery) String() string

type LastQuery 

type LastQuery struct{}

LastQuery returns the last element of an array. Returns null for empty arrays or non-array types.

func (*LastQuery) Exec 

func (q *LastQuery) Exec(n Node) ([]Node, error)

Exec returns the last element of an array. Returns null for empty arrays or non-array types.

func (*LastQuery) String 

func (q *LastQuery) String() string

type Map 

type Map map[string]Node

Map represents a map of Node.

func (Map) Append 

func (n Map) Append(v Node) error

Append returns a error.

func (Map) Array 

func (n Map) Array() Array

Array returns nil.

func (Map) Delete 

func (n Map) Delete(key any) error

Delete deletes n[key].

func (Map) Each 

func (n Map) Each(cb func(key any, n Node) error) error

Each calls the callback function for each Map values.

func (Map) Find 

func (n Map) Find(expr string) ([]Node, error)

Find finds a node using the query expression.

func (Map) Get 

func (n Map) Get(keys ...any) Node

Get returns an array value as Node.

func (Map) Has 

func (n Map) Has(keys ...any) bool

Has checks this node has key.

func (Map) IsNil 

func (n Map) IsNil() bool

IsNil returns true if this node is nil.

func (Map) Keys 

func (n Map) Keys() []string

Keys returns sorted keys of the map.

func (Map) Map 

func (n Map) Map() Map

Map returns this node as a Map.

func (Map) Set 

func (n Map) Set(key any, v Node) error

Set sets v to n[key].

func (Map) Type 

func (n Map) Type() Type

Type returns TypeMap.

func (*Map) UnmarshalJSON 

func (n *Map) UnmarshalJSON(data []byte) error

UnmarshalJSON is an implementation of json.Unmarshaler.

func (*Map) UnmarshalYAML 

func (n *Map) UnmarshalYAML(value *yaml.Node) error

UnmarshalYAML is an implementation of yaml.Unmarshaler (yaml.v3).

func (Map) Value 

func (n Map) Value() Value

Value returns nil.

func (Map) Values 

func (n Map) Values() []Node

Values returns values of the map.

type MapQuery 

type MapQuery string

MapQuery is a key of the Map that implements methods of the Query.

func (MapQuery) Append 

func (q MapQuery) Append(pn *Node, v Node) error

func (MapQuery) Delete 

func (q MapQuery) Delete(pn *Node) error

func (MapQuery) Exec 

func (q MapQuery) Exec(n Node) ([]Node, error)

func (MapQuery) Set 

func (q MapQuery) Set(pn *Node, v Node) error

func (MapQuery) String 

func (q MapQuery) String() string

type MergeOption 

type MergeOption int

MergeOption represents different merge strategies for combining nodes. 

var (
	// MergeOptionDefault merges with the following default rules.
	// For examples:
	// - {"a": 1, "b": 2} and {"a": 3, "c": 4} merges to {"a": 1, "b": 2, "c": 4}
	// - [1, 2] and [3, 4, 5] merges to [1, 2, 5]
	// - "a" and "b" merges to "a"
	MergeOptionDefault MergeOption = 0
	// MergeOptionOverrideMap overrides duplicate map keys.
	// For examples:
	// - {"a": 1, "b": 2} and {"a": 3} merges to {"a": 3, "b": 2}
	// - "a" and "b" merges to "b
	MergeOptionOverrideMap MergeOption = 0b000001
	// MergeOptionOverrideArray overrides duplicate array indexes.
	// For examples:
	// - [1, 2, 3] and [4, 5] merges to [4, 5, 3]
	// - "a" and "b" merges to "b
	MergeOptionOverrideArray MergeOption = 0b000010
	// MergeOptionOverride overrides duplicate map keys and array indexes.
	// For examples:
	// - {"a": 1, "b": 2} and {"a": 3} merges to {"a": 3, "b": 2}
	// - [1, 2, 3] and [4, 5] merges to [4, 5, 3]
	// - "a" and "b" merges to "b"
	MergeOptionOverride MergeOption = MergeOptionOverrideMap | MergeOptionOverrideArray
	// MergeOptionReplaceMap merges with replace map.
	// For examples:
	// - {"a": 1, "b": 2} and {"a": 3} merges to {"a": 3}
	// - "a" and "b" merges to "b"
	MergeOptionReplaceMap MergeOption = 0b000100
	// MergeOptionReplaceArray merges with replace array.
	// For examples:
	// - [1, 2, 3] and [4, 5] merges to [4, 5]
	// - "a" and "b" merges to "b"
	MergeOptionReplaceArray MergeOption = 0b001000
	// MergeOptionReplace merges with replace.
	// For examples:
	// - {"a": 1, "b": 2} and {"a": 3} merges to {"a": 3}
	// - [1, 2, 3] and [4, 5] merges to [4, 5]
	// - "a" and "b" merges to "b"
	MergeOptionReplace MergeOption = MergeOptionReplaceMap | MergeOptionReplaceArray
	// MergeOptionAppend acts when both are arrays and append them.
	// It takes precedence over MergeOptionOverride and MergeOptionReplace.
	// For examples:
	// - [1, 2, 3] and [4, 5] merges to [1, 2, 3, 4, 5]
	MergeOptionAppend MergeOption = 0b010000
	// MergeOptionSlurp acts on an array or value and converts it to an array and
	// merges it, even if the value is not an array.
	// It takes precedence over MergeOptionOverride and MergeOptionReplace.
	// For examples:
	// - [1, 2, 3] and [4, 5] merges to [1, 2, 3, 4, 5]
	// - [1, 2, 3] and 4 merges to [1, 2, 3, 4]
	// - 1 and 2 merges to [1, 2]
	MergeOptionSlurp MergeOption = 0b100000
)

type NewMethodQueryFunc 

type NewMethodQueryFunc func(args ...string) (Query, error)

NewMethodQueryFunc is a factory function type for creating method queries. It takes string arguments and returns a Query implementation.

type NilValue 

type NilValue struct{}

func (NilValue) Array 

func (n NilValue) Array() Array

Array returns nil.

func (NilValue) Bool 

func (n NilValue) Bool() bool

Bool returns false.

func (NilValue) Compare 

func (n NilValue) Compare(op Operator, v Value) bool

Compare compares n and v.

func (NilValue) Each 

func (n NilValue) Each(cb func(key any, n Node) error) error

Each calls cb(nil, n).

func (NilValue) Find 

func (n NilValue) Find(expr string) ([]Node, error)

Find finds a node using the query expression.

func (NilValue) Float64 

func (n NilValue) Float64() float64

Float64 returns 0.

func (NilValue) Get 

func (n NilValue) Get(keys ...any) Node

Get returns nil.

func (NilValue) Has 

func (n NilValue) Has(keys ...any) bool

Has returns false.

func (NilValue) Int 

func (n NilValue) Int() int

Int returns 0.

func (NilValue) Int64 

func (n NilValue) Int64() int64

Int64 returns 0.

func (NilValue) IsNil 

func (n NilValue) IsNil() bool

IsNil returns true if this node is nil.

func (NilValue) Map 

func (n NilValue) Map() Map

Map returns nil.

func (NilValue) MarshalJSON 

func (n NilValue) MarshalJSON() ([]byte, error)

MarshalJSON is an implementation of json.Marshaler.

func (NilValue) MarshalYAML 

func (n NilValue) MarshalYAML() (any, error)

MarshalYAML is an implementation of yaml.Marshaler.

func (NilValue) String 

func (n NilValue) String() string

String returns this as string.

func (NilValue) Type 

func (n NilValue) Type() Type

Type returns TypeValue.

func (NilValue) Value 

func (n NilValue) Value() Value

Value returns this.

type Node 

type Node interface {
	// IsNil returns true if this node is nil.
	IsNil() bool
	// Type returns this node type.
	Type() Type
	// Array returns this node as an Array.
	// If this type is not Array, returns a Array(nil).
	Array() Array
	// Map returns this node as a Map.
	// If this type is not Map, returns a Map(nil).
	Map() Map
	// Value returns this node as a Value.
	// If this type is not Value, returns a NilValue.
	Value() Value
	// Has checks this node has key.
	Has(keys ...any) bool
	// Get returns array/map value that matched by the specified key.
	// The key type allows int or string.
	// If the specified keys does not match, returns NilValue.
	Get(keys ...any) Node
	// Each calls the callback function for each Array|Map values.
	// If the node type is not Array|Map then the callback called once with nil key and self as value.
	Each(cb func(key any, v Node) error) error
	// Find finds a node using the query expression.
	Find(expr string) ([]Node, error)
}

A Node is an element on the tree.

func Clone 

func Clone(n Node) Node

Clone clones the node.

func CloneDeep 

func CloneDeep(n Node) Node

CloneDeep clones the node.

func DecodeJSON 

func DecodeJSON(dec *json.Decoder) (Node, error)

DecodeJSON decodes JSON as a node using the provided decoder.

func DecodeYAML 

func DecodeYAML(dec *yaml.Decoder) (Node, error)

DecodeYAML decodes YAML as a node using the provided decoder.

func Find 

func Find(n Node, expr string) ([]Node, error)

Find finds a node from n using the Query.

Example 
package main

import (
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	group := tree.Map{
		"ID":     tree.ToValue(1),
		"Name":   tree.ToValue("Reds"),
		"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
	}

	rs, err := group.Find(".Colors[1:3]")
	if err != nil {
		log.Fatal(err)
	}
	for _, r := range rs {
		fmt.Println(r)
	}

}

Output:
Red
Ruby

func MarshalViaJSON 

func MarshalViaJSON(v any) (Node, error)

MarshalViaJSON returns the node encoding of v via "encoding/json".

func MarshalViaYAML 

func MarshalViaYAML(v any) (Node, error)

MarshalViaYAML returns the node encoding of v via "gopkg.in/yaml.v3".

func Merge 

func Merge(a, b Node, opts MergeOption) Node

Merge merges two nodes with MergeOption. If you do not want to change the state of the node given as an argument, use CloneDeep. ex: merged := Merge(CloneDeep(a), CloneDeep(b), opts)

func ToNode 

func ToNode(v any) Node

ToNode converts the specified v to an Node.

func ToNodeValues 

func ToNodeValues(vs ...any) []Node

ToNodeValues calls ToValue for each provided vs and returns them as []Node.

func ToValue 

func ToValue(v any) Node

ToValue converts the specified v to a Value as Node. Node.Value() returns converted value.

func UnmarshalJSON 

func UnmarshalJSON(data []byte) (Node, error)

UnmarshalJSON parses the JSON-encoded data to a Node.

Example 
package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	data := []byte(`[
  {"Name": "Platypus", "Order": "Monotremata"},
  {"Name": "Quoll",    "Order": "Dasyuromorphia"}
]`)

	var animals tree.Array
	err := json.Unmarshal(data, &animals)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%v\n", animals)

}

Output:
[map[Name:Platypus Order:Monotremata] map[Name:Quoll Order:Dasyuromorphia]]
Example (Any) 
package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	data := []byte(`[
  {"Name": "Platypus", "Order": "Monotremata"},
  {"Name": "Quoll",    "Order": "Dasyuromorphia"}
]`)

	var animals tree.Any
	err := json.Unmarshal(data, &animals)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%v\n", animals.Type().IsArray())
	fmt.Printf("%v\n", animals.Array())

}

Output:
true
[map[Name:Platypus Order:Monotremata] map[Name:Quoll Order:Dasyuromorphia]]
Example (Combined) 
package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/mojatter/tree"
)

func main() {
	data := []byte(`[
  {"Name": "Platypus", "Order": "Monotremata"},
  {"Name": "Quoll",    "Order": "Dasyuromorphia"}
]`)
	type Animal struct {
		Name  string
		Order tree.StringValue
	}
	var animals []Animal
	err := json.Unmarshal(data, &animals)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", animals)

}

Output:
[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]

func UnmarshalYAML 

func UnmarshalYAML(data []byte) (Node, error)

UnmarshalYAML returns the YAML encoding of the specified node.

Example 
data := []byte(`---
Colors:
- Crimson
- Red
- Ruby
- Maroon
ID: 1
Name: Reds
`)

var group tree.Map
if err := yaml.Unmarshal(data, &group); err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", group)

Output:
map[Colors:[Crimson Red Ruby Maroon] ID:1 Name:Reds]

type NopQuery 

type NopQuery struct{}

NopQuery is a query that implements no-op Exec method.

func (NopQuery) Append 

func (q NopQuery) Append(pn *Node, v Node) error

func (NopQuery) Delete 

func (q NopQuery) Delete(pn *Node) error

func (NopQuery) Exec 

func (q NopQuery) Exec(n Node) ([]Node, error)

Exec returns the provided node.

func (NopQuery) Set 

func (q NopQuery) Set(pn *Node, v Node) error

func (NopQuery) String 

func (q NopQuery) String() string

type NumberValue 

type NumberValue float64

A NumberValue represents an number value.

func (NumberValue) Array 

func (n NumberValue) Array() Array

Array returns nil.

func (NumberValue) Bool 

func (n NumberValue) Bool() bool

Bool returns false.

func (NumberValue) Compare 

func (n NumberValue) Compare(op Operator, v Value) bool

Compare compares n and v.

func (NumberValue) Each 

func (n NumberValue) Each(cb func(key any, n Node) error) error

Each calls cb(nil, n).

func (NumberValue) Find 

func (n NumberValue) Find(expr string) ([]Node, error)

Find finds a node using the query expression.

func (NumberValue) Float64 

func (n NumberValue) Float64() float64

Float64 returns float64(n).

func (NumberValue) Get 

func (n NumberValue) Get(keys ...any) Node

Get returns nil.

func (NumberValue) Has 

func (n NumberValue) Has(keys ...any) bool

Has returns false.

func (NumberValue) Int 

func (n NumberValue) Int() int

Int returns int(n).

func (NumberValue) Int64 

func (n NumberValue) Int64() int64

Int64 returns int64(n).

func (NumberValue) IsNil 

func (n NumberValue) IsNil() bool

IsNil returns true if this node is nil.

func (NumberValue) Map 

func (n NumberValue) Map() Map

Map returns nil.

func (NumberValue) String 

func (n NumberValue) String() string

String returns this as string using strconv.FormatFloat(float64(n), 'f', -1, 64).

func (NumberValue) Type 

func (n NumberValue) Type() Type

Type returns TypeValue.

func (NumberValue) Value 

func (n NumberValue) Value() Value

Value returns this.

type Operator 

type Operator string

Operator represents an operator. 

var (
	// EQ is `==`.
	EQ Operator = "=="
	// GT is `>`.
	GT Operator = ">"
	// GE is `>=`.
	GE Operator = ">="
	// LT is `<`.
	LT Operator = "<"
	// LE is `<=`.
	LE Operator = "<="
	// NE is `!=`
	NE Operator = "!="
	// RE is `~=`
	RE Operator = "~="
)

type Or 

type Or []Selector

Or represents selectors that combines each selector with or.

func (Or) Matches 

func (o Or) Matches(n Node) (bool, error)

Matches returns true if anyone returns true.

func (Or) String 

func (o Or) String() string

type Query 

type Query interface {
	Exec(n Node) ([]Node, error)
	String() string
}

Query is an interface that defines the methods to query a node.

func NewContainsQuery 

func NewContainsQuery(args ...string) (Query, error)

NewContainsQuery creates a new ContainsQuery instance. Requires exactly one argument specifying the value to check.

func NewCountQuery 

func NewCountQuery(args ...string) (Query, error)

NewCountQuery creates a new CountQuery instance. Arguments are ignored for this query type.

func NewEmptyQuery 

func NewEmptyQuery(args ...string) (Query, error)

NewEmptyQuery creates a new EmptyQuery instance. Arguments are ignored for this query type.

func NewFirstQuery 

func NewFirstQuery(args ...string) (Query, error)

NewFirstQuery creates a new FirstQuery instance. Arguments are ignored for this query type.

func NewHasQuery 

func NewHasQuery(args ...string) (Query, error)

NewHasQuery creates a new HasQuery instance. Requires exactly one argument specifying the key to check.

func NewKeysQuery 

func NewKeysQuery(args ...string) (Query, error)

NewKeysQuery creates a new KeysQuery instance. Arguments are ignored for this query type.

func NewLastQuery 

func NewLastQuery(args ...string) (Query, error)

NewLastQuery creates a new LastQuery instance. Arguments are ignored for this query type.

func NewMethodQuery 

func NewMethodQuery(method string, args ...string) (Query, error)

NewMethodQuery creates a method query for the specified method name. Returns an error if the method is not registered.

func NewRSortQuery 

func NewRSortQuery(args ...string) (Query, error)

NewRSortQuery creates a new RSortQuery instance. Arguments:

  • args[0] (optional): the query expression to sort by.

func NewSortQuery 

func NewSortQuery(args ...string) (Query, error)

NewSortQuery creates a new SortQuery instance. Arguments:

  • args[0] (optional): the query expression to sort by.

func NewTypeQuery 

func NewTypeQuery(args ...string) (Query, error)

NewTypeQuery creates a new TypeQuery instance. Arguments are ignored for this query type.

func NewValuesQuery 

func NewValuesQuery(args ...string) (Query, error)

NewValuesQuery creates a new ValuesQuery instance. Arguments are ignored for this query type.

func ParseQuery 

func ParseQuery(expr string) (Query, error)

ParseQuery parses the provided expr to a Query. See https://github.com/mojatter/tree#Query

type RSortQuery 

type RSortQuery struct {
	Expr  string
	Query Query
}

RSortQuery sorts elements in an array in reverse order. For arrays of objects, it can optionally sort by a query expression.

func (*RSortQuery) Exec 

func (q *RSortQuery) Exec(n Node) ([]Node, error)

Exec sorts the elements of the node in reverse order if it's an array. For non-array types, returns the node as is in a slice.

func (*RSortQuery) String 

func (q *RSortQuery) String() string

type SelectQuery 

type SelectQuery struct {
	Selector
}

SelectQuery returns nodes that matched by selectors.

func (SelectQuery) Exec 

func (q SelectQuery) Exec(n Node) ([]Node, error)

func (SelectQuery) String 

func (q SelectQuery) String() string

type Selector 

type Selector interface {
	Matches(n Node) (bool, error)
	String() string
}

Selector checks if a node is eligible for selection.

type SlurpQuery 

type SlurpQuery struct{}

SlurpQuery is a special query that works in FilterQuery.

func (SlurpQuery) Exec 

func (q SlurpQuery) Exec(n Node) ([]Node, error)

Exec returns the provided node into a single node array. FilterQuery calls q.Exec(Array(results)), which has the effect of to slurp all the results into a single node array.

func (SlurpQuery) String 

func (q SlurpQuery) String() string

type SortQuery 

type SortQuery struct {
	Expr  string
	Query Query
}

SortQuery sorts elements in an array. For arrays of objects, it can optionally sort by a query expression.

func (*SortQuery) Exec 

func (q *SortQuery) Exec(n Node) ([]Node, error)

Exec sorts the elements of the node if it's an array. For non-array types, returns the node as is in a slice.

func (*SortQuery) String 

func (q *SortQuery) String() string

type StringValue 

type StringValue string

A StringValue represents a string value.

func (StringValue) Array 

func (n StringValue) Array() Array

Array returns nil.

func (StringValue) Bool 

func (n StringValue) Bool() bool

Bool returns false.

func (StringValue) Compare 

func (n StringValue) Compare(op Operator, v Value) bool

Compare compares n and v.

func (StringValue) Each 

func (n StringValue) Each(cb func(key any, n Node) error) error

Each calls cb(nil, n).

func (StringValue) Find 

func (n StringValue) Find(expr string) ([]Node, error)

Find finds a node using the query expression.

func (StringValue) Float64 

func (n StringValue) Float64() float64

Float64 returns 0.

func (StringValue) Get 

func (n StringValue) Get(keys ...any) Node

Get returns nil.

func (StringValue) Has 

func (n StringValue) Has(keys ...any) bool

Has returns false.

func (StringValue) Int 

func (n StringValue) Int() int

Int returns 0.

func (StringValue) Int64 

func (n StringValue) Int64() int64

Int64 returns 0.

func (StringValue) IsNil 

func (n StringValue) IsNil() bool

IsNil returns true if this node is nil.

func (StringValue) Map 

func (n StringValue) Map() Map

Map returns nil.

func (StringValue) String 

func (n StringValue) String() string

String returns this as string.

func (StringValue) Type 

func (n StringValue) Type() Type

Type returns TypeValue.

func (StringValue) Value 

func (n StringValue) Value() Value

Value returns this.

type Type 

type Type int

Type represents the Node type. 

const (
	TypeArray       Type = 0b0001
	TypeMap         Type = 0b0010
	TypeValue       Type = 0b1000
	TypeNilValue    Type = 0b1001
	TypeStringValue Type = 0b1010
	TypeBoolValue   Type = 0b1011
	TypeNumberValue Type = 0b1100
)

These variables are the Node types.

func (Type) IsArray 

func (t Type) IsArray() bool

IsArray returns t == TypeArray.

func (Type) IsBoolValue 

func (t Type) IsBoolValue() bool

IsBoolValue returns t == TypeBoolValue.

func (Type) IsMap 

func (t Type) IsMap() bool

IsMap returns t == TypeMap.

func (Type) IsNilValue 

func (t Type) IsNilValue() bool

IsNilValue returns t == TypeNilValue.

func (Type) IsNumberValue 

func (t Type) IsNumberValue() bool

IsNumberValue returns t == TypeNumberValue.

func (Type) IsStringValue 

func (t Type) IsStringValue() bool

IsStringValue returns t == TypeStringValue.

func (Type) IsValue 

func (t Type) IsValue() bool

IsValue returns true if t is TypeStringValue or TypeBoolValue or TypeNumberValue.

type TypeQuery 

type TypeQuery struct{}

TypeQuery returns the type name of the node. Returns "array", "object", "string", "number", "boolean", or "null".

func (*TypeQuery) Exec 

func (q *TypeQuery) Exec(n Node) ([]Node, error)

Exec returns the type name of the node as a string. Returns "array", "object", "string", "number", "boolean", or "null".

func (*TypeQuery) String 

func (q *TypeQuery) String() string

type Value 

type Value interface {
	Node
	String() string
	Bool() bool
	Int() int
	Int64() int64
	Float64() float64
	Compare(op Operator, v Value) bool
}

Value provides the accessor of primitive value.

type ValueQuery 

type ValueQuery struct {
	Node
}

ValueQuery is a query that returns the constant value.

func (ValueQuery) Exec 

func (q ValueQuery) Exec(n Node) ([]Node, error)

Exec returns the constant value.

func (ValueQuery) String 

func (q ValueQuery) String() string

type ValuesQuery 

type ValuesQuery struct{}

ValuesQuery returns the values of arrays or maps as an array. For arrays, returns the array itself. For maps, returns values in key order.

func (*ValuesQuery) Exec 

func (q *ValuesQuery) Exec(n Node) ([]Node, error)

Exec returns the values of the node as an array. For arrays, returns the array itself. For maps, returns values in key order. Returns nil for other node types.

func (*ValuesQuery) String 

func (q *ValuesQuery) String() string

type WalkFunc 

type WalkFunc func(n Node, keys []any) error

WalkFunc is the type of the function called by Walk to visit each nodes.

The keys argument contains that parent keys and the node key that type is int (array index) or string (map key).

type WalkQuery 

type WalkQuery string

WalkQuery is a key of each nodes that implements methods of the Query.

func (WalkQuery) Append 

func (q WalkQuery) Append(pn *Node, v Node) error

func (WalkQuery) Delete 

func (q WalkQuery) Delete(pn *Node) error

func (WalkQuery) Exec 

func (q WalkQuery) Exec(root Node) ([]Node, error)

Exec walks the specified root node and collects matching nodes using itself as a key.

func (WalkQuery) Set 

func (q WalkQuery) Set(pn *Node, v Node) error

func (WalkQuery) String 

func (q WalkQuery) String() string

Source Files

View all Source files

Directories

Path Synopsis
cmd
tq command

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.