ruby-sh 2.1.4 → 3.0.0

data/lib/rubsh/running_command.rb

@@ -1,5 +1,3 @@
-require "timeout"
-
 module Rubsh
   class RunningCommand
     SPECIAL_KWARGS = %i[
@@ -20,15 +18,6 @@ module Rubsh
       _no_err
       _long_sep
       _long_prefix
-      _pipeline
-    ]
-
-    SPECIAL_KWARGS_WITHIN_PIPELINE = %i[
-      _env
-      _cwd
-      _long_sep
-      _long_prefix
-      _pipeline
     ]
 
     # @!attribute [r] pid
@@ -39,6 +28,14 @@ module Rubsh
     # @return [Number]
     attr_reader :exit_code
 
+    # @!attribute [r] started_at
+    # @return [Time]
+    attr_reader :started_at
+
+    # @!attribute [r] finished_at
+    # @return [Time]
+    attr_reader :finished_at
+
     # @!attribute [r] stdout_data
     # @return [String]
     attr_reader :stdout_data
@@ -47,8 +44,7 @@ module Rubsh
     # @return [String]
     attr_reader :stderr_data
 
-    def initialize(sh, prog, progpath, *args, **kwargs)
-      @sh = sh
+    def initialize(prog, progpath, *args, **kwargs)
       @prog = prog
       @progpath = progpath
       @args = []
@@ -57,6 +53,8 @@ module Rubsh
       @prog_with_args = nil
       @pid = nil
       @exit_code = nil
+      @started_at = nil
+      @finished_at = nil
       @stdout_data = "".force_encoding(::Encoding.default_external)
       @stderr_data = "".force_encoding(::Encoding.default_external)
       @in_rd = nil
@@ -93,9 +91,6 @@ module Rubsh
       @_long_sep = "="
       @_long_prefix = "--"
 
-      # Special Kwargs - Misc
-      @_pipeline = nil
-
       opts = []
       args.each do |arg|
         if arg.is_a?(::Hash)
@@ -105,92 +100,43 @@ module Rubsh
         end
       end
       kwargs.each { |k, v| opts << Option.build(k, v) }
-      validate_opts(opts)
       extract_opts(opts)
     end
 
-    # @return [void]
-    def wait(timeout: nil)
-      timeout_occurred = false
-      _, status = nil, nil
-
-      if timeout
-        begin
-          ::Timeout.timeout(timeout) { _, status = ::Process.wait2(@pid) }
-        rescue ::Timeout::Error
-          timeout_occurred = true
-
-          ::Process.kill("TERM", @pid) # graceful stop
-          30.times do
-            _, status = ::Process.wait2(@pid, ::Process::WNOHANG | ::Process::WUNTRACED)
-            break if status
-            sleep 0.1
-          end
-          failure = @pid if status.nil?
-          failure && ::Process.kill("KILL", failure) # forceful stop
-        end
-      else
-        _, status = ::Process.wait2(@pid)
-      end
-
-      @exit_code = status&.exitstatus
-      raise Exceptions::CommandTimeoutError, "execution expired" if timeout_occurred
-    rescue Errno::ECHILD, Errno::ESRCH
-      raise Exceptions::CommandTimeoutError, "execution expired" if timeout_occurred
-    ensure
-      @out_rd_reader&.wait
-      @err_rd_reader&.wait
+    # @return [Numeric, nil]
+    def wall_time
+      @finished_at.nil? ? nil : @finished_at - @started_at
     end
+    alias_method :execution_time, :wall_time
 
-    # @return [String]
-    def inspect
-      format("#<Rubsh::RunningCommand '%s'>", @prog_with_args)
+    # @return [Boolean]
+    def ok?
+      @_ok_code.include?(@exit_code)
     end
 
     # @!visibility private
     def __run
-      if @_pipeline
-        @_pipeline.__add_running_command(self)
+      if @_bg
+        spawn
       else
-        @_bg ? run_in_background : run_in_foreground
+        spawn
+        wait(timeout: @_timeout)
       end
     end
 
-    # @!visibility private
-    def __spawn_arguments(env: nil, cwd: nil, redirection_args: nil)
-      env ||= @_env
-      cmd_args = compile_cmd_args
-      redirection_args ||= compile_redirection_args
-      extra_args = compile_extra_args(cwd: cwd)
-
-      # For logging
-      @prog_with_args = [@progpath].concat(cmd_args).join(" ")
-
-      # .
-      _args =
-        if env
-          [env, [@progpath, @prog], *cmd_args, **redirection_args, **extra_args, unsetenv_others: true]
-        else
-          [[@progpath, @prog], *cmd_args, **redirection_args, **extra_args]
-        end
+    # @return [void]
+    def wait(timeout: nil)
+      wait2(@pid, timeout)
+      handle_return_code
     end
 
-    # @!visibility private
-    def __prog_with_args
+    # @return [String]
+    def to_s
       @prog_with_args
     end
 
     private
 
-    def validate_opts(opts)
-      within_pipeline = opts.any? { |opt| opt.special_kwarg?(:_pipeline) }
-      within_pipeline && opts.each do |opt|
-        if opt.special_kwarg? && !SPECIAL_KWARGS_WITHIN_PIPELINE.include?(opt.k.to_sym)
-          raise ::ArgumentError, format("unsupported special kwargs within _pipeline `%s'", opt.k)
-        end
-      end
-    end
-
     def extract_opts(opts)
       args_hash = {}
       opts.each do |opt|
@@ -208,6 +154,8 @@ module Rubsh
           @args << arg
         end
       end
+
+      raise ::ArgumentError, "kwargs :_bg conflicts with kwargs :_timeout" if @_bg && @_timeout
     end
 
     def extract_special_kwargs_opts(opt)
@@ -246,11 +194,52 @@ module Rubsh
         @_long_sep = opt.v
       when :_long_prefix
         @_long_prefix = opt.v
-      when :_pipeline
-        @_pipeline = opt.v
       end
     end
 
+    def spawn
+      args = spawn_arguments
+      @pid = ::Process.spawn(*args)
+      @started_at = Time.now
+      @in_wr&.write(@_in_data) if @_in_data
+      @in_wr&.close
+
+      if @out_rd
+        @out_rd_reader = StreamReader.new(@out_rd, bufsize: @_capture ? @_out_bufsize : nil, &proc { |chunk|
+          @stdout_data << chunk unless @_no_out
+          @_capture&.call(chunk, nil)
+        })
+      end
+      if @err_rd
+        @err_rd_reader = StreamReader.new(@err_rd, bufsize: @_capture ? @_err_bufsize : nil, &proc { |chunk|
+          @stderr_data << chunk unless @_no_err
+          @_capture&.call(nil, chunk)
+        })
+      end
+    ensure
+      @in_rd&.close
+      @out_wr&.close
+      @err_wr&.close
+    end
+
+    def spawn_arguments
+      env = @_env
+      cmd_args = compile_cmd_args
+      redirection_args = compile_redirection_args
+      extra_args = compile_extra_args
+
+      # For logging
+      @prog_with_args = [@progpath].concat(cmd_args).join(" ")
+
+      # .
+      _args =
+        if env
+          [env, [@progpath, @prog], *cmd_args, **redirection_args, **extra_args, unsetenv_others: true]
+        else
+          [[@progpath, @prog], *cmd_args, **redirection_args, **extra_args]
+        end
+    end
+
     def compile_cmd_args
       @args.map { |arg| arg.compile(long_sep: @_long_sep, long_prefix: @_long_prefix) }.compact.flatten
     end
@@ -285,53 +274,47 @@ module Rubsh
       args
     end
 
-    def compile_extra_args(cwd: nil)
-      chdir = cwd || @_cwd
-
+    def compile_extra_args
       args = {}
-      args[:chdir] = chdir if chdir
+      args[:chdir] = @_cwd if @_cwd
       args
     end
 
-    def spawn
-      args = __spawn_arguments
-      @pid = ::Process.spawn(*args)
-      @in_wr&.write(@_in_data) if @_in_data
-      @in_wr&.close
+    def wait2(pid, timeout)
+      timeout_occurred = false
+      _, status = nil, nil
 
-      if @out_rd
-        @out_rd_reader = StreamReader.new(@out_rd, bufsize: @_capture ? @_out_bufsize : nil, &proc { |chunk|
-          @stdout_data << chunk unless @_no_out
-          @_capture&.call(chunk, nil)
-        })
-      end
-      if @err_rd
-        @err_rd_reader = StreamReader.new(@err_rd, bufsize: @_capture ? @_err_bufsize : nil, &proc { |chunk|
-          @stderr_data << chunk unless @_no_err
-          @_capture&.call(nil, chunk)
-        })
+      if timeout
+        begin
+          ::Timeout.timeout(timeout) { _, status = ::Process.wait2(pid) }
+        rescue ::Timeout::Error
+          timeout_occurred = true
+
+          ::Process.kill("TERM", pid) # graceful stop
+          30.times do
+            _, status = ::Process.wait2(pid, ::Process::WNOHANG | ::Process::WUNTRACED)
+            break if status
+            sleep 0.1
+          end
+          failure = pid if status.nil?
+          failure && ::Process.kill("KILL", failure) # forceful stop
+        end
+      else
+        _, status = ::Process.wait2(pid)
       end
+
+      @exit_code = status&.exitstatus || -1
+      @finished_at = Time.now
+      raise Exceptions::CommandTimeoutError, "execution expired" if timeout_occurred
     ensure
-      @in_rd&.close
-      @out_wr&.close
-      @err_wr&.close
+      @out_rd_reader&.wait
+      @err_rd_reader&.wait
     end
 
     def handle_return_code
-      return if @_ok_code.include?(@exit_code)
-      message = format("\n\n  RAN: %s\n\n  STDOUT:\n%s\n  STDERR:\n%s\n", @prog_with_args, @stdout_data, @stderr_data)
+      return if ok?
+      message = format("\n\n      $?: %s\n\n     RAN: %s\n\n  STDOUT:\n%s\n\n  STDERR:\n%s\n", @exit_code, @prog_with_args, @stdout_data, @stderr_data)
       raise Exceptions::CommandReturnFailureError.new(@exit_code, message)
     end
-
-    def run_in_background
-      spawn
-      Process.detach(@pid)
-    end
-
-    def run_in_foreground
-      spawn
-      wait(timeout: @_timeout)
-      handle_return_code
-    end
   end
 end

data/lib/rubsh/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubsh
-  VERSION = "2.1.4"
+  VERSION = "3.0.0"
 end

data/lib/rubsh.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
+require "timeout"
+
 require_relative "rubsh/argument"
 require_relative "rubsh/command"
 require_relative "rubsh/exceptions"
 require_relative "rubsh/option"
 require_relative "rubsh/running_command"
-require_relative "rubsh/running_pipeline"
-require_relative "rubsh/shell/env"
-require_relative "rubsh/shell"
 require_relative "rubsh/stream_reader"
 require_relative "rubsh/version"
+
+module Rubsh
+  def self.cmd(prog)
+    Command.new(prog)
+  end
+end

data/rubsh.gemspec

@@ -10,13 +10,13 @@ Gem::Specification.new do |spec|
 
   spec.summary = "Rubsh (a.k.a. ruby-sh) - Inspired by python-sh, allows you to call any program as if it were a function."
   spec.description = "Rubsh (a.k.a. ruby-sh) - Inspired by python-sh, allows you to call any program as if it were a function."
-  spec.homepage = "https://github.com/souk4711/rubsh"
+  spec.homepage = "https://github.com/souk4711/ruby-sh"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.7.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/souk4711/rubsh"
-  spec.metadata["changelog_uri"] = "https://github.com/souk4711/rubsh"
+  spec.metadata["source_code_uri"] = "https://github.com/souk4711/ruby-sh"
+  spec.metadata["changelog_uri"] = "https://github.com/souk4711/ruby-sh"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-sh
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 3.0.0
 platform: ruby
 authors:
 - John Doe
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Rubsh (a.k.a. ruby-sh) - Inspired by python-sh, allows you to call any
   program as if it were a function.
@@ -18,10 +17,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".overcommit.yml"
+- ".editorconfig"
 - ".rspec"
-- ".rubocop"
 - ".rubocop.yml"
+- ".ruby-version"
 - ".yardopts"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -35,22 +34,17 @@ files:
 - lib/rubsh/exceptions.rb
 - lib/rubsh/option.rb
 - lib/rubsh/running_command.rb
-- lib/rubsh/running_pipeline.rb
-- lib/rubsh/shell.rb
-- lib/rubsh/shell/env.rb
 - lib/rubsh/stream_reader.rb
 - lib/rubsh/version.rb
 - rubsh.gemspec
-- sig/rubsh.rbs
-homepage: https://github.com/souk4711/rubsh
+homepage: https://github.com/souk4711/ruby-sh
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/souk4711/rubsh
-  source_code_uri: https://github.com/souk4711/rubsh
-  changelog_uri: https://github.com/souk4711/rubsh
+  homepage_uri: https://github.com/souk4711/ruby-sh
+  source_code_uri: https://github.com/souk4711/ruby-sh
+  changelog_uri: https://github.com/souk4711/ruby-sh
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -65,8 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Rubsh (a.k.a. ruby-sh) - Inspired by python-sh, allows you to call any program
   as if it were a function.

data/.overcommit.yml

@@ -1,26 +0,0 @@
-# Use this file to configure the Overcommit hooks you wish to use. This will
-# extend the default configuration defined in:
-# https://github.com/sds/overcommit/blob/master/config/default.yml
-#
-# At the topmost level of this YAML file is a key representing type of hook
-# being run (e.g. pre-commit, commit-msg, etc.). Within each type you can
-# customize each hook, such as whether to only run it on certain files (via
-# `include`), whether to only display output if it fails (via `quiet`), etc.
-#
-# For a complete list of hooks, see:
-# https://github.com/sds/overcommit/tree/master/lib/overcommit/hook
-#
-# For a complete list of options that you can use to customize hooks, see:
-# https://github.com/sds/overcommit#configuration
-#
-# Uncomment the following lines to make the configuration take effect.
-
-PreCommit:
-  RuboCop:
-    enabled: true
-    command: 'bin/rubocop'
-
-PrePush:
-  RSpec:
-    enabled: true
-    command: 'bin/rspec'

data/lib/rubsh/running_pipeline.rb

@@ -1,243 +0,0 @@
-require "open3"
-
-module Rubsh
-  class RunningPipeline
-    SPECIAL_KWARGS = %i[
-      _in_data
-      _in
-      _out
-      _err
-      _err_to_out
-      _capture
-      _bg
-      _env
-      _timeout
-      _cwd
-      _ok_code
-      _out_bufsize
-      _err_bufsize
-      _no_out
-      _no_err
-    ]
-
-    # @!attribute [r] exit_code
-    # @return [Number]
-    attr_reader :exit_code
-
-    # @!attribute [r] stdout_data
-    # @return [String]
-    attr_reader :stdout_data
-
-    # @!attribute [r] stderr_data
-    # @return [String]
-    attr_reader :stderr_data
-
-    def initialize(sh)
-      @sh = sh
-      @rcmds = []
-
-      # Runtime
-      @prog_with_args = nil
-      @exit_code = nil
-      @stdout_data = "".force_encoding(::Encoding.default_external)
-      @stderr_data = "".force_encoding(::Encoding.default_external)
-      @in_rd = nil
-      @in_wr = nil
-      @out_rd = nil
-      @out_wr = nil
-      @err_rd = nil
-      @err_wr = nil
-      @out_rd_reader = nil
-      @err_rd_reader = nil
-      @waiters = []
-
-      # Special Kwargs - Controlling Input/Output
-      @_in_data = nil
-      @_in = nil
-      @_out = nil
-      @_err = nil
-      @_err_to_out = false
-      @_capture = nil
-
-      # Special Kwargs - Execution
-      @_bg = false
-      @_env = nil
-      @_timeout = nil
-      @_cwd = nil
-      @_ok_code = [0]
-
-      # Special Kwargs - Performance & Optimization
-      @_out_bufsize = 0
-      @_err_bufsize = 0
-      @_no_out = false
-      @_no_err = false
-    end
-
-    # @return [void]
-    def wait(timeout: nil)
-      timeout_occurred = false
-      last_status = nil
-
-      if timeout
-        begin
-          ::Timeout.timeout(timeout) { last_status = @waiters.map(&:value)[-1] }
-        rescue ::Timeout::Error
-          timeout_occurred = true
-
-          failures = []
-          @waiters.each { |w| ::Process.kill("TERM", w.pid) } # graceful stop
-          @waiters.each { |w|
-            _, status = nil, nil
-            30.times do
-              _, status = ::Process.wait2(w.pid, ::Process::WNOHANG | ::Process::WUNTRACED)
-              break if status
-              sleep 0.1
-            rescue ::Errno::ECHILD, ::Errno::ESRCH
-              status = true
-            end
-            failures << w.pid if status.nil?
-          }
-          failures.each { |pid| ::Process.kill("KILL", pid) } # forceful stop
-        end
-      else
-        last_status = @waiters.map(&:value)[-1]
-      end
-
-      @exit_code = last_status&.exitstatus
-      raise Exceptions::CommandTimeoutError, "execution expired" if timeout_occurred
-    rescue ::Errno::ECHILD, ::Errno::ESRCH
-      raise Exceptions::CommandTimeoutError, "execution expired" if timeout_occurred
-    ensure
-      @out_rd_reader&.wait
-      @err_rd_reader&.wait
-    end
-
-    # @return [String]
-    def inspect
-      format("#<Rubsh::RunningPipeline '%s'>", @prog_with_args)
-    end
-
-    # @!visibility private
-    def __add_running_command(cmd)
-      @rcmds << cmd
-    end
-
-    # @!visibility private
-    def __run(**kwargs)
-      raise Exceptions::CommandNotFoundError, format("no commands") if @rcmds.length == 0
-      extract_opts(**kwargs)
-      @_bg ? run_in_background : run_in_foreground
-    end
-
-    private
-
-    def extract_opts(**kwargs)
-      kwargs.each do |k, v|
-        raise ::ArgumentError, format("unsupported special kwarg `%s'", k) unless SPECIAL_KWARGS.include?(k.to_sym)
-        case k.to_sym
-        when :_in_data
-          @_in_data = v
-        when :_in
-          @_in = v
-        when :_out
-          @_out = v
-        when :_err
-          @_err = v
-        when :_err_to_out
-          @_err_to_out = v
-        when :_capture
-          @_capture = v
-        when :_bg
-          @_bg = v
-        when :_env
-          @_env = v.transform_keys(&:to_s).transform_values(&:to_s)
-        when :_timeout
-          @_timeout = v
-        when :_cwd
-          @_cwd = v
-        when :_ok_code
-          @_ok_code = [*v]
-        when :_out_bufsize
-          @_out_bufsize = v
-        when :_err_bufsize
-          @_err_bufsize = v
-        when :_no_out
-          @_no_out = v
-        when :_no_err
-          @_no_err = v
-        end
-      end
-    end
-
-    def compile_redirection_args
-      args = {}
-
-      if @_in
-        args[:in] = @_in
-      else
-        @in_rd, @in_wr = ::IO.pipe
-        @in_wr.sync = true
-        args[:in] = @in_rd.fileno
-      end
-
-      if @_out
-        args[:out] = @_out
-      else
-        @out_rd, @out_wr = ::IO.pipe
-        args[:out] = @out_wr.fileno
-      end
-
-      if @_err_to_out
-        args[:err] = [:child, :out]
-      elsif @_err
-        args[:err] = @_err
-      else
-        @err_rd, @err_wr = ::IO.pipe
-        args[:err] = @err_wr.fileno
-      end
-
-      args
-    end
-
-    def spawn
-      cmds = @rcmds.map { |r| r.__spawn_arguments(env: @_env, cwd: @_cwd, redirection_args: {}) }
-      @prog_with_args = @rcmds.map(&:__prog_with_args).join(" | ")
-      @waiters = ::Open3.pipeline_start(*cmds, compile_redirection_args)
-      @in_wr&.write(@_in_data) if @_in_data
-      @in_wr&.close
-
-      if @out_rd
-        @out_rd_reader = StreamReader.new(@out_rd, bufsize: @_capture ? @_out_bufsize : nil, &proc { |chunk|
-          @stdout_data << chunk unless @_no_out
-          @_capture&.call(chunk, nil)
-        })
-      end
-      if @err_rd
-        @err_rd_reader = StreamReader.new(@err_rd, bufsize: @_capture ? @_err_bufsize : nil, &proc { |chunk|
-          @stderr_data << chunk unless @_no_err
-          @_capture&.call(nil, chunk)
-        })
-      end
-    ensure
-      @in_rd&.close
-      @out_wr&.close
-      @err_wr&.close
-    end
-
-    def handle_return_code
-      return if @_ok_code.include?(@exit_code)
-      message = format("\n\n  RAN: %s\n\n  STDOUT:\n%s\n  STDERR:\n%s\n", @prog_with_args, @stdout_data, @stderr_data)
-      raise Exceptions::CommandReturnFailureError.new(@exit_code, message)
-    end
-
-    def run_in_background
-      spawn
-    end
-
-    def run_in_foreground
-      spawn
-      wait(timeout: @_timeout)
-      handle_return_code
-    end
-  end
-end