refactor: Process.run return Result Type now

- Use output: error: instead of out: err:
- MultiIO not add STDOUT twice

Author: initdc

.rubocop.yml

@@ -10,5 +10,14 @@ Metrics/BlockLength:
 Metrics/AbcSize:
   Enabled: false
 
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
 Style/ConditionalAssignment:
   Enabled: false
+
+Style/GlobalStdStream:
+  Enabled: false

lib/rb/process.rb

@@ -1,31 +1,75 @@
 # frozen_string_literal: true
 
 require "multi_io"
+require "stringio"
 require_relative "process/version"
 
 module Process
-  def self.run(*args, log_file: nil, **options)
-    if log_file && !log_file.is_a?(File)
-      raise ArgumentError.new("log_file must be a File with mode")
-    end
+  def self.run(*args, output: STDOUT, error: STDERR, **options)
+    output_strio = StringIO.new
+    error_strio = StringIO.new
 
-    mio = log_file ? MultiIO.new($stdout, log_file) : $stdout
-    result = String.new
+    output_writter = if !output.is_a?(IO)
+                       output
+                     elsif output != STDOUT
+                       MultiIO.new(STDOUT, output, output_strio)
+                     else
+                       MultiIO.new(STDOUT, output_strio)
+                     end
+    error_writter = if !error.is_a?(IO)
+                      error
+                    elsif error != STDERR
+                      MultiIO.new(STDERR, error, error_strio)
+                    else
+                      MultiIO.new(STDERR, error_strio)
+                    end
 
-    IO.popen(*args, **options) do |pipe|
-      if block_given?
-        yield pipe
-        pipe.close_write
-      end
-      while !pipe.eof
-        line = pipe.gets
-        mio.write(line)
-        result << line
+    # spawn don't support MultiIO nor StringIO
+    in_r, in_w = IO.pipe
+    out_r, out_w = IO.pipe
+    err_r, err_w = IO.pipe
+
+    # override the options, so put the option after the options
+    pid = spawn(*args, **options, in: in_r, out: out_w, err: err_w)
+
+    if block_given?
+      begin
+        yield in_w, out_r, err_r
+      rescue StandardError => e
+        Process.detach(pid)
+        raise e
       end
     end
 
-    log_file.close if log_file
-    result
+    in_w.close
+    out_w.close
+    err_w.close
+
+    out_r.each_line do |line|
+      output_writter.write(line)
+    end
+
+    err_r.each_line do |line|
+      error_writter.write(line)
+    end
+
+    in_r.close
+    out_r.close
+    err_r.close
+
+    pid, status = Process.wait2(pid)
+
+    output.close unless !output.is_a?(IO) || output == STDOUT
+    error.close unless !error.is_a?(IO) || error == STDERR
+    output_strio.close
+    error_strio.close
+
+    case status.success?
+    when true
+      output_strio.string
+    else
+      [output_strio.string, error_strio.string, status]
+    end
   end
 
   def self.output(...)

spec/rb/process_spec.rb

@@ -15,6 +15,23 @@
     expect(Process.run("uname")).to eq "Linux\n"
   end
 
+  it "print once Linux\n" do
+    expect(Process.run("uname", output: STDOUT)).to eq "Linux\n"
+  end
+
+  it "looks like ruby Open3 when bad" do
+    r = Process.run("echo good && echo bad >&2 && exit 1")
+    case r
+    when String
+      expect(r.chomp).to eq "good"
+    else
+      o, e, s = r
+      expect(o.chomp).to eq "good"
+      expect(e.chomp).to eq "bad"
+      expect(s.exitstatus).to eq 1
+    end
+  end
+
   it "get the output and not print" do
     expect(Process.output("uname").chomp).to eq "Linux"
   end
@@ -28,12 +45,12 @@
   end
 
   it "answer with cmd with ruby style" do
-    expect(Process.run("bash", "r+") { |pipe| pipe.puts "uname" }).to eq "Linux\n"
+    expect(Process.run("bash") { |i, _o, _e| i.puts "uname" }).to eq "Linux\n"
   end
 
   it "print and also log to file" do
     tempfile = Tempfile.new(["test_", ".log"])
-    Process.run("uname", log_file: File.open(tempfile.path, "w"))
+    Process.run("uname", output: File.open(tempfile.path, "w"))
 
     expect(tempfile.readlines).to eq ["Linux\n"]
     tempfile.delete