Save both STDOUT and STDERR when possible

Create an Output object that stores the returned output and error
streams from the executed commands. Because only Process.spawn and
Posix.spawn use pipes like this, they are the only two Runners that can
handle capturing both STDOUT and STDERR. The PopenRunner can only handle
one pipe, and backticks can only report on STDOUT.

lib/cocaine.rb

@@ -3,6 +3,8 @@
 require 'rbconfig'
 require 'cocaine/os_detector'
 require 'cocaine/command_line'
+require 'cocaine/command_line/output'
+require 'cocaine/command_line/multi_pipe'
 require 'cocaine/command_line/runners'
 require 'cocaine/exceptions'
 

lib/cocaine/command_line.rb

@@ -67,12 +67,11 @@ def command(interpolations = {})
  end
 
  def run(interpolations = {})
- output = ''
  @exit_status = nil
  begin
  full_command = command(interpolations)
  log("#{colored("Command")} :: #{full_command}")
- output = execute(full_command)
+ @output = execute(full_command)
  rescue Errno::ENOENT => e
  raise Cocaine::CommandNotFoundError, e.message
  ensure
@@ -86,12 +85,24 @@ def run(interpolations = {})
  unless @expected_outcodes.include?(@exit_status)
  message = [
  "Command '#{full_command}' returned #{@exit_status}. Expected #{@expected_outcodes.join(", ")}",
- "Here is the command output:\n",
- output
+ "Here is the command output: STDOUT:\n", command_output,
+ "\nSTDERR:\n", command_error_output
  ].join("\n")
  raise Cocaine::ExitStatusError, message
  end
- output
+ command_output
+ end
+
+ def command_output
+ output.output
+ end
+
+ def command_error_output
+ output.error_output
+ end
+
+ def output
+ @output || Output.new
  end
 
  private

lib/cocaine/command_line/multi_pipe.rb

@@ -0,0 +1,50 @@
+module Cocaine
+ class CommandLine
+ class MultiPipe
+ def initialize
+ @stdout_in, @stdout_out = IO.pipe
+ @stderr_in, @stderr_out = IO.pipe
+ end
+
+ def pipe_options
+ { out: @stdout_out, err: @stderr_out }
+ end
+
+ def output
+ Output.new(@stdout_output, @stderr_output)
+ end
+
+ def read_and_then(&block)
+ close_write
+ read
+ block.call
+ close_read
+ end
+
+ private
+
+ def close_write
+ @stdout_out.close
+ @stderr_out.close
+ end
+
+ def read
+ @stdout_output = read_stream(@stdout_in)
+ @stderr_output = read_stream(@stderr_in)
+ end
+
+ def close_read
+ @stdout_in.close
+ @stderr_in.close
+ end
+
+ def read_stream(io)
+ result = ""
+ while partial_result = io.read(8192)
+ result << partial_result
+ end
+ result
+ end
+ end
+ end
+end

lib/cocaine/command_line/output.rb

@@ -0,0 +1,12 @@
+class Cocaine::CommandLine::Output
+ def initialize(output = nil, error_output = nil)
+ @output = output
+ @error_output = error_output
+ end
+
+ attr_reader :output, :error_output
+
+ def to_s
+ output.to_s
+ end
+end

lib/cocaine/command_line/runners/backticks_runner.rb

@@ -15,7 +15,7 @@ def supported?
 
  def call(command, env = {}, options = {})
  with_modified_environment(env) do
- `#{command}`
+ Output.new(`#{command}`)
  end
  end
 

lib/cocaine/command_line/runners/fake_runner.rb

@@ -19,13 +19,12 @@ def initialize
 
  def call(command, env = {}, options = {})
  commands << [command, env]
- ""
+ Output.new("")
  end
 
  def ran?(predicate_command)
- @commands.any?{|(command, env)| command =~ Regexp.new(predicate_command) }
+ @commands.any?{|(command, _)| command =~ Regexp.new(predicate_command) }
  end
-
  end
  end
 end

lib/cocaine/command_line/runners/popen_runner.rb

@@ -14,7 +14,7 @@ def supported?
  def call(command, env = {}, options = {})
  with_modified_environment(env) do
  IO.popen(command, "r", options) do |pipe|
- pipe.read
+ Output.new(pipe.read)
  end
  end
  end

lib/cocaine/command_line/runners/posix_runner.rb

@@ -18,17 +18,12 @@ def supported?
  end
 
  def call(command, env = {}, options = {})
- input, output = IO.pipe
- options[:out] = output
- pid = spawn(env, command, options)
- output.close
- result = ""
- while partial_result = input.read(8192)
- result << partial_result
+ pipe = MultiPipe.new
+ pid = spawn(env, command, options.merge(pipe.pipe_options))
+ pipe.read_and_then do
+ waitpid(pid)
  end
- waitpid(pid)
- input.close
- result
+ pipe.output
  end
 
  private

lib/cocaine/command_line/runners/process_runner.rb

@@ -16,14 +16,12 @@ def supported?
  end
 
  def call(command, env = {}, options = {})
- input, output = IO.pipe
- options[:out] = output
- pid = spawn(env, command, options)
- output.close
- result = input.read
- waitpid(pid)
- input.close
- result
+ pipe = MultiPipe.new
+ pid = spawn(env, command, options.merge(pipe.pipe_options))
+ pipe.read_and_then do
+ waitpid(pid)
+ end
+ pipe.output
  end
 
  private

spec/cocaine/command_line/output_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Cocaine::CommandLine::Output do
+ it 'holds an input and error stream' do
+ output = Cocaine::CommandLine::Output.new(:a, :b)
+ expect(output.output).to eq :a
+ expect(output.error_output).to eq :b
+ end
+
+ it 'calls #to_s on the output when you call #to_s on it' do
+ output = Cocaine::CommandLine::Output.new(:a, :b)
+ expect(output.to_s).to eq 'a'
+ end
+end

spec/cocaine/command_line/runners/backticks_runner_spec.rb

@@ -4,12 +4,14 @@
  if Cocaine::CommandLine::BackticksRunner.supported?
  it_behaves_like 'a command that does not block'
 
- it 'runs the command given' do
- subject.call("echo hello").should == "hello\n"
+ it 'runs the command given and captures the output in an Output' do
+ output = subject.call("echo hello")
+ expect(output).to have_output "hello\n"
  end
 
  it 'modifies the environment and runs the command given' do
- subject.call("echo $yes", {"yes" => "no"}).should == "no\n"
+ output = subject.call("echo $yes", {"yes" => "no"})
+ expect(output).to have_output "no\n"
  end
 
  it 'sets the exitstatus when a command completes' do

spec/cocaine/command_line/runners/popen_runner_spec.rb

@@ -4,12 +4,14 @@
  if Cocaine::CommandLine::PopenRunner.supported?
  it_behaves_like 'a command that does not block'
 
- it 'runs the command given' do
- subject.call("echo hello").should == "hello\n"
+ it 'runs the command given and captures the output in an Output' do
+ output = subject.call("echo hello")
+ expect(output).to have_output "hello\n"
  end
 
  it 'modifies the environment and runs the command given' do
- subject.call("echo $yes", {"yes" => "no"}).should == "no\n"
+ output = subject.call("echo $yes", {"yes" => "no"})
+ expect(output).to have_output "no\n"
  end
 
  it 'sets the exitstatus when a command completes' do

spec/cocaine/command_line/runners/posix_runner_spec.rb

@@ -4,12 +4,19 @@
  if Cocaine::CommandLine::PosixRunner.supported?
  it_behaves_like 'a command that does not block'
 
- it 'runs the command given' do
- subject.call("echo hello").should == "hello\n"
+ it 'runs the command given and captures the output' do
+ output = subject.call("echo hello")
+ expect(output).to have_output "hello\n"
+ end
+
+ it 'runs the command given and captures the error output' do
+ output = subject.call("echo hello 1>&2")
+ expect(output).to have_error_output "hello\n"
  end
 
  it 'modifies the environment and runs the command given' do
- subject.call("echo $yes", {"yes" => "no"}).should == "no\n"
+ output = subject.call("echo $yes", {"yes" => "no"})
+ expect(output).to have_output "no\n"
  end
 
  it 'sets the exitstatus when a command completes' do

spec/cocaine/command_line/runners/process_runner_spec.rb

@@ -4,12 +4,19 @@
  if Cocaine::CommandLine::ProcessRunner.supported?
  it_behaves_like "a command that does not block"
 
- it 'runs the command given' do
- subject.call("echo hello").should == "hello\n"
+ it 'runs the command given and captures the output' do
+ output = subject.call("echo hello")
+ expect(output).to have_output "hello\n"
+ end
+
+ it 'runs the command given and captures the error output' do
+ output = subject.call("echo hello 1>&2")
+ expect(output).to have_error_output "hello\n"
  end
 
  it 'modifies the environment and runs the command given' do
- subject.call("echo $yes", {"yes" => "no"}).should == "no\n"
+ output = subject.call("echo $yes", {"yes" => "no"})
+ expect(output).to have_output "no\n"
  end
 
  it 'sets the exitstatus when a command completes' do

spec/cocaine/command_line_spec.rb

@@ -149,12 +149,26 @@
  cmd.command.should == "convert a.jpg b.png 2>NUL"
  end
 
- it "runs the command it's given and return the output" do
- cmd = Cocaine::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
- cmd.stubs(:execute).with("convert a.jpg b.png").returns(:correct_value)
- with_exitstatus_returning(0) do
- cmd.run.should == :correct_value
- end
+ it "runs the command it's given and returns the output" do
+ cmd = Cocaine::CommandLine.new("echo", "hello", :swallow_stderr => false)
+ expect(cmd.run).to eq "hello\n"
+ end
+
+ it "runs the command it's given and allows access to stdout afterwards" do
+ cmd = Cocaine::CommandLine.new("echo", "hello", :swallow_stderr => false)
+ cmd.run
+ expect(cmd.command_output).to eq "hello\n"
+ end
+
+ it "runs the command it's given and allows access to stderr afterwards" do
+ cmd = Cocaine::CommandLine.new(
+ "ruby",
+ "-e '$stdout.puts %{hello}; $stderr.puts %{goodbye}'",
+ :swallow_stderr => false
+ )
+ cmd.run
+ expect(cmd.command_output).to eq "hello\n"
+ expect(cmd.command_error_output).to eq "goodbye\n"
  end
 
  it "colorizes the output to a tty" do

spec/cocaine/errors_spec.rb

@@ -1,47 +1,40 @@
 require 'spec_helper'
 
 describe "When an error happens" do
- it "raises a CommandLineError if the result code from the command isn't expected" do
- cmd = Cocaine::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
- cmd.stubs(:execute).with("convert a.jpg b.png").returns(:correct_value)
+ it "raises a CommandLineError if the result code command isn't expected" do
+ cmd = Cocaine::CommandLine.new("echo", "hello")
+ cmd.stubs(:execute)
  with_exitstatus_returning(1) do
- lambda do
- cmd.run
- end.should raise_error(Cocaine::CommandLineError)
+ lambda { cmd.run }.should raise_error(Cocaine::CommandLineError)
  end
  end
 
  it "does not raise if the result code is expected, even if nonzero" do
- cmd = Cocaine::CommandLine.new("convert",
- "a.jpg b.png",
- :expected_outcodes => [0, 1],
- :swallow_stderr => false)
- cmd.stubs(:execute).with("convert a.jpg b.png").returns(:correct_value)
+ cmd = Cocaine::CommandLine.new("echo", "hello", expected_outcodes: [0, 1])
+ cmd.stubs(:execute)
  with_exitstatus_returning(1) do
- lambda do
- cmd.run
- end.should_not raise_error
+ lambda { cmd.run }.should_not raise_error
  end
  end
 
  it "adds command output to exception message if the result code is nonzero" do
- cmd = Cocaine::CommandLine.new("convert",
- "a.jpg b.png",
- :swallow_stderr => false)
+ cmd = Cocaine::CommandLine.new("echo", "hello")
  error_output = "Error 315"
- cmd.stubs(:execute).with("convert a.jpg b.png").returns(error_output)
+ cmd.
+ stubs(:execute).
+ returns(Cocaine::CommandLine::Output.new("", error_output))
  with_exitstatus_returning(1) do
  begin
  cmd.run
  rescue Cocaine::ExitStatusError => e
- e.message.should =~ /#{error_output}/
+ e.message.should =~ /STDERR:\s+#{error_output}/
  end
  end
  end
 
- it 'passes error message to the exception when command fails with Errno::ENOENT' do
+ it 'passes the error message to the exception when command is not found' do
  cmd = Cocaine::CommandLine.new('test', '')
- cmd.stubs(:execute).with('test').raises(Errno::ENOENT.new("not found"))
+ cmd.stubs(:execute).raises(Errno::ENOENT.new("not found"))
  begin
  cmd.run
  rescue Cocaine::CommandNotFoundError => e
@@ -58,7 +51,7 @@
  cmd.exit_status.should == 1
  end
 
- it "does not blow up if running the command errored before the actual execution" do
+ it "does not blow up if running the command errored before execution" do
  assuming_no_processes_have_been_run
  command = Cocaine::CommandLine.new("echo", ":hello_world")
  command.stubs(:command).raises("An Error")