refactor: Exec.run return Result Type now

- With Exec::IO::MultiWriter we can print and get output both
- Improve Exec.each_line performance
- Update CI, remove spec random order option
- Update README

Author: initdc

.github/workflows/main.yml

@@ -35,4 +35,4 @@ jobs:
       - name: Check formatting
         run: crystal tool format --check
       - name: Run tests
-        run: crystal spec --order=random
+        run: crystal spec

README.md

@@ -9,8 +9,8 @@
    ```yaml
    dependencies:
      exec:
-       github: initdc/exec
-       version: 0.0.1
+       github: initdc/exec.cr
+       version: 0.2.0
    ```
 
 2. Run `shards install`

shard.yml

@@ -1,5 +1,5 @@
 name: exec
-version: 0.1.1
+version: 0.2.0
 
 authors:
   - initdc <initd@outlook.com>

spec/exec_spec.cr

@@ -21,6 +21,33 @@ describe Exec do
     Exec.output("uname").should eq "Linux"
   end
 
+  it "get Linux\n" do
+    Exec.run("uname").should eq "Linux\n"
+  end
+
+  it "looks like ruby Open3 when bad" do
+    r = Exec.run("echo good && echo bad >&2 && exit 1")
+    case r
+    when String
+      r.chomp.should eq "good"
+    else
+      o, e, s = r
+      o.chomp.should eq "good"
+      e.chomp.should eq "bad"
+      s.exit_code.should eq 1
+    end
+  end
+
+  it "looks like ruby IO.popen" do
+    r = Exec.run("bash") do |process|
+      process.input.puts "uname"
+      process.input.close
+      process.output.gets_to_end
+    end
+
+    r.should eq "Linux\n"
+  end
+
   it "get Linux\n" do
     Exec.output("uname", false).should eq "Linux\n"
   end

src/exec.cr

@@ -1,11 +1,47 @@
 class Exec < Process
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
+
+  class IO
+    class MultiWriter < ::IO::MultiWriter
+      alias IO = ::IO | ::IO::FileDescriptor | ::String::Builder
+
+      def read(slice : Bytes) : NoReturn
+        raise ::IO::Error.new("Can't read from IO::MultiWriter")
+      end
+    end
+  end
 
   def self.run(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = true,
-               input : Stdio = Redirect::Inherit, output : Stdio = Redirect::Inherit, error : Stdio = Redirect::Inherit, chdir : Path | String? = nil) : Process::Status
-    status = new(command, args, env, clear_env, shell, input, output, error, chdir).wait
+               input : Stdio = Redirect::Inherit, output : Stdio = Redirect::Inherit, error : Stdio = Redirect::Inherit, chdir : Path | String? = nil) : String | {String, String, Process::Status}
+    output_strio = String::Builder.new
+    error_strio = String::Builder.new
+
+    output_writer = if output.is_a?(Redirect)
+                      output == Redirect::Close ? output : Exec::IO::MultiWriter.new(STDOUT, output_strio)
+                    else
+                      Exec::IO::MultiWriter.new(STDOUT, output, output_strio)
+                    end
+
+    error_writer = if error.is_a?(Redirect)
+                     error == Redirect::Close ? error : Exec::IO::MultiWriter.new(STDERR, error_strio)
+                   else
+                     Exec::IO::MultiWriter.new(STDERR, error, error_strio)
+                   end
+
+    status = new(command, args, env, clear_env, shell, input, output_writer, error_writer, chdir).wait
     $? = status
-    status
+
+    output.close unless output.is_a?(Redirect)
+    error.close unless error.is_a?(Redirect)
+    output_strio.close
+    error_strio.close
+
+    case status.success?
+    when true
+      output_strio.to_s
+    else
+      {output_strio.to_s, error_strio.to_s, status}
+    end
   end
 
   def self.code(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = true,
@@ -26,14 +62,13 @@ class Exec < Process
     output
   end
 
-  def self.each_line(command, chomp = false, &block : String ->) : Nil
+  def self.each_line(command, chomp = false, & : String ->) : Nil
     process = new(command, shell: true, input: Redirect::Inherit, output: Redirect::Pipe, error: Redirect::Inherit)
-    output = process.output.gets_to_end
-    status = process.wait
-    $? = status
-    output.each_line(chomp) do |line|
+    process.output.each_line(chomp) do |line|
       yield line
     end
+    status = process.wait
+    $? = status
   end
 
   def self.each_line(command, chomp = false)