ver 2010.02 → 2010.08

data/lib/ver/undo.rb

@@ -24,7 +24,12 @@ module VER
     # together.
     # It would also be handy if these operations could be identified
     # automagically (like multiple operations within one record block).
-    class Tree < Struct.new(:widget, :applied, :pending)
+    class Tree < Struct.new(:widget, :applied, :pending, :stack, :recording)
+      def initialize(widget)
+        self.widget = widget
+        self.stack = []
+      end
+
       def record_multi
         AutoSeparator.new self do |auto_separator|
           yield auto_separator
@@ -34,17 +39,27 @@ module VER
       end
 
       def record
-        current = Record.new(widget, applied)
+        if recording
+          stack << Proc.new
+        else
+          self.recording = true
+          current = Record.new(self, widget, applied)
 
-        yield current
+          yield current
 
-        applied.next = current if applied = self.applied
+          applied.next = current if applied = self.applied
 
-        self.applied = current
-        self.applied = current
-        self.pending = nil
+          self.applied = current
+          self.applied = current
+          self.pending = nil
 
-        compact!
+          compact!
+          self.recording = false
+
+          if pending = stack.shift
+            record(&pending)
+          end
+        end
       end
 
       # Undo last applied change so it becomes the next pending change.
@@ -142,11 +157,11 @@ module VER
     #
     # The applied property indicates whether or not this change has been applied
     # already.
-    class Record < Struct.new(:widget, :parent, :ctime, :childs, :applied,
-                              :undo_info, :redo_info, :separator)
+    class Record < Struct.new(:tree, :widget, :parent, :ctime, :childs,
+                              :applied, :undo_info, :redo_info, :separator)
 
-      def initialize(widget, parent = nil)
-        self.widget, self.parent = widget, parent
+      def initialize(tree, widget, parent = nil)
+        self.tree, self.widget, self.parent = tree, widget, parent
         self.ctime = Time.now
         self.childs = []
         self.applied = false
@@ -157,38 +172,50 @@ module VER
         pos = index(pos)
 
         widget.execute_only(:insert, pos, string, tag)
-        widget.touch!(pos.linestart, (pos + string.size).lineend)
+        widget.touch!(pos, "#{pos} + #{string.size} chars")
 
         self.redo_info = [:insert, pos, string, tag]
-        self.undo_info = [pos, pos + string.size, '']
+        self.undo_info = [pos, index("#{pos} + #{string.size} chars"), '']
         self.applied = true
         pos
       end
 
-      def replace(from, to, string)
+      def replace(from, to, string, tag = Tk::None)
         from, to = indices(from, to)
 
         data = widget.get(from, to)
-        widget.execute_only(:replace, from, to, string)
-        widget.touch!(from.linestart, to.lineend)
+        widget.execute_only(:replace, from, to, string, tag)
+        widget.touch!(from, to)
 
-        self.redo_info = [:replace, from, to, string]
-        self.undo_info = [from, from + string.size, data]
+        self.redo_info = [:replace, from, to, string, tag]
+        self.undo_info = [from, index("#{from} + #{string.size} chars"), data]
         self.applied = true
         from
       end
 
-      def delete(from, to)
-        from, to = indices(from, to)
-
-        data = widget.get(from, to)
-        widget.execute_only(:delete, from, to)
-        widget.touch!(from.linestart, to.lineend)
-
-        self.redo_info = [:delete, from, to]
-        self.undo_info = [from, from, data]
-        self.applied = true
-        from
+      def delete(*indices)
+        case indices.size
+        when 0
+          return
+        when 1 # pad to two
+          index = index(*indices)
+          delete(index, index + '1 chars')
+        when 2
+          first, last = indices(*indices)
+
+          data = widget.get(first, last)
+          widget.execute_only(:delete, first, last)
+          widget.touch!(first, last)
+
+          self.redo_info = [:delete, first, last]
+          self.undo_info = [first, first, data]
+          self.applied = true
+          first
+        else # sanitize and chunk into deletes
+          sanitize(*indices).map{|first, last|
+            tree.record{|rec| rec.delete(first, last) }
+          }.last
+        end
       end
 
       def undo
@@ -196,7 +223,7 @@ module VER
 
         from, to, string = undo_info
         widget.execute_only(:replace, from, to, string)
-        widget.touch!(from.linestart, to.lineend)
+        widget.touch!(from, to)
         widget.mark_set(:insert, from)
 
         self.applied = false
@@ -228,7 +255,7 @@ module VER
 
           # the records have to be consecutive so they can still be applied by a
           # single undo/redo
-          consecutive = (predo_pos + predo_string.size) == sredo_pos
+          consecutive = index("#{predo_pos} + #{predo_string.size} chars") == sredo_pos
           return parent.compact! unless consecutive
 
           redo_string = "#{predo_string}#{sredo_string}"
@@ -288,9 +315,9 @@ module VER
       end
 
       def indices(*given_indices)
-        given_indices.map do |index|
+        given_indices.map{|index|
           index.respond_to?(:to_index) ? index.to_index : widget.index(index)
-        end
+        }.sort
       end
 
       def index(given_index)
@@ -301,6 +328,54 @@ module VER
         end
       end
 
+      # Multi-index pair case requires that we prevalidate the indices and sort
+      # from last to first so that deletes occur in the exact (unshifted) text.
+      # It also needs to handle partial and fully overlapping ranges. We have to
+      # do this with multiple passes.
+      def sanitize(*indices)
+        raise ArgumentError if indices.size % 2 != 0
+
+        # first we get the real indices
+        indices = indices.map{|index| widget.index(index) }
+
+        # pair them, to make later code easier.
+        indices = indices.each_slice(2).to_a
+
+        # then we sort the indices in increasing order
+        indices = indices.sort
+
+        # Now we eliminate ranges where end is before start.
+        indices = indices.select{|st, en| st <= en }
+
+        # And finally we merge ranges where the end is after the start of a
+        # following range.
+        final = []
+
+        while rang = indices.shift
+          if prev = final.last
+            prev_start, prev_end = prev.at(0), prev.at(1)
+            rang_start, rang_end = rang.at(0), rang.at(1)
+          else
+            final << rang
+            next
+          end
+
+          if prev_start == rang_start
+            # starts are overlapping, use longer end
+            prev[1] = [prev_end, rang_end].max
+          elsif prev_end >= rang_start
+            # prev end is overlapping rang start, use longer end
+            prev[1] = [prev_end, rang_end].max
+          elsif prev_end >= rang_end
+            # prev end is overlapping rang end, skip
+          else
+            final << rang
+          end
+        end
+
+        final.reverse
+      end
+
       def inspect
         "#<Undo::Record sep=%p undo=%p redo=%p>" % [separator, undo_info, redo_info]
       end

data/lib/ver/vendor/eval_completer.rb

@@ -0,0 +1,184 @@
+module VER
+  # Completion based on some code of IRB::InputCompleter
+  #
+  # Copyright by Keiju ISHITSUKA <keiju@ishitsuka.com>
+  #          and Michael Fellinger <m.fellinger@gmail.com>
+  # From Original Idea of shugo@ruby-lang.org
+  module EvalCompleter
+    ReservedWords = %w[
+      BEGIN END alias and begin break case class def defined do else elsif end
+      ensure false for if in module next nil not or redo rescue retry return self
+      super then true undef unless until when while yield
+    ]
+
+    Operators = %w[
+      % & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~
+    ]
+
+    WordBreak = /[\t\n"'`><=;|&{(]/
+
+    module_function
+
+    def complete(input, bind = TOPLEVEL_BINDING)
+      case input
+      when /^(\/[^\/]*\/)\.([^.]*)$/
+        complete_regexp_method($1, Regexp.quote($2))
+      when /^([^\]]*\])\.([^.]*)$/
+        complete_array_method($1, Regexp.quote($2))
+      when /^([^\}]*\})\.([^.]*)$/
+        complete_proc_or_hash_method($1, Regexp.quote($2))
+      when /^(:[^:.]*)$/
+        complete_symbol(Regexp.quote($1))
+      when /^::([A-Z][^:\.\(]*)$/
+        complete_absolute_constant_or_class_method(Regexp.quote($1))
+      when /^(((::)?[A-Z][^:.\(]*)+)::?([^:.]*)$/
+        complete_constant_or_class_method(bind, $1, Regexp.quote($4))
+      when /^(:[^:.]+)\.([^.]*)$/
+        complete_symbol_method($1, Regexp.quote($2))
+      when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
+        complete_numeric_method(bind, $1, Regexp.quote($5))
+      when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
+        complete_numeric_hex_method(bind, $1, Regexp.quote($2))
+      when /^(\$[^.]*)$/
+        complete_global_variable(Regexp.new(Regexp.quote($1)))
+      when /^((\.?[^.]+)+)\.([^.]*)$/
+        complete_variable(bind, $1, Regexp.quote($3))
+      when /^\.([^.]*)$/
+        complete_unknown(Regexp.quote($1))
+      else
+        complete_else(bind, Regexp.quote(input))
+      end
+    end
+
+    def complete_regexp_method(receiver, message)
+      candidates = Regexp.instance_methods
+      select_message(receiver, message, candidates)
+    end
+
+    def complete_array_method(receiver, message)
+      candidates = Array.instance_methods
+      select_message(receiver, message, candidates)
+    end
+
+    def complete_proc_or_hash_method(receiver, message)
+      candidates = Proc.instance_methods
+      candidates |= Hash.instance_methods
+      select_message(receiver, message, candidates)
+    end
+
+    def complete_symbol(sym)
+      candidates = Symbol.all_symbols.map(&:inspect)
+      candidates.grep(/^#{sym}/)
+    end
+
+    def complete_absolute_constant_or_class_method(receiver)
+      candidates = Object.constants
+      candidates.grep(/^#{receiver}/).map{|name| "::#{name}" }
+    end
+
+    def complete_constant_or_class_method(bind, receiver, message)
+      begin
+        candidates =  eval("#{receiver}.constants", bind)
+        candidates |= eval("#{receiver}.methods", bind)
+      rescue Exception
+        candidates = [*candidates]
+      end
+
+      candidates.grep(/^#{message}/).map{|name| "#{receiver}::#{name}" }
+    end
+
+    def complete_symbol_method(receiver, message)
+      candidates = Symbol.instance_methods
+      select_message(receiver, message, candidates)
+    end
+
+    def complete_numeric_method(bind, receiver, message)
+      begin
+        candidates = eval(receiver, bind).methods
+      rescue Exception
+        candidates = []
+      end
+
+      select_message(receiver, message, candidates)
+    end
+
+    # Numeric(0xFFFF)
+    def complete_numeric_hex_method(bind, receiver, message)
+      begin
+        candidates = eval(receiver, bind).methods
+      rescue Exception
+        candidates = []
+      end
+
+      select_message(receiver, message, candidates)
+    end
+
+    def complete_global_variable(regmessage)
+      global_variables.grep(regmessage).map(&:to_s)
+    end
+
+    def complete_variable(bind, receiver, message)
+      gv = eval("global_variables",     bind).map(&:to_s)
+      lv = eval("local_variables",      bind).map(&:to_s)
+      cv = eval("self.class.constants", bind).map(&:to_s)
+
+      if (gv | lv | cv).include?(receiver)
+        # foo.func and foo is local var.
+        candidates = eval("#{receiver}.methods", bind)
+      elsif /^[A-Z]/ =~ receiver and /\./ !~ receiver
+        # Foo::Bar.func
+        begin
+          candidates = eval("#{receiver}.methods", bind)
+        rescue Exception
+          candidates = []
+        end
+      else
+        # func1.func2
+        candidates = []
+
+        ObjectSpace.each_object(Module) do |mod|
+          begin
+            name = mod.name
+          rescue Exception
+            name = ""
+          end
+
+          next if name != "IRB::Context" && /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+          candidates.concat mod.instance_methods(false)
+        end
+
+        candidates.sort!
+        candidates.uniq!
+      end
+
+      select_message(receiver, message, candidates)
+    end
+
+    # unknown(maybe String)
+    def complete_unknown(message)
+      receiver = ""
+
+      candidates = String.instance_methods(true)
+      select_message(receiver, message, candidates)
+    end
+
+    def complete_else(bind, receiver)
+      code = "methods | private_methods | local_variables | self.class.constants"
+      candidates = eval(code, bind)
+
+      (candidates|ReservedWords).grep(/^#{receiver}/).map(&:to_s)
+    end
+
+    def select_message(receiver, message, candidates)
+      candidates.grep(/^#{message}/).map{|entity|
+        case entity
+        when /^[a-zA-Z_]/
+          "#{receiver}.#{entity}"
+        when /^[0-9]/
+        when *Operators
+          # "#{receiver} #{entity}"
+        end
+      }.compact
+    end
+  end
+end

data/lib/ver/vendor/json_store.rb

@@ -0,0 +1,23 @@
+require 'json'
+require 'pstore'
+
+class JSON::Store < PStore
+  def dump(table)
+    JSON.pretty_unparse(@table)
+  end
+
+  def load(content)
+    JSON.load(content)
+  end
+
+  EMPTY_MARSHAL_DATA = {}.to_json
+  EMPTY_MARSHAL_CHECKSUM = Digest::MD5.digest(EMPTY_MARSHAL_DATA)
+
+  def empty_marshal_data
+    EMPTY_MARSHAL_DATA
+  end
+
+  def empty_marshal_checksum
+    EMPTY_MARSHAL_CHECKSUM
+  end
+end

data/lib/ver/vendor/open3.rb

@@ -0,0 +1,729 @@
+#
+# = 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[:stdin_data].  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[:stdin_data].  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[:stdin_data].  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") {|r, ts|
+  #     r.each_line {|line|
+  #       ...
+  #     }
+  #   }
+  #
+  #   Open3.pipeline_r("yes", "head -10") {|r, ts|
+  #     p r.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") {|w, ts|
+  #     w.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