ruby-sh 2.1.4

data/lib/rubsh/running_pipeline.rb

@@ -0,0 +1,243 @@
+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

data/lib/rubsh/shell/env.rb

@@ -0,0 +1,15 @@
+module Rubsh
+  class Shell
+    class Env
+      attr_reader :path
+
+      def initialize
+        @path = ::ENV["PATH"].split(::File::PATH_SEPARATOR)
+      end
+
+      def path=(path)
+        @path = [*path]
+      end
+    end
+  end
+end

data/lib/rubsh/shell.rb

@@ -0,0 +1,24 @@
+module Rubsh
+  class Shell
+    # @!attribute [r] env
+    # @return [Env]
+    attr_reader :env
+
+    def initialize
+      @env = Env.new
+    end
+
+    # @return [Command]
+    def command(prog)
+      Command.new(self, prog)
+    end
+    alias_method :cmd, :command
+
+    # @return [RunningPipeline]
+    def pipeline(**kwarg)
+      r = RunningPipeline.new(self).tap { |x| yield x }
+      r.__run(**kwarg)
+      r
+    end
+  end
+end

data/lib/rubsh/stream_reader.rb

@@ -0,0 +1,39 @@
+module Rubsh
+  class StreamReader
+    BUFSIZE = 16 * 1024
+
+    def initialize(rd, bufsize: nil, &block)
+      @thr = ::Thread.new do
+        if ::Thread.current.respond_to?(:report_on_exception)
+          ::Thread.current.report_on_exception = false
+        end
+
+        readers = [rd]
+        while readers.any?
+          ready = ::IO.select(readers, nil, readers)
+          ready[0].each do |reader|
+            if bufsize.nil?
+              chunk = reader.readpartial(BUFSIZE)
+            elsif bufsize == 0
+              chunk = reader.readline
+            else
+              chunk = reader.read(bufsize)
+              raise ::EOFError if chunk.nil?
+            end
+
+            chunk.force_encoding(::Encoding.default_external)
+            block.call(chunk)
+          rescue ::EOFError, ::Errno::EPIPE, ::Errno::EIO
+            readers.delete(reader)
+            reader.close
+          end
+        end
+      end
+    end
+
+    # @return [void]
+    def wait
+      @thr.join
+    end
+  end
+end

data/lib/rubsh/version.rb

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

data/lib/rubsh.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+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"

data/rubsh.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/rubsh/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby-sh"
+  spec.version = Rubsh::VERSION
+  spec.authors = ["John Doe"]
+  spec.email = ["johndoe@example.com"]
+
+  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.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"
+
+  # 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.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

data/sig/rubsh.rbs

@@ -0,0 +1,4 @@
+module Rubsh
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: ruby-sh
+version: !ruby/object:Gem::Version
+  version: 2.1.4
+platform: ruby
+authors:
+- John Doe
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-06-05 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.
+email:
+- johndoe@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".overcommit.yml"
+- ".rspec"
+- ".rubocop"
+- ".rubocop.yml"
+- ".yardopts"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rubsh.rb
+- lib/rubsh/argument.rb
+- lib/rubsh/command.rb
+- 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
+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
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+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.
+test_files: []