README
¶
Tree
Tree is a simple structure for dealing with dynamic or unknown JSON/YAML structures in Go.
Formats
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
package main
import (
"encoding/json"
"fmt"
"log"
"github.com/jarxorg/tree"
"gopkg.in/yaml.v2"
)
func main() {
group := tree.Map{
"ID": tree.ToValue(1),
"Name": tree.ToValue("Reds"),
"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
}
j, err := json.Marshal(group)
if err != nil {
log.Fatal(err)
}
fmt.Println()
fmt.Println(string(j))
fmt.Println()
y, err := yaml.Marshal(group)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(y))
fmt.Println()
var n tree.Map
if err := json.Unmarshal(j, &n); err != nil {
log.Fatal(err)
}
fmt.Printf("%#v\n", n)
// Output:
//
// {"Colors":["Crimson","Red","Ruby","Maroon"],"ID":1,"Name":"Reds"}
//
// Colors:
// - Crimson
// - Red
// - Ruby
// - Maroon
// ID: 1
// Name: Reds
//
// tree.Map{"Colors":tree.Array{"Crimson", "Red", "Ruby", "Maroon"}, "ID":1, "Name":"Reds"}
}
Query
| Tree Query | Results |
|---|---|
| .store.book[0] | {"category": "reference", "author": "Nigel Rees", "title": "Sayings of the Century", "price": 8.95} |
| .store.book[0].price | 8.95 |
| .store.book[1:2].price | [12.99, 8.99] |
| .store.book[].author | ["Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"] |
| .store.book[.category=="fiction" and .price < 10].title | ["Moby Dick"] |
| .store.book[.authors[0] == "Nigel Rees"].title | ["Sayings of the Century"] |
Illustrative Object
{
"store": {
"book": [{
"category": "reference",
"author": "Nigel Rees",
"title": "Sayings of the Century",
"price": 8.95
},
{
"category": "fiction",
"author": "Evelyn Waugh",
"title": "Sword of Honour",
"price": 12.99
},
{
"category": "fiction",
"author": "Herman Melville",
"title": "Moby Dick",
"isbn": "0-553-21311-3",
"price": 8.99
},
{
"category": "fiction",
"author": "J. R. R. Tolkien",
"title": "The Lord of the Rings",
"isbn": "0-395-19395-8",
"price": 22.99
}
],
"bicycle": {
"color": "red",
"price": 19.95
}
}
}
tq - Command line tool
Install
go install github.com/jarxorg/tree/cmd/tq@latest
Usage
tq is a portable command-line JSON/YAML processor.
Usage:
tq [flags] [query]
Flags:
-h help for tq
-i value
input format (json or yaml) (default "json") (default json)
-o value
output format (json or yaml) (default "json") (default json)
Examples:
% echo '{"colors": ["red", "green", "blue"]}' | tq '.colors[0]'
"red"
Documentation
¶
Index ¶
- Constants
- Variables
- func MarshalJSON(n Node) ([]byte, error)
- func MarshalYAML(n Node) ([]byte, error)
- func Walk(n Node, fn WalkFunc) error
- type Array
- type ArrayQuery
- type ArrayRangeQuery
- type BoolValue
- func (n BoolValue) Array() Array
- func (n BoolValue) Bool() bool
- func (n BoolValue) Compare(op Operator, v Value) bool
- func (n BoolValue) Float64() float64
- func (n BoolValue) Get(key interface{}) Node
- func (n BoolValue) Int() int
- func (n BoolValue) Int64() int64
- func (n BoolValue) Map() Map
- func (n BoolValue) String() string
- func (n BoolValue) Type() Type
- func (n BoolValue) Value() Value
- type Comparator
- type FilterQuery
- type Map
- type MapQuery
- type Node
- type NumberValue
- func (n NumberValue) Array() Array
- func (n NumberValue) Bool() bool
- func (n NumberValue) Compare(op Operator, v Value) bool
- func (n NumberValue) Float64() float64
- func (n NumberValue) Get(key interface{}) Node
- func (n NumberValue) Int() int
- func (n NumberValue) Int64() int64
- func (n NumberValue) Map() Map
- func (n NumberValue) String() string
- func (n NumberValue) Type() Type
- func (n NumberValue) Value() Value
- type Operator
- type Query
- type SelectQuery
- type Selector
- type StringValue
- func (n StringValue) Array() Array
- func (n StringValue) Bool() bool
- func (n StringValue) Compare(op Operator, v Value) bool
- func (n StringValue) Float64() float64
- func (n StringValue) Get(key interface{}) Node
- func (n StringValue) Int() int
- func (n StringValue) Int64() int64
- func (n StringValue) Map() Map
- func (n StringValue) String() string
- func (n StringValue) Type() Type
- func (n StringValue) Value() Value
- type Type
- type Value
- type ValueQuery
- type WalkFunc
Examples ¶
Constants ¶
const ( TypeArray Type = 1 << (32 - 1 - iota) TypeMap TypeValue TypeStringValue = TypeValue | iota TypeBoolValue TypeNumberValue )
These variables are the Node types.
Variables ¶
var SkipWalk = errors.New("skip")
SkipWalk is used as a return value from WalkFunc to indicate that the node and that children in the call is to be skipped. It is not returned as an error by any function.
Functions ¶
func MarshalJSON ¶
MarshalJSON returns the JSON encoding of the specified node.
Example ¶
package main
import (
"encoding/json"
"fmt"
"log"
"github.com/jarxorg/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/jarxorg/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 ¶
MarshalYAML returns the YAML encoding of the specified node.
Example ¶
group := tree.Map{
"ID": tree.ToValue(1),
"Name": tree.ToValue("Reds"),
"Colors": tree.ToArrayValues("Crimson", "Red", "Ruby", "Maroon"),
}
b, err := yaml.Marshal(group)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(b))
Output: Colors: - Crimson - Red - Ruby - Maroon ID: 1 Name: Reds
Types ¶
type Array ¶
type Array []Node
Array represents an array of Node.
func ToArrayValues ¶ added in v0.2.0
func ToArrayValues(vs ...interface{}) Array
ToArrayValues calss ToValues for each provided vs and returns them as an Array.
func (*Array) UnmarshalJSON ¶
UnmarshalJSON is an implementation of json.Unmarshaler.
func (*Array) UnmarshalYAML ¶
UnmarshalYAML is an implementation of yaml.Unmarshaler.
type ArrayQuery ¶ added in v0.2.0
type ArrayQuery int
ArrayQuery is an index of the Array that implements methods of the Query.
type ArrayRangeQuery ¶ added in v0.2.0
type ArrayRangeQuery []int
ArrayRangeQuery represents a range of the Array that implements methods of the Query.
type BoolValue ¶
type BoolValue bool
A BoolValue represents a bool value.
type Comparator ¶ added in v0.2.0
Comparator represents a comparable selector.
type FilterQuery ¶ added in v0.2.0
type FilterQuery []Query
FilterQuery consists of multiple queries that filter the nodes in order.
type Map ¶
Map represents a map of Node.
func (*Map) UnmarshalJSON ¶
UnmarshalJSON is an implementation of json.Unmarshaler.
func (*Map) UnmarshalYAML ¶
UnmarshalYAML is an implementation of yaml.Unmarshaler.
type MapQuery ¶ added in v0.2.0
type MapQuery string
MapQuery is a key of the Map that implements methods of the Query.
type Node ¶
type Node interface {
// Type returns this node type.
Type() Type
// Array returns this node as an Array.
Array() Array
// Map returns this node as a Map.
Map() Map
// Value returns this node as a Value.
Value() Value
// Get returns array/map value that matched by the specified key.
// The key type allows int or string.
Get(key interface{}) Node
}
A Node is an element on the tree.
func DecodeJSON ¶ added in v0.2.0
DecodeJSON decodes JSON as a node using the provided decoder.
func DecodeYAML ¶ added in v0.2.0
DecodeYAML decodes YAML as a node using the provided decoder.
func ToValue ¶
func ToValue(v interface{}) Node
ToValue converts the specified v to a Value as Node. Node.Value() returns converted value.
func UnmarshalJSON ¶
UnmarshalJSON parses the JSON-encoded data to a Node.
Example ¶
package main
import (
"encoding/json"
"fmt"
"log"
"github.com/jarxorg/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 (Combined) ¶
package main
import (
"encoding/json"
"fmt"
"log"
"github.com/jarxorg/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 ¶
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 NumberValue ¶
type NumberValue float64
A NumberValue represents an number value.
func (NumberValue) Compare ¶ added in v0.2.0
func (n NumberValue) Compare(op Operator, v Value) bool
Compare compares n and v.
func (NumberValue) Get ¶ added in v0.1.1
func (n NumberValue) Get(key interface{}) Node
Get returns nil.
func (NumberValue) String ¶
func (n NumberValue) String() string
String returns this as string using strconv.FormatFloat(float64(n), 'f', -1, 64).
type Query ¶ added in v0.2.0
Query is an interface that defines the methods to query a node.
var NopQuery Query = nopQuery{}
NopQuery is a query that implements no-op Exec method.
func ParseQuery ¶ added in v0.2.0
ParseQuery parses the provided expr to a Query. See https://github.com/jarxorg/tree#Query
type SelectQuery ¶ added in v0.2.0
SelectQuery returns nodes that matched by selectors.
type StringValue ¶
type StringValue string
A StringValue represents a string value.
func (StringValue) Compare ¶ added in v0.2.0
func (n StringValue) Compare(op Operator, v Value) bool
Compare compares n and v.
func (StringValue) Get ¶ added in v0.1.1
func (n StringValue) Get(key interface{}) Node
Get returns nil.
type Type ¶
type Type int
Type represents the Node type.
func (Type) IsNumberValue ¶
IsNumberValue returns t == TypeNumberValue.
func (Type) IsStringValue ¶
IsStringValue returns t == TypeStringValue.
type Value ¶
type Value interface {
Type() Type
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 ¶ added in v0.2.0
type ValueQuery struct {
Node
}
ValueQuery is a query that returns the constant value.
Source Files
Directories