replace Json with Read

README.md

@@ -10,7 +10,7 @@ type-wrapper is type wrapper generator for [Go programming language](https://gol
 type-wrap is a tool that generates:
 - Wrapper struct from any structs.
 - Getter and Setter methods
-- `Json` method which marshal the original type to `[]byte`
+- `Read` function to read the JSON `[]byte` of the struct
 - Interface for the wrapper struct
 
 Sometimes you might make struct fields unexported in order for values of fields not to be accessed
@@ -159,8 +159,8 @@ func (m MyStructWrapper) SetTime(val time.Time) {
 ```
 
 
-### Generate the `Json` method
-`type-wrapper` can generate `Json` method which uses `encoding/json` package to marshal the original type
+### Generate the `Read` function
+`type-wrapper` can generate `Read` method which uses `encoding/json` package to marshal the original type
 Here is an example ()
 ```go
 type MyStruct struct {
@@ -181,7 +181,7 @@ type IStruct interface {
 	SetField2(val *int)
 	Field3() time.Time
 	SetTime(val time.Time)
-	Json() []byte
+	Read(p []byte) (int, error)
 }
 
 // MyStructWrapper encapulates the type MyStruct
@@ -207,12 +207,14 @@ func (m MyStructWrapper) SetTime(val time.Time) {
 	m.MyStruct.Field3 = val
 }
 
-func (m MyStructWrapper) Json() []byte {
+func (m MyStructWrapper) Read(p []byte) (int, error) {
 	m.DataType = "MyStruct"
-	if data, err := json.Marshal(m); err == nil {
-		return data
+	data, err := json.Marshal(m)
+	if err != nil {
+		return 0, err
 	}
-	return []byte{}
+	n := copy(p, data)
+	return n, nil
 }
 ```
 
@@ -228,8 +230,8 @@ source-dir
 Flags:
   -interface string
         wrapper interface name to be generated
-  -json
-        generate Json() method
+  -reader
+        implement io.Reader interface
   -lock string
         lock name
   -output string
@@ -247,7 +249,7 @@ Flags:
 Example:
 
 ```shell
-$ type-wrapper -type MyStruct -wrapper WStruct -interface IStruct -json -receiver myStruct -output my_struct_wrapper.go path/to/target
+$ type-wrapper -type MyStruct -wrapper WStruct -interface IStruct -reader -receiver myStruct -output my_struct_wrapper.go path/to/target
 ```
 
 #### go generate
@@ -257,7 +259,7 @@ You can also generate wrappers by using `go generate`.
 ```go
 package mypackage
 
-//go:generate type-wrapper -type MyStruct -wrapper WStruct -interface IStruct -json -receiver myStruct -output my_struct_wrapper.go 
+//go:generate type-wrapper -type MyStruct -wrapper WStruct -interface IStruct -reader -receiver myStruct -output my_struct_wrapper.go 
 
 type MyStruct struct {
     field1 string `wrapper:"getter"`

cmd/cmd.go

@@ -35,7 +35,7 @@ func Execute(fs afero.Fs, args []string) {
 	flags := flag.NewFlagSet(args[0], flag.ContinueOnError)
 	flags.Usage = newUsage(flags)
 	version := flags.Bool("version", false, "show the version of wrap")
-	jsonMarshal := flags.Bool("json", false, "generate Json() method")
+	reader := flags.Bool("reader", false, "implement io.Reader interface")
 	typeName := flags.String("type", "", "type name; must be set")
 	wrapperTypeName := flags.String("wrapper", "", "wrapper type name; default <type_name>Wrapper")
 	interfaceName := flags.String("interface", "", "wrapper interface name to be generated")
@@ -87,12 +87,12 @@ func Execute(fs afero.Fs, args []string) {
 		wrapper.Output(*output),
 		wrapper.Receiver(*receiver),
 		wrapper.Lock(*lockName),
-		wrapper.Json(*jsonMarshal),
+		wrapper.Reader(*reader),
 		wrapper.Wrapper(*wrapperTypeName),
 		wrapper.Interface(*interfaceName),
 	}
 	if err = wrapper.Generate(fs, pkg, options...); err != nil {
-		log.Fatal("err")
+		log.Fatal("err", err)
 	}
 }
 

cmd/cmd_test.go

@@ -26,8 +26,8 @@ func TestExecute(t *testing.T) {
 			cmd:    "type-wrapper -type Tester -interface ITester testdata/getter",
 			output: "testdata/getter/tester_wrapper.go",
 		},
-		"GetterAndInterfaceAndJson": {
-			cmd:    "type-wrapper -type Tester -interface ITester -json testdata/getter",
+		"GetterAndInterfaceAndReader": {
+			cmd:    "type-wrapper -type Tester -interface ITester -reader testdata/getter",
 			output: "testdata/getter/tester_wrapper.go",
 		},
 		"Setter": {
@@ -54,16 +54,16 @@ func TestExecute(t *testing.T) {
 			cmd:    "type-wrapper -type Tester -receiver tester testdata/with_receiver",
 			output: "testdata/with_receiver/tester_wrapper.go",
 		},
-		"WithReceiverAndInterfaceAndJson": {
-			cmd:    "type-wrapper -type Tester -receiver tester -interface ITester -json testdata/with_receiver",
+		"WithReceiverAndInterfaceAndReader": {
+			cmd:    "type-wrapper -type Tester -receiver tester -interface ITester -reader testdata/with_receiver",
 			output: "testdata/with_receiver/tester_wrapper.go",
 		},
 		"WithLock": {
 			cmd:    "type-wrapper -type Tester -lock lock testdata/with_lock",
 			output: "testdata/with_lock/tester_wrapper.go",
 		},
-		"WithLockAndInterfaceAndJson": {
-			cmd:    "type-wrapper -type Tester -lock lock -interface ITester -json testdata/with_lock",
+		"WithLockAndInterfaceAndReader": {
+			cmd:    "type-wrapper -type Tester -lock lock -interface ITester -reader testdata/with_lock",
 			output: "testdata/with_lock/tester_wrapper.go",
 		},
 	}
@@ -77,7 +77,7 @@ func TestExecute(t *testing.T) {
 	for name, tt := range tests {
 		tt := tt
 		t.Run(name, func(t *testing.T) {
-			t.Parallel()
+			//	t.Parallel()
 
 			args := strings.Split(tt.cmd, " ")
 			cmd.Execute(fs, args)

internal/wrapper/generator.go

@@ -22,7 +22,7 @@ type generator struct {
 	output        string
 	receiver      string
 	lock          string
-	json          bool
+	reader        bool
 }
 
 type genParameters struct {
@@ -36,7 +36,7 @@ type genParameters struct {
 	Type          string
 	ZeroValue     string // used only when generating getter
 	Lock          string
-	Json          bool
+	Reader        bool
 }
 
 func newGenerator(fs afero.Fs, pkg *Package, options ...Option) *generator {
@@ -116,12 +116,12 @@ func Generate(fs afero.Fs, pkg *Package, options ...Option) error {
 			}
 		}
 
-		if g.json {
-			jsonFunc, err := g.generateJson(typeParams)
+		if g.reader {
+			readerFunc, err := g.generateReader(typeParams)
 			if err != nil {
 				return err
 			}
-			wrappers = append(wrappers, jsonFunc)
+			wrappers = append(wrappers, readerFunc)
 		}
 
 		iface, err := g.generateInterface(typeParams, ifaces)
@@ -243,7 +243,7 @@ func (g *generator) generateSetterInterface(
 	return buf.String(), nil
 }
 
-func (g *generator) generateJson(
+func (g *generator) generateReader(
 	params *genParameters,
 ) (string, error) {
 	var lockingCode string
@@ -254,17 +254,19 @@ func (g *generator) generateJson(
 	}
 
 	var tpl = `
-	func ({{.Receiver}} {{.WrapperStruct}}) Json() []byte {		
+	func ({{.Receiver}} {{.WrapperStruct}}) Read(p []byte) (int, error) {		
 	` +
 		lockingCode + // inject locking code
 		`{{.Receiver}}.DataType = "{{.Struct}}"
-		if data, err := json.Marshal({{.Receiver}}); err == nil {
-			return data
+		data, err := json.Marshal({{.Receiver}}) 
+		if err != nil {
+			return 0, err
 		}
-		return []byte{}
+		n := copy(p, data)
+		return n, nil
 	}`
 
-	t := template.Must(template.New("json").Parse(tpl))
+	t := template.Must(template.New("reader").Parse(tpl))
 	buf := new(bytes.Buffer)
 
 	if err := t.Execute(buf, params); err != nil {
@@ -278,8 +280,8 @@ func (g *generator) generateStruct(
 	params *genParameters,
 ) (string, error) {
 	var datatype string
-	if g.json {
-		datatype = `// The name of the original type, it gets initalized when calling Json() function, DO NOT USE IT
+	if g.reader {
+		datatype = `// The name of the original type, it gets initalized when calling Read() function, DO NOT USE IT
 		DataType string ` + "`json:\"_data_type,omitempty\"`"
 	}
 	var tpl = `
@@ -305,13 +307,13 @@ func (g *generator) generateInterface(params *genParameters, methods []string) (
 		return "", nil
 	}
 	methodsList := strings.Join(methods, "")
-	var json string
-	if g.json {
-		json = `Json() []byte
+	var reader string
+	if g.reader {
+		reader = `Read(p []byte) (int, error)
 		`
 	}
 	var tpl = `
-	type {{.Interface}} interface {` + methodsList + json + `
+	type {{.Interface}} interface {` + methodsList + reader + `
 	}
 	`
 	t := template.Must(template.New("struct").Parse(tpl))
@@ -341,7 +343,7 @@ func (g *generator) setupParameters(
 		Type:          typeName,
 		ZeroValue:     g.zeroValue(field.Type, typeName),
 		Lock:          g.lock,
-		Json:          g.json,
+		Reader:        g.reader,
 		Interface:     g.interfaceName,
 	}
 }
@@ -355,7 +357,7 @@ func (g *generator) setupTypeParameters(
 		Struct:        st.Name,
 		WrapperStruct: g.wrapperType,
 		Lock:          g.lock,
-		Json:          g.json,
+		Reader:        g.reader,
 		Interface:     g.interfaceName,
 	}
 }
@@ -446,7 +448,7 @@ func (g *generator) generateImportStrings(pkgs []*packages.Package) []string {
 		return pkgs[i].Name < pkgs[j].Name
 	})
 
-	if g.json {
+	if g.reader {
 		var added bool
 		for _, pkg := range pkgs {
 			if pkg.PkgPath == "encoding/json" {

internal/wrapper/options.go

@@ -30,10 +30,10 @@ func Lock(lock string) Option {
 	}
 }
 
-// Generte JSON function
-func Json(json bool) Option {
+// Implement io.Reader
+func Reader(reader bool) Option {
 	return func(g *generator) {
-		g.json = json
+		g.reader = reader
 	}
 }