Post-run emitter helper

- When both PostRun (output transformer) and DisplayCLI (terminal output) are present, ensure that both are run.

`EmitResponse` helper in executor.go is invoked by both local and HTTP client executors: the client fibs the command.Run interface via anonymous function.

Author: jbouwman

Diff for: examples/adder/cmd.go

@@ -93,7 +93,7 @@ var RootCmd = &cmds.Command{
 				}),
 			},
 		},
-		// the best UX
+		// using stdio via PostRun
 		"postRunAdd": {
 			Arguments: []cmds.Argument{
 				cmds.StringArg("summands", true, true, "values that are supposed to be summed"),
@@ -151,6 +151,140 @@ var RootCmd = &cmds.Command{
 				},
 			},
 		},
+		// DisplayCLI for terminal control
+		"displayCliAdd": {
+			Arguments: []cmds.Argument{
+				cmds.StringArg("summands", true, true, "values that are supposed to be summed"),
+			},
+			// this is the same as for encoderAdd
+			Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
+				sum := 0
+
+				for i, str := range req.Arguments {
+					num, err := strconv.Atoi(str)
+					if err != nil {
+						return err
+					}
+
+					sum += num
+					err = re.Emit(&AddStatus{
+						Current: sum,
+						Left:    len(req.Arguments) - i - 1,
+					})
+					if err != nil {
+						return err
+					}
+
+					time.Sleep(200 * time.Millisecond)
+				}
+				return nil
+			},
+			Type: &AddStatus{},
+			DisplayCLI: func(res cmds.Response, stdout, stderr io.Writer) error {
+				defer fmt.Fprintln(stdout)
+
+				// length of line at last iteration
+				var lastLen int
+
+				for {
+					v, err := res.Next()
+					if err == io.EOF {
+						return nil
+					}
+					if err != nil {
+						return err
+					}
+
+					fmt.Fprint(stdout, "\r" + strings.Repeat(" ", lastLen))
+
+					s := v.(*AddStatus)
+					if s.Left > 0 {
+						lastLen, _ = fmt.Fprintf(stdout, "\rcalculation sum... current: %d; left: %d", s.Current, s.Left)
+					} else {
+						lastLen, _ = fmt.Fprintf(stdout, "\rsum is %d.", s.Current)
+					}
+				}
+			},
+		},
+		// PostRun and DisplayCLI: PostRun intercepts and doubles the sum
+		"defectiveAdd": {
+			Arguments: []cmds.Argument{
+				cmds.StringArg("summands", true, true, "values that are supposed to be summed"),
+			},
+			// this is the same as for encoderAdd
+			Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
+				sum := 0
+
+				for i, str := range req.Arguments {
+					num, err := strconv.Atoi(str)
+					if err != nil {
+						return err
+					}
+
+					sum += num
+					err = re.Emit(&AddStatus{
+						Current: sum,
+						Left:    len(req.Arguments) - i - 1,
+					})
+					if err != nil {
+						return err
+					}
+
+					time.Sleep(200 * time.Millisecond)
+				}
+				return nil
+			},
+			Type: &AddStatus{},
+			PostRun: cmds.PostRunMap{
+				cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
+					defer re.Close()
+
+					for {
+						v, err := res.Next()
+						if err == io.EOF {
+							return nil
+						}
+						if err != nil {
+							return err
+						}
+
+						s := v.(*AddStatus)
+						err = re.Emit(&AddStatus{
+							Current: s.Current + s.Current,
+							Left:    s.Left,
+						})
+						if err != nil {
+							return err
+						}
+					}
+				},
+			},
+			DisplayCLI: func(res cmds.Response, stdout, stderr io.Writer) error {
+				defer fmt.Fprintln(stdout)
+
+				// length of line at last iteration
+				var lastLen int
+
+				for {
+					v, err := res.Next()
+					if err == io.EOF {
+						return nil
+					}
+					if err != nil {
+						return err
+					}
+
+					fmt.Fprint(stdout, "\r" + strings.Repeat(" ", lastLen))
+
+					s := v.(*AddStatus)
+					if s.Left > 0 {
+						lastLen, _ = fmt.Fprintf(stdout, "\rcalculation sum... current: %d; left: %d", s.Current, s.Left)
+					} else {
+						lastLen, _ = fmt.Fprintf(stdout, "\rsum is %d.", s.Current)
+					}
+				}
+			},
+		},
 		// how to set program's return value
 		"exitAdd": {
 			Arguments: []cmds.Argument{

Diff for: examples/adder/local/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"os"
 
 	"github.com/ipfs/go-ipfs-cmds/examples/adder"
@@ -26,29 +25,11 @@ func main() {
 		panic(err)
 	}
 
-	wait := make(chan struct{})
-	var re cmds.ResponseEmitter = cliRe
-	if pr, ok := req.Command.PostRun[cmds.CLI]; ok {
-		var (
-			res   cmds.Response
-			lower = re
-		)
-
-		re, res = cmds.NewChanResponsePair(req)
-
-		go func() {
-			defer close(wait)
-			err := pr(res, lower)
-			if err != nil {
-				fmt.Println("error: ", err)
-			}
-		}()
-	} else {
-		close(wait)
+	exec := cmds.NewExecutor(adder.RootCmd)
+	err = exec.Execute(req, cliRe, nil)
+	if err != nil {
+		panic(err)
 	}
 
-	adder.RootCmd.Call(req, re, nil)
-	<-wait
-
 	os.Exit(cliRe.Status())
 }

Diff for: executor.go

@@ -33,14 +33,6 @@ type executor struct {
 	root *Command
 }
 
-type emitterEncoder struct {
-	emitter ResponseEmitter
-}
-
-func (enc *emitterEncoder) Encode(value interface{}) error {
-	return enc.emitter.Emit(value)
-}
-
 func (x *executor) Execute(req *Request, re ResponseEmitter, env Environment) error {
 	cmd := req.Command
 
@@ -59,19 +51,44 @@ func (x *executor) Execute(req *Request, re ResponseEmitter, env Environment) er
 			return err
 		}
 	}
+
+	return EmitResponse(cmd.Run, req, re, env)
+}
+
+// Helper for Execute that handles post-Run emitter logic
+func EmitResponse(run Function, req *Request, re ResponseEmitter, env Environment) error {
+
+	// Keep track of the lowest emitter to select the correct
+	// PostRun method.
+	lowest := re
+	cmd := req.Command
+
+	// contains the error returned by DisplayCLI or PostRun
+	errCh := make(chan error, 1)
+
+	if cmd.DisplayCLI != nil && GetEncoding(req, "json") == "text" {
+		var res Response
+
+		// This overwrites the emitter provided as an
+		// argument. Maybe it's better to provide the
+		// 'DisplayCLI emitter' as an argument to Execute.
+		re, res = NewChanResponsePair(req)
+
+		go func() {
+			defer close(errCh)
+			errCh <- cmd.DisplayCLI(res, os.Stdout, os.Stderr)
+		}()
+	}
+
+
 	maybeStartPostRun := func(formatters PostRunMap) <-chan error {
 		var (
 			postRun   func(Response, ResponseEmitter) error
 			postRunCh = make(chan error)
 		)
 
-		if postRun == nil {
-			close(postRunCh)
-			return postRunCh
-		}
-
 		// check if we have a formatter for this emitter type
-		typer, isTyper := re.(interface {
+		typer, isTyper := lowest.(interface {
 			Type() PostRunType
 		})
 		if isTyper &&
@@ -97,7 +114,7 @@ func (x *executor) Execute(req *Request, re ResponseEmitter, env Environment) er
 	}
 
 	postRunCh := maybeStartPostRun(cmd.PostRun)
-	runCloseErr := re.CloseWithError(cmd.Run(req, re, env))
+	runCloseErr := re.CloseWithError(run(req, re, env))
 	postCloseErr := <-postRunCh
 	switch runCloseErr {
 	case ErrClosingClosedEmitter, nil:

Diff for: http/client.go

@@ -7,7 +7,6 @@ import (
 	"net"
 	"net/http"
 	"net/url"
-	"os"
 	"strings"
 
 	"github.com/ipfs/go-ipfs-cmds"
@@ -118,27 +117,11 @@ func (c *client) Execute(req *cmds.Request, re cmds.ResponseEmitter, env cmds.En
 		return err
 	}
 
-	if cmd.PostRun != nil {
-		if typer, ok := re.(interface {
-			Type() cmds.PostRunType
-		}); ok && cmd.PostRun[typer.Type()] != nil {
-			err := cmd.PostRun[typer.Type()](res, re)
-			closeErr := re.CloseWithError(err)
-			if closeErr == cmds.ErrClosingClosedEmitter {
-				// ignore double close errors
-				return nil
-			}
-
-			return closeErr
-		}
-	}
-
-	if cmd.DisplayCLI != nil &&
-		cmds.GetEncoding(req, cmds.Undefined) == cmds.Text {
-		return cmd.DisplayCLI(res, os.Stdout, os.Stderr)
+	copy := func(_ *cmds.Request, re cmds.ResponseEmitter, _ cmds.Environment) error {
+		return cmds.Copy(re, res)
 	}
 
-	return cmds.Copy(re, res)
+	return cmds.EmitResponse(copy, req, re, env)
 }
 
 func (c *client) toHTTPRequest(req *cmds.Request) (*http.Request, error) {