exeggutor 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f12efae289d93904fde9c9f64edda09e2b085805969648d3345c4054597032fc
-  data.tar.gz: 35d7e49dd376fc0a03dc70c02b61c947bbbc0d27c0ba31c16250b4bce9332b74
+  metadata.gz: 8d90faa7fb5d339db88d49c085d3a878d92f274595ea95e5a0efead535b3ad48
+  data.tar.gz: 7291380ab60f90b974af5e7f32127d1cb45e567bb17455e9978e31ce166fe744
 SHA512:
-  metadata.gz: 9d627a0d4a40b7a235643f57a8a67836c9f016ff66c1473da7e629f30cbd2cb084ae91ed9a76fd8ac931f7fd95424331de6ebe8a5f918ac8eba48d425ccf261d
-  data.tar.gz: 16e0d72b24bc2b0da0a4522c0e90720eefbcf18c28cdae17daea1d9ad2bdc76880769040517763bdc90c2fd62df85ddbd4a6a183f2c44acadd185fc8f9e7392c
+  metadata.gz: 8f9d68fa39c285bf2d838331fe5ab795c8b606e1ebf694a0df42c1147b6d979d3080959b3c601eff396e04a2790e2e3540a7f8bb66e907bf54c602aacec9c719
+  data.tar.gz: 541d557d0340ede5b74a99e2200548ce253e155c7e8af9e55e57fecca5c7346b5cb74520ba83e995eec1d18683215bb64c93b6d0e3bf5fa93b68fde06d3a3814

data/lib/exeggutor.rb

@@ -2,9 +2,10 @@ require 'open3'
 require 'shellwords'
 
 module Exeggutor
+
   # A handle to a process, with IO handles to communicate with it
   # and a {ProcessResult} object when it's done. It's largely similar to the array
-  # of 4 values return by {Open3.popen3}. However, it doesn't suffer from that library's
+  # of 4 values return by Open3.popen3. However, it doesn't suffer from that library's
   # dead-locking issue. For example, even if lots of data has been written to stdout that hasn't been
   # read, the subprocess can still write to stdout and stderr without blocking
   class ProcessHandle
@@ -121,7 +122,7 @@ module Exeggutor
   # Represents an error that occurs during a process execution.
   # The error contains a {ProcessResult} object with details about the process.
   #
-  # @attr_reader result [ProcessResult] The result of the process execution.
+  # @attr_reader result {ProcessResult} The result of the process execution.
   class ProcessError < StandardError
     attr_reader :result
 
@@ -143,65 +144,6 @@ module Exeggutor
     end
   end
 
-  # @private
-  def self.exeg(args, can_fail: false, show_stdout: false, show_stderr: false, env: nil, chdir: nil, stdin_data: nil)
-    raise "args.size must be >= 1" if args.empty?
-
-    stdin_io, stdout_io, stderr_io, wait_thr = Exeggutor::run_popen3(args, env, chdir)
-    stdin_io.write(stdin_data) if stdin_data
-    stdin_io.close
-
-    # Make the streams as synchronous as possible, to minimize the possibility of a surprising lack
-    # of output
-    stdout_io.sync = true
-    stderr_io.sync = true
-
-    stdout = +''
-    stderr = +''
-
-    # Although there could be more code sharing between this and exeg_async, it would either complicate exeg_async's inner workings
-    # or force us to pay the same performance cost that exeg_async does
-    remaining_ios = [stdout_io, stderr_io]
-    while remaining_ios.size > 0
-      readable_ios, = IO.select(remaining_ios)
-      for readable_io in readable_ios
-        begin
-          data = readable_io.read_nonblock(100_000)
-          if readable_io == stdout_io
-            stdout << data
-            $stdout.print(data) if show_stdout
-          else
-            stderr << data
-            $stderr.print(data) if show_stderr
-          end
-        rescue IO::WaitReadable
-          # Shouldn't usually happen because IO.select indicated data is ready, but maybe due to EINTR or something
-          next
-        rescue EOFError
-          remaining_ios.delete(readable_io)
-        end
-      end
-    end
-
-    result = ProcessResult.new(
-      stdout: stdout,
-      stderr: stderr,
-      exit_code: wait_thr.value.exitstatus,
-      pid: wait_thr.pid
-    )
-    if !can_fail && !result.success?
-      error_str = <<~ERROR_STR
-        Command failed: #{args.shelljoin}
-        Exit code: #{result.exit_code}
-        stdout: #{result.stdout}
-        stderr: #{result.stderr}
-        pid: #{result.pid}
-      ERROR_STR
-      raise ProcessError.new(result), error_str
-    end
-
-    result
-  end
 end
 
 # Executes a command with the provided arguments and options. Waits for the process to finish.
@@ -215,11 +157,66 @@ end
 # @param env [Hash{String => String}, nil] A hashmap containing environment variable overrides,
 #        or `nil` if no overrides are desired
 #
-# @return [ProcessResult] An object containing process info such as stdout, stderr, and exit code. 
+# @return {ProcessResult} An object containing process info such as stdout, stderr, and exit code.
 #
-# @raise [ProcessError] If the command fails and `can_fail` is false.
-def exeg(...)
-  Exeggutor::exeg(...)
+# @raise {ProcessError} If the command fails and `can_fail` is false.
+def exeg(args, can_fail: false, show_stdout: false, show_stderr: false, env: nil, chdir: nil, stdin_data: nil)
+  raise "args.size must be >= 1" if args.empty?
+
+  stdin_io, stdout_io, stderr_io, wait_thr = Exeggutor::run_popen3(args, env, chdir)
+  stdin_io.write(stdin_data) if stdin_data
+  stdin_io.close
+
+  # Make the streams as synchronous as possible, to minimize the possibility of a surprising lack
+  # of output
+  stdout_io.sync = true
+  stderr_io.sync = true
+
+  stdout = +''
+  stderr = +''
+
+  # Although there could be more code sharing between this and exeg_async, it would either complicate exeg_async's inner workings
+  # or force us to pay the same performance cost that exeg_async does
+  remaining_ios = [stdout_io, stderr_io]
+  while remaining_ios.size > 0
+    readable_ios, = IO.select(remaining_ios)
+    for readable_io in readable_ios
+      begin
+        data = readable_io.read_nonblock(100_000)
+        if readable_io == stdout_io
+          stdout << data
+          $stdout.print(data) if show_stdout
+        else
+          stderr << data
+          $stderr.print(data) if show_stderr
+        end
+      rescue IO::WaitReadable
+        # Shouldn't usually happen because IO.select indicated data is ready, but maybe due to EINTR or something
+        next
+      rescue EOFError
+        remaining_ios.delete(readable_io)
+      end
+    end
+  end
+
+  result = ProcessResult.new(
+    stdout: stdout,
+    stderr: stderr,
+    exit_code: wait_thr.value.exitstatus,
+    pid: wait_thr.pid
+  )
+  if !can_fail && !result.success?
+    error_str = <<~ERROR_STR
+      Command failed: #{args.shelljoin}
+      Exit code: #{result.exit_code}
+      stdout: #{result.stdout}
+      stderr: #{result.stderr}
+      pid: #{result.pid}
+    ERROR_STR
+    raise ProcessError.new(result), error_str
+  end
+
+  result
 end
 
 # Executes a command with the provided arguments and options. Does not wait for the process to finish.
@@ -229,9 +226,7 @@ end
 # @param env [Hash{String => String}, nil] A hashmap containing environment variable overrides,
 #        or `nil` if no overrides are desired
 #
-# @return [ProcessHandle]
-#
-# @raise [ProcessError] If the command fails and `can_fail` is false.
-def exeg_async(...)
-  Exeggutor::ProcessHandle.new(...)
+# @return {ProcessHandle}
+def exeg_async(args, env: nil, chdir: nil)
+  Exeggutor::ProcessHandle.new(args, env: env, chdir: chdir)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exeggutor
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Michael Eisel