ProcessPilot 0.0.1.20120118 → 1.0.0.20120124

data/ChangeLog

@@ -1,5 +1,13 @@
 = Process Pilot Release History
 
+== 1.0.0.20120124 (Beta)
+
+* Removed dependency on ChildProcess: now uses Open3
+* Client code does not need to return the value to wait for the process
+* Client code now receives a ChildProcessInfo parameter in 4th position that might be nil on some platforms
+* Replaced IO::gets_blocking and IO::read_blocking with IO::gets and IO::read taking an optional :TimeOutSecs option
+* Regression: Added some dots and removed some quotes at the end of echoed lines for Windows compatibility
+
 == 0.0.1.20120118 (Beta)
 
 * Initial public release.

data/Credits

@@ -1,10 +1,5 @@
 = Projects used by Process Pilot
 
-== ChildProcess
-* Jari Bakken (http://github.com/jarib)
-* http://github.com/jarib/childprocess
-* Used to internally pilot stdin in real time
-
 == Ruby
 * Yukihiro « matz » Matsumoto (http://www.rubyist.net/~matz/)
 * http://www.ruby-lang.org/

data/README

@@ -11,8 +11,8 @@ Check the website at http://processpilot.sourceforge.net
 
 == Who wrote it ?
 
-Check the AUTHORS[link:files/AUTHORS.html] file.
+Check the AUTHORS[link:AUTHORS.html] file.
 
 == What is the license ?
 
-You can find out in the LICENSE[link:files/LICENSE.html] file.
+You can find out in the LICENSE[link:LICENSE.html] file.

data/ReleaseInfo

@@ -2,7 +2,7 @@
 # This file has been generated by RubyPackager during a delivery.
 # More info about RubyPackager: http://rubypackager.sourceforge.net
 {
-  :Version => '0.0.1.20120118',
+  :Version => '1.0.0.20120124',
   :Tags => [ 'Beta' ],
   :DevStatus => 'Beta'
 }

data/lib/processpilot/processpilot.rb

@@ -3,11 +3,36 @@
 # Licensed under the terms specified in LICENSE file. No warranty is provided.
 #++
 
-require 'childprocess'
-require 'tempfile'
+require 'open3'
+require 'timeout'
 
 module ProcessPilot
 
+  class ChildProcessInfo
+
+    # Constructor
+    #
+    # Parameters:
+    # * *iWaitThread* (_Thread_): The waiting thread, can be nil if already stopped or dead
+    def initialize(iWaitThread)
+      @WaitThread = iWaitThread
+    end
+
+    # Has the waiting process exited already ?
+    #
+    # Return:
+    # * _Boolean_: Has the waiting process exited already ?
+    def exited?
+      return ((@WaitThread == nil) or (@WaitThread.stop?))
+    end
+
+    # Stop the process' execution
+    def stop
+      @WaitThread.kill if @WaitThread
+    end
+
+  end
+
   # Pilot a process.
   # This will create a new thread for the process to be run.
   # If the process is a Ruby process, you can force STDOUT sync by specifying it in options. In this case the command line should begin with the Ruby file name to be executed (don't use ruby executable, and specifiy ruby options in iOptions[:RubyCmdLine]).
@@ -23,9 +48,7 @@ module ProcessPilot
   # ** *oStdIN* (_IO_): The process' STDIN
   # ** *iStdOUT* (_IO_): The process' STDOUT
   # ** *iStdERR* (_IO_): The process' STDERR
-  # ** *iChildProcess* (_ChildProcess_): The corresponding child process. Don't use it to pilot std* IO objects.
-  # ** Return:
-  # ** _Boolean_: Do we have to wait until the process' completion ?
+  # ** *iChildProcess* (_ChildProcess_): The corresponding child process. Don't use it to pilot std* IO objects. Depending on the platforms, this might be nil.
   def self.pilot(*iArgs)
     iCmdLine = iArgs
     iOptions = (iArgs[-1].is_a?(Hash)) ? iArgs.pop : {}
@@ -43,40 +66,9 @@ module ProcessPilot
     lRealCmdLine = (iForceRubyProcessSync) ? iRubyCmdLine + [ "#{File.dirname(__FILE__)}/wrapper.rb" ] + iCmdLine : iCmdLine
 
     logDebug "[ProcessPilot] Command line: #{lRealCmdLine.inspect}" if iDebug
-    lProcess = ChildProcess.build(*lRealCmdLine)
-
-    # Indication of stdin usage
-    lProcess.duplex = true
-
-    # Specify files for stdout/stderr
-    # ! Use w+ mode to make it possible for our monitoring thread to reopen the file in r mode
-    Tempfile.open('processpilot.stdout') do |oStdOUT|
-      logDebug "[ProcessPilot] STDOUT file: #{oStdOUT.path}" if iDebug
-      lProcess.io.stdout = oStdOUT
-      Tempfile.open('processpilot.stderr') do |oStdERR|
-        logDebug "[ProcessPilot] STDERR file: #{oStdERR.path}" if iDebug
-        lProcess.io.stderr = oStdERR
-
-        # Start the process: this creates the background thread running our command
-        lProcess.start
-
-        # In our main thread: open the STDOUT/ERR files
-        lStdOUT = File.open(oStdOUT.path, 'r')
-        lStdERR = File.open(oStdERR.path, 'r')
-        lStdIN = lProcess.io.stdin
-
-        # Call client code
-        lWaitUntilCompletion = yield(lStdIN, lStdOUT, lStdERR, lProcess)
-
-        # Wait for the process termination in case it is late
-        if (lWaitUntilCompletion)
-          while (!lProcess.exited?)
-            sleep 1
-          end
-        end
-      end
+    Open3::popen3(*lRealCmdLine) do |oStdIN, iStdOUT, iStdERR, iWaitThread|
+      yield(oStdIN, iStdOUT, iStdERR, ChildProcessInfo.new(iWaitThread))
     end
-
   end
 
 end
@@ -84,114 +76,42 @@ end
 # Define some helpers that can be handy in case of process piloting from IO
 class IO
 
-  # Exception thrown when timeout has been reached
-  class TimeOutError < RuntimeError
-  end
-
-  # Implement a blocking read of a new string ending with newline.
-  # Make sure we wait for the end of a string before returning.
-  # This is done to ensure we will get the new string we are expecting.
-  # If the timeout is reached, an exception is thrown.
-  #
-  # Parameters:
-  # * *iOptions* (<em>map<Symbol,Object></em>): Optional arguments [optional = {}]:
-  # ** *:TimeOutSecs* (_Integer_): Time out in seconds (nil = no timeout) [optional = nil]
-  # ** *:PollingIntervalSecs* (_Float_): Polling interval in seconds [optional = 0.1]
-  # ** *:ChildProcess* (_ChildProcess_): Corresponding child process linked to this IO. Can be used to detect the end of IO. [optional = nil]
-  # Return:
-  # * _String_: The next string from IO (separator is $/). Can be empty if the corresponding child process has exited already.
-  def gets_blocking(iOptions = {})
-    return get_data_blocking(
-      Proc.new { |iStr| iStr[-1..-1] == $/ },
-      iOptions
-    ) do |iStr|
-      next self.gets
-    end
-  end
-
-  # Implement a blocking read of a given size.
-  # Make sure we wait for the end of a string before returning.
-  # This is done to ensure we will get the new string we are expecting.
-  # If the timeout is reached, an exception is thrown.
-  #
-  # Parameters:
-  # * *iSize* (_Integer_): Size of the data to read
-  # * *iOptions* (<em>map<Symbol,Object></em>): Optional arguments [optional = {}]:
-  # ** *:TimeOutSecs* (_Integer_): Time out in seconds (nil = no timeout) [optional = nil]
-  # ** *:PollingIntervalSecs* (_Float_): Polling interval in seconds [optional = 0.1]
-  # ** *:ChildProcess* (_ChildProcess_): Corresponding child process linked to this IO. Can be used to detect the end of IO. [optional = nil]
-  # Return:
-  # * _String_: The next string from IO (separator is $/). Can be empty if the corresponding child process has exited already.
-  def read_blocking(iSize, iOptions = {})
-    return get_data_blocking(
-      Proc.new { |iStr| iStr.size == iSize },
-      iOptions
-    ) do |iStr|
-      next self.read(iSize-iStr.size)
+  alias :gets_ORG_ProcessPilot :gets
+  # Add the possibility to gets to take an optional Hash:
+  # *:TimeOutSecs* (_Integer_): Timeout in seconds to read data. nil means no timeout (regular gets) [optional = nil].
+  def gets(*iArgs)
+    if (iArgs[-1].is_a?(Hash))
+      lOptions = iArgs[-1]
+      lTimeOutSecs = lOptions[:TimeOutSecs]
+      if (lTimeOutSecs == nil)
+        return gets_ORG_ProcessPilot(*iArgs[0..-2])
+      else
+        return Timeout::timeout(lTimeOutSecs) do
+          next gets_ORG_ProcessPilot(*iArgs[0..-2])
+        end
+      end
+    else
+      return gets_ORG_ProcessPilot(*iArgs)
     end
   end
 
-  # Send a synchronized input to an IO.
-  # Make sure it will be flushed.
-  #
-  # Parameters:
-  # * *iStr* (_String_): The string to send
-  def write_flushed(iStr)
-    self.write iStr
-    self.flush
-  end
-
-  private
-
-  # Implement a blocking read of a data unless the data read conforms to a given validation code.
-  # Take a validation proc to know if the data was read correctly, and yields code to read effectively data.
-  # Proper implementation should have a more efficient algo.
-  # If the timeout is reached, an exception is thrown.
-  #
-  # Parameters:
-  # * *iProcValidation* (_Proc_): The validation proc:
-  # ** Parameters:
-  # ** *iData* (_String_): The data to validate
-  # ** Return:
-  # ** _Boolean_: Is the data valid ?
-  # * *iOptions* (<em>map<Symbol,Object></em>): Optional arguments [optional = {}]:
-  # ** *:TimeOutSecs* (_Integer_): Time out in seconds (nil = no timeout) [optional = nil]
-  # ** *:PollingIntervalSecs* (_Float_): Polling interval in seconds [optional = 0.1]
-  # ** *:ChildProcess* (_ChildProcess_): Corresponding child process linked to this IO. Can be used to detect the end of IO. [optional = nil]
-  # * _CodeBlock_: Code called to read data effectively:
-  # ** Parameters:
-  # ** *iStr* (_String_): The data already read
-  # ** Return:
-  # ** _String_: String of data read (can be nil if no data was read)
-  # Return:
-  # * _String_: The next string from IO (separator is $/). Can be empty if the corresponding child process has exited already.
-  def get_data_blocking(iProcValidation, iOptions = {})
-    rStr = ''
-    iPollingInterval = (iOptions[:PollingIntervalSecs] || 0.1)
-    iTimeOutSecs = iOptions[:TimeOutSecs]
-    iChildProcess = iOptions[:ChildProcess]
-
-    require 'time' if (iTimeOutSecs != nil)
-
-    # Concatenate chunks unless we have the separator.
-    # As we deal with stdin flow, it is possible to have a line without ending already written in the file and already flushed by the IO.
-    lTimeOut = (iTimeOutSecs == nil) ? nil : Time.now + iTimeOutSecs
-    while (!iProcValidation.call(rStr))
-      lNewChunk = nil
-      while (lNewChunk == nil)
-        lNewChunk = yield(rStr)
-        #$stdout.puts "===== Read #{lNewChunk.inspect}"
-        break if ((iChildProcess != nil) and (iChildProcess.exited?))
-        if (lNewChunk == nil)
-          sleep iPollingInterval
-          raise TimeOutError.new("Timeout of #{iTimeOutSecs} secs reached while waiting for data.") if ((lTimeOut != nil) and (Time.now > lTimeOut))
+  alias :read_ORG_ProcessPilot :read
+  # Add the possibility to gets to take an optional Hash:
+  # *:TimeOutSecs* (_Integer_): Timeout in seconds to read data. nil means no timeout (regular gets) [optional = nil].
+  def read(*iArgs)
+    if (iArgs[-1].is_a?(Hash))
+      lOptions = iArgs[-1]
+      lTimeOutSecs = lOptions[:TimeOutSecs]
+      if (lTimeOutSecs == nil)
+        return read_ORG_ProcessPilot(*iArgs[0..-2])
+      else
+        return Timeout::timeout(lTimeOutSecs) do
+          next read_ORG_ProcessPilot(*iArgs[0..-2])
         end
       end
-      rStr.concat(lNewChunk) if (lNewChunk != nil)
-      break if ((iChildProcess != nil) and (iChildProcess.exited?))
+    else
+      return read_ORG_ProcessPilot(*iArgs)
     end
-
-    return rStr
   end
 
 end

data/test/ProcessPilotTest/Common.rb

@@ -210,29 +210,29 @@ module ProcessPilotTest
     # * *iStdERR* (_IO_): STDERR
     # * *iChildProcess* (_ChildProcess_): Corresponding ChildProcess
     def assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
-      assert_equal "STDOUT Line 1\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-      assert_equal 'Enter string 1 from STDOUT: ', iStdOUT.read_blocking(28, :ChildProcess => iChildProcess)
-      assert_raise IO::TimeOutError do
-        iStdERR.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_equal "STDOUT Line 1.\n", iStdOUT.gets(:TimeOutSecs => 1)
+      assert_equal 'Enter string 1 from STDOUT: ', iStdOUT.read(28)
+      assert_raise Timeout::Error do
+        iStdERR.read(1, :TimeOutSecs => 1)
       end
-      assert_raise IO::TimeOutError do
-        iStdOUT.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_raise Timeout::Error do
+        iStdOUT.read(1, :TimeOutSecs => 1)
       end
-      oStdIN.write_flushed "Test String 1\n"
-      assert_equal "STDOUT Line 2 Test String 1\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-      assert_equal "STDERR Line 1\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-      assert_equal 'Enter string 2 from STDERR: ', iStdERR.read_blocking(28, :ChildProcess => iChildProcess)
-      assert_raise IO::TimeOutError do
-        iStdERR.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      oStdIN.write "Test String 1\n"
+      assert_equal "STDOUT Line 2: Test String 1\n", iStdOUT.gets(:TimeOutSecs => 1)
+      assert_equal "STDERR Line 1.\n", iStdERR.gets(:TimeOutSecs => 1)
+      assert_equal 'Enter string 2 from STDERR: ', iStdERR.read(28)
+      assert_raise Timeout::Error do
+        iStdERR.read(1, :TimeOutSecs => 1)
       end
-      assert_raise IO::TimeOutError do
-        iStdOUT.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_raise Timeout::Error do
+        iStdOUT.read(1, :TimeOutSecs => 1)
       end
-      oStdIN.write_flushed "Test String 2\n"
-      assert_equal "STDOUT Line 3 Test String 2\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-      assert_equal "STDERR Line 2\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-      assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-      assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      oStdIN.write "Test String 2\n"
+      assert_equal "STDOUT Line 3: Test String 2\n", iStdOUT.gets(:TimeOutSecs => 1)
+      assert_equal "STDERR Line 2.\n", iStdERR.gets(:TimeOutSecs => 1)
+      assert_equal nil, iStdOUT.gets(:TimeOutSecs => 1)
+      assert_equal nil, iStdERR.gets(:TimeOutSecs => 1)
       assert iChildProcess.exited?
     end
 

data/test/ProcessPilotTest/NonRuby.rb

@@ -11,101 +11,91 @@ module ProcessPilotTest
 
     def testNotInteractiveSTDOUT
       ProcessPilot::pilot(*getNotInteractiveCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1)
-        assert_raise IO::TimeOutError do
-          iStdERR.gets_blocking(:TimeOutSecs => 1)
-        end
+        assert_equal "Hello World\n", iStdOUT.gets(:TimeOutSecs => 1)
+        assert_nil iStdERR.gets
         assert iChildProcess.exited?
-        next true
       end
     end
 
     def testNotInteractiveSTDOUTEndOfProcess
       ProcessPilot::pilot(*getNotInteractiveCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal "Hello World\n", iStdOUT.gets(:TimeOutSecs => 1)
+        assert_equal nil, iStdOUT.gets(:TimeOutSecs => 1)
+        assert_equal nil, iStdERR.gets(:TimeOutSecs => 1)
         assert iChildProcess.exited?
-        next true
       end
     end
 
     def testNotInteractiveSTDERR
       ProcessPilot::pilot(*getNotInteractiveCmdLineSTDERR) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal "Hello World\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal nil, iStdOUT.gets(:TimeOutSecs => 1)
+        assert_equal "Hello World\n", iStdERR.gets(:TimeOutSecs => 1)
+        assert_equal nil, iStdERR.gets(:TimeOutSecs => 1)
         assert iChildProcess.exited?
-        next true
       end
     end
 
     def testInteractiveSTDOUT
       ProcessPilot::pilot(*getInteractiveCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_raise IO::TimeOutError do
-          iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal "Hello World\n", iStdOUT.gets(:TimeOutSecs => 1)
+        assert_raise Timeout::Error do
+          iStdOUT.gets(:TimeOutSecs => 1)
         end
-        oStdIN.write_flushed "Test String\n"
-        assert_equal "Hello Test String\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        oStdIN.write "Test String\n"
+        assert_equal "Hello Test String\n", iStdOUT.gets(:TimeOutSecs => 1)
+        assert_equal nil, iStdOUT.gets(:TimeOutSecs => 1)
         assert iChildProcess.exited?
-        next true
       end
     end
 
     def testInteractiveSTDERR
       ProcessPilot::pilot(*getInteractiveCmdLineSTDERR) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_raise IO::TimeOutError do
-          iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_raise Timeout::Error do
+          iStdOUT.gets(:TimeOutSecs => 1)
         end
-        assert_equal "Hello World\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_raise IO::TimeOutError do
-          iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal "Hello World\n", iStdERR.gets(:TimeOutSecs => 1)
+        assert_raise Timeout::Error do
+          iStdERR.gets(:TimeOutSecs => 1)
         end
-        oStdIN.write_flushed "Test String\n"
-        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal "Hello Test String\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        oStdIN.write "Test String\n"
+        assert_equal nil, iStdOUT.gets(:TimeOutSecs => 1)
+        assert_equal "Hello Test String\n", iStdERR.gets(:TimeOutSecs => 1)
+        assert_equal nil, iStdERR.gets(:TimeOutSecs => 1)
         assert iChildProcess.exited?
-        next true
       end
     end
 
     def testInteractiveWithPromptSTDOUT
       ProcessPilot::pilot(*getInteractivePromptCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal 'Enter string: ', iStdOUT.read_blocking(14, :ChildProcess => iChildProcess)
-        assert_raise IO::TimeOutError do
-          iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal "Hello World\n", iStdOUT.gets(:TimeOutSecs => 1)
+        assert_equal 'Enter string: ', iStdOUT.read(14)
+        assert_raise Timeout::Error do
+          iStdOUT.gets(:TimeOutSecs => 1)
         end
-        oStdIN.write_flushed "Test String\n"
-        assert_equal "Hello Test String\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        oStdIN.write "Test String\n"
+        assert_equal "Hello Test String\n", iStdOUT.gets(:TimeOutSecs => 1)
+        assert_equal nil, iStdOUT.gets(:TimeOutSecs => 1)
         assert iChildProcess.exited?
-        next true
       end
     end
 
     def testInteractiveWithPromptSTDERR
       ProcessPilot::pilot(*getInteractivePromptCmdLineSTDERR) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_equal "Hello World\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal 'Enter string: ', iStdERR.read_blocking(14, :ChildProcess => iChildProcess)
-        assert_raise IO::TimeOutError do
-          iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal "Hello World\n", iStdERR.gets(:TimeOutSecs => 1)
+        assert_equal 'Enter string: ', iStdERR.read(14)
+        assert_raise Timeout::Error do
+          iStdERR.gets(:TimeOutSecs => 1)
         end
-        oStdIN.write_flushed "Test String\n"
-        assert_equal "Hello Test String\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
-        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        oStdIN.write "Test String\n"
+        assert_equal "Hello Test String\n", iStdERR.gets(:TimeOutSecs => 1)
+        assert_equal nil, iStdERR.gets(:TimeOutSecs => 1)
         assert iChildProcess.exited?
-        next true
       end
     end
 
     def testSeveralPrompts
       ProcessPilot::pilot(*getInteractiveSeveralPrompts) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
         assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
-        next true
       end
     end
 

data/test/ProcessPilotTest/Ruby.rb

@@ -12,24 +12,21 @@ module ProcessPilotTest
     def testSyncedSTDOUT
       ProcessPilot::pilot(*getSyncedRubyCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
         assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
-        next true
       end
     end
 
     def testNormalSTDOUT
       ProcessPilot::pilot(*getNormalRubyCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
-        assert_raise IO::TimeOutError do
-          iStdOUT.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_raise Timeout::Error do
+          iStdOUT.read(1, :TimeOutSecs => 1)
         end
         iChildProcess.stop
-        next true
       end
     end
 
     def testNormalSTDOUTWithForceSync
       ProcessPilot::pilot(*getNormalRubyWithSyncCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
         assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
-        next true
       end
     end
 

data/test/Programs/Bash/InteractiveSeveralPrompts.sh

@@ -1,11 +1,11 @@
 #!/bin/sh
 
-echo "STDOUT Line 1"
+echo "STDOUT Line 1."
 echo -n "Enter string 1 from STDOUT: "
 read VAR
-echo "STDOUT Line 2 ${VAR}"
-echo "STDERR Line 1" >&2
+echo "STDOUT Line 2: ${VAR}"
+echo "STDERR Line 1." >&2
 echo -n "Enter string 2 from STDERR: " >&2
 read VAR
-echo "STDOUT Line 3 ${VAR}"
-echo "STDERR Line 2" >&2
+echo "STDOUT Line 3: ${VAR}"
+echo "STDERR Line 2." >&2

data/test/Programs/Ruby/Scenario.rb

@@ -9,15 +9,15 @@ module ProcessPilotTest
 
     # Execute the testing scenario
     def self.run
-      $stdout.puts 'STDOUT Line 1'
+      $stdout.puts 'STDOUT Line 1.'
       $stdout.write 'Enter string 1 from STDOUT: '
       lVar = $stdin.gets
-      $stdout.puts "STDOUT Line 2 #{lVar}"
-      $stderr.puts 'STDERR Line 1'
+      $stdout.puts "STDOUT Line 2: #{lVar}"
+      $stderr.puts 'STDERR Line 1.'
       $stderr.write 'Enter string 2 from STDERR: '
       lVar = $stdin.gets
-      $stdout.puts "STDOUT Line 3 #{lVar}"
-      $stderr.puts 'STDERR Line 2'
+      $stdout.puts "STDOUT Line 3: #{lVar}"
+      $stderr.puts 'STDERR Line 2.'
     end
 
   end

data/test/Programs/Windows/InteractiveSTDERR.bat

@@ -1,4 +1,4 @@
 @echo off
-echo Hello World >&2
+echo Hello World>&2
 set /p var="" %=%
-echo Hello %var% >&2
+echo Hello %var%>&2

data/test/Programs/Windows/InteractiveSeveralPrompts.bat

@@ -1,9 +1,10 @@
 @echo off
-echo STDOUT Line 1
+echo STDOUT Line 1.
 set /p var="Enter string 1 from STDOUT: " %=%
-echo STDOUT Line 2 %var%
-echo "STDERR Line 1">&2
+echo STDOUT Line 2: %var%
+set line=
+echo STDERR Line 1.>&2
 echo/|set /p ="Enter string 2 from STDERR: " >&2
 set /p var= %=%
-echo STDOUT Line 3 %var%
-echo "STDERR Line 2">&2
+echo STDOUT Line 3: %var%
+echo STDERR Line 2.>&2

metadata

@@ -3,11 +3,11 @@ name: ProcessPilot
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
   - 0
-  - 1
-  - 20120118
-  version: 0.0.1.20120118
+  - 20120124
+  version: 1.0.0.20120124
 platform: ruby
 authors: 
 - Muriel Salvan
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-18 00:00:00 +01:00
+date: 2012-01-24 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,21 +32,6 @@ dependencies:
         version: "0.3"
   type: :runtime
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: childprocess
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 2
-        - 3
-        version: 0.2.3
-  type: :runtime
-  version_requirements: *id002
 description: Ruby library giving a simple way to pilot an external process' stdin, stdout and stderr in real time. Very useful for interactive processes testing or automation.
 email: muriel@x-aeon.com
 executables: []