tty-command 0.1.0

data/Rakefile

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+
+FileList['tasks/**/*.rake'].each(&method(:import))
+
+task default: :spec
+
+desc 'Run all specs'
+task ci: %w[ spec ]

data/bin/console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'tty-command'
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/examples/bash.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'tty-command'
+
+cmd = TTY::Command.new
+
+f = 'file'
+if cmd.test("[ -f #{f} ]")
+  puts "#{f} already exists!"
+else
+  cmd.run :touch, f
+end

data/examples/basic.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'tty-command'
+
+cmd = TTY::Command.new
+
+out, err = cmd.execute(:echo, 'hello world!')
+
+puts "Result: #{out}"

data/examples/env.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'tty-command'
+
+cmd = TTY::Command.new
+
+out, err = cmd.run(:echo, "$FOO", env: { foo: 'hello'})
+
+puts "Result: #{out}"

data/examples/logger.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'logger'
+require 'tty-command'
+
+logger = Logger.new('dev.log')
+
+cmd = TTY::Command.new(output: logger, color: false)
+
+cmd.run(:ls)

data/examples/redirect_stderr.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'tty-command'
+
+cmd = TTY::Command.new
+
+out, err = cmd.run("echo 'hello' 1>& 2")
+
+puts "out: #{out}"
+puts "err: #{err}"

data/examples/redirect_stdout.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'tty-command'
+
+cmd = TTY::Command.new
+
+cmd.run(:ls, :out => 'ls_sample')

data/examples/timeout.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'tty-command'
+
+cmd = TTY::Command.new
+
+cmd.run("while test 1; do echo 'hello'; sleep 1; done", timeout: 5)

data/lib/tty-command.rb

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

data/lib/tty/command.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require 'thread'
+require 'tty/command/version'
+require 'tty/command/cmd'
+require 'tty/command/exit_error'
+require 'tty/command/dry_runner'
+require 'tty/command/process_runner'
+require 'tty/command/printers/null'
+require 'tty/command/printers/pretty'
+require 'tty/command/printers/progress'
+require 'tty/command/printers/quiet'
+
+module TTY
+  class Command
+    ExecuteError = Class.new(StandardError)
+
+    TimeoutExceeded = Class.new(StandardError)
+
+    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)
+    end
+
+    # Start external executable in a child process
+    #
+    # @example
+    #   cmd.run(command, [argv1, ..., argvN], [options])
+    #
+    # @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.
+    #
+    # @raise [ExitError]
+    #   raised when command exits with non-zero code
+    #
+    # @api public
+    def run(*args)
+      cmd = command(*args)
+      yield(cmd) if block_given?
+      result = execute_command(cmd)
+      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)
+      cmd = command(*args)
+      yield(cmd) if block_given?
+      execute_command(cmd)
+    end
+
+    # Execute shell test command
+    #
+    # @api public
+    def test(*args)
+      run!(:test, *args).success?
+    end
+
+    # Check if in dry mode
+    #
+    # @return [Boolean]
+    #
+    # @public
+    def dry_run?
+      @dry_run
+    end
+
+    def printer
+      use_printer(@printer_name, color: @color, uuid: @uuid)
+    end
+
+    private
+
+    # @api private
+    def command(*args)
+      Cmd.new(*args)
+    end
+
+    # @api private
+    def execute_command(cmd)
+      mutex = Mutex.new
+      dry_run = @dry_run || cmd.options[:dry_run] || false
+      @runner = select_runner(@printer, dry_run)
+      mutex.synchronize { @runner.run(cmd) }
+    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.capitalize.to_sym
+      if const_name.empty? || !TTY::Command::Printers.const_defined?(const_name)
+        fail ArgumentError, %(Unknown printer type "#{name}")
+      end
+      TTY::Command::Printers.const_get(const_name)
+    end
+
+    # @api private
+    def select_runner(printer, dry_run)
+      if dry_run
+        DryRunner.new(printer)
+      else
+        ProcessRunner.new(printer)
+      end
+    end
+  end # Command
+end # TTY

data/lib/tty/command/cmd.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+require 'securerandom'
+
+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
+
+      # 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| shell_escape(i) }
+        end
+        @env ||= {}
+        @options = opts
+      end
+
+      # Unique identifier
+      #
+      # @api public
+      def uuid
+        @uuid ||= SecureRandom.uuid.split('-')[0]
+      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} ; %s )) % [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 #{options[:chdir]} && %s) % [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
+
+      # @api private
+      def sanitize(value)
+        cmd = value.to_s.dup
+        lines = cmd.lines.to_a
+        lines.each_with_index.reduce('') do |acc, (line, index)|
+          acc << line.strip
+          acc << '; ' if (index + 1) != lines.size
+          acc
+        end
+      end
+
+      # Enclose s in quotes if it contains characters that require escaping
+      #
+      # @param [String] arg
+      #   the argument to escape
+      #
+      # @api private
+      def shell_escape(arg)
+        str = arg.to_s.dup
+        return str if str =~ /^[0-9A-Za-z+,.\/:=@_-]+$/
+        str.gsub!("'", "'\\''")
+        "'#{str}'"
+      end
+    end # Cmd
+  end # Command
+end # TTY

data/lib/tty/command/dry_runner.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module TTY
+  class Command
+    class DryRunner
+      def initialize(printer)
+        @printer = printer
+      end
+
+      def run(cmd)
+        cmd.to_command
+        message = "#{@printer.decorate('(dry run)', :blue)} "
+        message << @printer.decorate(cmd.to_command, :yellow, :bold)
+        @printer.write(message, cmd.uuid)
+        Result.new(0, '', '')
+      end
+    end # DryRunner
+  end # Command
+end # TTY

data/lib/tty/command/execute.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require 'tempfile'
+require 'securerandom'
+
+module TTY
+  class Command
+    module Execute
+      extend self
+
+      # Execute command in a child process
+      #
+      # 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 execute
+      #
+      # @return [pid, stdin, stdout, stderr]
+      #
+      # @api public
+      def spawn(cmd)
+        @process_options = normalize_redirect_options(cmd.options)
+
+        # Create pipes
+        in_rd,  in_wr  = IO.pipe # reading
+        out_rd, out_wr = IO.pipe # writing
+        err_rd, err_wr = IO.pipe # error
+
+        # redirect fds
+        opts = ({
+          :in  => in_rd, # in_wr  => :close,
+          :out => out_wr,# out_rd => :close,
+          :err => err_wr,# err_rd => :close
+        }).merge(@process_options)
+
+        pid = Process.spawn(cmd.to_command, opts)
+
+        # close in parent process
+        [out_wr, err_wr].each { |fd| fd.close if fd }
+
+        tuple = [pid, in_wr, out_rd, err_rd]
+
+        if block_given?
+          begin
+            return yield(*tuple)
+          ensure
+            [in_wr, out_rd, err_rd].each { |fd| fd.close if fd && !fd.closed? }
+          end
+        else
+          tuple
+        end
+      end
+
+      private
+
+      def normalize_redirect_options(options)
+        options.reduce({}) do |opts, (key, value)|
+          if fd?(key)
+            process_key = fd_to_process_key(key)
+            if process_key.to_s == 'in'
+              value = convert_to_fd(value)
+            end
+            opts[process_key]= value
+          end
+          opts
+        end
+      end
+
+      # @api private
+      def fd?(object)
+        case object
+        when :stdin, :stdout, :stderr, :in, :out, :err
+          true
+        when STDIN, STDOUT, STDERR, $stdin, $stdout, $stderr, ::IO
+          true
+        when ::IO
+          true
+        when ::Fixnum
+          object >= 0
+        when respond_to?(:to_i) && !object.to_io.nil?
+          true
+        else
+          false
+        end
+      end
+
+      def try_reading(object)
+        if object.respond_to?(:read)
+          object.read
+        elsif object.respond_to?(:to_s)
+          object.to_s
+        else
+          object
+        end
+      end
+
+      def convert_to_fd(object)
+        return object if fd?(object)
+
+        if object.is_a?(::String) && File.exists?(object)
+          return object
+        end
+
+        tmp = Tempfile.new(SecureRandom.uuid.split('-')[0])
+
+        content = try_reading(object)
+        tmp.write(content)
+        tmp.rewind
+        tmp
+      end
+
+      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 Fixnum
+          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
+    end # Execute
+  end # Command
+end # TTY