added flag for marshalling nil slices/maps to []/{} instead of null (#1)

* added flag for marshalling nil slices to [] instead of null

* added similar functionality for nil maps

* fixed comment

LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,4 @@
+# json
+This is a fork of [golang's encoding/json](https://github.com/golang/go/tree/master/src/encoding/json) with an extra method `MarshalSafeCollections` that marshals nil slices and maps into `[]` and `{}` respectfully instead of `null`. Additionally added `SetNilSafeCollection` to the `Encoder` in order to turn on the flag (default: false).
+
+Currently master is a fork of `go1.9.4`.

encode.go

@@ -165,6 +165,17 @@ func Marshal(v interface{}) ([]byte, error) {
 	return e.Bytes(), nil
 }
 
+// MarshalSafeCollections is like Marshal except it will marshal nil maps and
+// slices as '{}' and '[]' respectfully instead of 'null'
+func MarshalSafeCollections(v interface{}) ([]byte, error) {
+	e := &encodeState{}
+	err := e.marshal(v, encOpts{escapeHTML: true, nilSafeCollection: true})
+	if err != nil {
+		return nil, err
+	}
+	return e.Bytes(), nil
+}
+
 // MarshalIndent is like Marshal but applies Indent to format the output.
 func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
 	b, err := Marshal(v)
@@ -328,6 +339,9 @@ type encOpts struct {
 	quoted bool
 	// escapeHTML causes '<', '>', and '&' to be escaped in JSON strings.
 	escapeHTML bool
+	// nilSafeCollection marshals a nil slices and maps into '[]' and '{}'
+	// respectfully instead of 'null'
+	nilSafeCollection bool
 }
 
 type encoderFunc func(e *encodeState, v reflect.Value, opts encOpts)
@@ -657,7 +671,11 @@ type mapEncoder struct {
 
 func (me *mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	if v.IsNil() {
-		e.WriteString("null")
+		if opts.nilSafeCollection {
+			e.WriteString("{}")
+		} else {
+			e.WriteString("null")
+		}
 		return
 	}
 	e.WriteByte('{')
@@ -698,9 +716,13 @@ func newMapEncoder(t reflect.Type) encoderFunc {
 	return me.encode
 }
 
-func encodeByteSlice(e *encodeState, v reflect.Value, _ encOpts) {
+func encodeByteSlice(e *encodeState, v reflect.Value, opts encOpts) {
 	if v.IsNil() {
-		e.WriteString("null")
+		if opts.nilSafeCollection {
+			e.WriteString("[]")
+		} else {
+			e.WriteString("null")
+		}
 		return
 	}
 	s := v.Bytes()
@@ -727,7 +749,11 @@ type sliceEncoder struct {
 
 func (se *sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	if v.IsNil() {
-		e.WriteString("null")
+		if opts.nilSafeCollection {
+			e.WriteString("[]")
+		} else {
+			e.WriteString("null")
+		}
 		return
 	}
 	se.arrayEnc(e, v, opts)

encode_test.go

@@ -978,3 +978,49 @@ func TestMarshalRawMessageValue(t *testing.T) {
 		}
 	}
 }
+
+func TestMarshalSafeCollections(t *testing.T) {
+	var (
+		nilSlice  []interface{}
+		pNilSlice *[]interface{}
+		nilMap    map[string]interface{}
+		pNilMap   *map[string]interface{}
+	)
+
+	type (
+		nilSliceStruct struct {
+			NilSlice []interface{} `json:"nil_slice"`
+		}
+		nilMapStruct struct {
+			NilMap map[string]interface{} `json:"nil_map"`
+		}
+	)
+
+	tests := []struct {
+		in   interface{}
+		want string
+	}{
+		{nilSlice, "[]"},
+		{[]interface{}{}, "[]"},
+		{make([]interface{}, 0), "[]"},
+		{[]int{1, 2, 3}, "[1,2,3]"},
+		{pNilSlice, "null"},
+		{nilSliceStruct{}, "{\"nil_slice\":[]}"},
+		{nilMap, "{}"},
+		{map[string]interface{}{}, "{}"},
+		{make(map[string]interface{}, 0), "{}"},
+		{map[string]interface{}{"1": 1, "2": 2, "3": 3}, "{\"1\":1,\"2\":2,\"3\":3}"},
+		{pNilMap, "null"},
+		{nilMapStruct{}, "{\"nil_map\":{}}"},
+	}
+
+	for i, tt := range tests {
+		b, err := MarshalSafeCollections(tt.in)
+		if err != nil {
+			t.Errorf("test %d, unexpected failure: %v", i, err)
+		}
+		if got := string(b); got != tt.want {
+			t.Errorf("test %d, Marshal(%#v) = %q, want %q", i, tt.in, got, tt.want)
+		}
+	}
+}

stream.go

@@ -166,9 +166,10 @@ func nonSpace(b []byte) bool {
 
 // An Encoder writes JSON values to an output stream.
 type Encoder struct {
-	w          io.Writer
-	err        error
-	escapeHTML bool
+	w                 io.Writer
+	err               error
+	escapeHTML        bool
+	nilSafeCollection bool
 
 	indentBuf    *bytes.Buffer
 	indentPrefix string
@@ -190,7 +191,7 @@ func (enc *Encoder) Encode(v interface{}) error {
 		return enc.err
 	}
 	e := newEncodeState()
-	err := e.marshal(v, encOpts{escapeHTML: enc.escapeHTML})
+	err := e.marshal(v, encOpts{escapeHTML: enc.escapeHTML, nilSafeCollection: enc.nilSafeCollection})
 	if err != nil {
 		return err
 	}
@@ -241,6 +242,12 @@ func (enc *Encoder) SetEscapeHTML(on bool) {
 	enc.escapeHTML = on
 }
 
+// SetNilSafeCollection specifies whether to represent nil slices and maps as
+// '[]' or '{}' respectfully (flag on) instead of 'null' (default) when marshaling json.
+func (enc *Encoder) SetNilSafeCollection(on bool) {
+	enc.nilSafeCollection = on
+}
+
 // RawMessage is a raw encoded JSON value.
 // It implements Marshaler and Unmarshaler and can
 // be used to delay JSON decoding or precompute a JSON encoding.

stream_test.go

@@ -123,6 +123,48 @@ func TestEncoderSetEscapeHTML(t *testing.T) {
 	}
 }
 
+func TestEncoderSetNilSafeCollection(t *testing.T) {
+	var (
+		nilSlice  []interface{}
+		pNilSlice *[]interface{}
+		nilMap    map[string]interface{}
+		pNilMap   *map[string]interface{}
+	)
+	for _, tt := range []struct {
+		name        string
+		v           interface{}
+		want        string
+		rescuedWant string
+	}{
+		{"nilSlice", nilSlice, "null", "[]"},
+		{"nonNilSlice", []interface{}{}, "[]", "[]"},
+		{"sliceWithValues", []interface{}{1, 2, 3}, "[1,2,3]", "[1,2,3]"},
+		{"pNilSlice", pNilSlice, "null", "null"},
+		{"nilMap", nilMap, "null", "{}"},
+		{"nonNilMap", map[string]interface{}{}, "{}", "{}"},
+		{"mapWithValues", map[string]interface{}{"1": 1, "2": 2, "3": 3}, "{\"1\":1,\"2\":2,\"3\":3}", "{\"1\":1,\"2\":2,\"3\":3}"},
+		{"pNilMap", pNilMap, "null", "null"},
+	} {
+		var buf bytes.Buffer
+		enc := NewEncoder(&buf)
+		if err := enc.Encode(tt.v); err != nil {
+			t.Fatalf("Encode(%s): %s", tt.name, err)
+		}
+		if got := strings.TrimSpace(buf.String()); got != tt.want {
+			t.Errorf("Encode(%s) = %#q, want %#q", tt.name, got, tt.want)
+		}
+		buf.Reset()
+		enc.SetNilSafeCollection(true)
+		if err := enc.Encode(tt.v); err != nil {
+			t.Fatalf("SetNilSafeCollection(true) Encode(%s): %s", tt.name, err)
+		}
+		if got := strings.TrimSpace(buf.String()); got != tt.rescuedWant {
+			t.Errorf("SetNilSafeCollection(true) Encode(%s) = %#q, want %#q",
+				tt.name, got, tt.want)
+		}
+	}
+}
+
 func TestDecoder(t *testing.T) {
 	for i := 0; i <= len(streamTest); i++ {
 		// Use stream without newlines as input,