vim-jar 0.0.3 → 0.1.0

data/bundler/ruby/1.8/gems/autotest-4.4.5/test/test_unit_diff.rb

@@ -0,0 +1,335 @@
+require File.expand_path('test/helper')
+require 'unit_diff'
+
+class TestUnitDiff < Test::Unit::TestCase
+
+  def setup
+    @diff = UnitDiff.new
+  end
+
+  def test_input
+    header = "Loaded suite ./blah\nStarted\nFF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n  2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n<\"line1\"> expected but was\n<\"line2\\nline3\\n\\n\">.\n\n2 tests, 2 assertions, 2 failures, 0 errors\n"
+
+    # TODO: I think I'd like a separate footer array as well
+    expected = [[["  1) Failure:\n", "test_test1(TestBlah) [./blah.rb:25]:\n", "<\"line1\\nline2\\nline3\\n\"> expected but was\n", "<\"line4\\nline5\\nline6\\n\">.\n"],
+                 ["  2) Failure:\n", "test_test2(TestBlah) [./blah.rb:29]:\n", "<\"line1\"> expected but was\n", "<\"line2\\nline3\\n\\n\">.\n"]],
+                ["\n", "2 tests, 2 assertions, 2 failures, 0 errors\n"]]
+
+    util_unit_diff(header, input, expected, :parse_input)
+  end
+
+  def test_input_miniunit
+    header = "Loaded suite -e\nStarted\nF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:
+test_blah(TestBlah) [./blah.rb:25]:
+Expected ['a', 'b', 'c'], not ['a', 'c', 'b'].
+
+1 tests, 1 assertions, 1 failures, 0 errors
+"
+
+    expected = [[["  1) Failure:\n",
+                  "test_blah(TestBlah) [./blah.rb:25]:\n",
+                  "Expected ['a', 'b', 'c'], not ['a', 'c', 'b'].\n"]],
+                ["\n", "1 tests, 1 assertions, 1 failures, 0 errors\n"]]
+
+    util_unit_diff(header, input, expected, :parse_input)
+  end
+
+  def test_input_miniunit_multiline
+    header = "Loaded suite -e\nStarted\nF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:
+test_blah(TestBlah) [./blah.rb:25]:
+Expected ['a',
+ 'b',
+ 'c'], not ['a',
+ 'c',
+ 'b'].
+
+1 tests, 1 assertions, 1 failures, 0 errors
+"
+
+    expected = [[["  1) Failure:\n",
+                  "test_blah(TestBlah) [./blah.rb:25]:\n",
+                  "Expected ['a',\n 'b',\n 'c'], not ['a',\n 'c',\n 'b'].\n"]],
+                ["\n", "1 tests, 1 assertions, 1 failures, 0 errors\n"]]
+
+    util_unit_diff(header, input, expected, :parse_input)
+  end
+
+  def test_input_mspec
+    header = <<-HEADER
+Started
+.......F
+Finished in 0.1 seconds
+
+    HEADER
+
+    failure = <<-FAILURE
+1)
+The unless expression should fail FAILED
+Expected nil to equal "baz":
+    FAILURE
+
+    backtrace = <<-BACKTRACE
+      PositiveExpectation#== at spec/mspec.rb:217
+          main.__script__ {} at spec/language/unless_spec.rb:49
+                   Proc#call at kernel/core/proc.rb:127
+               SpecRunner#it at spec/mspec.rb:368
+                     main.it at spec/mspec.rb:412
+          main.__script__ {} at spec/language/unless_spec.rb:48
+                   Proc#call at kernel/core/proc.rb:127
+         SpecRunner#describe at spec/mspec.rb:378
+               main.describe at spec/mspec.rb:408
+             main.__script__ at spec/language/unless_spec.rb:3
+    CompiledMethod#as_script at kernel/bootstrap/primitives.rb:41
+                   main.load at kernel/core/compile.rb:150
+          main.__script__ {} at last_mspec.rb:11
+               Array#each {} at kernel/core/array.rb:545
+       Integer(Fixnum)#times at kernel/core/integer.rb:15
+                  Array#each at kernel/core/array.rb:545
+             main.__script__ at last_mspec.rb:16
+    CompiledMethod#as_script at kernel/bootstrap/primitives.rb:41
+                   main.load at kernel/core/compile.rb:150
+             main.__script__ at kernel/loader.rb:145
+    BACKTRACE
+
+    footer = "\n8 examples, 1 failures\n"
+    input = header + failure + backtrace + footer
+
+    expected_backtrace = backtrace.split("\n").map {|l| "#{l}\n"}
+    expected = [[["1)\n", "The unless expression should fail FAILED\n",
+      "Expected nil to equal \"baz\":\n",
+      *expected_backtrace]],
+      ["\n", "8 examples, 1 failures\n"]]
+    util_unit_diff(header, input, expected, :parse_input)
+  end
+
+  def test_input_mspec_multiline
+    header = <<-HEADER
+Started
+.......F
+Finished in 0.1 seconds
+
+    HEADER
+
+failure = <<-FAILURE
+1)
+Compiler compiles a case without an argument FAILED
+Expected #<TestGenerator [[:push, :false], [:gif, #<Label 5>], [:push_literal, "foo"], [:string_dup], [:goto, #<Label 19>], [:set_label, #<Label 5>], [:push, :nil], [:gif, #<Label 10>], [:push_literal, "foo"], [:string_dup], [:goto, #<Label 19>], [:set_label, #<Label 10>], [:push, 2], [:push, 1], [:send, :==, 1, false], [:gif, #<Label 17>], [:push_literal, "bar"], [:string_dup], [:goto, #<Label 19>], [:set_label, #<Label 17>], [:push_literal, "baz"], [:string_dup], [:set_label, #<Label 19>]]
+to equal #<TestGenerator [[:push, false], [:gif, #<Label 5>], [:push, "foo"], [:string_dup], [:goto, #<Label 6>], [:set_label, #<Label 5>], [:push, nil], [:set_label, #<Label 6>], [:pop], [:push, nil], [:gif, #<Label 12>], [:push, "foo"], [:string_dup], [:goto, #<Label 13>], [:set_label, #<Label 12>], [:push, nil], [:set_label, #<Label 13>], [:pop], [:push, 2], [:push, 1], [:send, :==, 1], [:gif, #<Label 21>], [:push, "bar"], [:string_dup], [:goto, #<Label 23>], [:set_label, #<Label 21>], [:push_literal, "baz"], [:string_dup], [:set_label, #<Label 23>], [:sret]]:
+      FAILURE
+
+backtrace = <<-BACKTRACE
+      PositiveExpectation#== at spec/mspec.rb:216
+                    main.gen at ./compiler2/spec/helper.rb:125
+          main.__script__ {} at compiler2/spec/control_spec.rb:448
+    BACKTRACE
+
+    footer = "\n8 examples, 1 failures\n"
+    input = header + failure + backtrace + footer
+
+    expected_backtrace = backtrace.split("\n").map {|l| "#{l}\n"}
+    expected_failure = failure.split("\n").map {|l| "#{l}\n"}
+    expected = [[[*(expected_failure + expected_backtrace)]],
+      ["\n", "8 examples, 1 failures\n"]]
+    util_unit_diff(header, input, expected, :parse_input)
+  end
+
+  def test_unit_diff_empty # simulates broken pipe at the least
+    input = ""
+    expected = ""
+    util_unit_diff("", "", "")
+  end
+
+  def test_parse_diff_angles
+    input = ["  1) Failure:\n",
+             "test_test1(TestBlah) [./blah.rb:25]:\n",
+             "<\"<html>\"> expected but was\n",
+             "<\"<body>\">.\n"
+            ]
+
+    expected = [["  1) Failure:\n", "test_test1(TestBlah) [./blah.rb:25]:\n"],
+                ["<html>"],
+                ["<body>"],
+                []]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff_miniunit
+    input = ["  1) Failure:\n",
+             "test_blah(TestBlah) [./blah.rb:25]:\n",
+             "Expected ['a', 'b', 'c'], not ['a', 'c', 'b'].\n"]
+
+    expected = [["  1) Failure:\n", "test_blah(TestBlah) [./blah.rb:25]:\n"],
+                ["['a', 'b', 'c']"],
+                ["['a', 'c', 'b']"],
+                []]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff_miniunit_multiline
+    input = ["  1) Failure:\n",
+             "test_blah(TestBlah) [./blah.rb:25]:\n",
+             "Expected ['a',\n'b',\n'c'], not ['a',\n'c',\n'b'].\n"]
+
+    expected = [["  1) Failure:\n", "test_blah(TestBlah) [./blah.rb:25]:\n"],
+                ["['a',\n'b',\n'c']"],
+                ["['a',\n'c',\n'b']"],
+                []]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff1
+    input = ["  1) Failure:\n",
+             "test_test1(TestBlah) [./blah.rb:25]:\n",
+             "<\"line1\\nline2\\nline3\\n\"> expected but was\n",
+             "<\"line4\\nline5\\nline6\\n\">.\n"
+            ]
+
+    expected = [["  1) Failure:\n", "test_test1(TestBlah) [./blah.rb:25]:\n"], ["line1\\nline2\\nline3\\n"], ["line4\\nline5\\nline6\\n"], []]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff2
+    input = ["  2) Failure:\n",
+             "test_test2(TestBlah) [./blah.rb:29]:\n",
+             "<\"line1\"> expected but was\n",
+             "<\"line2\\nline3\\n\\n\">.\n"
+            ]
+
+    expected = [["  2) Failure:\n",
+                 "test_test2(TestBlah) [./blah.rb:29]:\n"],
+                ["line1"],
+                ["line2\\nline3\\n\\n"],
+                []
+               ]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff3
+    input = [" 13) Failure:\n",
+             "test_case_stmt(TestRubyToRubyC) [./r2ctestcase.rb:1198]:\n",
+             "Unknown expected data.\n",
+             "<false> is not true.\n"]
+
+    expected = [[" 13) Failure:\n", "test_case_stmt(TestRubyToRubyC) [./r2ctestcase.rb:1198]:\n", "Unknown expected data.\n"], ["<false> is not true.\n"], nil, []]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff_suspect_equals
+    input = ["1) Failure:\n",
+             "test_util_capture(AssertionsTest) [test/test_zentest_assertions.rb:53]:\n",
+             "<\"out\"> expected but was\n",
+             "<\"out\">.\n"]
+    expected = [["1) Failure:\n",
+                 "test_util_capture(AssertionsTest) [test/test_zentest_assertions.rb:53]:\n"],
+                ["out"],
+                ["out"], []]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff_NOT_suspect_equals
+    input = ["1) Failure:\n",
+             "test_util_capture(AssertionsTest) [test/test_zentest_assertions.rb:53]:\n",
+             "<\"out\"> expected but was\n",
+             "<\"out\\n\">.\n"]
+    expected = [["1) Failure:\n",
+                 "test_util_capture(AssertionsTest) [test/test_zentest_assertions.rb:53]:\n"],
+                ["out"],
+                ["out\\n"], []]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff_mspec
+    input = ["1)\n", "The unless expression should fail FAILED\n",
+      "Expected nil to equal \"baz\":\n",
+      "    PositiveExpectation#== at spec/mspec.rb:217\n"]
+
+    expected = [["1)\n", "The unless expression should fail FAILED\n"],
+      ["nil"],
+      ["\"baz\""],
+      ["    PositiveExpectation#== at spec/mspec.rb:217"]]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_parse_diff_mspec_multiline
+    input = ["1)\n", "The unless expression should fail FAILED\n",
+    "Expected #<TestGenerator [[:push, :true],\n", "  [:dup]\n", "]\n",
+    "to equal #<TestGenerator [[:pop],\n", "  [:dup]\n", "]:\n",
+    "    PositiveExpectation#== at spec/mspec.rb:217\n"]
+
+    expected = [["1)\n", "The unless expression should fail FAILED\n"],
+      ["#<TestGenerator [[:push, :true],\n", "  [:dup]\n", "]"],
+      ["#<TestGenerator [[:pop],\n", "  [:dup]\n", "]"],
+      ["    PositiveExpectation#== at spec/mspec.rb:217"]]
+
+    assert_equal expected, @diff.parse_diff(input)
+  end
+
+  def test_unit_diff_angles
+    header = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"<html>\"> expected but was\n<\"<body>\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors\n"
+    expected = "1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1c1\n< <html>\n---\n> <body>\n\n1 tests, 1 assertions, 1 failures, 0 errors"
+
+    util_unit_diff(header, input, expected)
+  end
+
+  def test_unit_diff1
+    header = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors\n"
+    expected = "1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1,3c1,3\n< line1\n< line2\n< line3\n---\n> line4\n> line5\n> line6\n\n1 tests, 1 assertions, 1 failures, 0 errors"
+
+    util_unit_diff(header, input, expected)
+  end
+
+  def test_unit_diff2
+    header = "Loaded suite ./blah\nStarted\nFF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n  2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n<\"line1\"> expected but was\n<\"line2\\nline3\\n\\n\">.\n\n2 tests, 2 assertions, 2 failures, 0 errors\n"
+    expected = "1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1,3c1,3\n< line1\n< line2\n< line3\n---\n> line4\n> line5\n> line6\n\n2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n1c1,4\n< line1\n---\n> line2\n> line3\n> \n> \n\n2 tests, 2 assertions, 2 failures, 0 errors"
+
+    util_unit_diff(header, input, expected)
+  end
+
+  def test_unit_diff3
+    header = ""
+    input = " 13) Failure:\ntest_case_stmt(TestRubyToRubyC) [./r2ctestcase.rb:1198]:\nUnknown expected data.\n<false> is not true.\n"
+    expected = "13) Failure:\ntest_case_stmt(TestRubyToRubyC) [./r2ctestcase.rb:1198]:\nUnknown expected data.\n<false> is not true."
+
+    util_unit_diff(header, input, expected)
+  end
+
+  def test_unit_diff_suspect_equals
+    header   = "Loaded suite ./blah\nStarted\n.............................................F............................................\nFinished in 0.834671 seconds.\n\n"
+    footer   = "90 tests, 241 assertions, 1 failures, 0 errors"
+    input    = "#{header}  1) Failure:\ntest_unit_diff_suspect_equals(TestUnitDiff) [./test/test_unit_diff.rb:122]:\n<\"out\"> expected but was\n<\"out\">.\n\n#{footer}"
+    expected = "1) Failure:\ntest_unit_diff_suspect_equals(TestUnitDiff) [./test/test_unit_diff.rb:122]:\n[no difference--suspect ==]\n\n#{footer}"
+
+    util_unit_diff(header, input, expected)
+  end
+
+  def test_unit_diff_NOT_suspect_equals
+    header   = "Loaded suite ./blah\nStarted\n.\nFinished in 0.0 seconds.\n\n"
+    input    = "#{header}  1) Failure:\ntest_blah(TestBlah)\n<\"out\"> expected but was\n<\"out\\n\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors"
+    expected = "1) Failure:\ntest_blah(TestBlah)\n1a2\n> \n\n1 tests, 1 assertions, 1 failures, 0 errors"
+
+    util_unit_diff(header, input, expected)
+  end
+
+  def util_unit_diff(header, input, expected, msg=:unit_diff)
+    output = StringIO.new("")
+    actual = @diff.send(msg, StringIO.new(input), output)
+    assert_equal header, output.string, "header output"
+    assert_equal expected, actual
+  end
+end
+

data/bundler/ruby/1.8/gems/background_process-1.2/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Tim Harper
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bundler/ruby/1.8/gems/background_process-1.2/README.textile

@@ -0,0 +1,82 @@
+h1. Background Process
+
+This is like popen4, but provides several convenience methods for interacting
+with the process. It only works on UNIX and Ruby implementations that support
+fork and native UNIX I/O streams.
+
+"Click here for Complete Documentation":http://rdoc.info/projects/timcharper/background_process
+
+Example:
+
+<pre>
+process = BackgroundProcess.run("sh -c 'sleep 1; exit 1'")
+process.running? # => true
+process.wait # => #<Process::Status: pid=34774,exited(1)>
+process.running? #=> false
+process.exitstatus # => 1
+</pre>
+
+<pre>
+process = BackgroundProcess.run("sh -c 'sleep 1; exit 1'")
+process.kill("KILL") # => true
+process.running? # => false
+process.exitstatus # => nil
+</pre>
+
+<pre>
+process = BackgroundProcess.run("sh -c '
+  echo Service Starting
+  sleep 2
+  echo Service Started 1>&2
+'")
+if process.detect(:stderr, 10) { |line| line.include?("Service Started") }
+  puts "Service was started!"
+else
+  puts "Service failed to start!"
+end
+process.kill
+</pre>
+
+h2. Common signal names
+
+| Name   | id |
+| HUP    | 1  |
+| INT    | 2  |
+| QUIT   | 3  |
+| ABRT   | 6  |
+| KILL   | 9  |
+| ALRM   | 14 |
+| TERM   | 15 |
+| USR1   | 30 |
+| USR2   | 31 |
+
+h2. A word about buffered output
+
+Some processes (like Ruby) buffer their output if they detect that they aren't
+attached to a tty. This means that unless the program explicitly calls
+STDOUT.flush, much of the output won't be available for reading until the
+buffer is full, forcing it to be flushed.
+
+You can force the output of a ruby script to be unbuffered by using a wrapper
+like the following:
+
+<pre>
+  BackgroundProcess.run %(ruby -e 'STDERR.sync, STDOUT.sync = true, true; $0="./server.rb"; load "server.rb"')
+</pre>
+
+If no such workaround is available, this gem provides PTYBackgroundProcess
+which will wrap the command any pseudo-terminal interface. This has the
+advantage of forcing many programs to not buffer their output, but at a
+disadvantage too (you can't get the exit status of the process, you lose any
+output that hasn't been read yet when the process exits, and stderr gets
+merged into stdout). It seems there should be ways to work around these
+limitations, but I wasn't able to figure out an way to do it (without
+resorting to C code at least). Given your circumstances, this may fit your
+needs and be a viable solution to you.
+
+Please see the documentation for BackgroundProcess.run and
+PTYBackgroundProcess.run for further information.
+
+h2. Author
+
+Tim Harper, on behalf of Lead Media Partners

data/bundler/ruby/1.8/gems/background_process-1.2/lib/background_process/background_process.rb

@@ -0,0 +1,114 @@
+class BackgroundProcess
+  attr_reader :stdin, :stdout, :stderr, :pid
+
+  # Initialize a BackgroundProcess task. Don't do this.  Use BackgroundProcess.run or BackgroundProcess.run_pty instead
+  def initialize(pid, stdin, stdout, stderr = nil)
+    @pid, @stdin, @stdout, @stderr = pid, stdin, stdout, stderr
+    ObjectSpace.define_finalizer(self) { kill }
+  end
+
+
+  # Run a command, connecting it's IO streams (stdin, sterr, stdout) via IO pipes,
+  # which are not tty IO streams.
+  #
+  # Because of this, some programs (like ruby) will buffer their output and only
+  # make it available when it's explicitely flushed (with IO#flush or when the
+  # buffer gets full). This behavior can be overridden by setting the streams to
+  # sync, like this:
+  #
+  # STDOUT.sync, STDERR.sync = true, true
+  #
+  # If you can't control the program and have it explicitly flush its output when it
+  # should, or you can't tell the streams to run in sync mode, see
+  # PTYBackgroundProcess.run for a workaround.
+  def self.run(command)
+    command = sanitize_params(command) if command.is_a?(Array)
+    child_stdin, parent_stdin = IO::pipe
+    parent_stdout, child_stdout = IO::pipe
+    parent_stderr, child_stderr = IO::pipe
+
+    pid = Kernel.fork do
+      [parent_stdin, parent_stdout, parent_stderr].each { |io| io.close }
+
+      STDIN.reopen(child_stdin)
+      STDOUT.reopen(child_stdout)
+      STDERR.reopen(child_stderr)
+
+      [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+
+      exec command
+    end
+
+    [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+    parent_stdin.sync = true
+
+    new(pid, parent_stdin, parent_stdout, parent_stderr)
+  end
+
+  # send a signal to the process. If the processes and running, do nothing.
+  # Valid signals are those in Signal.list. Default is "TERM"
+  def kill(signal = 'TERM')
+    if running?
+      Process.kill(Signal.list[signal], @pid)
+      true
+    end
+  end
+
+  # Sends the interrupt signal to the process. The equivalent of pressing control-C in it.
+  def interrupt
+    kill('INT')
+  end
+
+  # asks the operating system is the process still exists.
+  def running?
+    return false unless @pid
+    Process.getpgid(@pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  # waits for the process to finish. Freeze the process so it can rest in peace.
+  # You should call this on every background job you create to avoid a flood of
+  # zombie processes. (Processes won't go away until they are waited on)
+  def wait(timeout = nil)
+    @exit_status ||= Timeout.timeout(timeout) do
+      Process.wait(@pid)
+      $?
+    end
+  rescue Timeout::Error
+    nil
+  end
+
+  # Waits for the process to terminate, and then returns the exit status
+  def exitstatus
+    wait && wait.exitstatus
+  end
+
+  # Calls block each time a line is available in the specified output buffer(s) and returns the first non-false value
+  # By default, both stdout and stderr are monitored.
+  #
+  # Args:
+  # * which: which streams to monitor. valid values are :stdout, :stderr, or :both.
+  # * timeout: Total time in seconds to run detect for. If result not found within this time, abort and return nil. Pass nil for no timeout.
+  # * &block: the block to call.  If block takes two arguments, it will pass both the stream that received the input (an instance of IO, not the symbol), and the line read from the buffer.
+  def detect(which = :both, timeout = nil, &block)
+    streams = select_streams(which)
+    BackgroundProcess::IOHelpers.detect(streams, timeout, &block)
+  end
+
+  protected
+  # It's protected. What do you care? :P
+  def self.sanitize_params(params)
+    params.map { |p| p.gsub(' ', '\ ') }.join(" ")
+  end
+
+  def select_streams(which)
+    case which
+    when :stdout then [stdout]
+    when :stderr then [stderr]
+    when :both   then [stdout, stderr]
+    else raise(ArgumentError, "invalid stream specification: #{which}")
+    end.compact
+  end
+end

data/bundler/ruby/1.8/gems/background_process-1.2/lib/background_process/io_helpers.rb

@@ -0,0 +1,24 @@
+module BackgroundProcess::IOHelpers
+  extend self
+  def detect(streams = [], timeout = nil, &block)
+    begin
+      Timeout::timeout(timeout) do
+        # Something that should be interrupted if it takes too much time...
+        until streams.empty?
+          active_streams, _, _ = Kernel.select(streams, nil, nil, 1)
+          active_streams.each do |s|
+            (streams -= [s]; next) if s.eof?
+            content = s.gets
+            if result = (block.arity == 1 ? yield(content) : yield(s, content))
+              return result
+            end
+          end if active_streams
+        end
+      end
+      nil
+    rescue Timeout::Error
+      nil
+    end
+
+  end
+end

data/bundler/ruby/1.8/gems/background_process-1.2/lib/background_process/pty_background_process.rb

@@ -0,0 +1,64 @@
+require 'pty'
+
+class PTYBackgroundProcess < BackgroundProcess
+  # Runs a subprocess in a pseudo terminal, tricking a program into not
+  # buffering its output.
+  #
+  # A great write up on pseudo-terminals here:
+  # http://stackoverflow.com/questions/1154846/continuously-read-from-stdout-of-external-process-in-ruby
+  #
+  # It has the following disadvantages:
+  # * You can't get the exit status
+  # * When the process dies, whatever output you haven't read yet is lost.
+  # * stderr is merged into stdout
+  def self.run(command)
+    thread = Thread.new do # why run PTY separate thread? When a PTY instance
+                           # dies, it raises PTY::ChildExited on the thread that
+                           # spawned it, interrupting whatever happens to be
+                           # running at the time
+      PTY.spawn(command) do |output, input, pid|
+        begin
+          bp = new(pid, input, output)
+          Thread.current[:background_process] = bp
+          bp.wait
+        rescue Exception => e
+          puts e
+          puts e.backtrace
+        end
+      end
+    end
+    sleep 0.01 until thread[:background_process]
+    thread[:background_process]
+  end
+
+  def stderr
+    raise ArgumentError, "stderr is merged into stdout with PTY subprocesses"
+  end
+
+  def wait(timeout = nil)
+    begin
+      Timeout.timeout(timeout) do
+        Process.wait(@pid)
+      end
+    rescue Timeout::Error
+      nil
+    rescue PTY::ChildExited
+      true
+    rescue Errno::ECHILD
+      true
+    end
+  end
+
+  def exitstatus
+    raise ArgumentError, "exitstatus is not available for PTY subprocesses"
+  end
+
+protected
+  def select_streams(which)
+    case which
+    when :stderr        then stderr # let stderr throw the exception
+    when :stdout, :both then [stdout]
+    else raise(ArgumentError, "invalid stream specification: #{which}")
+    end.compact
+  end
+end

data/bundler/ruby/1.8/gems/background_process-1.2/lib/background_process.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + "/background_process/background_process"
+require File.dirname(__FILE__) + "/background_process/pty_background_process"
+require File.dirname(__FILE__) + "/background_process/io_helpers"