acoc 0.7.1

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/TODO

@@ -0,0 +1,11 @@
+$Id: TODO,v 1.12 2005/02/27 01:05:20 ianmacd Exp $
+
+- add many more sample rules to acoc.conf
+
+- fix pseudo-tty handling to be bidirectional
+
+
+Maybes
+------
+
+- new config file format with more flexible syntax

data/acoc.conf

@@ -0,0 +1,226 @@
+# sample configuration file for acoc
+#
+# $Id: acoc.conf,v 1.35 2005/02/27 02:08:43 ianmacd Exp $
+
+#[default]
+#
+# default rules go here
+
+# all kinds of diffs
+[diff,rcsdiff/t,cvs diff/t,p4 diff/t]
+/^([+>*].*)/				green
+/^([-<].*)/				red
+/^(@@.*|diff.*|[\d,acd]+)/		blue
+
+[ping/ap]
+# hostname and IP address
+/from (\S+) \(((?:\d?\d?\d\.){3}\d?\d?\d)/ bold
+# < 100 ms RTT
+/(\d\d?\.\d+ ms)/			green
+# > 100 ms RTT
+/[^.](1\d\d ms)/			yellow
+# > 200 ms RTT
+/[^.]([2-9]\d\d\d? ms)/			red
+# end report
+/(\d+) packets transmitted, (\d+) received, (\d+%) packet loss, time (\d+ms)/ bold
+@rtt min/avg/max/mdev = (\d+\.\d+)/(\d+\.\d+)/(\d+\.\d+)/(\d+\.\d+ ms)@	  bold
+
+[traceroute/a]
+# < 100 ms RTT
+/[^\d]\d\d?\.\d* ms/g			green
+# > 100 ms RTT
+/1\d\d\.\d* ms/g			yellow
+# > 200 ms RTT
+/[2-9]\d\d\d?\.\d* ms/g			red
+# no response or TTL < 1
+/(\*|![HNPSFXVC]?)/g			red
+
+# compilation and package building
+[make,gmake,rpmbuild -b,rpmbuild --rebuild,rpm -b,rpm --rebuild]
+/^(make.*)$/				yellow
+
+[configure,rpmbuild -b,rpmbuild --rebuild,rpm -b,rpm --rebuild]
+/^(checking .+\.\.\.) (yes)$/		yellow,green
+/^(checking .+\.\.\.) (no)$/		yellow,red
+/^(checking .+\.\.\.) ?(?!yes|no)(.+)$/	yellow,magenta
+
+[make,gmake,cc,gcc,rpmbuild -b,rpmbuild --rebuild,rpm -b,rpm --rebuild]
+/(\S+\.c)\b/				cyan
+/-o\s+(\S+(?:\.o)?)\b/			green
+/\s(-l\S+)\b/g				magenta
+/^([^:]+): (In function `)(.+)(':)/	green,yellow,cyan,yellow
+/^([^:]+):(\d+): (warning: [^`]+`)([^']+)(.+)$/	green,bold,yellow,cyan,yellow
+/^([^:]+):(\d+): (warning: [^`]+)$/	green,bold,yellow
+
+# package building
+[rpmbuild -b/ae,rpmbuild --rebuild/ae,rpm -b/ae,rpm --rebuild/ae]
+/^(\+.*)$/				bold
+/^(Executing)([^:]+): (.+)$/		yellow,cyan,green
+/^(Patch #\d+) \((.+)\):$/		yellow,green
+/^(Wrote: )(.+)/			yellow,green
+
+# package querying
+[rpm -.*(q.*i|i.*q)/a,rpm -.*(q.*p.*i|q.*i.*p|p.*i.*q|p.*q.*i|i.*p.*q|i.*q.*p)/a]
+/^(Name|Version|Release|Install Date|Group|Size)\s*: (.+)\s\s/	yellow,green
+/(^Signature|^Packager|^URL|^Summary|Relocations|Vendor|Build (?:Date|Host)|Source RPM|License)\s*: (.+)$/	yellow,green
+
+[w/a]
+/^(\S+)\s+(\S+)\s+(\S+)\s+(.{7})\s+\S+\s+(\S+)\s+(\S+)\s+(.+)$/	bold,blue,bold,yellow,green,green,magenta
+/(\d+days)/				red
+
+#[irb]
+# irb doesn't function correctly
+#/^irb\(([^)]+)\):(\d+):(\d+)(.)/	bold,yellow,cyan,green
+
+# Highlight Ruby source files, etc., when there's an exception.
+#[ruby/er]
+# message and error class
+#/:\d+:in `.*?': (.*) \((\w+)\)\s*$/	bold,red+bold
+# file name and line number
+#/^(?:\s+from)?(.*?):(\d+)/		green+bold,yellow+bold
+# method name
+#/:in `(.*?)'/				cyan+bold
+
+[vmstat]
+# load
+/^\s+([5-9]\d*).*/			yellow
+/^\s+([1-9]\d+).*/			red
+# free RAM
+/^\s+\S+\s+\S+\s+\S+\s+(\d\d)\s+.*/	red
+
+[top/a]
+# load average < 0.70
+/0\.[0-6]\d(?!\s+\w)/g			green+bold
+# load average 0.99 < load < 0.70
+/0\.[7-9]\d(?!\s+\w)/g			yellow+bold
+# load average > 1.00
+/[^0]\.\d\d(?!\s+\w)/g			red+bold
+# process information
+/^(\d+) processes\D+(\d+)\D+(\d+)\D+(\d+)\D+(\d)/ cyan+bold
+# header percentages, except for idle
+/\d+\.\d+% (?!idle)/g			cyan+bold
+# idle percentage 0 - 19%
+/((?:1\d|[^\d]\d)\.\d%) idle/		red+bold
+# idle percentage 20 - 49%
+/([2-4]\d\.\d%) idle/			yellow+bold
+# idle percentage 50 - 100%
+/(1?[5-9]\d\.\d%) idle/			green+bold
+# memory
+/\d+k/g					cyan+bold
+# root processes
+/root\s+(?:\S+\s+){9}(?:\d\s+)?(.+)$/	red
+# stat names (doesn't quite work)
+/\b(up|load average|processes|sleeping|running|zombie|stopped|user|system|nice|iowait|av|used|free|shrd|buff|(?:in)?active|cached)\b/g	  magenta+bold
+# zombies and processes in uninterruptible sleep
+/\b([ZD])\b/				red
+
+[df]
+# 91 - 95% full
+/.*(9[1-5]%)\s+(.+)$/			yellow,bold
+# 96 - 100% full
+/.*(9[6-9]%|100%)\s+(.+)$/		red,bold
+
+[ifconfig,route]
+# IP addresses
+/(?:\d?\d?\d\.){3}\d?\d?\d/g		cyan
+
+[route/a]
+# interface
+/([a-z]+\d+|lo)$/			magenta
+
+[ifconfig/ae]
+/^(\S+).*((?:[\dA-F][\dA-F]:){5}[\dA-F][\dA-F])/	      magenta
+/[RT]X packets:(\d+).*(?:frame|carrier):(\d+)/		      green
+/errors:([^0]+)\s+dropped:([^0]+)\s+overruns:([^0]+)/	      red
+/collisions:([^0][\d\s]*)/				      red
+/RX bytes:(\d+)\s+\(([^)]+)\)\s+TX bytes:(\d+)\s+\(([^)]+)\)/ green
+
+[tcpdump/t]
+# ARP
+/^(\d\d:\d\d:\d\d\.\d+)\s+(arp\s+\S+)\s+(\S+)\s+(\S+)\s+(\S+)$/	 green,bold,cyan,bold,cyan
+# everything else
+/^(\d\d:\d\d:\d\d\.\d+)\s+(\S+)\.(\S+)\s+>\s+(\S+)\.(\S+):(.+)$/ green,cyan,yellow,cyan,yellow,bold
+
+[ldd/t]
+/(\S+) => (\S+) (\S+)/			yellow,bold,magenta
+
+[nm/t]
+/^(\S+) ([[:lower:]]) (\S+)/		yellow,green+bold,magenta
+/^(\S+) ([[:upper:]]) (\S+)/		yellow,cyan+bold,magenta
+# undefined symbols
+/([Uu] \w+?@@\S+)/			red
+
+[strace/aet]
+# calls to open
+/^(open)\("([^"]+)", (\S+)/		yellow,green,cyan
+# return value
+/= (.+)/				bold
+
+[ltrace/et]
+# syscalls
+/^([^(]+)\(/				green
+
+[id]
+/\d+/g					bold
+
+# ls needs a pseudo-terminal
+[ls/ap]
+# setuid
+/^-[r-][w-]([Ss])/			bold
+# setgid
+/^-[rwx-]{5}([Ss])/			bold
+# sticky bit
+/^d[rwx-]{8}(t)/			bold
+/^(?:\S+)\s+(\d+)\s+(\w+)\s+(\w+)\s+(\d+(?:\.?\d?[KM]?))\s+(\S+\s+\S+\s+\S+)/  green,cyan,yellow,magenta,blue
+
+[ps .*a]
+/^\s*(\d+)\s+(\S+)\s+([^DZ\s]+)\s+(\S+)/  magenta,yellow,green,cyan
+# zombies and uninterruptible sleep
+/^\s*(\d+)\s+(\S+)\s+([DZ]+)\s+(\S+)/	magenta,yellow,red,cyan
+
+[ps -.*(e.*f|f.*e)]
+/^(\S+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)/ green,magenta,magenta,blue,cyan,yellow,cyan
+
+# Apt package utilities
+[apt-cache search]
+/^(.*?) - .*/ 			green
+
+[apt-cache show]
+/^Package: (.*)/		green
+/^Priority: (required)/  	red
+/^Priority: (standard)/		green
+/^Priority: (optional)/		yellow
+/^Description: (.*)/		yellow
+/^Version: (.*)/		blue
+/^Size: (.*)/			magenta
+/^Conflicts: (.*)/		red
+
+[apt-get install]
+/^ +(.*)/			green
+/^.*\[(.*)\]$/			magenta
+
+[apt-get remove]
+/^ +(.*)/			red
+/^.*\[(.*)\]$/			magenta
+
+# some network utilities
+[nmap]
+/^.*\((.*)\).*/				green
+/^(\d+)/(\w+)\s+(open)\s+(\S+)/  	magenta,bold,green,cyan
+/^(\d+)/(\w+)\s+(filtered)\s+(\S+)/  	magenta,bold,yellow,cyan
+/^(\d+)/(\w+)\s+(closed)\s+(\S+)/  	magenta,red,cyan
+
+[netstat]
+/^(\w+)\s+\d+\s+\d+\s+(\S+)\s+(.+)\s+(ESTABLISHED)/ bold,cyan,green,bold
+/^(\w+)\s+\d+\s+\d+\s+(\S+)\s+(.+)\s+(TIME_WAIT)/ bold,cyan,green,yellow
+/^(\w+)\s+\d+\s+\d+\s+(\S+)\s+(.+)\s+(SYN_(?:SENT|RECV))/ bold,cyan,green,magenta
+/^(\w+)\s+\d+\s+\d+\s+(\S+)\s+(.+)\s+(CLOSE(?:_WAIT|ING))/ bold,cyan,green,red
+/^(\w+)\s+\d+\s+\d+\s+(\S+)\s+(.+)\s+(LAST_ACK|FIN_WAIT[12])/ bold,cyan,green,red
+/^(\w+)\s+\d+\s+\d+\s+(\S+)\s+(.+)\s+(CLOSED)/ bold,cyan,green,blue
+
+# some utilities
+[lsmod]
+/^(\w+)\s+(\d+)\s+(\d+)/			green,magenta,bold 
+
+[whereis]
+/^(.+): (.+)/					yellow,bold

data/acoc.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acoc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "acoc"
+  spec.version       = ACOC::VERSION
+  spec.authors       = ["Ian Macdonald"]
+  spec.email         = ["ian@caliban.org"]
+  spec.description   = <<END
+`acoc` is a regular expression based colour formatter for programs
+that display output on the command-line.
+
+It works as a wrapper around the target program, executing it
+and capturing the stdout stream. Optionally, stderr can
+be redirected to stdout, so that it, too, can be manipulated.
+
+`acoc` then applies matching rules to patterns in the output
+and applies colour sets to those matches.
+END
+  spec.summary       = 'Arbitrary Command Output Colourer'
+  spec.homepage      = "http://caliban.org/ruby/acoc.shtml"
+  spec.license       = "GPL-2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "term-ansicolor"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/bin/acoc

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+#   __    __    ___   __
+#  / /\  / /`  / / \ / /`
+# /_/--\ \_\_, \_\_/ \_\_,
+#
+# acoc - Arbitrary Command Output Colorer
+# $Id: acoc,v 1.67 2005/02/27 01:02:24 ianmacd Exp $
+#
+# Version : 0.7.1
+# Author  : Ian Macdonald <ian@caliban.org>
+#
+# Copyright (C) 2003-2005 Ian Macdonald
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2, or (at your option)
+#   any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program; if not, write to the Free Software Foundation,
+#   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+require 'acoc'
+
+begin
+  ACOC.initialise
+
+  if File.lstat($0).symlink?  # we're being invoked via a symlink
+    # Remove symlink's directory from PATH,
+    # multiple times if necessary
+    # Otherwise, acoc will reinvoke itself.
+    ENV['PATH'] = ENV['PATH'].gsub(/#{File.dirname($0)}:?/, '')
+
+    # prefix command line with symlink's name
+    ARGV.unshift 'acoc' # ARGV can now be either exec'ed or popen'ed
+  end
+
+  ACOC.usage   if ARGV.empty? || %w[-h --help].include?(ARGV[0])
+  ACOC.version if %w[-v --version].include?(ARGV[0])
+
+  # sort the keys to ensure we find the longest (i.e. most specific)
+  # match for the command line, e.g. a config section for [ps ax]
+  # will match before one for [ps a]
+  prog = nil
+  ACOC::cmd.keys.sort { |a,b| b.length <=> a.length }.each do |key|
+    if ARGV.join(' ').match(/^#{key}/)
+      prog = key
+      break
+    end
+  end
+
+  # if there's no config section for this command and no 'default'
+  # section, simply execute it normally.
+  # Do same if $ACOC set to 'none'.
+  ACOC.run(ARGV) if ENV['ACOC'] == 'none' || ! (prog || ACOC::cmd.include?('default'))
+
+  # use default section if no program-specific section available
+  prog ||= 'default'
+
+  # if there's a config section for the command, but no rules to
+  # accompany it, simply execute it normally.
+  # Likewise if STDOUT is not a tty and the 't' flag is
+  # not specified.
+  ACOC.run(ARGV) if ACOC::cmd[prog].specs.empty? ||
+    ! ($stdout.tty? || ACOC::cmd[prog].flags.include?('t'))
+
+  # colour program output
+  ACOC.colour(prog, *ARGV)
+end
+

data/lib/acoc.rb

@@ -0,0 +1,307 @@
+
+require 'English'
+require 'fileutils'
+require 'acoc/version'
+require 'acoc/program'
+require 'acoc/config'
+require 'acoc/rule'
+
+require 'term/ansicolor'
+include Term::ANSIColor
+
+# Optionally requiring Ruby/TPty
+# TODO: How to do it cleanly on `gemspec`,
+#       since it's not a gem.
+begin
+  require 'tpty'
+rescue LoadError
+
+module ACOC
+  module_function
+
+  # All options from the configuration file, in a Hash
+  def cmd
+    @@cmd = Config.new unless defined? @@cmd
+
+    @@cmd
+  end
+
+  # set things up
+  #
+  def initialise
+    # Queen's or Dubya's English?
+    if ENV['LANG'] == "en_US" || ENV['LC_ALL'] == "en_US"
+      @@colour = "color"
+    else
+      @@colour = "colour"
+    end
+
+    config_files = %w(/etc/acoc.conf /usr/local/etc/acoc.conf)
+    config_files << ENV['HOME'] + "/.acoc.conf"
+    config_files << ENV['ACOCRC'] if ENV['ACOCRC']
+
+    # If there's no config file on user's home directory,
+    # we'll place our default one there.
+    #
+    # The default one lies on the same directory as the
+    # rest of the source code.
+    # Since __FILE__ is inside lib/, we'll need to jump
+    # above.
+    #
+    if not File.exists? File.expand_path '~/.acoc.conf'
+      fixed_config = File.expand_path(File.dirname(__FILE__) + '/../acoc.conf')
+
+      FileUtils.cp(fixed_config, File.expand_path('~/.acoc.conf'))
+    end
+
+    if parse_config(*config_files) == 0
+      $stderr.puts "No readable config files found."
+      exit 1
+    end
+  end
+
+  # display usage message and exit
+  #
+  def usage(code = 0)
+    $stderr.puts <<EOF
+Usage: acoc command [arg1 .. argN]
+       acoc [-h|--help|-v|--version]
+EOF
+
+    exit code
+  end
+
+  # display version and copyright message, then exit
+  #
+  def version
+    $stderr.puts <<EOF
+acoc #{ACOC::VERSION}
+
+Copyright 2003-2005 Ian Macdonald <ian@caliban.org>
+This is free software; see the source for copying conditions.
+There is NO warranty; not even for MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE, to the extent permitted by law.
+EOF
+
+    exit
+  end
+
+  # get configuration data
+  #
+  def parse_config(*files)
+    @@cmd   = Config.new
+    parsed = 0
+
+    files.each do |file|
+      $stderr.printf("Attempting to read config file: %s\n", file) if $DEBUG
+      next unless file && FileTest::file?(file) && FileTest::readable?(file)
+
+      begin
+        f = File.open(file) do |f|
+          while line = f.gets do
+            next if line =~ /^(#|$)/     # skip blank lines and comments
+
+            if line =~ /^[@\[]([^\]]+)[@\]]$/  # start of program section
+              # get program invocation
+              progs = $1.split(/\s*,\s*/)
+              progs.each do |prog|
+                invocation, flags = prog.split(%r(/))
+
+                if ! flags.nil? && flags.include?('r')
+                  # remove matching entries for this program
+                  program = invocation.sub(/\s.*$/, '')
+                  @@cmd.each_key do |key|
+                    @@cmd.delete(key) if key =~ /^#{program}\b/
+                  end
+                  flags.delete 'r'
+                end
+
+                # create entry for this program
+                if @@cmd.has_key?(invocation)
+                  @@cmd[invocation].flags += flags unless flags.nil?
+                else
+                  @@cmd[invocation] = Program.new(flags)
+                end
+                prog.sub!(%r(/\w+), '')
+              end
+              next
+            end
+
+            begin
+              regex, flags, colours =
+                /^(.)([^\1]*)\1(g?)\s+(.*)/.match(line)[2..4]
+            rescue
+              $stderr.puts "Ignoring bad config line #{$NR}: #{line}"
+            end
+
+            colours = colours.split(/\s*,\s*/)
+            colours.join(' ').split(/[+\s]+/).each do |colour|
+              raise "#{@@colour} is not a supported #{@@colour}" \
+              unless attributes.collect { |a| a.to_s }.include? colour
+              end
+
+              progs.each do |prog|
+                @@cmd[prog].specs << Rule.new(Regexp.new(regex), flags, colours)
+              end
+            end
+          end
+        rescue Errno::ENOENT
+          $stderr.puts "Failed to open config file: #{$ERROR_INFO}"
+          exit 1
+        rescue
+          $stderr.puts "Error while parsing config file #{file} @ line #{$NR}: #{$ERROR_INFO}"
+          exit 2
+        end
+
+        parsed += 1
+      end
+
+      $stderr.printf("Action data: %s\n", @@cmd.inspect) if $DEBUG
+
+      parsed
+    end
+
+    def trap_signal(signals)
+      signals.each do |signal|
+        trap(signal) do
+          # make sure terminal is never left in a coloured state
+          begin
+            print reset
+          rescue Errno::EPIPE  # Errno::EPIPE can occur when we're being piped
+          end
+
+          # reap the child and collect its exit status
+          # WNOHANG is needed to prevent hang when pty is used
+          begin
+            pid, status = Process.waitpid2(-1, Process::WNOHANG)
+
+          rescue Errno::ECHILD  # Errno::ECHILD can occur in waitpid2
+
+          ensure
+            # exit must be wrapped in at_exit to make sure all output buffers
+            # are flushed. Shift 8 bits to convert exit/signal to just exit status
+            at_exit { exit status.nil? ? 0 : status >> 8 }
+          end
+        end
+      end
+    end
+
+    def run(args)
+      exec(*args)
+    rescue Errno::ENOENT => reason
+      # can't find the program we're supposed to run
+      $stderr.puts reason
+      exit Errno::ENOENT::Errno
+    end
+
+    # match and colour an individual line
+    #
+    def colour_line(prog, line)
+      matched = false
+
+      # act on only the first match unless the /a flag was given
+      return if matched && ! @@cmd[prog].flags.include?('a')
+
+      # get a pattern and attribute set pairing for this command
+      @@cmd[prog].specs.each do |spec|
+
+        if r = spec.regex.match(line)  # line matches this regex
+          matched = true
+          if spec.flags.include? 'g'   # global flag
+            matches = 0
+
+            # perform global substitution
+            line.gsub!(spec.regex) do |match|
+              index = [matches, spec.colours.size - 1].min
+              spec.colours[index].split(/[+\s]+/).each do |colour|
+                match = match.send(colour)
+              end
+              matches += 1
+              match
+            end
+
+          else  # colour each match separately
+            # work from right to left, bracketing each match
+            (r.size - 1).downto(1) do |i|
+              start  = r.begin(i)
+              length = r.end(i) - start
+              index  = [i - 1, spec.colours.size - 1].min
+              ansi_offset = 0
+              spec.colours[index].split(/[+\s]+/).each do |colour|
+                line[start + ansi_offset, length] =
+                  line[start + ansi_offset, length].send(colour)
+                # when applying multiple colours, we apply them one at a
+                # time, so we need to compensate for the start of the string
+                # moving to the right as the colour codes are applied
+                ansi_offset += send(colour).length
+              end
+            end
+          end
+        end
+      end
+
+      line
+    end
+
+    # process program output, one line at a time
+    #
+    def colour(prog, *cmd_line)
+      block = proc do |f|
+        while ! f.eof?
+          begin
+            line = f.gets
+          rescue  # why do we need rescue here?
+            exit  # why the Errno::EIO when running ls(1)?
+          end
+
+          coloured_line = colour_line(prog, line)
+
+          begin
+            print coloured_line
+          rescue Errno::EPIPE => reason   # catch broken pipes
+            $stderr.puts reason
+            exit Errno::EPIPE::Errno
+          end
+
+        end
+      end
+
+      # take care of any embedded single quotes in args expanded from globs
+      cmd_line.map! { |arg| arg.gsub(/'/, %q('"'"')) }
+
+      # prepare command line: requote each argument for the shell
+      cmd_line = "'" << cmd_line.join(%q(' ')) << "'"
+
+      # redirect stderr to stdout if /e flag given
+      cmd_line << " 2>&1" if @@cmd[prog].flags.include? 'e'
+
+      # make sure we don't buffer output when stdout is connected to a pipe
+      $stdout.sync = true
+
+      # install signal handler
+      trap_signal(%w(HUP INT QUIT CLD))
+
+      if @@cmd[prog].flags.include?('p') && $LOADED_FEATURES.include?('tpty.so')
+        # allocate program a pseudo-terminal and run through that
+        pty = TPty.new do |s,|
+          fork do
+            # redirect child streams to slave
+            STDIN.reopen(s)
+            STDOUT.reopen(s)
+            #STDERR.reopen(s)
+            s.close
+            run(cmd_line)
+          end
+        end
+
+        # no buffering on pty
+        # pty.master.sync = true
+        block.call(pty.master)
+      else
+        # execute command
+        IO.popen(cmd_line) { |f| block.call(f) }
+      end
+    end
+  end
+end
+