Gecko [ www.corporacionhdm.com.pe ]

Name	Size	Permission	Date
cgi	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
date	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
digest	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
dl	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
drb	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
fiddle	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
irb	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
json	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
matrix	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
net	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
openssl	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
optparse	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
psych	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
racc	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
rake	[ DIR ]	drwxr-xr-x	2024-03-03 22:50
rbconfig	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
rdoc	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
rexml	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
rinda	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
ripper	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
rss	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
rubygems	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
shell	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
syck	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
test	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
uri	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
webrick	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
x86_64-linux	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
xmlrpc	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
yaml	[ DIR ]	drwxr-xr-x	2024-03-03 22:48
English.rb	5.59 KB	-rw-r--r--	2009-10-02 10:45
abbrev.rb	2.57 KB	-rw-r--r--	2011-05-18 21:19
base64.rb	2.63 KB	-rw-r--r--	2009-10-02 10:45
benchmark.rb	18 KB	-rw-r--r--	2011-06-28 06:09
cgi.rb	9.3 KB	-rw-r--r--	2011-05-16 21:21
cmath.rb	7.22 KB	-rw-r--r--	2011-07-30 14:53
complex.rb	380 B	-rw-r--r--	2009-08-16 15:34
csv.rb	82.66 KB	-rw-r--r--	2011-07-21 21:40
date.rb	946 B	-rw-r--r--	2011-05-21 12:25
debug.rb	23.23 KB	-rw-r--r--	2011-06-28 11:45
delegate.rb	9.74 KB	-rw-r--r--	2011-07-27 19:56
digest.rb	2.24 KB	-rw-r--r--	2011-05-16 20:52
dl.rb	176 B	-rw-r--r--	2010-06-12 15:28
drb.rb	19 B	-rw-r--r--	2009-10-02 10:45
e2mmap.rb	3.8 KB	-rw-r--r--	2011-05-19 00:07
erb.rb	25.72 KB	-rw-r--r--	2012-12-13 05:24
expect.rb	1.33 KB	-rw-r--r--	2011-08-26 23:54
fiddle.rb	928 B	-rw-r--r--	2011-08-16 00:51
fileutils.rb	45.32 KB	-rw-r--r--	2012-02-25 08:11
find.rb	2.03 KB	-rw-r--r--	2011-05-18 21:19
forwardable.rb	7.64 KB	-rw-r--r--	2011-05-22 02:14
getoptlong.rb	15.38 KB	-rw-r--r--	2011-05-19 00:07
gserver.rb	8.83 KB	-rw-r--r--	2013-10-31 14:40
ipaddr.rb	24.92 KB	-rw-r--r--	2013-04-11 02:31
irb.rb	8.34 KB	-rw-r--r--	2011-05-19 00:07
json.rb	1.74 KB	-rw-r--r--	2011-08-30 02:25
kconv.rb	5.74 KB	-rw-r--r--	2010-12-07 11:47
logger.rb	20.85 KB	-rw-r--r--	2011-05-19 00:07
mathn.rb	6.52 KB	-rw-r--r--	2011-08-26 23:54
matrix.rb	47.65 KB	-rw-r--r--	2011-07-09 19:11
mkmf.rb	68.9 KB	-rw-r--r--	2014-02-06 05:20
monitor.rb	6.94 KB	-rw-r--r--	2011-06-17 22:33
mutex_m.rb	1.61 KB	-rw-r--r--	2011-05-19 00:07
observer.rb	5.69 KB	-rw-r--r--	2011-05-16 21:53
open-uri.rb	25.84 KB	-rw-r--r--	2014-02-24 03:43
open3.rb	20.64 KB	-rw-r--r--	2011-05-18 21:19
openssl.rb	547 B	-rw-r--r--	2011-07-25 06:38
optparse.rb	51.13 KB	-rw-r--r--	2014-02-14 04:52
ostruct.rb	6.49 KB	-rw-r--r--	2012-02-24 14:49
pathname.rb	14.21 KB	-rw-r--r--	2011-08-26 23:54
pp.rb	13.31 KB	-rw-r--r--	2010-08-01 14:09
prettyprint.rb	9.63 KB	-rw-r--r--	2011-08-02 15:25
prime.rb	13.98 KB	-rw-r--r--	2011-06-01 00:21
profile.rb	205 B	-rw-r--r--	2009-10-02 10:45
profiler.rb	1.59 KB	-rw-r--r--	2009-10-02 10:45
pstore.rb	15.81 KB	-rw-r--r--	2011-10-10 23:14
psych.rb	9.82 KB	-rw-r--r--	2012-08-07 20:50
rake.rb	2.02 KB	-rw-r--r--	2011-06-29 03:09
rational.rb	308 B	-rw-r--r--	2009-09-24 00:42
rdoc.rb	4.29 KB	-rw-r--r--	2013-02-06 08:00
resolv-replace.rb	1.74 KB	-rw-r--r--	2010-10-29 22:02
resolv.rb	59.91 KB	-rw-r--r--	2014-02-14 06:56
ripper.rb	91 B	-rw-r--r--	2009-10-02 10:45
rss.rb	2.84 KB	-rw-r--r--	2011-05-11 10:22
rubygems.rb	34.13 KB	-rw-r--r--	2013-12-22 04:38
scanf.rb	23.53 KB	-rw-r--r--	2011-05-20 12:22
securerandom.rb	8.46 KB	-rw-r--r--	2012-05-07 11:25
set.rb	29.91 KB	-rw-r--r--	2012-02-10 08:28
shell.rb	5.9 KB	-rw-r--r--	2011-05-19 00:07
shellwords.rb	3.88 KB	-rw-r--r--	2012-02-12 07:51
singleton.rb	4.02 KB	-rw-r--r--	2011-05-18 14:09
socket.rb	23.22 KB	-rw-r--r--	2014-01-30 12:04
syck.rb	13.91 KB	-rw-r--r--	2010-07-19 04:54
sync.rb	6.87 KB	-rw-r--r--	2011-06-29 03:09
tempfile.rb	10.42 KB	-rw-r--r--	2013-10-31 14:44
thread.rb	6.59 KB	-rw-r--r--	2014-02-14 03:48
thwait.rb	3.38 KB	-rw-r--r--	2011-06-29 03:09
time.rb	17.03 KB	-rw-r--r--	2013-10-31 14:06
timeout.rb	3.26 KB	-rw-r--r--	2013-04-02 04:09
tmpdir.rb	3.72 KB	-rw-r--r--	2011-05-18 21:19
tracer.rb	6.63 KB	-rw-r--r--	2011-06-29 13:19
tsort.rb	6.79 KB	-rw-r--r--	2009-03-06 04:23
ubygems.rb	268 B	-rw-r--r--	2009-10-02 10:45
un.rb	8.32 KB	-rw-r--r--	2011-05-19 00:07
uri.rb	3.07 KB	-rw-r--r--	2011-05-13 20:03
weakref.rb	2.29 KB	-rw-r--r--	2011-08-26 23:54
webrick.rb	6.8 KB	-rw-r--r--	2011-05-10 23:37
yaml.rb	2.58 KB	-rw-r--r--	2013-05-29 12:00

Rename

#
# = open3.rb: Popen, but with stderr, too
#
# Author:: Yukihiro Matsumoto
# Documentation:: Konrad Meyer
#
# Open3 gives you access to stdin, stdout, and stderr when running other
# programs.
#

#
# Open3 grants you access to stdin, stdout, stderr and a thread to wait the
# child process when running another program.
# You can specify various attributes, redirections, current directory, etc., of
# the program as Process.spawn.
#
# - Open3.popen3 : pipes for stdin, stdout, stderr
# - Open3.popen2 : pipes for stdin, stdout
# - Open3.popen2e : pipes for stdin, merged stdout and stderr
# - Open3.capture3 : give a string for stdin.  get strings for stdout, stderr
# - Open3.capture2 : give a string for stdin.  get a string for stdout
# - Open3.capture2e : give a string for stdin.  get a string for merged stdout and stderr
# - Open3.pipeline_rw : pipes for first stdin and last stdout of a pipeline
# - Open3.pipeline_r : pipe for last stdout of a pipeline
# - Open3.pipeline_w : pipe for first stdin of a pipeline
# - Open3.pipeline_start : a pipeline
# - Open3.pipeline : run a pipline and wait
#

module Open3

# Open stdin, stdout, and stderr streams and start external executable.
  # In addition, a thread for waiting the started process is noticed.
  # The thread has a pid method and thread variable :pid which is the pid of
  # the started process.
  #
  # Block form:
  #
  #   Open3.popen3([env,] cmd... [, opts]) {|stdin, stdout, stderr, wait_thr|
  #     pid = wait_thr.pid # pid of the started process.
  #     ...
  #     exit_status = wait_thr.value # Process::Status object returned.
  #   }
  #
  # Non-block form:
  #
  #   stdin, stdout, stderr, wait_thr = Open3.popen3([env,] cmd... [, opts])
  #   pid = wait_thr[:pid]  # pid of the started process.
  #   ...
  #   stdin.close  # stdin, stdout and stderr should be closed explicitly in this form.
  #   stdout.close
  #   stderr.close
  #   exit_status = wait_thr.value  # Process::Status object returned.
  #
  # The parameters +cmd...+ is passed to Process.spawn.
  # So a commandline string and list of argument strings can be accepted as follows.
  #
  #   Open3.popen3("echo a") {|i, o, e, t| ... }
  #   Open3.popen3("echo", "a") {|i, o, e, t| ... }
  #   Open3.popen3(["echo", "argv0"], "a") {|i, o, e, t| ... }
  #
  # If the last parameter, opts, is a Hash, it is recognized as an option for Process.spawn.
  #
  #   Open3.popen3("pwd", :chdir=>"/") {|i,o,e,t|
  #     p o.read.chomp #=> "/"
  #   }
  #
  # wait_thr.value waits the termination of the process.
  # The block form also waits the process when it returns.
  #
  # Closing stdin, stdout and stderr does not wait the process.
  #
  def popen3(*cmd, &block)
    if Hash === cmd.last
      opts = cmd.pop.dup
    else
      opts = {}
    end

in_r, in_w = IO.pipe
    opts[:in] = in_r
    in_w.sync = true

out_r, out_w = IO.pipe
    opts[:out] = out_w

err_r, err_w = IO.pipe
    opts[:err] = err_w

popen_run(cmd, opts, [in_r, out_w, err_w], [in_w, out_r, err_r], &block)
  end
  module_function :popen3

# Open3.popen2 is similer to Open3.popen3 except it doesn't make a pipe for
  # the standard error stream.
  #
  # Block form:
  #
  #   Open3.popen2([env,] cmd... [, opts]) {|stdin, stdout, wait_thr|
  #     pid = wait_thr.pid # pid of the started process.
  #     ...
  #     exit_status = wait_thr.value # Process::Status object returned.
  #   }
  #
  # Non-block form:
  #
  #   stdin, stdout, wait_thr = Open3.popen2([env,] cmd... [, opts])
  #   ...
  #   stdin.close  # stdin and stdout should be closed explicitly in this form.
  #   stdout.close
  #
  # See Process.spawn for the optional hash arguments _env_ and _opts_.
  #
  # Example:
  #
  #   Open3.popen2("wc -c") {|i,o,t|
  #     i.print "answer to life the universe and everything"
  #     i.close
  #     p o.gets #=> "42\n"
  #   }
  #
  #   Open3.popen2("bc -q") {|i,o,t|
  #     i.puts "obase=13"
  #     i.puts "6 * 9"
  #     p o.gets #=> "42\n"
  #   }
  #
  #   Open3.popen2("dc") {|i,o,t|
  #     i.print "42P"
  #     i.close
  #     p o.read #=> "*"
  #   }
  #
  def popen2(*cmd, &block)
    if Hash === cmd.last
      opts = cmd.pop.dup
    else
      opts = {}
    end

in_r, in_w = IO.pipe
    opts[:in] = in_r
    in_w.sync = true

out_r, out_w = IO.pipe
    opts[:out] = out_w

popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
  end
  module_function :popen2

# Open3.popen2e is similer to Open3.popen3 except it merges
  # the standard output stream and the standard error stream.
  #
  # Block form:
  #
  #   Open3.popen2e([env,] cmd... [, opts]) {|stdin, stdout_and_stderr, wait_thr|
  #     pid = wait_thr.pid # pid of the started process.
  #     ...
  #     exit_status = wait_thr.value # Process::Status object returned.
  #   }
  #
  # Non-block form:
  #
  #   stdin, stdout_and_stderr, wait_thr = Open3.popen2e([env,] cmd... [, opts])
  #   ...
  #   stdin.close  # stdin and stdout_and_stderr should be closed explicitly in this form.
  #   stdout_and_stderr.close
  #
  # See Process.spawn for the optional hash arguments _env_ and _opts_.
  #
  # Example:
  #   # check gcc warnings
  #   source = "foo.c"
  #   Open3.popen2e("gcc", "-Wall", source) {|i,oe,t|
  #     oe.each {|line|
  #       if /warning/ =~ line
  #         ...
  #       end
  #     }
  #   }
  #
  def popen2e(*cmd, &block)
    if Hash === cmd.last
      opts = cmd.pop.dup
    else
      opts = {}
    end

in_r, in_w = IO.pipe
    opts[:in] = in_r
    in_w.sync = true

out_r, out_w = IO.pipe
    opts[[:out, :err]] = out_w

popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
  end
  module_function :popen2e

def popen_run(cmd, opts, child_io, parent_io) # :nodoc:
    pid = spawn(*cmd, opts)
    wait_thr = Process.detach(pid)
    child_io.each {|io| io.close }
    result = [*parent_io, wait_thr]
    if defined? yield
      begin
        return yield(*result)
      ensure
        parent_io.each{|io| io.close unless io.closed?}
        wait_thr.join
      end
    end
    result
  end
  module_function :popen_run
  class << self
    private :popen_run
  end

# Open3.capture3 captures the standard output and the standard error of a command.
  #
  #   stdout_str, stderr_str, status = Open3.capture3([env,] cmd... [, opts])
  #
  # The arguments env, cmd and opts are passed to Open3.popen3 except
  # opts[:stdin_data] and opts[:binmode].  See Process.spawn.
  #
  # If opts[:stdin_data] is specified, it is sent to the command's standard input.
  #
  # If opts[:binmode] is true, internal pipes are set to binary mode.
  #
  # Example:
  #
  #   # dot is a command of graphviz.
  #   graph = <<'End'
  #     digraph g {
  #       a -> b
  #     }
  #   End
  #   layouted_graph, dot_log = Open3.capture3("dot -v", :stdin_data=>graph)
  #
  #   o, e, s = Open3.capture3("echo a; sort >&2", :stdin_data=>"foo\nbar\nbaz\n")
  #   p o #=> "a\n"
  #   p e #=> "bar\nbaz\nfoo\n"
  #   p s #=> #<Process::Status: pid 32682 exit 0>
  #
  #   # generate a thumnail image using the convert command of ImageMagick.
  #   # However, if the image stored really in a file,
  #   # system("convert", "-thumbnail", "80", "png:#{filename}", "png:-") is better
  #   # because memory consumption.
  #   # But if the image is stored in a DB or generated by gnuplot Open3.capture2 example,
  #   # Open3.capture3 is considerable.
  #   #
  #   image = File.read("/usr/share/openclipart/png/animals/mammals/sheep-md-v0.1.png", :binmode=>true)
  #   thumnail, err, s = Open3.capture3("convert -thumbnail 80 png:- png:-", :stdin_data=>image, :binmode=>true)
  #   if s.success?
  #     STDOUT.binmode; print thumnail
  #   end
  #
  def capture3(*cmd, &block)
    if Hash === cmd.last
      opts = cmd.pop.dup
    else
      opts = {}
    end

stdin_data = opts.delete(:stdin_data) || ''
    binmode = opts.delete(:binmode)

popen3(*cmd, opts) {|i, o, e, t|
      if binmode
        i.binmode
        o.binmode
        e.binmode
      end
      out_reader = Thread.new { o.read }
      err_reader = Thread.new { e.read }
      i.write stdin_data
      i.close
      [out_reader.value, err_reader.value, t.value]
    }
  end
  module_function :capture3

# Open3.capture2 captures the standard output of a command.
  #
  #   stdout_str, status = Open3.capture2([env,] cmd... [, opts])
  #
  # The arguments env, cmd and opts are passed to Open3.popen3 except
  # opts[:stdin_data] and opts[:binmode].  See Process.spawn.
  #
  # If opts[:stdin_data] is specified, it is sent to the command's standard input.
  #
  # If opts[:binmode] is true, internal pipes are set to binary mode.
  #
  # Example:
  #
  #   # factor is a command for integer factorization.
  #   o, s = Open3.capture2("factor", :stdin_data=>"42")
  #   p o #=> "42: 2 3 7\n"
  #
  #   # generate x**2 graph in png using gnuplot.
  #   gnuplot_commands = <<"End"
  #     set terminal png
  #     plot x**2, "-" with lines
  #     1 14
  #     2 1
  #     3 8
  #     4 5
  #     e
  #   End
  #   image, s = Open3.capture2("gnuplot", :stdin_data=>gnuplot_commands, :binmode=>true)
  #
  def capture2(*cmd, &block)
    if Hash === cmd.last
      opts = cmd.pop.dup
    else
      opts = {}
    end

stdin_data = opts.delete(:stdin_data) || ''
    binmode = opts.delete(:binmode)

popen2(*cmd, opts) {|i, o, t|
      if binmode
        i.binmode
        o.binmode
      end
      out_reader = Thread.new { o.read }
      i.write stdin_data
      i.close
      [out_reader.value, t.value]
    }
  end
  module_function :capture2

# Open3.capture2e captures the standard output and the standard error of a command.
  #
  #   stdout_and_stderr_str, status = Open3.capture2e([env,] cmd... [, opts])
  #
  # The arguments env, cmd and opts are passed to Open3.popen3 except
  # opts[:stdin_data] and opts[:binmode].  See Process.spawn.
  #
  # If opts[:stdin_data] is specified, it is sent to the command's standard input.
  #
  # If opts[:binmode] is true, internal pipes are set to binary mode.
  #
  # Example:
  #
  #   # capture make log
  #   make_log, s = Open3.capture2e("make")
  #
  def capture2e(*cmd, &block)
    if Hash === cmd.last
      opts = cmd.pop.dup
    else
      opts = {}
    end

stdin_data = opts.delete(:stdin_data) || ''
    binmode = opts.delete(:binmode)

popen2e(*cmd, opts) {|i, oe, t|
      if binmode
        i.binmode
        oe.binmode
      end
      outerr_reader = Thread.new { oe.read }
      i.write stdin_data
      i.close
      [outerr_reader.value, t.value]
    }
  end
  module_function :capture2e

# Open3.pipeline_rw starts a list of commands as a pipeline with pipes
  # which connects stdin of the first command and stdout of the last command.
  #
  #   Open3.pipeline_rw(cmd1, cmd2, ... [, opts]) {|first_stdin, last_stdout, wait_threads|
  #     ...
  #   }
  #
  #   first_stdin, last_stdout, wait_threads = Open3.pipeline_rw(cmd1, cmd2, ... [, opts])
  #   ...
  #   first_stdin.close
  #   last_stdout.close
  #
  # Each cmd is a string or an array.
  # If it is an array, the elements are passed to Process.spawn.
  #
  #   cmd:
  #     commandline                              command line string which is passed to a shell
  #     [env, commandline, opts]                 command line string which is passed to a shell
  #     [env, cmdname, arg1, ..., opts]          command name and one or more arguments (no shell)
  #     [env, [cmdname, argv0], arg1, ..., opts] command name and arguments including argv[0] (no shell)
  #
  #   Note that env and opts are optional, as Process.spawn.
  #
  # The option to pass Process.spawn is constructed by merging
  # +opts+, the last hash element of the array and
  # specification for the pipe between each commands.
  #
  # Example:
  #
  #   Open3.pipeline_rw("tr -dc A-Za-z", "wc -c") {|i,o,ts|
  #     i.puts "All persons more than a mile high to leave the court."
  #     i.close
  #     p o.gets #=> "42\n"
  #   }
  #
  #   Open3.pipeline_rw("sort", "cat -n") {|stdin, stdout, wait_thrs|
  #     stdin.puts "foo"
  #     stdin.puts "bar"
  #     stdin.puts "baz"
  #     stdin.close     # send EOF to sort.
  #     p stdout.read   #=> "     1\tbar\n     2\tbaz\n     3\tfoo\n"
  #   }
  def pipeline_rw(*cmds, &block)
    if Hash === cmds.last
      opts = cmds.pop.dup
    else
      opts = {}
    end

in_r, in_w = IO.pipe
    opts[:in] = in_r
    in_w.sync = true

out_r, out_w = IO.pipe
    opts[:out] = out_w

pipeline_run(cmds, opts, [in_r, out_w], [in_w, out_r], &block)
  end
  module_function :pipeline_rw

# Open3.pipeline_r starts a list of commands as a pipeline with a pipe
  # which connects stdout of the last command.
  #
  #   Open3.pipeline_r(cmd1, cmd2, ... [, opts]) {|last_stdout, wait_threads|
  #     ...
  #   }
  #
  #   last_stdout, wait_threads = Open3.pipeline_r(cmd1, cmd2, ... [, opts])
  #   ...
  #   last_stdout.close
  #
  # Each cmd is a string or an array.
  # If it is an array, the elements are passed to Process.spawn.
  #
  #   cmd:
  #     commandline                              command line string which is passed to a shell
  #     [env, commandline, opts]                 command line string which is passed to a shell
  #     [env, cmdname, arg1, ..., opts]          command name and one or more arguments (no shell)
  #     [env, [cmdname, argv0], arg1, ..., opts] command name and arguments including argv[0] (no shell)
  #
  #   Note that env and opts are optional, as Process.spawn.
  #
  # Example:
  #
  #   Open3.pipeline_r("zcat /var/log/apache2/access.log.*.gz",
  #                    [{"LANG"=>"C"}, "grep", "GET /favicon.ico"],
  #                    "logresolve") {|o, ts|
  #     o.each_line {|line|
  #       ...
  #     }
  #   }
  #
  #   Open3.pipeline_r("yes", "head -10") {|o, ts|
  #     p o.read      #=> "y\ny\ny\ny\ny\ny\ny\ny\ny\ny\n"
  #     p ts[0].value #=> #<Process::Status: pid 24910 SIGPIPE (signal 13)>
  #     p ts[1].value #=> #<Process::Status: pid 24913 exit 0>
  #   }
  #
  def pipeline_r(*cmds, &block)
    if Hash === cmds.last
      opts = cmds.pop.dup
    else
      opts = {}
    end

out_r, out_w = IO.pipe
    opts[:out] = out_w

pipeline_run(cmds, opts, [out_w], [out_r], &block)
  end
  module_function :pipeline_r

# Open3.pipeline_w starts a list of commands as a pipeline with a pipe
  # which connects stdin of the first command.
  #
  #   Open3.pipeline_w(cmd1, cmd2, ... [, opts]) {|first_stdin, wait_threads|
  #     ...
  #   }
  #
  #   first_stdin, wait_threads = Open3.pipeline_w(cmd1, cmd2, ... [, opts])
  #   ...
  #   first_stdin.close
  #
  # Each cmd is a string or an array.
  # If it is an array, the elements are passed to Process.spawn.
  #
  #   cmd:
  #     commandline                              command line string which is passed to a shell
  #     [env, commandline, opts]                 command line string which is passed to a shell
  #     [env, cmdname, arg1, ..., opts]          command name and one or more arguments (no shell)
  #     [env, [cmdname, argv0], arg1, ..., opts] command name and arguments including argv[0] (no shell)
  #
  #   Note that env and opts are optional, as Process.spawn.
  #
  # Example:
  #
  #   Open3.pipeline_w("bzip2 -c", :out=>"/tmp/hello.bz2") {|i, ts|
  #     i.puts "hello"
  #   }
  #
  def pipeline_w(*cmds, &block)
    if Hash === cmds.last
      opts = cmds.pop.dup
    else
      opts = {}
    end

in_r, in_w = IO.pipe
    opts[:in] = in_r
    in_w.sync = true

pipeline_run(cmds, opts, [in_r], [in_w], &block)
  end
  module_function :pipeline_w

# Open3.pipeline_start starts a list of commands as a pipeline.
  # No pipe made for stdin of the first command and
  # stdout of the last command.
  #
  #   Open3.pipeline_start(cmd1, cmd2, ... [, opts]) {|wait_threads|
  #     ...
  #   }
  #
  #   wait_threads = Open3.pipeline_start(cmd1, cmd2, ... [, opts])
  #   ...
  #
  # Each cmd is a string or an array.
  # If it is an array, the elements are passed to Process.spawn.
  #
  #   cmd:
  #     commandline                              command line string which is passed to a shell
  #     [env, commandline, opts]                 command line string which is passed to a shell
  #     [env, cmdname, arg1, ..., opts]          command name and one or more arguments (no shell)
  #     [env, [cmdname, argv0], arg1, ..., opts] command name and arguments including argv[0] (no shell)
  #
  #   Note that env and opts are optional, as Process.spawn.
  #
  # Example:
  #
  #   # run xeyes in 10 seconds.
  #   Open3.pipeline_start("xeyes") {|ts|
  #     sleep 10
  #     t = ts[0]
  #     Process.kill("TERM", t.pid)
  #     p t.value #=> #<Process::Status: pid 911 SIGTERM (signal 15)>
  #   }
  #
  #   # convert pdf to ps and send it to a printer.
  #   # collect error message of pdftops and lpr.
  #   pdf_file = "paper.pdf"
  #   printer = "printer-name"
  #   err_r, err_w = IO.pipe
  #   Open3.pipeline_start(["pdftops", pdf_file, "-"],
  #                        ["lpr", "-P#{printer}"],
  #                        :err=>err_w) {|ts|
  #     err_w.close
  #     p err_r.read # error messages of pdftops and lpr.
  #   }
  #
  def pipeline_start(*cmds, &block)
    if Hash === cmds.last
      opts = cmds.pop.dup
    else
      opts = {}
    end

if block
      pipeline_run(cmds, opts, [], [], &block)
    else
      ts, = pipeline_run(cmds, opts, [], [])
      ts
    end
  end
  module_function :pipeline_start

# Open3.pipeline starts a list of commands as a pipeline.
  # It waits the finish of the commands.
  # No pipe made for stdin of the first command and
  # stdout of the last command.
  #
  #   status_list = Open3.pipeline(cmd1, cmd2, ... [, opts])
  #
  # Each cmd is a string or an array.
  # If it is an array, the elements are passed to Process.spawn.
  #
  #   cmd:
  #     commandline                              command line string which is passed to a shell
  #     [env, commandline, opts]                 command line string which is passed to a shell
  #     [env, cmdname, arg1, ..., opts]          command name and one or more arguments (no shell)
  #     [env, [cmdname, argv0], arg1, ..., opts] command name and arguments including argv[0] (no shell)
  #
  #   Note that env and opts are optional, as Process.spawn.
  #
  # Example:
  #
  #   fname = "/usr/share/man/man1/ruby.1.gz"
  #   p Open3.pipeline(["zcat", fname], "nroff -man", "less")
  #   #=> [#<Process::Status: pid 11817 exit 0>,
  #   #    #<Process::Status: pid 11820 exit 0>,
  #   #    #<Process::Status: pid 11828 exit 0>]
  #
  #   fname = "/usr/share/man/man1/ls.1.gz"
  #   Open3.pipeline(["zcat", fname], "nroff -man", "colcrt")
  #
  #   # convert PDF to PS and send to a printer by lpr
  #   pdf_file = "paper.pdf"
  #   printer = "printer-name"
  #   Open3.pipeline(["pdftops", pdf_file, "-"],
  #                  ["lpr", "-P#{printer}"])
  #
  #   # count lines
  #   Open3.pipeline("sort", "uniq -c", :in=>"names.txt", :out=>"count")
  #
  #   # cyclic pipeline
  #   r,w = IO.pipe
  #   w.print "ibase=14\n10\n"
  #   Open3.pipeline("bc", "tee /dev/tty", :in=>r, :out=>w)
  #   #=> 14
  #   #   18
  #   #   22
  #   #   30
  #   #   42
  #   #   58
  #   #   78
  #   #   106
  #   #   202
  #
  def pipeline(*cmds)
    if Hash === cmds.last
      opts = cmds.pop.dup
    else
      opts = {}
    end

pipeline_run(cmds, opts, [], []) {|ts|
      ts.map {|t| t.value }
    }
  end
  module_function :pipeline

def pipeline_run(cmds, pipeline_opts, child_io, parent_io, &block) # :nodoc:
    if cmds.empty?
      raise ArgumentError, "no commands"
    end

opts_base = pipeline_opts.dup
    opts_base.delete :in
    opts_base.delete :out

wait_thrs = []
    r = nil
    cmds.each_with_index {|cmd, i|
      cmd_opts = opts_base.dup
      if String === cmd
        cmd = [cmd]
      else
        cmd_opts.update cmd.pop if Hash === cmd.last
      end
      if i == 0
        if !cmd_opts.include?(:in)
          if pipeline_opts.include?(:in)
            cmd_opts[:in] = pipeline_opts[:in]
          end
        end
      else
        cmd_opts[:in] = r
      end
      if i != cmds.length - 1
        r2, w2 = IO.pipe
        cmd_opts[:out] = w2
      else
        if !cmd_opts.include?(:out)
          if pipeline_opts.include?(:out)
            cmd_opts[:out] = pipeline_opts[:out]
          end
        end
      end
      pid = spawn(*cmd, cmd_opts)
      wait_thrs << Process.detach(pid)
      r.close if r
      w2.close if w2
      r = r2
    }
    result = parent_io + [wait_thrs]
    child_io.each {|io| io.close }
    if defined? yield
      begin
        return yield(*result)
      ensure
        parent_io.each{|io| io.close unless io.closed?}
        wait_thrs.each {|t| t.join }
      end
    end
    result
  end
  module_function :pipeline_run
  class << self
    private :pipeline_run
  end

end

if $0 == __FILE__
  a = Open3.popen3("nroff -man")
  Thread.start do
    while line = gets
      a[0].print line
    end
    a[0].close
  end
  while line = a[1].gets
    print ":", line
  end
end