Merge pull request #5666 from overbool/refactor/commands/object

commands/object: use new cmds

core/commands/object/diff.go

 package objectcmd
 
 import (
-	"bytes"
 	"fmt"
 	"io"
 
-	cmds "github.com/ipfs/go-ipfs/commands"
-	e "github.com/ipfs/go-ipfs/core/commands/e"
+	cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
 	coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
 	"github.com/ipfs/go-ipfs/dagutils"
 
+	cmds "gx/ipfs/QmSXUokcP4TJpFfqozT69AVAYRtzXVMUjzQVkYX41R9Svs/go-ipfs-cmds"
 	cmdkit "gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
 )
 
+const (
+	verboseOptionName = "verbose"
+)
+
 type Changes struct {
 	Changes []*dagutils.Change
 }
@@ -49,34 +52,30 @@ Example:
 		cmdkit.StringArg("obj_b", true, false, "Object to diff."),
 	},
 	Options: []cmdkit.Option{
-		cmdkit.BoolOption("verbose", "v", "Print extra information."),
+		cmdkit.BoolOption(verboseOptionName, "v", "Print extra information."),
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-		api, err := req.InvocContext().GetApi()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		api, err := cmdenv.GetApi(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		a := req.Arguments()[0]
-		b := req.Arguments()[1]
+		a := req.Arguments[0]
+		b := req.Arguments[1]
 
 		pa, err := coreiface.ParsePath(a)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		pb, err := coreiface.ParsePath(b)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		changes, err := api.Object().Diff(req.Context(), pa, pb)
+		changes, err := api.Object().Diff(req.Context, pa, pb)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		out := make([]*dagutils.Change, len(changes))
@@ -95,45 +94,36 @@ Example:
 			}
 		}
 
-		res.SetOutput(&Changes{out})
+		return cmds.EmitOnce(res, &Changes{out})
 	},
 	Type: Changes{},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: func(res cmds.Response) (io.Reader, error) {
-			v, err := unwrapOutput(res.Output())
-			if err != nil {
-				return nil, err
-			}
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Changes) error {
+			verbose, _ := req.Options[verboseOptionName].(bool)
 
-			verbose, _, _ := res.Request().Option("v").Bool()
-			changes, ok := v.(*Changes)
-			if !ok {
-				return nil, e.TypeErr(changes, v)
-			}
-
-			buf := new(bytes.Buffer)
-			for _, change := range changes.Changes {
+			for _, change := range out.Changes {
 				if verbose {
 					switch change.Type {
 					case dagutils.Add:
-						fmt.Fprintf(buf, "Added new link %q pointing to %s.\n", change.Path, change.After)
+						fmt.Fprintf(w, "Added new link %q pointing to %s.\n", change.Path, change.After)
 					case dagutils.Mod:
-						fmt.Fprintf(buf, "Changed %q from %s to %s.\n", change.Path, change.Before, change.After)
+						fmt.Fprintf(w, "Changed %q from %s to %s.\n", change.Path, change.Before, change.After)
 					case dagutils.Remove:
-						fmt.Fprintf(buf, "Removed link %q (was %s).\n", change.Path, change.Before)
+						fmt.Fprintf(w, "Removed link %q (was %s).\n", change.Path, change.Before)
 					}
 				} else {
 					switch change.Type {
 					case dagutils.Add:
-						fmt.Fprintf(buf, "+ %s %q\n", change.After, change.Path)
+						fmt.Fprintf(w, "+ %s %q\n", change.After, change.Path)
 					case dagutils.Mod:
-						fmt.Fprintf(buf, "~ %s %s %q\n", change.Before, change.After, change.Path)
+						fmt.Fprintf(w, "~ %s %s %q\n", change.Before, change.After, change.Path)
 					case dagutils.Remove:
-						fmt.Fprintf(buf, "- %s %q\n", change.Before, change.Path)
+						fmt.Fprintf(w, "- %s %q\n", change.Before, change.Path)
 					}
 				}
 			}
-			return buf, nil
-		},
+
+			return nil
+		}),
 	},
 }

core/commands/object/patch.go

@@ -3,12 +3,8 @@ package objectcmd
 import (
 	"fmt"
 	"io"
-	"strings"
 
-	oldcmds "github.com/ipfs/go-ipfs/commands"
-	lgc "github.com/ipfs/go-ipfs/commands/legacy"
 	cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
-	e "github.com/ipfs/go-ipfs/core/commands/e"
 	coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
 	"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
 
@@ -28,26 +24,12 @@ result. This is the Merkle-DAG version of modifying an object.
 	Arguments: []cmdkit.Argument{},
 	Subcommands: map[string]*cmds.Command{
 		"append-data": patchAppendDataCmd,
-		"add-link":    lgc.NewCommand(patchAddLinkCmd),
-		"rm-link":     lgc.NewCommand(patchRmLinkCmd),
-		"set-data":    lgc.NewCommand(patchSetDataCmd),
+		"add-link":    patchAddLinkCmd,
+		"rm-link":     patchRmLinkCmd,
+		"set-data":    patchSetDataCmd,
 	},
 }
 
-func objectMarshaler(res oldcmds.Response) (io.Reader, error) {
-	v, err := unwrapOutput(res.Output())
-	if err != nil {
-		return nil, err
-	}
-
-	o, ok := v.(*Object)
-	if !ok {
-		return nil, e.TypeErr(o, v)
-	}
-
-	return strings.NewReader(o.Hash + "\n"), nil
-}
-
 var patchAppendDataCmd = &cmds.Command{
 	Helptext: cmdkit.HelpText{
 		Tagline: "Append data to the data segment of a dag node.",
@@ -67,7 +49,7 @@ the limit will not be respected by the network.
 		cmdkit.StringArg("root", true, false, "The hash of the node to modify."),
 		cmdkit.FileArg("data", true, false, "Data to append.").EnableStdin(),
 	},
-	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
 		api, err := cmdenv.GetApi(env)
 		if err != nil {
 			return err
@@ -88,7 +70,7 @@ the limit will not be respected by the network.
 			return err
 		}
 
-		return cmds.EmitOnce(re, &Object{Hash: p.Cid().String()})
+		return cmds.EmitOnce(res, &Object{Hash: p.Cid().String()})
 	},
 	Type: &Object{},
 	Encoders: cmds.EncoderMap{
@@ -99,7 +81,7 @@ the limit will not be respected by the network.
 	},
 }
 
-var patchSetDataCmd = &oldcmds.Command{
+var patchSetDataCmd = &cmds.Command{
 	Helptext: cmdkit.HelpText{
 		Tagline: "Set the data field of an IPFS object.",
 		ShortDescription: `
@@ -114,36 +96,39 @@ Example:
 		cmdkit.StringArg("root", true, false, "The hash of the node to modify."),
 		cmdkit.FileArg("data", true, false, "The data to set the object to.").EnableStdin(),
 	},
-	Run: func(req oldcmds.Request, res oldcmds.Response) {
-		api, err := req.InvocContext().GetApi()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		api, err := cmdenv.GetApi(env)
+		if err != nil {
+			return err
+		}
 
-		root, err := coreiface.ParsePath(req.StringArguments()[0])
+		root, err := coreiface.ParsePath(req.Arguments[0])
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		data, err := req.Files().NextFile()
+		data, err := req.Files.NextFile()
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		p, err := api.Object().SetData(req.Context(), root, data)
+		p, err := api.Object().SetData(req.Context, root, data)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		res.SetOutput(&Object{Hash: p.Cid().String()})
+		return cmds.EmitOnce(res, &Object{Hash: p.Cid().String()})
 	},
 	Type: Object{},
-	Marshalers: oldcmds.MarshalerMap{
-		oldcmds.Text: objectMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error {
+			fmt.Fprintln(w, out.Hash)
+			return nil
+		}),
 	},
 }
 
-var patchRmLinkCmd = &oldcmds.Command{
+var patchRmLinkCmd = &cmds.Command{
 	Helptext: cmdkit.HelpText{
 		Tagline: "Remove a link from a given object.",
 		ShortDescription: `
@@ -154,35 +139,35 @@ Remove a Merkle-link from the given object and return the hash of the result.
 		cmdkit.StringArg("root", true, false, "The hash of the node to modify."),
 		cmdkit.StringArg("name", true, false, "Name of the link to remove."),
 	},
-	Run: func(req oldcmds.Request, res oldcmds.Response) {
-		api, err := req.InvocContext().GetApi()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		api, err := cmdenv.GetApi(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		root, err := coreiface.ParsePath(req.Arguments()[0])
+		root, err := coreiface.ParsePath(req.Arguments[0])
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		name := req.Arguments()[1]
-		p, err := api.Object().RmLink(req.Context(), root, name)
+		name := req.Arguments[1]
+		p, err := api.Object().RmLink(req.Context, root, name)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		res.SetOutput(&Object{Hash: p.Cid().String()})
+		return cmds.EmitOnce(res, &Object{Hash: p.Cid().String()})
 	},
 	Type: Object{},
-	Marshalers: oldcmds.MarshalerMap{
-		oldcmds.Text: objectMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error {
+			fmt.Fprintln(w, out.Hash)
+			return nil
+		}),
 	},
 }
 
-var patchAddLinkCmd = &oldcmds.Command{
+var patchAddLinkCmd = &cmds.Command{
 	Helptext: cmdkit.HelpText{
 		Tagline: "Add a link to a given object.",
 		ShortDescription: `
@@ -206,44 +191,42 @@ to a file containing 'bar', and returns the hash of the new object.
 	Options: []cmdkit.Option{
 		cmdkit.BoolOption("create", "p", "Create intermediary nodes."),
 	},
-	Run: func(req oldcmds.Request, res oldcmds.Response) {
-		api, err := req.InvocContext().GetApi()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		api, err := cmdenv.GetApi(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		root, err := coreiface.ParsePath(req.Arguments()[0])
+		root, err := coreiface.ParsePath(req.Arguments[0])
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		name := req.Arguments()[1]
+		name := req.Arguments[1]
 
-		child, err := coreiface.ParsePath(req.Arguments()[2])
+		child, err := coreiface.ParsePath(req.Arguments[2])
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		create, _, err := req.Option("create").Bool()
+		create, _ := req.Options["create"].(bool)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		p, err := api.Object().AddLink(req.Context(), root, name, child,
+		p, err := api.Object().AddLink(req.Context, root, name, child,
 			options.Object.Create(create))
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		res.SetOutput(&Object{Hash: p.Cid().String()})
+		return cmds.EmitOnce(res, &Object{Hash: p.Cid().String()})
 	},
 	Type: Object{},
-	Marshalers: oldcmds.MarshalerMap{
-		oldcmds.Text: objectMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error {
+			fmt.Fprintln(w, out.Hash)
+			return nil
+		}),
 	},
 }

core/commands/root.go

@@ -174,14 +174,14 @@ var rootROSubcommands = map[string]*cmds.Command{
 			"resolve": name.IpnsCmd,
 		},
 	},
-	"object": lgc.NewCommand(&oldcmds.Command{
-		Subcommands: map[string]*oldcmds.Command{
+	"object": {
+		Subcommands: map[string]*cmds.Command{
 			"data":  ocmd.ObjectDataCmd,
 			"links": ocmd.ObjectLinksCmd,
 			"get":   ocmd.ObjectGetCmd,
 			"stat":  ocmd.ObjectStatCmd,
 		},
-	}),
+	},
 	"dag": {
 		Subcommands: map[string]*cmds.Command{
 			"get":     dag.DagGetCmd,