childprocess 0.1.0 → 0.1.1

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/childprocess.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{childprocess}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jari Bakken"]
@@ -25,42 +25,49 @@ Gem::Specification.new do |s|
      "VERSION",
      "childprocess.gemspec",
      "lib/childprocess.rb",
+     "lib/childprocess/abstract_io.rb",
      "lib/childprocess/abstract_process.rb",
      "lib/childprocess/errors.rb",
      "lib/childprocess/ironruby.rb",
      "lib/childprocess/ironruby/process.rb",
      "lib/childprocess/jruby.rb",
+     "lib/childprocess/jruby/io.rb",
      "lib/childprocess/jruby/process.rb",
+     "lib/childprocess/jruby/redirector.rb",
      "lib/childprocess/unix.rb",
+     "lib/childprocess/unix/io.rb",
      "lib/childprocess/unix/process.rb",
      "lib/childprocess/windows.rb",
      "lib/childprocess/windows/api.rb",
      "lib/childprocess/windows/constants.rb",
      "lib/childprocess/windows/functions.rb",
      "lib/childprocess/windows/handle.rb",
+     "lib/childprocess/windows/io.rb",
      "lib/childprocess/windows/process.rb",
      "lib/childprocess/windows/structs.rb",
      "spec/childprocess_spec.rb",
+     "spec/jruby_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
-     "spec/unix_process_spec.rb"
+     "spec/unix_spec.rb"
   ]
   s.homepage = %q{http://github.com/jarib/childprocess}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Cross-platform ruby library for managing child processes.}
   s.test_files = [
     "spec/childprocess_spec.rb",
+     "spec/jruby_spec.rb",
      "spec/spec_helper.rb",
-     "spec/unix_process_spec.rb"
+     "spec/unix_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_development_dependency(%q<yard>, [">= 0"])
       s.add_runtime_dependency(%q<ffi>, ["~> 0.6.3"])

data/lib/childprocess.rb

@@ -1,5 +1,6 @@
-require 'childprocess/abstract_process'
 require 'childprocess/errors'
+require 'childprocess/abstract_process'
+require 'childprocess/abstract_io'
 
 module ChildProcess
   autoload :Unix,     'childprocess/unix'
@@ -35,6 +36,14 @@ module ChildProcess
       end
     end
 
+    def unix?
+      !jruby? && [:macosx, :linux, :unix].include?(os)
+    end
+
+    def jruby?
+      platform == :jruby
+    end
+
     def os
       @os ||= (
         require "rbconfig"

data/lib/childprocess/abstract_io.rb

@@ -0,0 +1,22 @@
+module ChildProcess
+  class AbstractIO
+    attr_reader :stderr, :stdout
+
+    def stderr=(io)
+      check_type io
+      @stderr = io
+    end
+
+    def stdout=(io)
+      check_type io
+      @stdout = io
+    end
+
+    private
+
+    def check_type(io)
+      raise SubclassResponsibility, "check_type"
+    end
+
+  end
+end

data/lib/childprocess/abstract_process.rb

@@ -21,6 +21,14 @@ module ChildProcess
       @exit_code = nil
     end
 
+    #
+    # Returns a ChildProcess::AbstractIO subclass to configure the child's IO streams.
+    #
+
+    def io
+      raise SubclassResponsibility, "io"
+    end
+
     #
     # Launch the child process
     #
@@ -57,15 +65,28 @@ module ChildProcess
     #
     # Is this process running?
     #
+    # @return [Boolean]
+    #
 
     def alive?
       started? && !exited?
     end
 
+    #
+    # Returns true if the process has exited and the exit code was not 0.
+    #
+    # @return [Boolean]
+    #
+
     def crashed?
       exited? && @exit_code != 0
     end
 
+    #
+    # Wait for the process to exit, raising a ChildProcess::TimeoutError if
+    # the timeout expires.
+    #
+
     def poll_for_exit(timeout)
       log "polling #{timeout} seconds for exit"
 

data/lib/childprocess/jruby.rb

@@ -3,4 +3,7 @@ module ChildProcess
   end
 end
 
+require "java"
+require "childprocess/jruby/redirector"
+require "childprocess/jruby/io"
 require "childprocess/jruby/process"

data/lib/childprocess/jruby/io.rb

@@ -0,0 +1,16 @@
+module ChildProcess
+  module JRuby
+    class IO < AbstractIO
+      private
+
+      def check_type(output)
+        unless output.respond_to?(:to_outputstream) && output.respond_to?(:write)
+          raise ArgumentError, "expected #{output.inspect} to respond to :to_outputstream"
+        end
+      end
+
+    end # IO
+  end # Unix
+end # ChildProcess
+
+

data/lib/childprocess/jruby/process.rb

@@ -3,11 +3,16 @@ require "java"
 module ChildProcess
   module JRuby
     class Process < AbstractProcess
+      def io
+        @io ||= JRuby::IO.new
+      end
+
       def exited?
         return true if @exit_code
 
         assert_started
         @exit_code = @process.exitValue
+        true
       rescue java.lang.IllegalThreadStateException
         false
       ensure
@@ -26,35 +31,35 @@ module ChildProcess
       private
 
       def launch_process
-        # background_args! if @detach
-
         pb = java.lang.ProcessBuilder.new(@args)
 
-        # not sure why this is necessary
         env = pb.environment
         ENV.each { |k,v| env.put(k, v) }
 
         @process = pb.start
-
-        # Firefox 3.6 on Snow Leopard has a lot output on stderr, which makes
-        # the launch act funny if we don't do something to the streams
-        # Closing the streams solves the problem for now, but on other platforms
-        # we might need to actually read them.
-
-        @process.getErrorStream.close
-        @process.getInputStream.close
+        setup_io
       end
 
-      def background_args!
-        case ChildProcess.os
-        when :windows
-          args = %w[start /wait /b]
-          @args.unshift(*args) unless @args[0] == start
+      def setup_io
+        if @io
+          redirect @process.getErrorStream, @io.stderr
+          redirect @process.getInputStream, @io.stdout
         else
-          @args.push "&" unless @args.last == "&"
+          @process.getErrorStream.close
+          @process.getInputStream.close
         end
       end
 
+      def redirect(input, output)
+        if output.nil?
+          input.close
+          return
+        end
+
+        output = output.to_outputstream
+        Thread.new { Redirector.new(input, output).run }
+      end
+
     end # Process
   end # JRuby
 end # ChildProcess

data/lib/childprocess/jruby/redirector.rb

@@ -0,0 +1,29 @@
+module ChildProcess
+  module JRuby
+    class Redirector
+      BUFFER_SIZE = 2048
+
+      def initialize(input, output)
+        @input = input
+        @output = output
+        @buffer = Java.byte[BUFFER_SIZE].new
+      end
+
+      def run
+        read, avail = 0, 0
+
+        while(read != -1)
+          avail = [@input.available, 1].max
+          read  = @input.read(@buffer, 0, avail)
+
+          if read > 0
+            @output.write(@buffer, 0, read)
+          end
+        end
+      rescue java.io.IOException => ex
+        $stderr.puts ex.message, ex.backtrace if $DEBUG
+      end
+
+    end # Redirector
+  end # JRuby
+end # ChildProcess

data/lib/childprocess/unix.rb

@@ -3,4 +3,5 @@ module ChildProcess
   end
 end
 
+require "childprocess/unix/io"
 require "childprocess/unix/process"

data/lib/childprocess/unix/io.rb

@@ -0,0 +1,21 @@
+module ChildProcess
+  module Unix
+    class IO < AbstractIO
+      private
+
+      def check_type(io)
+        unless io.respond_to? :to_io
+          raise ArgumentError, "expected #{io.inspect} to respond to :to_io"
+        end
+
+        result = io.to_io
+        unless result && result.kind_of?(::IO)
+          raise TypeError, "expected IO, got #{result.inspect}:#{result.class}"
+        end
+      end
+
+    end # IO
+  end # Unix
+end # ChildProcess
+
+

data/lib/childprocess/unix/process.rb

@@ -2,6 +2,10 @@ module ChildProcess
   module Unix
     class Process < AbstractProcess
 
+      def io
+        @io ||= Unix::IO.new
+      end
+
       def stop(timeout = 3)
         assert_started
         send_term
@@ -63,10 +67,14 @@ module ChildProcess
       end
 
       def launch_process
+        if @io
+          stdout = @io.stdout
+          stderr = @io.stderr
+        end
+
         @pid = fork {
-          unless $DEBUG
-            [STDOUT, STDERR].each { |io| io.reopen("/dev/null") }
-          end
+          STDOUT.reopen(stdout || "/dev/null")
+          STDERR.reopen(stderr || "/dev/null")
 
           exec(*@args)
         }

data/lib/childprocess/windows.rb

@@ -1,19 +1,34 @@
 require "ffi"
+require "rbconfig"
 
 module ChildProcess
   module Windows
     module Lib
       extend FFI::Library
 
-      ffi_lib "kernel32"
+      def self.msvcrt_name
+        host_part = RbConfig::CONFIG['host_os'].split("_")[1]
+        manifest  = File.join(RbConfig::CONFIG['bindir'], 'ruby.exe.manifest')
+
+        if host_part && host_part.to_i > 80 && File.exists?(manifest)
+          "msvcr#{host_part}"
+        else
+          "msvcrt"
+        end
+      end
+
+      ffi_lib "kernel32", msvcrt_name
       ffi_convention :stdcall
-    end
-  end
-end
+
+
+    end # Library
+  end # Windows
+end # ChildProcess
 
 require "childprocess/windows/constants"
 require "childprocess/windows/structs"
 require "childprocess/windows/functions"
 require "childprocess/windows/handle"
 require "childprocess/windows/api"
-require "childprocess/windows/process"
+require "childprocess/windows/io"
+require "childprocess/windows/process"

data/lib/childprocess/windows/constants.rb

@@ -19,6 +19,10 @@ module ChildProcess::Windows
 
   DETACHED_PROCESS              = 0x00000008
 
+  STARTF_USESTDHANDLES          = 0x00000100
+  INVALID_HANDLE_VALUE          = 0xFFFFFFFF
+
+
   module Lib
     enum :wait_status, [ :wait_object_0,  0,
                          :wait_timeout,   0x102,

data/lib/childprocess/windows/functions.rb

@@ -13,6 +13,15 @@ module ChildProcess
         si = StartupInfo.new
         pi = ProcessInfo.new
 
+        if opts[:stdout] || opts[:stderr]
+          si[:dwFlags] ||= 0
+          si[:dwFlags] |= STARTF_USESTDHANDLES
+          inherit = true
+
+          si[:hStdOutput] = get_os_file_handle(opts[:stdout].fileno) if opts[:stdout]
+          si[:hStdError]  = get_os_file_handle(opts[:stderr].fileno) if opts[:stderr]
+        end
+
         ok = create_process(nil, cmd_ptr, nil, nil, inherit, flags, nil, nil, si, pi)
         ok or raise Error, last_error_message
 
@@ -34,6 +43,33 @@ module ChildProcess
         buf.read_string(size).strip
       end
 
+      def self.get_os_file_handle(fd_or_io)
+        case fd_or_io
+        when IO
+          handle = _get_osfhandle(fd.fileno)
+        when Fixnum
+          handle = _get_osfhandle(fd_or_io)
+        else
+          if fd_or_io.respond_to?(:to_io)
+            io = fd_or_io.to_io
+
+            unless io.kind_of?(IO)
+              raise TypeError, "expected #to_io to return an instance of IO"
+            end
+
+            handle = _get_osfhandle(io.fileno)
+          else
+            raise TypeError, "invalid type: #{fd_or_io.inspect}"
+          end
+        end
+
+        if handle == INVALID_HANDLE_VALUE
+          raise Error, Lib.last_error_message
+        end
+
+        handle
+      end
+
       #
       # BOOL WINAPI CreateProcess(
       #   __in_opt     LPCTSTR lpApplicationName,
@@ -139,6 +175,14 @@ module ChildProcess
 
       attach_function :terminate_process, :TerminateProcess, [:pointer, :uint], :bool
 
+      #
+      # long _get_osfhandle(
+      #    int fd
+      # );
+      #
+
+      attach_function :_get_osfhandle, :_get_osfhandle, [:int], :long
+
     end # Lib
   end # Windows
 end # ChildProcess

data/lib/childprocess/windows/handle.rb

@@ -1,87 +1,89 @@
-module ChildProcess::Windows
-  class Handle
+module ChildProcess
+  module Windows
+    class Handle
 
-    class << self
-      private :new
+      class << self
+        private :new
 
-      def open(pid, access = PROCESS_ALL_ACCESS)
-        handle = Lib.open_process(access, false, pid)
+        def open(pid, access = PROCESS_ALL_ACCESS)
+          handle = Lib.open_process(access, false, pid)
 
-        if handle.null?
-          raise Error, Lib.last_error_message
-        end
+          if handle.null?
+            raise Error, Lib.last_error_message
+          end
 
-        h = new(handle, pid)
-        return h unless block_given?
+          h = new(handle, pid)
+          return h unless block_given?
 
-        begin
-          yield h
-        ensure
-          h.close
+          begin
+            yield h
+          ensure
+            h.close
+          end
         end
       end
-    end
 
-    def initialize(handle, pid)
-      unless handle.kind_of?(FFI::Pointer)
-        raise TypeError, "invalid handle: #{handle.inspect}"
-      end
+      def initialize(handle, pid)
+        unless handle.kind_of?(FFI::Pointer)
+          raise TypeError, "invalid handle: #{handle.inspect}"
+        end
 
-      if handle.null?
-        raise ArgumentError, "handle is null: #{handle.inspect}"
-      end
+        if handle.null?
+          raise ArgumentError, "handle is null: #{handle.inspect}"
+        end
 
-      @pid    = pid
-      @handle = handle
-      @closed = false
-    end
+        @pid    = pid
+        @handle = handle
+        @closed = false
+      end
 
-    def exit_code
-      code_pointer = FFI::MemoryPointer.new :ulong
-      ok = Lib.get_exit_code(@handle, code_pointer)
+      def exit_code
+        code_pointer = FFI::MemoryPointer.new :ulong
+        ok = Lib.get_exit_code(@handle, code_pointer)
 
-      if ok
-        code_pointer.get_ulong(0)
-      else
-        close
-        raise Error, Lib.last_error_message
+        if ok
+          code_pointer.get_ulong(0)
+        else
+          close
+          raise Error, Lib.last_error_message
+        end
       end
-    end
-
-    def send(signal)
-      case signal
-      when 0
-        exit_code == PROCESS_STILL_ALIVE
-      when WIN_SIGINT
-        Lib.generate_console_ctrl_event(CTRL_C_EVENT, @pid)
-      when WIN_SIGBREAK
-        Lib.generate_console_ctrl_event(CTRL_BREAK_EVENT, @pid)
-      when WIN_SIGKILL
-        ok = Lib.terminate_process(@handle, @pid)
-        ok or raise Error, Lib.last_error_message
-      else
-        thread_id     = FFI::MemoryPointer.new(:ulong)
-        module_handle = Lib.get_module_handle("kernel32")
-        proc_address  = Lib.get_proc_address(module_handle, "ExitProcess")
-
-        thread = Lib.create_remote_thread(@handle, 0, 0, proc_address, 0, 0, thread_id)
-        thread or raise Error, Lib.last_error_message
-
-        Lib.wait_for_single_object(thread, 5)
-        true
+
+      def send(signal)
+        case signal
+        when 0
+          exit_code == PROCESS_STILL_ALIVE
+        when WIN_SIGINT
+          Lib.generate_console_ctrl_event(CTRL_C_EVENT, @pid)
+        when WIN_SIGBREAK
+          Lib.generate_console_ctrl_event(CTRL_BREAK_EVENT, @pid)
+        when WIN_SIGKILL
+          ok = Lib.terminate_process(@handle, @pid)
+          ok or raise Error, Lib.last_error_message
+        else
+          thread_id     = FFI::MemoryPointer.new(:ulong)
+          module_handle = Lib.get_module_handle("kernel32")
+          proc_address  = Lib.get_proc_address(module_handle, "ExitProcess")
+
+          thread = Lib.create_remote_thread(@handle, 0, 0, proc_address, 0, 0, thread_id)
+          thread or raise Error, Lib.last_error_message
+
+          Lib.wait_for_single_object(thread, 5)
+          true
+        end
       end
-    end
 
-    def close
-      return if @closed
+      def close
+        return if @closed
 
-      Lib.close_handle(@handle)
-      @closed = true
-    end
+        Lib.close_handle(@handle)
+        @closed = true
+      end
 
-    def wait(milliseconds = nil)
-      Lib.wait_for_single_object(@handle, milliseconds || INFINITE)
-    end
+      def wait(milliseconds = nil)
+        Lib.wait_for_single_object(@handle, milliseconds || INFINITE)
+      end
 
-  end # Handle
-end # WindowsProcess
+    end # Handle
+  end # Windows
+end # ChildProcess

data/lib/childprocess/windows/io.rb

@@ -0,0 +1,25 @@
+module ChildProcess
+  module Windows
+    class IO < AbstractIO
+      private
+
+      def check_type(io)
+        return if has_fileno?(io)
+        return if has_to_io?(io)
+
+        raise ArgumentError, "#{io.inspect}:#{io.class} must have :fileno or :to_io"
+      end
+
+      def has_fileno?(io)
+        io.respond_to?(:fileno) && io.fileno
+      end
+
+      def has_to_io?
+        io.respond_to?(:to_io) && io.to_io.kind_of?(::IO)
+      end
+
+    end # IO
+  end # Windows
+end # ChildProcess
+
+

data/lib/childprocess/windows/process.rb

@@ -2,6 +2,10 @@ module ChildProcess
   module Windows
     class Process < AbstractProcess
 
+      def io
+        @io ||= Windows::IO.new
+      end
+
       def stop(timeout = 3)
         assert_started
 
@@ -33,11 +37,19 @@ module ChildProcess
       private
 
       def launch_process
-        @pid = Lib.create_proc(
-          @args.join(' '),
+        opts = {
           :inherit => false,
-          :detach  => @detach
-        )
+          :detach  => @detach,
+        }
+
+        if @io
+          opts[:stdout] = @io.stdout
+          opts[:stderr] = @io.stderr
+        end
+
+        command = @args.map { |e| e.inspect }.join(' ')
+
+        @pid = Lib.create_proc(command, opts)
         @handle = Handle.open(@pid)
 
         self

data/lib/childprocess/windows/structs.rb

@@ -32,6 +32,7 @@ module ChildProcess::Windows
            :dwXCountChars,    :ulong,
            :dwYCountChars,    :ulong,
            :dwFillAttribute,  :ulong,
+           :dwFlags,          :ulong,
            :wShowWindow,      :ushort,
            :cbReserved2,      :ushort,
            :lpReserved2,      :pointer,

data/spec/childprocess_spec.rb

@@ -63,8 +63,37 @@ describe ChildProcess do
   end
 
   it "lets a detached child live on" do
-    # hmm. how do we spec this?
+    pending "how do we spec this?"
+  end
+
+  it "can redirect stdout and stderr" do
+    process = ruby(<<-CODE)
+      [STDOUT, STDERR].each_with_index do |io, idx|
+        io.sync = true
+        io.puts idx
+      end
+      sleep 0.2
+    CODE
+
+    out = Tempfile.new("stdout-spec")
+    err = Tempfile.new("stderr-spec")
+
+    begin
+      process.io.stdout = out
+      process.io.stderr = err
+
+      process.start
+      process.poll_for_exit(EXIT_TIMEOUT)
+
+      out.rewind
+      err.rewind
+
+      out.read.should == "0\n"
+      err.read.should == "1\n"
+    ensure
+      out.close
+      err.close
+    end
   end
 
-  it_should_behave_like "unix process" if ChildProcess.platform == :unix
 end

data/spec/jruby_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+if ChildProcess.jruby?
+  describe ChildProcess::JRuby::IO do
+    let(:io) { ChildProcess::JRuby::IO.new }
+
+    it "raises an ArgumentError if given IO does not respond to :to_outputstream" do
+      lambda { io.stdout = nil }.should raise_error(ArgumentError)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -85,6 +85,7 @@ module ChildProcessSpecHelper
 
 end # ChildProcessSpecHelper
 
+Thread.abort_on_exception = true
 
 Spec::Runner.configure do |config|
   config.include(ChildProcessSpecHelper)
@@ -92,5 +93,3 @@ Spec::Runner.configure do |config|
     @process && @process.alive? && @process.stop
   }
 end
-
-require "unix_process_spec"

data/spec/unix_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+if ChildProcess.unix?
+  describe ChildProcess::Unix::Process do
+    it "handles ECHILD race condition where process dies between timeout and KILL" do
+      process = sleeping_ruby
+
+      process.stub!(:fork).and_return('fakepid')
+      process.stub!(:send_term)
+      process.stub!(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
+      process.stub!(:send_kill).and_raise(Errno::ECHILD)
+
+      process.start
+      lambda { process.stop }.should_not raise_error
+
+      process.stub(:alive?).and_return(false)
+    end
+
+    it "handles ESRCH race condition where process dies between timeout and KILL" do
+      process = sleeping_ruby
+
+      process.stub!(:fork).and_return('fakepid')
+      process.stub!(:send_term)
+      process.stub!(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
+      process.stub!(:send_kill).and_raise(Errno::ESRCH)
+
+      process.start
+      lambda { process.stop }.should_not raise_error
+
+      process.stub(:alive?).and_return(false)
+    end
+  end
+
+  describe ChildProcess::Unix::IO do
+    let(:io) { ChildProcess::Unix::IO.new }
+
+    it "raises an ArgumentError if given IO does not respond to :to_io" do
+      lambda { io.stdout = nil }.should raise_error(ArgumentError, /to respond to :to_io/)
+    end
+
+    it "raises an ArgumentError if the IO's fileno is nil" do
+      fake_io = Object.new
+      def fake_io.to_io() StringIO.new end
+
+      lambda { io.stdout = fake_io }.should raise_error(TypeError, /expected IO, got/)
+    end
+  end
+
+end

metadata

@@ -3,13 +3,13 @@ name: childprocess
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
-    - 0
-    - 1
-    - 0
-  version: 0.1.0
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
-  - Jari Bakken
+- Jari Bakken
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -17,46 +17,49 @@ cert_chain: []
 date: 2010-10-17 00:00:00 +02:00
 default_executable: 
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: rspec
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 1
-              - 2
-              - 9
-            version: 1.2.9
-    type: :development
-    version_requirements: *id001
-  - !ruby/object:Gem::Dependency 
-    name: yard
-    prerelease: false
-    requirement: &id002 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :development
-    version_requirements: *id002
-  - !ruby/object:Gem::Dependency 
-    name: ffi
-    prerelease: false
-    requirement: &id003 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-              - 6
-              - 3
-            version: 0.6.3
-    type: :runtime
-    version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 3
+        version: 0.6.3
+  type: :runtime
+  version_requirements: *id003
 description: This gem aims at being a simple and reliable solution for controlling external programs running in the background on any Ruby / OS combination.
 email: jari.bakken@gmail.com
 executables: []
@@ -64,67 +67,76 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-  - LICENSE
-  - README.rdoc
+- LICENSE
+- README.rdoc
 files: 
-  - .document
-  - .gitignore
-  - LICENSE
-  - README.rdoc
-  - Rakefile
-  - VERSION
-  - childprocess.gemspec
-  - lib/childprocess.rb
-  - lib/childprocess/abstract_process.rb
-  - lib/childprocess/errors.rb
-  - lib/childprocess/ironruby.rb
-  - lib/childprocess/ironruby/process.rb
-  - lib/childprocess/jruby.rb
-  - lib/childprocess/jruby/process.rb
-  - lib/childprocess/unix.rb
-  - lib/childprocess/unix/process.rb
-  - lib/childprocess/windows.rb
-  - lib/childprocess/windows/api.rb
-  - lib/childprocess/windows/constants.rb
-  - lib/childprocess/windows/functions.rb
-  - lib/childprocess/windows/handle.rb
-  - lib/childprocess/windows/process.rb
-  - lib/childprocess/windows/structs.rb
-  - spec/childprocess_spec.rb
-  - spec/spec.opts
-  - spec/spec_helper.rb
-  - spec/unix_process_spec.rb
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- childprocess.gemspec
+- lib/childprocess.rb
+- lib/childprocess/abstract_io.rb
+- lib/childprocess/abstract_process.rb
+- lib/childprocess/errors.rb
+- lib/childprocess/ironruby.rb
+- lib/childprocess/ironruby/process.rb
+- lib/childprocess/jruby.rb
+- lib/childprocess/jruby/io.rb
+- lib/childprocess/jruby/process.rb
+- lib/childprocess/jruby/redirector.rb
+- lib/childprocess/unix.rb
+- lib/childprocess/unix/io.rb
+- lib/childprocess/unix/process.rb
+- lib/childprocess/windows.rb
+- lib/childprocess/windows/api.rb
+- lib/childprocess/windows/constants.rb
+- lib/childprocess/windows/functions.rb
+- lib/childprocess/windows/handle.rb
+- lib/childprocess/windows/io.rb
+- lib/childprocess/windows/process.rb
+- lib/childprocess/windows/structs.rb
+- spec/childprocess_spec.rb
+- spec/jruby_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unix_spec.rb
 has_rdoc: true
 homepage: http://github.com/jarib/childprocess
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-  - --charset=UTF-8
+- --charset=UTF-8
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Cross-platform ruby library for managing child processes.
 test_files: 
-  - spec/childprocess_spec.rb
-  - spec/spec_helper.rb
-  - spec/unix_process_spec.rb
+- spec/childprocess_spec.rb
+- spec/jruby_spec.rb
+- spec/spec_helper.rb
+- spec/unix_spec.rb

data/spec/unix_process_spec.rb

@@ -1,29 +0,0 @@
-shared_examples_for "unix process" do
-  it "handles ECHILD race condition where process dies between timeout and KILL" do
-    process = sleeping_ruby
-
-    process.stub!(:fork).and_return('fakepid')
-    process.stub!(:send_term)
-    process.stub!(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
-    process.stub!(:send_kill).and_raise(Errno::ECHILD)
-
-    process.start
-    lambda { process.stop }.should_not raise_error
-
-    process.stub(:alive?).and_return(false)
-  end
-
-  it "handles ESRCH race condition where process dies between timeout and KILL" do
-    process = sleeping_ruby
-
-    process.stub!(:fork).and_return('fakepid')
-    process.stub!(:send_term)
-    process.stub!(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
-    process.stub!(:send_kill).and_raise(Errno::ESRCH)
-
-    process.start
-    lambda { process.stop }.should_not raise_error
-
-    process.stub(:alive?).and_return(false)
-  end
-end