Add: jsonc decoder

1. Add: Decode commented json.
2. Add: Implement io.Reader.

Author: akshaybharambe14

README.md

@@ -1 +1,50 @@
-go-jsonc
+# JSON with comments for GO
+
+- Decodes a "commented json" to "json". Provided, yhe input must be a valid jsonc document.
+- Supports io.Reader
+
+Inspired by [muhammadmuzzammil1998](https://github.com/muhammadmuzzammil1998/jsonc)
+
+```jsonc
+{
+  /*
+        some block comment
+  */
+  "string": "foo", // a string
+  "bool": false, // a boolean
+  "number": 42, // a number
+  // "object":{
+  //     "key":"val"
+  // },
+  "array": [
+    // example of an array
+    1,
+    2,
+    3
+  ]
+}
+```
+
+Gets converted to (spaces omitted)
+
+```json
+{ "string": "foo", "bool": false, "number": 42, "array": [1, 2, 3] }
+```
+
+## Usage
+
+Get this package
+
+```sh
+
+go get github.com/akshaybharambe14/go-jsonc
+
+```
+
+## Example
+
+see [examples](https://github.com/akshaybharambe14/go-jsonc/examples)
+
+## License
+
+`go-jsonc` is available under [MIT License](License.md)

examples/main.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+
+	"github.com/akshaybharambe14/go-jsonc"
+)
+
+func main() {
+	// create new decoder
+	d := jsonc.NewDecoder(bytes.NewBuffer([]byte(`{
+		/*
+			some block comment
+		*/
+		"string": "foo", // a string
+		"bool": true, // a boolean
+		"number": 42, // a number
+		// "object":{
+		//     "key":"val"
+		// },
+		"array": [ // example of an array
+			1,
+			2,
+			3
+		]
+	}`)))
+
+	// read json
+	res, err := ioutil.ReadAll(d)
+	if err != nil {
+		fmt.Println("error decoding commented json: ", err)
+		return
+	}
+
+	// Unmarshal to a struct
+
+	type Test struct {
+		Str string `json:"string"`
+		Bln bool   `json:"bool"`
+		Num int    `json:"number"`
+		Arr []int  `json:"array"`
+	}
+
+	t := Test{}
+	if err = json.Unmarshal(res, &t); err != nil {
+		fmt.Println("error while json Unmarshal: ", err)
+		return
+	}
+
+	fmt.Printf("%+v\n", t)
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/akshaybharambe14/go-jsonc
+
+go 1.13

jsonc.go

@@ -0,0 +1,140 @@
+package jsonc
+
+import (
+	"errors"
+	"io"
+)
+
+type (
+	state int
+
+	comment struct {
+		state   state
+		multiLn bool
+		isJSON  bool
+	}
+
+	// Decoder implements io.Reader. It wraps provided source.
+	Decoder struct {
+		r io.Reader
+		c comment
+	}
+)
+
+const (
+	// byte representations of string literals
+	tab      = 9   // (	)
+	newLine  = 10  // (\n)
+	space    = 32  // ( )
+	quote    = 34  // ("")
+	star     = 42  // (*)
+	fwdSlash = 47  // (/)
+	bkdSlash = 92  // (\)
+	charN    = 110 // (n)
+)
+
+const (
+	stopped  state = iota // 0, default state
+	canStart              // 1
+	started               // 2
+	canStop               // 3
+)
+
+var (
+	ErrUnexpectedEndOfJSON = errors.New("unexpected end of json")
+)
+
+// New a new io.Reader wrapping the provided one.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{
+		c: comment{},
+		r: r,
+	}
+}
+
+// Read reads from underlying writer and processes the stream to omit comments.
+// A single read doesn't guaranttee a valid JSON. Depends on length of passed slice.
+//
+// Produces ErrUnexpectedEndOfJSON for incomplete comments
+func (d *Decoder) Read(p []byte) (int, error) {
+
+	n, err := d.r.Read(p)
+	if err != nil {
+		return n, err
+	}
+
+	shortRead := n <= len(p)
+	n = d.decode(p[:n])
+
+	if shortRead && d.c.state != stopped {
+		return 0, ErrUnexpectedEndOfJSON
+	}
+
+	return n, nil
+}
+
+func (d *Decoder) decode(p []byte) int {
+	i := 0
+	for _, s := range p {
+		if d.c.handle(s) {
+			p[i] = s
+			i++
+		}
+	}
+
+	return i
+}
+
+// handle the current byte, if returned true, add the byte to result.
+func (c *comment) handle(s byte) bool {
+	switch c.state {
+
+	case stopped:
+		if s == quote { // all characters between "" are valid, can be added to result
+			c.isJSON = !c.isJSON
+		}
+
+		if c.isJSON {
+			return true
+		}
+
+		if s == space || s == tab || s == newLine {
+			return false
+		}
+
+		if s == fwdSlash {
+			c.state = canStart
+			return false
+		}
+
+		return true
+
+	case canStart:
+
+		if s == star || s == fwdSlash {
+			c.state = started
+		}
+
+		c.multiLn = (s == star)
+
+	case started:
+
+		if s == star || s == bkdSlash {
+			c.state = canStop
+		}
+
+		if s == newLine && !c.multiLn {
+			c.state = stopped
+		}
+
+	case canStop:
+
+		if s == fwdSlash || s == charN {
+			c.state = stopped
+			c.multiLn = false
+		}
+
+	}
+
+	return false
+}

jsonc_test.go

@@ -0,0 +1,73 @@
+package jsonc
+
+import (
+	"bytes"
+	"testing"
+)
+
+func ts(b []byte) *Decoder { return &Decoder{r: bytes.NewBuffer(b)} }
+
+var (
+	validSingle   = []byte(`{"foo": // this is a single line comment\n"bar foo", "true": false, "number": 42, "object": { "test": "done" }, "array" : [1, 2, 3], "url" : "https://github.com" }`)
+	invalidSingle = []byte(`{"foo": // this is a single line comment "bar foo", "true": false, "number": 42, "object": { "test": "done" }, "array" : [1, 2, 3], "url" : "https://github.com" }`)
+
+	validBlock   = []byte(`{"foo": /* this is a block comment */ "bar foo", "true": false, "number": 42, "object": { "test": "done" }, "array" : [1, 2, 3], "url" : "https://github.com" }`)
+	invalidBlock = []byte(`{"foo": /* this is a block comment "bar foo", "true": false, "number": 42, "object": { "test": "done" }, "array" : [1, 2, 3], "url" : "https://github.com" }`)
+)
+
+func Test_Decoder_Read(t *testing.T) {
+
+	type args struct {
+		p []byte
+	}
+
+	tests := []struct {
+		name    string
+		d       *Decoder
+		args    args
+		want    int
+		wantErr bool
+	}{
+		{
+			name:    "Valid single line comment",
+			d:       ts(validSingle),
+			args:    args{p: make([]byte, len(validSingle))},
+			want:    110, // (163(total) - 34(comments) - 19(spaces))
+			wantErr: false,
+		},
+		{
+			name:    "Invalid single line comment",
+			d:       ts(invalidSingle),
+			args:    args{p: make([]byte, len(invalidSingle))},
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name:    "Valid block comment",
+			d:       ts(validBlock),
+			args:    args{p: make([]byte, len(validBlock))},
+			want:    110, // (159(total) - 29(comments) - 20(spaces))
+			wantErr: false,
+		},
+		{
+			name:    "Invalid block comment",
+			d:       ts(invalidBlock),
+			args:    args{p: make([]byte, len(invalidBlock))},
+			want:    0,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.d.Read(tt.args.p)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Decoder.Read() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("Decoder.Read() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}