childprocess 0.3.6 → 0.3.7

data/.gitignore

@@ -18,5 +18,6 @@ coverage
 rdoc
 pkg
 .rbx
+Gemfile.lock
 
 ## PROJECT::SPECIFIC

data/.travis.yml

@@ -9,10 +9,8 @@ env:
   - CHILDPROCESS_POSIX_SPAWN=true
   - CHILDPROCESS_POSIX_SPAWN=false
 matrix:
-  exclude:
+  allow_failures:
     - rvm: jruby
       env: CHILDPROCESS_POSIX_SPAWN=true
     - rvm: rbx
       env: CHILDPROCESS_POSIX_SPAWN=true
-  allow_failures:
-    - rvm: ruby-head

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2012 Jari Bakken
+Copyright (c) 2010-2013 Jari Bakken
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,16 +1,19 @@
-childprocess
-============
+# childprocess
 
 This gem aims at being a simple and reliable solution for controlling
 external programs running in the background on any Ruby / OS combination.
 
-The code originated in the selenium-webdriver gem, but should prove useful as
+The code originated in the [selenium-webdriver](https://rubygems.org/gems/selenium-webdriver) gem, but should prove useful as
 a standalone library.
 
 [![Build Status](https://secure.travis-ci.org/jarib/childprocess.png)](http://travis-ci.org/jarib/childprocess)
 
-Usage
------
+# Usage
+
+The object returned from `ChildProcess.build` will implement `ChildProcess::AbstractProcess`.
+
+### Basic examples
+
 ```ruby
 process = ChildProcess.build("ruby", "-e", "sleep")
 
@@ -24,6 +27,9 @@ process.io.stdout = Tempfile.new("child-output")
 process.environment["a"] = "b"
 process.environment["c"] = nil
 
+# set the child's working directory
+process.cwd = '/some/path'
+
 # start the process
 process.start
 
@@ -35,6 +41,9 @@ process.exited?   #=> false
 process.wait
 process.exited?   #=> true
 
+# get the exit code
+process.exit_code #=> 0
+
 # ...or poll for exit + force quit
 begin
   process.poll_for_exit(10)
@@ -43,29 +52,93 @@ rescue ChildProcess::TimeoutError
 end
 ```
 
-The object returned from ChildProcess.build will implement ChildProcess::AbstractProcess.
+### Advanced examples
+
+#### Output to pipe
+
+```ruby
+r, w = IO.pipe
+
+proc = ChildProcess.build("echo", "foo")
+proc.io.stdout = proc.io.stderr = w
+proc.start
+proc.wait
+
+w.close
+r.read #=> "test\n"
+```
+
+#### Write to stdin
+
+```ruby
+process = ChildProcess.build("cat")
+
+out      = Tempfile.new("duplex")
+out.sync = true
+
+process.io.stdout = process.io.stderr = out
+process.duplex    = true # sets up pipe so process.io.stdin will be available after .start
+
+process.start
+process.io.stdin.puts "hello world"
+process.io.stdin.close
+
+process.poll_for_exit(exit_timeout_in_seconds)
+
+out.rewind
+out.read #=> "hello world\n"
+```
+
+#### Pipe output to another ChildProcess
+
+```ruby
+search           = ChildProcess.build("grep", '-E', %w(redis memcached).join('|'))
+search.duplex    = true # sets up pipe so search.io.stdin will be available after .start
+search.io.stdout = $stdout
+search.start
+
+listing           = ChildProcess.build("ps", "aux")
+listing.io.stdout = search.io.stdin
+listing.start
+listing.wait
+
+search.io.stdin.close
+search.wait
+```
+
+#### Prefer posix_spawn on *nix
+
+If the parent process is using a lot of memory, `fork+exec` can be very expensive. The `posix_spawn()` API removes this overhead.
+
+```ruby
+ChildProcess.posix_spawn = true
+process = ChildProcess.build(*args)
+```
+
+#### Detach from parent
+
+```ruby
+process = ChildProcess.build("sleep", "10")
+process.detach = true
+process.start
+```
 
-Implementation
---------------
+# Implementation
 
 How the process is launched and killed depends on the platform:
 
-* Unix     : fork + exec (or posix_spawn if enabled)
-* Windows  : CreateProcess and friends
-* JRuby    : java.lang.{Process,ProcessBuilder}
+* Unix     : `fork + exec` (or `posix_spawn` if enabled)
+* Windows  : `CreateProcess()` and friends
+* JRuby    : `java.lang.{Process,ProcessBuilder}`
 
-Note on Patches/Pull Requests
------------------------------
+# Note on Patches/Pull Requests
 
 * Fork the project.
 * Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
-Copyright
----------
+# Copyright
 
-Copyright (c) 2010-2012 Jari Bakken. See LICENSE for details.
+Copyright (c) 2010-2013 Jari Bakken. See LICENSE for details.

data/Rakefile

@@ -11,7 +11,6 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.ruby_opts  = "-I lib:spec"
   spec.pattern    = 'spec/**/*_spec.rb'
-  spec.rcov_opts  = %w[--exclude spec,ruby-debug,/Library/Ruby,.gem --include lib/childprocess]
 end
 
 desc 'Run specs for rcov'

data/lib/childprocess/abstract_process.rb

@@ -36,6 +36,7 @@ module ChildProcess
       @started     = false
       @exit_code   = nil
       @io          = nil
+      @cwd         = nil
       @detach      = false
       @duplex      = false
       @environment = {}

data/lib/childprocess/jruby/process.rb

@@ -88,14 +88,7 @@ module ChildProcess
         end
 
         if duplex?
-          stdin = @process.getOutputStream.to_io
-          stdin.sync = true
-          stdin.instance_variable_set(:@java_stream, @process.getOutputStream)
-          def stdin.__flushit; @java_stream.flush; end #The stream provided is a BufferedeOutputStream, so we have to flush it to make the bytes flow to the process
-          def stdin.flush; super; self.__flushit; end
-          def stdin.puts(*args); super(*args); self.__flushit; end
-
-          io._stdin = stdin
+          io._stdin = create_stdin
         else
           @process.getOutputStream.close
         end
@@ -120,6 +113,31 @@ module ChildProcess
         end
       end
 
+      def create_stdin
+        output_stream = @process.getOutputStream
+
+        stdin = output_stream.to_io
+        stdin.sync = true
+        stdin.instance_variable_set(:@childprocess_java_stream, output_stream)
+
+        class << stdin
+          # The stream provided is a BufferedeOutputStream, so we
+          # have to flush it to make the bytes flow to the process
+          def __childprocess_flush__
+            @childprocess_java_stream.flush
+          end
+
+          [:flush, :print, :printf, :putc, :puts, :write, :write_nonblock].each do |m|
+            define_method(m) do |*args|
+              super(*args)
+              self.__childprocess_flush__
+            end
+          end
+        end
+
+        stdin
+      end
+
     end # Process
   end # JRuby
 end # ChildProcess

data/lib/childprocess/unix/fork_exec_process.rb

@@ -33,8 +33,10 @@ module ChildProcess
             writer.close
           end
 
+          executable, *args = @args
+
           begin
-            exec(*@args)
+            exec([executable, executable], *args)
           rescue SystemCallError => ex
             exec_w << ex.message
           end

data/lib/childprocess/version.rb

@@ -1,3 +1,3 @@
 module ChildProcess
-  VERSION = "0.3.6"
+  VERSION = "0.3.7"
 end

data/spec/childprocess_spec.rb

@@ -163,6 +163,15 @@ describe ChildProcess do
     end
   end
 
+  it 'handles whitespace in the executable name' do
+    path = File.expand_path('foo bar')
+
+    with_executable_at(path) do |proc|
+      proc.start.should == proc
+      proc.should be_started
+    end
+  end
+
   it "times out when polling for exit" do
     process = sleeping_ruby.start
     lambda { process.poll_for_exit(0.1) }.should raise_error(ChildProcess::TimeoutError)

data/spec/io_spec.rb

@@ -57,15 +57,15 @@ describe ChildProcess do
   it "pumps all output" do
     10.times do |i|
       process = echo
-      
+
       out = Tempfile.new("duplex")
-      
+
       begin
         process.io.stdout = out
-        
+
         process.start
         process.poll_for_exit(exit_timeout)
-        
+
         out.rewind
         out.read.should == "hello\n"
       ensure
@@ -111,21 +111,32 @@ describe ChildProcess do
       process.duplex = true
 
       process.start
-      process.io.stdin.puts "hello"
-      sleep 0.1
-      out_receiver.read.should == "hello\n"
-      process.io.stdin.puts "new"
-      sleep 0.1
-      out_receiver.read.should == "new\n"
-      process.io.stdin.write "world\n"
-      process.io.stdin.flush
-      sleep 0.1
-      out_receiver.read.should == "world\n"
-      process.io.stdin.close
-      process.poll_for_exit(exit_timeout)
 
-      out_receiver.rewind
-      out_receiver.read.should == "hello\nnew\nworld\n"
+      stdin = process.io.stdin
+      lf = ChildProcess.windows? ? "\r\n" : "\n"
+
+      stdin.puts "hello"
+      stdin.flush
+      wait_until { rewind_and_read(out_receiver).should == "hello#{lf}" }
+
+      stdin.putc "n"
+      stdin.flush
+      wait_until { rewind_and_read(out_receiver).should == "hello#{lf}n" }
+
+      stdin.print "e"
+      stdin.flush
+      wait_until { rewind_and_read(out_receiver).should == "hello#{lf}ne" }
+
+      stdin.printf "w"
+      stdin.flush
+      wait_until { rewind_and_read(out_receiver).should == "hello#{lf}new" }
+
+      stdin.write "\nworld\n"
+      stdin.flush
+      wait_until { rewind_and_read(out_receiver).should == "hello#{lf}new#{lf}world#{lf}" }
+
+      stdin.close
+      process.poll_for_exit(exit_timeout)
      ensure
       out_receiver.close
       out.close

data/spec/spec_helper.rb

@@ -97,10 +97,8 @@ module ChildProcessSpecHelper
   def cat
     if ChildProcess.os == :windows
       ruby(<<-CODE)
-            STDIN.sync  = true
-            STDOUT.sync = true
-
-            puts STDIN.read
+            STDIN.sync = STDOUT.sync = true
+            IO.copy_stream(STDIN, STDOUT)
           CODE
     else
       ChildProcess.build("cat")
@@ -124,6 +122,25 @@ module ChildProcessSpecHelper
     ruby_process(tmp_script(code))
   end
 
+  def with_executable_at(path, &blk)
+    if ChildProcess.os == :windows
+      path << ".cmd"
+      content = "@echo foo"
+    else
+      content = "#!/bin/sh\necho foo"
+    end
+
+    File.open(path, 'w', 0744) { |io| io << content }
+    proc = ChildProcess.build(path)
+
+    begin
+      yield proc
+    ensure
+      proc.stop if proc.alive?
+      File.delete path
+    end
+  end
+
   def exit_timeout
     10
   end
@@ -149,13 +166,22 @@ module ChildProcessSpecHelper
 
   def wait_until(timeout = 10, &blk)
     end_time = Time.now + timeout
+    last_exception = nil
 
     until Time.now >= end_time
-      return if yield
+      begin
+        return if yield
+      rescue RSpec::Expectations::ExpectationNotMetError => ex
+        last_exception = ex
+      end
+
       sleep 0.05
     end
 
-    raise "timed out"
+    msg = "timed out after #{timeout} seconds"
+    msg << ":\n#{last_exception.message}" if last_exception
+
+    raise msg
   end
 
   def can_bind?(host, port)
@@ -165,6 +191,11 @@ module ChildProcessSpecHelper
     false
   end
 
+  def rewind_and_read(io)
+    io.rewind
+    io.read
+  end
+
 end # ChildProcessSpecHelper
 
 Thread.abort_on_exception = true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: childprocess
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-17 00:00:00.000000000 Z
+date: 2013-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec