Add buffered combinedoutput (#76)

* updates to add combined output 2>&1 into the buffered stdout

updated options, logic, and tests to implement a redirection of all stderr into the stdout buffer that can be retrieve from the status object in the proper order.

* Update cmd_test.go

* Updated comment on BufferedCombined Option

* renamed BufferedCombined option to CombinedOutput

* add test for coverage and updated option name.

Author: jwomackgsa

cmd.go

@@ -5,33 +5,33 @@
 //
 // A basic example that runs env and prints its output:
 //
-//   import (
-//       "fmt"
-//       "github.com/go-cmd/cmd"
-//   )
+//	import (
+//	    "fmt"
+//	    "github.com/go-cmd/cmd"
+//	)
 //
-//   func main() {
-//       // Create Cmd, buffered output
-//       envCmd := cmd.NewCmd("env")
+//	func main() {
+//	    // Create Cmd, buffered output
+//	    envCmd := cmd.NewCmd("env")
 //
-//       // Run and wait for Cmd to return Status
-//       status := <-envCmd.Start()
+//	    // Run and wait for Cmd to return Status
+//	    status := <-envCmd.Start()
 //
-//       // Print each line of STDOUT from Cmd
-//       for _, line := range status.Stdout {
-//           fmt.Println(line)
-//       }
-//   }
+//	    // Print each line of STDOUT from Cmd
+//	    for _, line := range status.Stdout {
+//	        fmt.Println(line)
+//	    }
+//	}
 //
 // Commands can be ran synchronously (blocking) or asynchronously (non-blocking):
 //
-//   envCmd := cmd.NewCmd("env") // create
+//	envCmd := cmd.NewCmd("env") // create
 //
-//   status := <-envCmd.Start() // run blocking
+//	status := <-envCmd.Start() // run blocking
 //
-//   statusChan := envCmd.Start() // run non-blocking
-//   // Do other work while Cmd is running...
-//   status <- statusChan // blocking
+//	statusChan := envCmd.Start() // run non-blocking
+//	// Do other work while Cmd is running...
+//	status <- statusChan // blocking
 //
 // Start returns a channel to which the final Status is sent when the command
 // finishes for any reason. The first example blocks receiving on the channel.
@@ -111,9 +111,9 @@ var (
 // for any reason, this combination of values indicates success (presuming the
 // command only exits zero on success):
 //
-//   Exit     = 0
-//   Error    = nil
-//   Complete = true
+//	Exit     = 0
+//	Error    = nil
+//	Complete = true
 //
 // Error is a Go error from the underlying os/exec.Cmd.Start or os/exec.Cmd.Wait.
 // If not nil, the command either failed to start (it never ran) or it started
@@ -147,6 +147,12 @@ type Options struct {
 	// See Cmd.Status for more info.
 	Buffered bool
 
+	// If CombinedOutput is true, STDOUT and STDERR are written to Status.Stdout ONLY similar to 2>&1.
+	// If CombinedOutput is used at the same time as Buffered, CombinedOutput will take preference.
+	// Status.StdErr will be empty. The caller can call Cmd.Status to read output at intervals.
+	// See Cmd.Status for more info.
+	CombinedOutput bool
+
 	// If Streaming is true, Cmd.Stdout and Cmd.Stderr channels are created and
 	// STDOUT and STDERR output lines are written them in real time. This is
 	// faster and more efficient than polling Cmd.Status. The caller must read both
@@ -193,6 +199,11 @@ func NewCmdOptions(options Options, name string, args ...string) *Cmd {
 		c.stderrBuf = NewOutputBuffer()
 	}
 
+	if options.CombinedOutput {
+		c.stdoutBuf = NewOutputBuffer()
+		c.stderrBuf = nil
+	}
+
 	if options.Streaming {
 		c.Stdout = make(chan string, DEFAULT_STREAM_CHAN_SIZE)
 		c.stdoutStream = NewOutputStream(c.Stdout)
@@ -223,8 +234,9 @@ func NewCmdOptions(options Options, name string, args ...string) *Cmd {
 func (c *Cmd) Clone() *Cmd {
 	clone := NewCmdOptions(
 		Options{
-			Buffered:  c.stdoutBuf != nil,
-			Streaming: c.stdoutStream != nil,
+			Buffered:       c.stdoutBuf != nil,
+			CombinedOutput: c.stdoutBuf != nil,
+			Streaming:      c.stdoutStream != nil,
 		},
 		c.Name,
 		c.Args...,
@@ -246,13 +258,13 @@ func (c *Cmd) Clone() *Cmd {
 // can use to receive the final Status of the command when it ends. The caller
 // can start the command and wait like,
 //
-//   status := <-myCmd.Start() // blocking
+//	status := <-myCmd.Start() // blocking
 //
 // or start the command asynchronously and be notified later when it ends,
 //
-//   statusChan := myCmd.Start() // non-blocking
-//   // Do other work while Cmd is running...
-//   status := <-statusChan // blocking
+//	statusChan := myCmd.Start() // non-blocking
+//	// Do other work while Cmd is running...
+//	status := <-statusChan // blocking
 //
 // Exactly one Status is sent on the channel when the command ends. The channel
 // is not closed. Any Go error is set to Status.Error. Start is idempotent; it
@@ -320,9 +332,9 @@ func (c *Cmd) Stop() error {
 // as of the Status call time. For example, if the command counts to 3 and three
 // calls are made between counts, Status.Stdout contains:
 //
-//   "1"
-//   "1 2"
-//   "1 2 3"
+//	"1"
+//	"1 2"
+//	"1 2 3"
 //
 // The caller is responsible for tailing the buffered output if needed. Else,
 // consider using streaming output. When the command finishes, buffered output
@@ -344,9 +356,12 @@ func (c *Cmd) Status() Status {
 		if !c.final {
 			if c.stdoutBuf != nil {
 				c.status.Stdout = c.stdoutBuf.Lines()
-				c.status.Stderr = c.stderrBuf.Lines()
 				c.stdoutBuf = nil // release buffers
-				c.stderrBuf = nil
+
+			}
+			if c.stderrBuf != nil {
+				c.status.Stderr = c.stderrBuf.Lines()
+				c.stderrBuf = nil // release buffers
 			}
 			c.final = true
 		}
@@ -355,6 +370,9 @@ func (c *Cmd) Status() Status {
 		c.status.Runtime = time.Now().Sub(c.startTime).Seconds()
 		if c.stdoutBuf != nil {
 			c.status.Stdout = c.stdoutBuf.Lines()
+
+		}
+		if c.stderrBuf != nil {
 			c.status.Stderr = c.stderrBuf.Lines()
 		}
 	}
@@ -391,12 +409,19 @@ func (c *Cmd) run(in io.Reader) {
 	// Set exec.Cmd.Stdout and .Stderr to our concurrent-safe stdout/stderr
 	// buffer, stream both, or neither
 	switch {
-	case c.stdoutBuf != nil && c.stdoutStream != nil: // buffer and stream
+
+	case c.stdoutBuf != nil && c.stderrBuf != nil && c.stdoutStream != nil: // buffer and stream
 		cmd.Stdout = io.MultiWriter(c.stdoutStream, c.stdoutBuf)
 		cmd.Stderr = io.MultiWriter(c.stderrStream, c.stderrBuf)
-	case c.stdoutBuf != nil: // buffer only
+	case c.stdoutBuf != nil && c.stderrBuf == nil && c.stdoutStream != nil: // combined buffer and stream
+		cmd.Stdout = io.MultiWriter(c.stdoutStream, c.stdoutBuf)
+		cmd.Stderr = io.MultiWriter(c.stderrStream, c.stdoutBuf)
+	case c.stdoutBuf != nil && c.stderrBuf != nil: // buffer only
 		cmd.Stdout = c.stdoutBuf
 		cmd.Stderr = c.stderrBuf
+	case c.stdoutBuf != nil && c.stderrBuf == nil: // buffer combining stderr into stdout
+		cmd.Stdout = c.stdoutBuf
+		cmd.Stderr = c.stdoutBuf
 	case c.stdoutStream != nil: // stream only
 		cmd.Stdout = c.stdoutStream
 		cmd.Stderr = c.stderrStream
@@ -521,11 +546,11 @@ func (c *Cmd) run(in io.Reader) {
 // default when created by calling NewCmd. To use OutputBuffer directly with
 // a Go standard library os/exec.Command:
 //
-//   import "os/exec"
-//   import "github.com/go-cmd/cmd"
-//   runnableCmd := exec.Command(...)
-//   stdout := cmd.NewOutputBuffer()
-//   runnableCmd.Stdout = stdout
+//	import "os/exec"
+//	import "github.com/go-cmd/cmd"
+//	runnableCmd := exec.Command(...)
+//	stdout := cmd.NewOutputBuffer()
+//	runnableCmd.Stdout = stdout
 //
 // While runnableCmd is running, call stdout.Lines() to read all output
 // currently written.
@@ -613,20 +638,19 @@ func (e ErrLineBufferOverflow) Error() string {
 // created by calling NewCmdOptions and Options.Streaming is true. To use
 // OutputStream directly with a Go standard library os/exec.Command:
 //
-//   import "os/exec"
-//   import "github.com/go-cmd/cmd"
-//
-//   stdoutChan := make(chan string, 100)
-//   go func() {
-//       for line := range stdoutChan {
-//           // Do something with the line
-//       }
-//   }()
+//	import "os/exec"
+//	import "github.com/go-cmd/cmd"
 //
-//   runnableCmd := exec.Command(...)
-//   stdout := cmd.NewOutputStream(stdoutChan)
-//   runnableCmd.Stdout = stdout
+//	stdoutChan := make(chan string, 100)
+//	go func() {
+//	    for line := range stdoutChan {
+//	        // Do something with the line
+//	    }
+//	}()
 //
+//	runnableCmd := exec.Command(...)
+//	stdout := cmd.NewOutputStream(stdoutChan)
+//	runnableCmd.Stdout = stdout
 //
 // While runnableCmd is running, lines are sent to the channel as soon as they
 // are written and newline-terminated by the command.