refactor: Decoder, Encoder, clearer names

README.md

@@ -11,14 +11,14 @@ Fast json for go. Lightweight fork of [jsoniter](https://github.com/json-iterato
 
 ## Capture
 
-The `Reader.Capture` method allows to unread everything is read in callback.
+The `Decoder.Capture` method allows to unread everything is read in callback.
 This is useful for multi-pass parsing:
 ```go
-func TestReader_Capture(t *testing.T) {
-	r := ParseString(`["foo", "bar", "baz"]`)
+func TestDecoder_Capture(t *testing.T) {
+	d := DecodeString(`["foo", "bar", "baz"]`)
 	var elems int
-	if err := r.Capture(func(r *Reader) error {
-		return r.Array(func(r *Reader) error {
+	if err := d.Capture(func(d *Reader) error {
+		return d.Arr(func(d *Reader) error {
 			elems++
 			return r.Skip()
 		})

any.go

@@ -66,26 +66,26 @@ func (v Any) Obj(f func(k string, v Any)) {
 	}
 }
 
-// Any reads Any value from r.
-func (r *Reader) Any() (Any, error) {
+// Any reads Any value.
+func (d *Decoder) Any() (Any, error) {
 	var v Any
-	if err := v.Read(r); err != nil {
+	if err := v.Read(d); err != nil {
 		return Any{}, err
 	}
 	return v, nil
 }
 
-// Any writes Any value to w.
-func (w *Writer) Any(a Any) error {
-	return a.Write(w)
+// Any writes Any value.
+func (e *Encoder) Any(a Any) error {
+	return a.Write(e)
 }
 
-func (v *Any) Read(r *Reader) error {
-	switch r.Next() {
+func (v *Any) Read(d *Decoder) error {
+	switch d.Next() {
 	case Invalid:
 		return xerrors.New("invalid")
 	case Number:
-		n, err := r.Number()
+		n, err := d.Number()
 		if err != nil {
 			return xerrors.Errorf("number: %w", err)
 		}
@@ -106,27 +106,27 @@ func (v *Any) Read(r *Reader) error {
 			v.Type = AnyInt
 		}
 	case String:
-		s, err := r.Str()
+		s, err := d.String()
 		if err != nil {
 			return xerrors.Errorf("str: %w", err)
 		}
 		v.Str = s
 		v.Type = AnyStr
 	case Nil:
-		if err := r.Null(); err != nil {
+		if err := d.Null(); err != nil {
 			return xerrors.Errorf("null: %w", err)
 		}
 		v.Type = AnyNull
 	case Bool:
-		b, err := r.Bool()
+		b, err := d.Bool()
 		if err != nil {
 			return xerrors.Errorf("bool: %w", err)
 		}
 		v.Bool = b
 		v.Type = AnyBool
 	case Object:
 		v.Type = AnyObj
-		if err := r.Obj(func(r *Reader, s string) error {
+		if err := d.Object(func(r *Decoder, s string) error {
 			var elem Any
 			if err := elem.Read(r); err != nil {
 				return xerrors.Errorf("elem: %w", err)
@@ -141,7 +141,7 @@ func (v *Any) Read(r *Reader) error {
 		return nil
 	case Array:
 		v.Type = AnyArr
-		if err := r.Array(func(r *Reader) error {
+		if err := d.Array(func(r *Decoder) error {
 			var elem Any
 			if err := elem.Read(r); err != nil {
 				return xerrors.Errorf("elem: %w", err)
@@ -153,19 +153,19 @@ func (v *Any) Read(r *Reader) error {
 		}
 		return nil
 	default:
-		return xerrors.Errorf("unexpected type %s", r.Next())
+		return xerrors.Errorf("unexpected type %s", d.Next())
 	}
 	return nil
 }
 
-// Write json representation of Any to Writer.
-func (v Any) Write(w *Writer) error {
+// Write json representation of Any to Encoder.
+func (v Any) Write(w *Encoder) error {
 	if v.KeyValid {
 		w.ObjField(v.Key)
 	}
 	switch v.Type {
 	case AnyStr:
-		w.Str(v.Str)
+		w.String(v.Str)
 	case AnyFloat:
 		if err := w.Float64(v.Float); err != nil {
 			return err

any_test.go

@@ -11,15 +11,15 @@ import (
 )
 
 func TestAny_Read(t *testing.T) {
-	t.Run("Obj", func(t *testing.T) {
+	t.Run("Object", func(t *testing.T) {
 		var v Any
 		const input = `{"foo":{"bar":1,"baz":[1,2,3.14],"200":null}}`
-		r := ReadString(input)
+		r := DecodeString(input)
 		assert.NoError(t, v.Read(r))
 		assert.Equal(t, `{foo: {bar: 1, baz: [1, 2, f3.14], 200: null}}`, v.String())
 
 		buf := new(bytes.Buffer)
-		w := NewWriter(buf, 1024)
+		w := NewEncoder(buf, 1024)
 		require.NoError(t, w.Any(v))
 		require.NoError(t, w.Flush())
 		require.Equal(t, input, buf.String(), "encoded value should equal to input")
@@ -34,11 +34,11 @@ func TestAny_Read(t *testing.T) {
 			t.Run(tt.Input, func(t *testing.T) {
 				var v Any
 				input := []byte(tt.Input)
-				r := ReadBytes(input)
+				r := DecodeBytes(input)
 				require.NoError(t, v.Read(r))
 
 				buf := new(bytes.Buffer)
-				s := NewWriter(buf, 1024)
+				s := NewEncoder(buf, 1024)
 				require.NoError(t, v.Write(s))
 				require.NoError(t, s.Flush())
 				require.Equal(t, tt.Input, buf.String(), "encoded value should equal to input")
@@ -58,7 +58,7 @@ func TestAny_Read(t *testing.T) {
 
 func BenchmarkAny(b *testing.B) {
 	data := []byte(`[true, null, false, 100, "false"]`)
-	r := NewReader()
+	r := NewDecoder()
 
 	b.ReportAllocs()
 	b.SetBytes(int64(len(data)))

bench_test.go

@@ -15,11 +15,11 @@ var data []byte
 */
 func Benchmark_large_file(b *testing.B) {
 	b.ReportAllocs()
-	iter := Read(nil, 4096)
+	iter := Decode(nil, 4096)
 
 	for n := 0; n < b.N; n++ {
 		iter.ResetBytes(data)
-		if err := iter.Array(func(iter *Reader) error {
+		if err := iter.Array(func(iter *Decoder) error {
 			return iter.Skip()
 		}); err != nil {
 			b.Fatal(err)

bool_test.go

@@ -9,20 +9,20 @@ import (
 
 func Test_true(t *testing.T) {
 	should := require.New(t)
-	iter := ReadString(`true`)
+	iter := DecodeString(`true`)
 	should.True(iter.Bool())
 }
 
 func Test_false(t *testing.T) {
 	should := require.New(t)
-	iter := ReadString(`false`)
+	iter := DecodeString(`false`)
 	should.False(iter.Bool())
 }
 
 func Test_write_true_false(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	w := NewWriter(buf, 4096)
+	w := NewEncoder(buf, 4096)
 	w.True()
 	w.False()
 	w.Bool(false)