The encoding/json library allows you to use the Decoder type to parse JSON and preserve the formatting of numbers using the UseNumber method. When doing this, colorjson fails to render the numbers in the output.

With the following code:

package main

import (
	"encoding/json"
	"fmt"
	"strings"
	"github.com/TylerBrock/colorjson"
)

func main() {
	str := `{
  "str": "foo",
  "num": 100.0,
  "bool": false,
  "null": null,
  "array": ["foo", "bar", "baz"],
  "obj": { "a": 1, "b": 2 }
}`

	d := json.NewDecoder(strings.NewReader(str))
	d.UseNumber()
	var obj interface{}
	_ = d.Decode(&obj)


	f := colorjson.NewFormatter()
	f.Indent = 2

	s, _ := colorjson.Marshal(obj)
	fmt.Println(string(s))

}

The output is shown below (note the absence of any numeric values

{ "array": [ "foo", "bar", "baz" ], "bool": false, "null": null, "num": , "obj": { "a": , "b":  }, "str": "foo" } 

The expected output is below (note that num is rendered as 100.0 rather than 100 as it would have been output without the UseNumber call)

{ "array": [ "foo", "bar", "baz" ], "bool": false, "null": null, "num": 100.0, "obj": { "a": 1, "b": 2 }, "str": "foo" }

I've been trying to get this library working, but no matter what I always get an empty array ([]) as the result, even though json.Marshal works just fine.

Usage between colorjson.Marshal and json.Marshal is identical, and there are no errors, so I'm not sure what's up.

With this flag set to true (which is the default) and f.Indent = 0, then the behaviour is as previous, eg.

{ "a": 5, "b": [ 1, 2, 3 ], "c": { "d": "e" } }

When f.ObjectSeparator = false and f.Indent = 0, it would render the object as:

{"a":5,"b":[1,2,3],"c":{"d":"e"}}

Pretty printing strings with HTML unsafe characters (e.g <) can be quite "unpretty" with the default HTML escaping. This PR adds option to control this.

The RawStrings option can achieve similar effect, but with this option the output is both pretty and still valid JSON.

I kept the original code path using json.Marshal as before, so the performance with default options should not be affected except for the bool check.

marshalValue doesn't handle the wide range of values supported by encoding/json (such as any value implementing json.Marshaler) but silently fails (no output) instead of reporting an error indicating an unsupported data type.

Example: https://play.golang.org/p/dmF0aGDl0J5

package main

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

	"github.com/TylerBrock/colorjson"
)

func main() {
	raw := json.RawMessage(`{
  "str": "foo",
  "num": 100,
  "bool": false,
  "null": null,
  "array": ["foo", "bar", "baz"],
  "obj": { "a": 1, "b": 2 }
}`)

	f := colorjson.NewFormatter()
	f.Indent = 2

	b, err := f.Marshal(raw)
	if err != nil {
		log.Fatal(err)
	}
	if len(b) == 0 {
		log.Fatal("no output")
	}
	fmt.Println(string(b))
}

I added support for various int and uint types, as well as float32.

I understand that your library was targeting unmarshalled JSON structs, so this might not be in scope. I am using colorjson to pretty-print my structs for debugging purposes and noticed that since these types aren't implemented, they return as an empty string in the output.

Also, unsure if there's a better way to implement this; Golang doesn't seem to like grouping int/uint types together and then type casting, so I have to make a case for each. The other option would of course be to use reflect but it's quite a bit slower.