jsongo

package module

v1.0.1 Latest Latest Go to latest Published: Jan 10, 2019 License: MIT Imports: 8 Imported by: 9

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/bennyscetbun/jsongo

Links

Open Source Insights

README ¶

jsongo

Jsongo is a simple library for golang to help you build Json without static struct or map[string]interface

json.Marshal and json.Unmarshal have never been that easy

If you had only one function to look at, look at the "At" function

If you want an easy way to turn your json into a structure you should use the "Print" function after unmarshalling json in a JSONNODE

[2018/10/11] Project is not dead. We are using it quite often. We haven't found any necessary update

You can find the doc on godoc.org

JsonNode

JsonNode is the basic Structure that you must use when using jsongo. It can either be a:

Map (jsongo.TypeMap)
Array (jsongo.TypeArray)
Value (jsongo.TypeValue) Precisely a pointer store in an interface{}
Undefined (jsongo.TypeUndefined) default type

When a JSONNode Type is set you cant change it without using Unset() first

Val

Synopsis:

turn this JSONNode to TypeValue and set that value

func (that *JSONNode) Val(val interface{})

Examples

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)

func main() {
    root := jsongo.JSONNode{}
	root.Val(42)
	root.DebugPrint("")
}

output:

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)
type MyStruct struct {
	Member1 string
	Member2 int
}

func main() {
	root := jsongo.JSONNode{}
	root.Val(MyStruct{"The answer", 42})
	root.DebugPrint("")
}

output:

{
  "Member1": "The answer",
  "Member2": 42
}

Array

Synopsis:

Turn this JSONNode to a TypeArray and/or set the array size (reducing size will make you loose data)

func (that *JSONNode) Array(size int) *[]JSONNode

Examples

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)

func main() {
    root := jsongo.JSONNode{}
	a := root.Array(4)
    for i := 0; i < 4; i++ {
        (*a)[i].Val(i)
    }
	root.DebugPrint("")
}

output:

[
  0,
  1,
  2,
  3
]

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)

func main() {
    root := jsongo.JSONNode{}
    a := root.Array(4)
    for i := 0; i < 4; i++ {
        (*a)[i].Val(i)
    }
    root.Array(2) //Here we reduce the size and we loose some data
	root.DebugPrint("")
}

output:

[
  0,
  1
]

Map

Synopsis:

Turn this JSONNode to a TypeMap and/or Create a new element for key if necessary and return it

func (that *JSONNode) Map(key string) *JSONNode

Examples

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)

func main() {
    root := jsongo.JSONNode{}
    root.Map("there").Val("you are")
    root.Map("here").Val("you should be")
	root.DebugPrint("")
}

output:

{
  "here": "you should be",
  "there": "you are"
}

At

Synopsis:

Helps you move through your node by building them on the fly

val can be string or int only

strings are keys for TypeMap

ints are index in TypeArray (it will make array grow on the fly, so you should start to populate with the biggest index first)

func (that *JSONNode) At(val ...interface{}) *JSONNode

Examples

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)

func main() {
    root := jsongo.JSONNode{}
    root.At(4, "Who").Val("Let the dog out") //is equivalent to (*root.Array(5))[4].Map("Who").Val("Let the dog out")
    root.DebugPrint("")
}

output:

[
  null,
  null,
  null,
  null,
  {
    "Who": "Let the dog out"
  }
]

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)

func main() {
    root := jsongo.JSONNode{}
    root.At(4, "Who").Val("Let the dog out")
    //to win some time you can even even save a certain JSONNode
	node := root.At(2, "What")
	node.At("Can", "You").Val("do with that?")
	node.At("Do", "You", "Think").Val("Of that")
    root.DebugPrint("")
}

output:

[
  null,
  null,
  {
    "What": {
      "Can": {
        "You": "do with that?"
      },
      "Do": {
        "You": {
          "Think": "Of that"
        }
      }
    }
  },
  null,
  {
    "Who": "Let the dog out"
  }
]

Print

Synopsis:

Helps you build your code by printing a go structure from the json you ve just unmarshaled

func (that *JSONNode) Print()

Other Function

There is plenty of other function, you should check the complete doc

A last Example for fun

code:

package main

import (
    "github.com/bennyscetbun/jsongo"
)

func ShowOnlyValue(current *jsongo.JSONNode) {
    switch current.GetType() {
    	case jsongo.TypeValue:
			println(current.Get().(string))
		case jsongo.TypeMap:
			for _, key := range current.GetKeys() {
				ShowOnlyValue(current.At(key))
			}
		case jsongo.TypeArray:
			for _, key := range current.GetKeys() {
				ShowOnlyValue(current.At(key))
			}
	}
}

func main() {
    root := jsongo.JSONNode{}
    root.At(4, "Who").Val("Let the dog out")
	node := root.At(2, "What")
	node.At("Can", "You").Val("do with that?")
	node.At("Do", "You", "Think").Val("Of that")
	ShowOnlyValue(&root)
}

output:

Of that
do with that?
Let the dog out

Json Marshal/Unmarshal

One of the main purpose of jsongo was to create Json from data without using static structure or map[string]interface.

You can use the full power of the encoding/json package with jsongo.

Marshal

Example

code:

package main

import (
    "encoding/json"
	"fmt"
    "github.com/bennyscetbun/jsongo"
)

type Test struct {
	Static string `json:"static"`
	Over int `json:"over"`
}

func main() {
	root := jsongo.JSONNode{}
	root.At("A", "AA", "AAA").Val(42)

	node := root.At("A", "AB")
	node.At(1).Val("Peace")
	node.At(0).Val(Test{"struct suck when you build json", 9000})
	root.At("B").Val("Oh Yeah")

	tojson, err := json.MarshalIndent(&root, "", "  ")
	if err != nil {
		fmt.Printf("%s\n", err.Error())
		return
	}
	fmt.Printf("%s\n", tojson)
}

output:

{
  "A": {
    "AA": {
      "AAA": 42
    },
    "AB": [
      {
        "static": "struct suck when you build json",
        "over": 9000
      },
      "Peace"
    ]
  },
  "B": "Oh Yeah"
}

Unmarshal

Unmarshal using JSONNode follow some simple rules:

Any TypeUndefined JSONNode will be set to the right type, any other type wont be changed
Array will grow if necessary
New keys will be added to Map
Values set to nil ".Val(nil)" will be turn into the type decide by Json
It will respect any current mapping and will return errors if needed

You can set a node as "DontExpand" with the UnmarshalDontExpand function and thoose rules will apply:

The type wont be change for any type
Array wont grow
New keys wont be added to Map
Values set to nil ".Val(nil)" will be turn into the type decide by Json
It will respect any current mapping and will return errors if needed

Example of full expand

code:

package main

import (
    "encoding/json"
    "github.com/bennyscetbun/jsongo"
    "fmt"
)

func main() {
    root := jsongo.JSONNode{}
    fromjson := `{
	  "A": {
		"AA": {
		  "AAA": 42
		},
		"AB": [
		  {
			"static": "struct suck when you build json",
			"over": 9000
		  },
		  "Peace"
		]
	  },
	  "B": "Oh Yeah"
	}`
    err := json.Unmarshal([]byte(fromjson), &root)
	if err != nil {
		fmt.Printf("%s\n", err.Error())
		return
	}
	root.DebugProspect(0, "\t")
}

output:

Is of Type: TypeMap
A:
        Is of Type: TypeMap
        AA:
                Is of Type: TypeMap
                AAA:
                        Is of Type: TypeValue
                        Value of type: float64
                        42
        AB:
                Is of Type: TypeArray
                [0]:
                        Is of Type: TypeMap
                        static:
                                Is of Type: TypeValue
                                Value of type: string
                                struct suck when you build json
                        over:
                                Is of Type: TypeValue
                                Value of type: float64
                                9000
                [1]:
                        Is of Type: TypeValue
                        Value of type: string
                        Peace
B:
        Is of Type: TypeValue
        Value of type: string
        Oh Yeah

Example expand with mapping

code:

package main

import (
    "encoding/json"
    "github.com/bennyscetbun/jsongo"
    "fmt"
)
type Test struct {
    Static string `json:"static"`
    Over int `json:"over"`
}

func main() {
	root := jsongo.JSONNode{}
    fromjson := `{
      "A": {
		"AA": {
		  "AAA": 42
		},
		"AB": [
		  {
			"static": "struct suck when you build json",
			"over": 9000
		  },
		  "Peace"
		]
	  },
	  "B": "Oh Yeah"
	}`
	root.At("A", "AB", 0).Val(Test{})
    err := json.Unmarshal([]byte(fromjson), &root)
	if err != nil {
		fmt.Printf("%s\n", err.Error())
		return
	}
	root.DebugProspect(0, "\t")
}

output:

Is of Type: TypeMap
A:
        Is of Type: TypeMap
        AB:
                Is of Type: TypeArray
                [0]:
                        Is of Type: TypeValue
                        Value of type: main.Test
                        {Static:struct suck when you build json Over:9000}
                [1]:
                        Is of Type: TypeValue
                        Value of type: string
                        Peace
        AA:
                Is of Type: TypeMap
                AAA:
                        Is of Type: TypeValue
                        Value of type: float64
                        42
B:
        Is of Type: TypeValue
        Value of type: string
        Oh Yeah

Example expand with some UnmarshalDontExpand

code:

package main

import (
    "encoding/json"
    "github.com/bennyscetbun/jsongo"
    "fmt"
)
type Test struct {
	Static string `json:"static"`
	Over int `json:"over"`
}

func main() {
    root := jsongo.JSONNode{}
    fromjson := `{
      "A": {
		"AA": {
		  "AAA": 42
		},
		"AB": [
		  {
			"static": "struct suck when you build json",
			"over": 9000
		  },
		  "Peace"
		]
	  },
	  "B": "Oh Yeah"
	}`
	root.At("A", "AB").UnmarshalDontExpand(true, false).At(0).Val(Test{})
    err := json.Unmarshal([]byte(fromjson), &root)
	if err != nil {
		fmt.Printf("%s\n", err.Error())
		return
	}
	root.DebugProspect(0, "\t")
}

output:

Is of Type: TypeMap
A:
        Is of Type: TypeMap
        AB:
                Is of Type: TypeArray
                [0]:
                        Is of Type: TypeValue
                        Value of type: main.Test
                        {Static:struct suck when you build json Over:9000}
        AA:
                Is of Type: TypeMap
                AAA:
                        Is of Type: TypeValue
                        Value of type: float64
                        42
B:
        Is of Type: TypeValue
        Value of type: string
        Oh Yeah

Documentation ¶

Constants ¶

This section is empty.

Variables ¶

View Source

var ErrorArrayNegativeValue = errors.New("jsongo negative index for array")

ErrorArrayNegativeValue error if you ask for a negative index in an array

View Source

var ErrorAtUnsupportedType = errors.New("jsongo Unsupported Type as At argument")

ErrorArrayNegativeValue error if you ask for a negative index in an array

View Source

var ErrorCopyType = errors.New("jsongo: Copy: This JSONNode is not a TypeUndefined")

ErrorCopyType error if you try to call Copy on a JSONNode that isnt a TypeUndefined

View Source

var ErrorDeleteKey = errors.New("jsongo: DelKey: This JSONNode is not a TypeMap")

ErrorDeleteKey error if you try to call DelKey on a JSONNode that isnt a TypeMap

View Source

var ErrorGetKeys = errors.New("jsongo: GetKeys: JSONNode is not a TypeMap or TypeArray")

ErrorGetKeys error if you try to get the keys from a JSONNode that isnt a TypeMap or a TypeArray

View Source

var ErrorKeyAlreadyExist = errors.New("jsongo key already exist")

ErrorKeyAlreadyExist error if a key already exist in current JSONNode

View Source

var ErrorMultipleType = errors.New("jsongo this node is already set to a different jsonNodeType")

ErrorMultipleType error if a JSONNode already got a different type of value

View Source

var ErrorRetrieveUserValue = errors.New("jsongo Cannot retrieve node's value which is not of type value")

ErrorRetrieveUserValue error if you ask the value of a node that is not a value node

View Source

var ErrorTypeUnmarshaling = errors.New("jsongo Wrong type when Unmarshaling")

ErrorTypeUnmarshaling error if you try to unmarshal something in the wrong type

View Source

var ErrorUnknowType = errors.New("jsongo Unknow JSONNodeType")

ErrorUnknowType error if you try to use an unknow JSONNodeType

View Source

var ErrorValNotPointer = errors.New("jsongo: Val: arguments must be a pointer and not nil")

ErrorValNotPointer error if you try to use Val without a valid pointer

Functions ¶

func UpperCamelCase ¶

func UpperCamelCase(str string) string

UpperCamelCase converts a string to it's upper camel case version.

Types ¶

type JSONNode ¶

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

JSONNode Datastructure to build and maintain Nodes

func (*JSONNode) Array ¶

func (that *JSONNode) Array(size int) *[]JSONNode

Array Turn this JSONNode to a TypeArray and/or set the array size (reducing size will make you loose data)

func (*JSONNode) At ¶

func (that *JSONNode) At(val ...interface{}) *JSONNode

At helps you move through your node by building them on the fly

val can be string or int only

strings are keys for TypeMap

ints are index in TypeArray (it will make array grow on the fly, so you should start to populate with the biggest index first)*

func (*JSONNode) Copy ¶

func (that *JSONNode) Copy(other *JSONNode, deepCopy bool) *JSONNode

Copy Will set this node like the one in argument. this node must be of type TypeUndefined

if deepCopy is true we will copy all the children recursively else we will share the children

return the current JSONNode

func (*JSONNode) DebugPrint ¶

func (that *JSONNode) DebugPrint(prefix string)

DebugPrint Print a JSONNode as json withindent

func (*JSONNode) DebugProspect ¶

func (that *JSONNode) DebugProspect(indentlevel int, indentchar string)

DebugProspect Print all the data the we ve got on a node and all it s children

func (*JSONNode) DelKey ¶

func (that *JSONNode) DelKey(key string) *JSONNode

DelKey will remove a key in the map.

return the current JSONNode.

func (*JSONNode) Get ¶

func (that *JSONNode) Get() interface{}

Get Return value of a TypeValue as interface{}

func (*JSONNode) GetKeys ¶

func (that *JSONNode) GetKeys() []interface{}

GetKeys Return a slice interface that represent the keys to use with the At fonction (Works only on TypeMap and TypeArray)

func (*JSONNode) GetType ¶

func (that *JSONNode) GetType() JSONNodeType

GetType Is use to Get the Type of a node

func (*JSONNode) Len ¶

func (that *JSONNode) Len() int

Len Return the length of the current Node

if TypeUndefined return 0

if TypeValue return 1

if TypeArray return the size of the array

if TypeMap return the size of the map

func (*JSONNode) Map ¶

func (that *JSONNode) Map(key string) *JSONNode

Map Turn this JSONNode to a TypeMap and/or Create a new element for key if necessary and return it

func (*JSONNode) MarshalJSON ¶

func (that *JSONNode) MarshalJSON() ([]byte, error)

MarshalJSON Make JSONNode a Marshaler Interface compatible

func (*JSONNode) MustGetBool ¶ added in v1.0.1

func (that *JSONNode) MustGetBool() bool

MustGetBool Return value of a TypeValue as bool will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetFloat32 ¶ added in v1.0.1

func (that *JSONNode) MustGetFloat32() float32

MustGetFloat32 Return value of a TypeValue as float32 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetFloat64 ¶ added in v1.0.1

func (that *JSONNode) MustGetFloat64() float64

MustGetFloat64 Return value of a TypeValue as float64 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetInt ¶ added in v1.0.1

func (that *JSONNode) MustGetInt() int

MustGetInt Return value of a TypeValue as int will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetInt8 ¶ added in v1.0.1

func (that *JSONNode) MustGetInt8() int8

MustGetInt8 Return value of a TypeValue as int8 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetInt16 ¶ added in v1.0.1

func (that *JSONNode) MustGetInt16() int16

MustGetInt16 Return value of a TypeValue as int16 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetInt32 ¶ added in v1.0.1

func (that *JSONNode) MustGetInt32() int32

MustGetInt32 Return value of a TypeValue as int32 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetInt64 ¶ added in v1.0.1

func (that *JSONNode) MustGetInt64() int64

MustGetInt64 Return value of a TypeValue as int64 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetString ¶ added in v1.0.1

func (that *JSONNode) MustGetString() string

MustGetString Return value of a TypeValue as string will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetUint ¶ added in v1.0.1

func (that *JSONNode) MustGetUint() uint

MustGetUint Return value of a TypeValue as uint will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetUint8 ¶ added in v1.0.1

func (that *JSONNode) MustGetUint8() uint8

MustGetUint8 Return value of a TypeValue as uint8 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetUint16 ¶ added in v1.0.1

func (that *JSONNode) MustGetUint16() uint16

MustGetUint16 Return value of a TypeValue as uint16 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetUint32 ¶ added in v1.0.1

func (that *JSONNode) MustGetUint32() uint32

MustGetUint32 Return value of a TypeValue as uint32 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) MustGetUint64 ¶ added in v1.0.1

func (that *JSONNode) MustGetUint64() uint64

MustGetUint64 Return value of a TypeValue as uint64 will panic if cant convert the internal value or if the node is not a TypeValue

func (*JSONNode) Print ¶

func (that *JSONNode) Print()

Print Print all the data the we ve got on a node and all it s children as a go struct :) (FOR DEV PURPOSE)

func (*JSONNode) SetType ¶

func (that *JSONNode) SetType(t JSONNodeType) *JSONNode

SetType Is use to set the Type of a node and return the current Node you are working on

func (*JSONNode) UnmarshalDontExpand ¶

func (that *JSONNode) UnmarshalDontExpand(val bool, recurse bool) *JSONNode

UnmarshalDontExpand set or not if Unmarshall will generate anything in that JSONNode and its children

val: will change the expanding rules for this node

- The type wont be change for any type

- Array wont grow

- New keys wont be added to Map

- Values set to nil "*.Val(nil)*" will be turn into the type decide by Json

- It will respect any current mapping and will return errors if needed

recurse: if true, it will set all the children of that JSONNode with val

func (*JSONNode) UnmarshalJSON ¶

func (that *JSONNode) UnmarshalJSON(data []byte) error

UnmarshalJSON Make JSONNode a Unmarshaler Interface compatible

func (*JSONNode) Unset ¶

func (that *JSONNode) Unset()

Unset Will unset everything in the JSONnode. All the children data will be lost

func (*JSONNode) Val ¶

func (that *JSONNode) Val(val interface{})

Val Turn this JSONNode to Value type and/or set that value to val

type JSONNodeType ¶

type JSONNodeType uint

JSONNodeType is used to set, check and get the inner type of a JSONNode

const (
	//TypeUndefined is set by default for empty JSONNode
	TypeUndefined JSONNodeType = iota
	//TypeMap is set when a JSONNode is a Map
	TypeMap
	//TypeArray is set when a JSONNode is an Array
	TypeArray
	//TypeValue is set when a JSONNode is a Value Node
	TypeValue
)

func (JSONNodeType) String ¶

func (i JSONNodeType) String() string

Source Files ¶

View all Source files

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