outstand-tty-command 0.10.0.pre

data/lib/tty-command.rb

@@ -0,0 +1 @@
+require 'tty/command'

data/lib/tty/command.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+require_relative 'command/cmd'
+require_relative 'command/exit_error'
+require_relative 'command/dry_runner'
+require_relative 'command/process_runner'
+require_relative 'command/printers/null'
+require_relative 'command/printers/pretty'
+require_relative 'command/printers/progress'
+require_relative 'command/printers/quiet'
+require_relative 'command/version'
+
+module TTY
+  class Command
+    ExecuteError = Class.new(StandardError)
+
+    TimeoutExceeded = Class.new(StandardError)
+
+    # Path to the current Ruby
+    RUBY = ENV['RUBY'] || ::File.join(
+      RbConfig::CONFIG['bindir'],
+      RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']
+    )
+
+    WIN_PLATFORMS = /cygwin|mswin|mingw|bccwin|wince|emx/.freeze
+
+    def self.record_separator
+      @record_separator ||= $/
+    end
+
+    def self.record_separator=(sep)
+      @record_separator = sep
+    end
+
+    def self.windows?
+      !!(RbConfig::CONFIG['host_os'] =~ WIN_PLATFORMS)
+    end
+
+    attr_reader :printer
+
+    # Initialize a Command object
+    #
+    # @param [Hash] options
+    # @option options [IO] :output
+    #   the stream to which printer prints, defaults to stdout
+    # @option options [Symbol] :printer
+    #   the printer to use for output logging, defaults to :pretty
+    # @option options [Symbol] :dry_run
+    #   the mode for executing command
+    #
+    # @api public
+    def initialize(**options)
+      @output = options.fetch(:output) { $stdout }
+      @color   = options.fetch(:color) { true }
+      @uuid    = options.fetch(:uuid) { true }
+      @printer_name = options.fetch(:printer) { :pretty }
+      @dry_run = options.fetch(:dry_run) { false }
+      @printer = use_printer(@printer_name, color: @color, uuid: @uuid)
+      @cmd_options = {}
+      @cmd_options[:verbose] = options.fetch(:verbose, true)
+      @cmd_options[:pty] = true if options[:pty]
+      @cmd_options[:binmode] = true if options[:binmode]
+      @cmd_options[:timeout] = options[:timeout] if options[:timeout]
+    end
+
+    # Start external executable in a child process
+    #
+    # @example
+    #   cmd.run(command, [argv1, ..., argvN], [options])
+    #
+    # @example
+    #   cmd.run(command, ...) do |result|
+    #     ...
+    #   end
+    #
+    # @param [String] command
+    #   the command to run
+    #
+    # @param [Array[String]] argv
+    #   an array of string arguments
+    #
+    # @param [Hash] options
+    #   hash of operations to perform
+    # @option options [String] :chdir
+    #   The current directory.
+    # @option options [Integer] :timeout
+    #   Maximum number of seconds to allow the process
+    #   to run before aborting with a TimeoutExceeded
+    #   exception.
+    # @option options [Symbol] :signal
+    #   Signal used on timeout, SIGKILL by default
+    #
+    # @yield [out, err]
+    #   Yields stdout and stderr output whenever available
+    #
+    # @raise [ExitError]
+    #   raised when command exits with non-zero code
+    #
+    # @api public
+    def run(*args, &block)
+      cmd = command(*args)
+      result = execute_command(cmd, &block)
+      if result && result.failure?
+        raise ExitError.new(cmd.to_command, result)
+      end
+      result
+    end
+
+    # Start external executable without raising ExitError
+    #
+    # @example
+    #   cmd.run!(command, [argv1, ..., argvN], [options])
+    #
+    # @api public
+    def run!(*args, &block)
+      cmd = command(*args)
+      execute_command(cmd, &block)
+    end
+
+    # Wait on long running script until output matches a specific pattern
+    #
+    # @example
+    #   cmd.wait 'tail -f /var/log/php.log', /something happened/
+    #
+    # @api public
+    def wait(*args)
+      pattern = args.pop
+      unless pattern
+        raise ArgumentError, 'Please provide condition to wait for'
+      end
+
+      run(*args) do |out, _|
+        raise if out =~ /#{pattern}/
+      end
+    rescue ExitError
+      # noop
+    end
+
+    # Execute shell test command
+    #
+    # @api public
+    def test(*args)
+      run!(:test, *args).success?
+    end
+
+    # Run Ruby interperter with the given arguments
+    #
+    # @example
+    #   ruby %q{-e "puts 'Hello world'"}
+    #
+    # @api public
+    def ruby(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      if args.length > 1
+        run(*([RUBY] + args + [options]), &block)
+      else
+        run("#{RUBY} #{args.first}", options, &block)
+      end
+    end
+
+    # Check if in dry mode
+    #
+    # @return [Boolean]
+    #
+    # @public
+    def dry_run?
+      @dry_run
+    end
+
+    private
+
+    # @api private
+    def command(*args)
+      cmd = Cmd.new(*args)
+      cmd.update(**@cmd_options)
+      cmd
+    end
+
+    # @api private
+    def execute_command(cmd, &block)
+      dry_run = @dry_run || cmd.options[:dry_run] || false
+      @runner = select_runner(dry_run).new(cmd, @printer, &block)
+      @runner.run!
+    end
+
+    # @api private
+    def use_printer(class_or_name, options)
+      if class_or_name.is_a?(TTY::Command::Printers::Abstract)
+        return class_or_name
+      end
+
+      if class_or_name.is_a?(Class)
+        class_or_name
+      else
+        find_printer_class(class_or_name)
+      end.new(@output, options)
+    end
+
+    # Find printer class or fail
+    #
+    # @raise [ArgumentError]
+    #
+    # @api private
+    def find_printer_class(name)
+      const_name = name.to_s.split('_').map(&:capitalize).join.to_sym
+      if const_name.empty? || !TTY::Command::Printers.const_defined?(const_name)
+        raise ArgumentError, %(Unknown printer type "#{name}")
+      end
+      TTY::Command::Printers.const_get(const_name)
+    end
+
+    # @api private
+    def select_runner(dry_run)
+      if dry_run
+        DryRunner
+      else
+        ProcessRunner
+      end
+    end
+  end # Command
+end # TTY

data/lib/tty/command/child_process.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'securerandom'
+require 'io/console'
+
+module TTY
+  class Command
+    module ChildProcess
+      # Execute command in a child process with all IO streams piped
+      # in and out. The interface is similar to Process.spawn
+      #
+      # The caller should ensure that all IO objects are closed
+      # when the child process is finished. However, when block
+      # is provided this will be taken care of automatically.
+      #
+      # @param [Cmd] cmd
+      #   the command to spawn
+      #
+      # @return [pid, stdin, stdout, stderr]
+      #
+      # @api public
+      def spawn(cmd)
+        process_opts = normalize_redirect_options(cmd.options)
+        binmode = cmd.options[:binmode] || false
+        pty     = cmd.options[:pty] || false
+        verbose = cmd.options[:verbose]
+
+        pty = try_loading_pty(verbose) if pty
+        require('pty') if pty # load within this scope
+
+        # Create pipes
+        in_rd,  in_wr  = pty ? PTY.open : IO.pipe('utf-8') # reading
+        out_rd, out_wr = pty ? PTY.open : IO.pipe('utf-8') # writing
+        err_rd, err_wr = pty ? PTY.open : IO.pipe('utf-8') # error
+        in_wr.sync = true
+
+        if binmode
+          in_wr.binmode
+          out_rd.binmode
+          err_rd.binmode
+        end
+
+        if pty
+          in_wr.raw!
+          out_wr.raw!
+          err_wr.raw!
+        end
+
+        # redirect fds
+        opts = {
+          in: in_rd,
+          out: out_wr,
+          err: err_wr
+        }
+        unless TTY::Command.windows?
+          close_child_fds = {
+            in_wr  => :close,
+            out_rd => :close,
+            err_rd => :close
+          }
+          opts.merge!(close_child_fds)
+        end
+        opts.merge!(process_opts)
+
+        pid = Process.spawn(cmd.to_command, opts)
+
+        # close streams in parent process talking to the child
+        close_fds(in_rd, out_wr, err_wr)
+
+        tuple = [pid, in_wr, out_rd, err_rd]
+
+        if block_given?
+          begin
+            return yield(*tuple)
+          ensure
+            # ensure parent pipes are closed
+            close_fds(in_wr, out_rd, err_rd)
+          end
+        else
+          tuple
+        end
+      end
+      module_function :spawn
+
+      # Close all streams
+      # @api private
+      def close_fds(*fds)
+        fds.each { |fd| fd && !fd.closed? && fd.close }
+      end
+      module_function :close_fds
+
+      # Try loading pty module
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def try_loading_pty(verbose = false)
+        require 'pty'
+        true
+      rescue LoadError
+        warn("Requested PTY device but the system doesn't support it.") if verbose
+        false
+      end
+      module_function :try_loading_pty
+
+      # Normalize spawn fd into :in, :out, :err keys.
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def normalize_redirect_options(options)
+        options.reduce({}) do |opts, (key, value)|
+          if fd?(key)
+            spawn_key, spawn_value = convert(key, value)
+            opts[spawn_key] = spawn_value
+          elsif key.is_a?(Array) && key.all?(&method(:fd?))
+            key.each do |k|
+              spawn_key, spawn_value = convert(k, value)
+              opts[spawn_key] = spawn_value
+            end
+          end
+          opts
+        end
+      end
+      module_function :normalize_redirect_options
+
+      # Convert option pari to recognized spawn option pair
+      #
+      # @api private
+      def convert(spawn_key, spawn_value)
+        key   = fd_to_process_key(spawn_key)
+        value = spawn_value
+
+        if key.to_s == 'in'
+          value = convert_to_fd(spawn_value)
+        end
+
+        if fd?(spawn_value)
+          value = fd_to_process_key(spawn_value)
+          value = [:child, value] # redirect in child process
+        end
+        [key, value]
+      end
+      module_function :convert
+
+      # Determine if object is a fd
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def fd?(object)
+        case object
+        when :stdin, :stdout, :stderr, :in, :out, :err,
+             STDIN, STDOUT, STDERR, $stdin, $stdout, $stderr, ::IO
+          true
+        when ::Integer
+          object >= 0
+        else
+          respond_to?(:to_i) && !object.to_io.nil?
+        end
+      end
+      module_function :fd?
+
+      # Convert fd to name :in, :out, :err
+      #
+      # @api private
+      def fd_to_process_key(object)
+        case object
+        when STDIN, $stdin, :in, :stdin, 0
+          :in
+        when STDOUT, $stdout, :out, :stdout, 1
+          :out
+        when STDERR, $stderr, :err, :stderr, 2
+          :err
+        when Integer
+          object >= 0 ? IO.for_fd(object) : nil
+        when IO
+          object
+        when respond_to?(:to_io)
+          object.to_io
+        else
+          raise ExecuteError, "Wrong execute redirect: #{object.inspect}"
+        end
+      end
+      module_function :fd_to_process_key
+
+      # Convert file name to file handle
+      #
+      # @api private
+      def convert_to_fd(object)
+        return object if fd?(object)
+
+        if object.is_a?(::String) && ::File.exist?(object)
+          return object
+        end
+
+        tmp = ::Tempfile.new(::SecureRandom.uuid.split('-')[0])
+        content = try_reading(object)
+        tmp.write(content)
+        tmp.rewind
+        tmp
+      end
+      module_function :convert_to_fd
+
+      # Attempts to read object content
+      #
+      # @api private
+      def try_reading(object)
+        if object.respond_to?(:read)
+          object.read
+        elsif object.respond_to?(:to_s)
+          object.to_s
+        else
+          object
+        end
+      end
+      module_function :try_reading
+    end # ChildProcess
+  end # Command
+end # TTY

data/lib/tty/command/cmd.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'shellwords'
+
+module TTY
+  class Command
+    class Cmd
+      # A string command name, or shell program
+      # @api public
+      attr_reader :command
+
+      # A string arguments
+      # @api public
+      attr_reader :argv
+
+      # Hash of operations to peform
+      # @api public
+      attr_reader :options
+
+      # Unique identifier
+      # @api public
+      attr_reader :uuid
+
+      # Flag that controls whether to print the output only on error or not
+      attr_reader :only_output_on_error
+
+      # Initialize a new Cmd object
+      #
+      # @api private
+      def initialize(env_or_cmd, *args)
+        opts = args.last.respond_to?(:to_hash) ? args.pop : {}
+        if env_or_cmd.respond_to?(:to_hash)
+          @env = env_or_cmd
+          unless command = args.shift
+            raise ArgumentError, 'Cmd requires command argument'
+          end
+        else
+          command = env_or_cmd
+        end
+
+        if args.empty? && cmd = command.to_s
+          raise ArgumentError, 'No command provided' if cmd.empty?
+          @command = sanitize(cmd)
+          @argv = []
+        else
+          if command.respond_to?(:to_ary)
+            @command = sanitize(command[0])
+            args.unshift(*command[1..-1])
+          else
+            @command = sanitize(command)
+          end
+          @argv = args.map { |i| Shellwords.escape(i) }
+        end
+        @env ||= {}
+        @options = opts
+
+        @uuid = SecureRandom.uuid.split('-')[0]
+        @only_output_on_error = opts.fetch(:only_output_on_error) { false }
+        freeze
+      end
+
+      # Extend command options if keys don't already exist
+      #
+      # @api public
+      def update(options)
+        @options.update(options.update(@options))
+      end
+
+      # The shell environment variables
+      #
+      # @api public
+      def environment
+        @env.merge(options.fetch(:env, {}))
+      end
+
+      def environment_string
+        environment.map do |key, val|
+          converted_key = key.is_a?(Symbol) ? key.to_s.upcase : key.to_s
+          escaped_val = val.to_s.gsub(/"/, '\"')
+          %(#{converted_key}="#{escaped_val}")
+        end.join(' ')
+      end
+
+      def evars(value, &block)
+        return (value || block) unless environment.any?
+        "( export #{environment_string} ; #{value || block.call} )"
+      end
+
+      def umask(value)
+        return value unless options[:umask]
+        %(umask #{options[:umask]} && %s) % [value]
+      end
+
+      def chdir(value)
+        return value unless options[:chdir]
+        %(cd #{Shellwords.escape(options[:chdir])} && #{value})
+      end
+
+      def user(value)
+        return value unless options[:user]
+        vars = environment.any? ? "#{environment_string} " : ''
+        %(sudo -u #{options[:user]} #{vars}-- sh -c '%s') % [value]
+      end
+
+      def group(value)
+        return value unless options[:group]
+        %(sg #{options[:group]} -c \\\"%s\\\") % [value]
+      end
+
+      # Clear environment variables except specified by env
+      #
+      # @api public
+      def with_clean_env
+      end
+
+      # Assemble full command
+      #
+      # @api public
+      def to_command
+        chdir(umask(evars(user(group(to_s)))))
+      end
+
+      # @api public
+      def to_s
+        [command.to_s, *Array(argv)].join(' ')
+      end
+
+      # @api public
+      def to_hash
+        {
+          command: command,
+          argv:    argv,
+          uuid:    uuid
+        }
+      end
+
+      private
+
+      # Coerce to string
+      #
+      # @api private
+      def sanitize(value)
+        value.to_s.dup
+      end
+    end # Cmd
+  end # Command
+end # TTY